[{"_1":2,"_22935":-5,"_22936":-5},"loaderData",{"_3":4,"_10":11},"root",{"_5":6,"_7":8},"isAuthenticated",false,"features",{"_9":6},"billing","routes/functions.$functionId",{"_12":13,"_35":36,"_3930":3931},"function",{"_14":15,"_16":17,"_18":19,"_20":19,"_21":22,"_31":32,"_33":34},"name","mfem.coefficients.vectorFunction","signature","mfem.coefficients.vectorFunction(fn, dim?)","summary","Create a vector coefficient from a JavaScript function.","description","params",[23,27],{"_14":24,"_20":25,"_26":6},"fn","- Function (x, y, z) => number[]","optional",{"_14":28,"_20":29,"_26":30},"dim","- Output vector dimension (defaults to 3)",true,"returns","Promise","examples",[],"package",{"_37":38,"_14":39,"_20":40,"_41":42,"_43":44,"_45":46,"_47":48},"id","mfem-generated","Finite Element (MFEM)","Finite element library powered by MFEM compiled to WebAssembly. Provides mesh generation, finite element spaces, bilinear/linear forms, coefficients, and iterative solvers.","tier","free","icon","🔷","namespace","mfem","functions",[49,63,77,86,102,120,135,144,153,165,172,181,190,199,209,217,227,244,255,262,275,283,295,305,317,327,335,343,352,361,372,391,408,425,438,450,459,472,488,499,512,522,532,545,555,568,578,586,595,604,616,625,636,646,655,670,682,692,701,710,719,732,745,755,764,777,789,802,813,824,833,843,852,13,863,872,880,888,897,905,913,921,929,939,951,962,970,977,985,994,1001,1010,1018,1026,1033,1041,1049,1059,1068,1076,1084,1092,1101,1111,1119,1133,1144,1156,1170,1182,1193,1201,1210,1219,1231,1238,1254,1265,1276,1287,1297,1307,1317,1330,1340,1349,1360,1371,1381,1390,1400,1412,1427,1437,1449,1458,1473,1485,1495,1506,1516,1526,1535,1546,1561,1579,1590,1601,1615,1627,1639,1649,1660,1671,1681,1692,1701,1709,1717,1730,1743,1752,1765,1774,1786,1796,1805,1815,1824,1832,1844,1852,1860,1869,1877,1888,1894,1901,1907,1913,1920,1926,1932,1939,1946,1953,1959,1965,1972,1981,1992,2001,2010,2018,2025,2036,2046,2056,2066,2079,2086,2101,2108,2117,2125,2138,2148,2158,2166,2180,2190,2197,2204,2211,2218,2233,2244,2251,2257,2264,2276,2287,2297,2307,2321,2330,2340,2349,2356,2363,2371,2378,2389,2396,2405,2412,2420,2427,2438,2445,2452,2459,2470,2479,2485,2495,2503,2510,2517,2524,2532,2539,2546,2552,2558,2565,2577,2585,2593,2601,2613,2624,2633,2642,2651,2660,2669,2678,2687,2696,2709,2718,2727,2734,2746,2757,2769,2781,2801,2820,2833,2847,2858,2868,2880,2889,2900,2915,2927,2938,2951,2959,2974,2987,2996,3004,3012,3020,3029,3037,3048,3060,3068,3075,3085,3096,3107,3119,3127,3137,3146,3157,3167,3179,3186,3196,3205,3212,3219,3226,3233,3240,3247,3254,3261,3268,3275,3282,3289,3296,3306,3313,3320,3327,3336,3343,3350,3357,3364,3371,3378,3385,3392,3399,3406,3413,3421,3430,3437,3449,3457,3468,3476,3486,3496,3503,3510,3517,3526,3533,3540,3547,3554,3561,3570,3578,3585,3593,3601,3609,3617,3624,3631,3638,3645,3652,3659,3667,3676,3684,3693,3699,3706,3712,3718,3729,3737,3748,3764,3774,3787,3799,3809,3815,3822,3829,3836,3843,3850,3856,3864,3874,3883,3890,3897,3910,3920],{"_14":50,"_16":51,"_18":52,"_20":53,"_21":54,"_31":61,"_33":62},"mfem.bilinearForms.addBoundaryMassIntegrator","mfem.bilinearForms.addBoundaryMassIntegrator(blf, coeff?)","Add a boundary mass integrator to the bilinear form.\r","Add a boundary mass integrator to the bilinear form.\r\n\r\nComputes: ∫_∂Ω c * u * v ds",[55,58],{"_14":56,"_20":57,"_26":6},"blf","- BilinearForm instance",{"_14":59,"_20":60,"_26":30},"coeff","- Optional scalar coefficient","void",[],{"_14":64,"_16":65,"_18":66,"_20":67,"_21":68,"_31":61,"_33":76},"mfem.bilinearForms.addConvectionIntegrator","mfem.bilinearForms.addConvectionIntegrator(blf, velocity, alpha?)","Add a convection integrator (v · ∇u) to the bilinear form.\r","Add a convection integrator (v · ∇u) to the bilinear form.\r\n\r\nComputes: ∫ α * (β · ∇u) * v dx",[69,70,73],{"_14":56,"_20":57,"_26":6},{"_14":71,"_20":72,"_26":6},"velocity","- Vector coefficient for velocity field",{"_14":74,"_20":75,"_26":30},"alpha","- Scaling factor (defaults to 1.0)",[],{"_14":78,"_16":79,"_18":80,"_20":81,"_21":82,"_31":61,"_33":85},"mfem.bilinearForms.addCurlCurlIntegrator","mfem.bilinearForms.addCurlCurlIntegrator(blf, coeff?)","Add a curl-curl integrator (∇×u · ∇×v) to the bilinear form.\r","Add a curl-curl integrator (∇×u · ∇×v) to the bilinear form.\r\nUsed for H(curl) finite element spaces.\r\n\r\nComputes: ∫ c * (∇×u) · (∇×v) dx",[83,84],{"_14":56,"_20":57,"_26":6},{"_14":59,"_20":60,"_26":30},[],{"_14":87,"_16":88,"_18":89,"_20":90,"_21":91,"_31":61,"_33":101},"mfem.bilinearForms.addDGDiffusionIntegrator","mfem.bilinearForms.addDGDiffusionIntegrator(blf, coeff, sigma, kappa)","Add DG diffusion integrator for interior penalty method.\r","Add DG diffusion integrator for interior penalty method.\r\nAdds integrators for both interior and boundary faces.",[92,93,95,98],{"_14":56,"_20":57,"_26":6},{"_14":59,"_20":94,"_26":6},"- Diffusion coefficient (optional)",{"_14":96,"_20":97,"_26":6},"sigma","- Symmetry parameter (-1 = SIPG, 0 = IIPG, 1 = NIPG)",{"_14":99,"_20":100,"_26":6},"kappa","- Penalty parameter (typically 10 * p^2 / h)",[],{"_14":103,"_16":104,"_18":105,"_20":106,"_21":107,"_31":61,"_33":119},"mfem.bilinearForms.addDGElasticityIntegrator","mfem.bilinearForms.addDGElasticityIntegrator(blf, lambda, mu, alpha?, kappa?)","Add a discontinuous Galerkin (DG) elasticity integrator.\r","Add a discontinuous Galerkin (DG) elasticity integrator.\r\n\r\nUsed for elasticity problems with discontinuous Galerkin methods\r\nwhere displacement jumps occur across element boundaries.\r\nThis adds interior face integrators for the DG formulation.",[108,109,112,115,117],{"_14":56,"_20":57,"_26":6},{"_14":110,"_20":111,"_26":6},"lambda","- Lamé first parameter",{"_14":113,"_20":114,"_26":6},"mu","- Shear modulus",{"_14":74,"_20":116,"_26":30},"- Symmetry parameter (default: -1.0 for symmetric form)",{"_14":99,"_20":118,"_26":30},"- Penalty parameter for stability",[],{"_14":121,"_16":122,"_18":123,"_20":124,"_21":125,"_31":61,"_33":134},"mfem.bilinearForms.addDGTraceIntegrator","mfem.bilinearForms.addDGTraceIntegrator(blf, coeff?, alpha?, beta?)","Add DG trace integrator for face terms.\r","Add DG trace integrator for face terms.\r\nUsed for upwinding in DG advection problems.",[126,127,129,131],{"_14":56,"_20":57,"_26":6},{"_14":59,"_20":128,"_26":30},"- Optional coefficient (VectorCoefficient)",{"_14":74,"_20":130,"_26":30},"- Upwinding parameter (default: 0)",{"_14":132,"_20":133,"_26":30},"beta","- Penalty parameter (default: 0)",[],{"_14":136,"_16":137,"_18":138,"_20":139,"_21":140,"_31":61,"_33":143},"mfem.bilinearForms.addDiffusionIntegrator","mfem.bilinearForms.addDiffusionIntegrator(blf, coeff?)","Add a diffusion integrator (∇u · ∇v) to the bilinear form.\r","Add a diffusion integrator (∇u · ∇v) to the bilinear form.\r\n\r\nComputes: ∫ c * ∇u · ∇v dx",[141,142],{"_14":56,"_20":57,"_26":6},{"_14":59,"_20":60,"_26":30},[],{"_14":145,"_16":146,"_18":147,"_20":148,"_21":149,"_31":61,"_33":152},"mfem.bilinearForms.addDivDivIntegrator","mfem.bilinearForms.addDivDivIntegrator(blf, coeff?)","Add a div-div integrator (∇·u)(∇·v) to the bilinear form.\r","Add a div-div integrator (∇·u)(∇·v) to the bilinear form.\r\nUsed for H(div) finite element spaces.\r\n\r\nComputes: ∫ c * (∇·u)(∇·v) dx",[150,151],{"_14":56,"_20":57,"_26":6},{"_14":59,"_20":60,"_26":30},[],{"_14":154,"_16":155,"_18":156,"_20":157,"_21":158,"_31":61,"_33":164},"mfem.bilinearForms.addElasticityIntegrator","mfem.bilinearForms.addElasticityIntegrator(blf, lambda, mu)","Add a linear elasticity integrator to the bilinear form.\r","Add a linear elasticity integrator to the bilinear form.\r\n\r\nImplements the bilinear form for linear elasticity:\r\na(u,v) = ∫ λ(∇·u)(∇·v) + 2μ ε(u):ε(v) dx\r\n\r\nwhere:\r\n- λ (lambda) is the first Lamé parameter\r\n- μ (mu) is the second Lamé parameter (shear modulus)\r\n- ε is the strain tensor: ε(u) = (∇u + (∇u)ᵀ)/2",[159,160,162],{"_14":56,"_20":57,"_26":6},{"_14":110,"_20":161,"_26":6},"- Lamé first parameter (scalar coefficient)",{"_14":113,"_20":163,"_26":6},"- Shear modulus / Lamé second parameter (scalar coefficient)",[],{"_14":166,"_16":167,"_18":168,"_20":168,"_21":169,"_31":61,"_33":171},"mfem.bilinearForms.addGradientIntegrator","mfem.bilinearForms.addGradientIntegrator(blf)","Add a gradient integrator to the bilinear form.",[170],{"_14":56,"_20":57,"_26":6},[],{"_14":173,"_16":174,"_18":175,"_20":176,"_21":177,"_31":61,"_33":180},"mfem.bilinearForms.addMassIntegrator","mfem.bilinearForms.addMassIntegrator(blf, coeff?)","Add a mass integrator (u, v) to the bilinear form.\r","Add a mass integrator (u, v) to the bilinear form.\r\n\r\nComputes: ∫ c * u * v dx",[178,179],{"_14":56,"_20":57,"_26":6},{"_14":59,"_20":60,"_26":30},[],{"_14":182,"_16":183,"_18":184,"_20":185,"_21":186,"_31":61,"_33":189},"mfem.bilinearForms.addVectorDiffusionIntegrator","mfem.bilinearForms.addVectorDiffusionIntegrator(blf, coeff?)","Add a vector diffusion integrator to the bilinear form.\r","Add a vector diffusion integrator to the bilinear form.\r\nFor vector-valued finite element functions.",[187,188],{"_14":56,"_20":57,"_26":6},{"_14":59,"_20":60,"_26":30},[],{"_14":191,"_16":192,"_18":193,"_20":194,"_21":195,"_31":61,"_33":198},"mfem.bilinearForms.addVectorMassIntegrator","mfem.bilinearForms.addVectorMassIntegrator(blf, coeff?)","Add a vector mass integrator (u · v) to the bilinear form.\r","Add a vector mass integrator (u · v) to the bilinear form.\r\nFor vector-valued finite element functions.\r\n\r\nComputes: ∫ c * u · v dx",[196,197],{"_14":56,"_20":57,"_26":6},{"_14":59,"_20":60,"_26":30},[],{"_14":200,"_16":201,"_18":202,"_20":202,"_21":203,"_31":61,"_33":208},"mfem.bilinearForms.assemble","mfem.bilinearForms.assemble(blf, skipZeros?)","Assemble bilinear form into sparse matrix.",[204,205],{"_14":56,"_20":57,"_26":6},{"_14":206,"_20":207,"_26":30},"skipZeros","- If true, skip storing zeros in the matrix (default: true)",[],{"_14":210,"_16":211,"_18":212,"_20":213,"_21":214,"_31":61,"_33":216},"mfem.bilinearForms.assemblePartial","mfem.bilinearForms.assemblePartial(blf)","Partial assembly for matrix-free operations.\r","Partial assembly for matrix-free operations.\r\nSets the assembly level to PARTIAL and then assembles.",[215],{"_14":56,"_20":57,"_26":6},[],{"_14":218,"_16":219,"_18":220,"_20":220,"_21":221,"_31":225,"_33":226},"mfem.bilinearForms.create","mfem.bilinearForms.create(fespace)","Create a bilinear form on a finite element space.",[222],{"_14":223,"_20":224,"_26":6},"fespace","- FiniteElementSpace instance","Promise",[],{"_14":228,"_16":229,"_18":230,"_20":231,"_21":232,"_31":61,"_33":243},"mfem.bilinearForms.eliminateEssentialBC","mfem.bilinearForms.eliminateEssentialBC(blf, essentialDofs, sol, rhs)","Eliminate essential BCs from system.\r","Eliminate essential BCs from system.\r\nModifies the RHS vector in place for non-homogeneous boundary conditions.",[233,234,237,240],{"_14":56,"_20":57,"_26":6},{"_14":235,"_20":236,"_26":6},"essentialDofs","- Essential DOF indices",{"_14":238,"_20":239,"_26":6},"sol","- Solution vector with boundary values",{"_14":241,"_20":242,"_26":6},"rhs","- Right-hand side vector (modified in place)",[],{"_14":245,"_16":246,"_18":247,"_20":248,"_21":249,"_31":253,"_33":254},"mfem.bilinearForms.formSystemMatrix","mfem.bilinearForms.formSystemMatrix(blf, essentialDofs)","Form system matrix with essential BC elimination.\r","Form system matrix with essential BC elimination.\r\nWorks with static condensation if enabled.",[250,252],{"_14":56,"_20":251,"_26":6},"- BilinearForm instance (must be assembled first)",{"_14":235,"_20":236,"_26":6},"SparseMatrix",[],{"_14":256,"_16":257,"_18":258,"_20":258,"_21":259,"_31":253,"_33":261},"mfem.bilinearForms.getMatrix","mfem.bilinearForms.getMatrix(blf)","Get assembled sparse matrix from a bilinear form.",[260],{"_14":56,"_20":251,"_26":6},[],{"_14":263,"_16":264,"_18":265,"_20":265,"_21":266,"_31":273,"_33":274},"mfem.bilinearForms.createMixed","mfem.bilinearForms.createMixed(trialFES, testFES)","Create a mixed bilinear form on trial and test spaces.",[267,270],{"_14":268,"_20":269,"_26":6},"trialFES","- Trial FiniteElementSpace",{"_14":271,"_20":272,"_26":6},"testFES","- Test FiniteElementSpace","Promise",[],{"_14":276,"_16":277,"_18":278,"_20":278,"_21":279,"_31":225,"_33":282},"mfem.bilinearForms.BilinearForm.create","mfem.bilinearForms.BilinearForm.create(fespace)","Creates a new bilinear form on the specified finite element space.",[280],{"_14":223,"_20":281,"_26":6},"- The finite element space",[],{"_14":284,"_16":285,"_18":286,"_20":286,"_21":287,"_31":273,"_33":294},"mfem.bilinearForms.MixedBilinearForm.create","mfem.bilinearForms.MixedBilinearForm.create(trialFespace, testFespace)","Creates a new mixed bilinear form.",[288,291],{"_14":289,"_20":290,"_26":6},"trialFespace","- The trial finite element space",{"_14":292,"_20":293,"_26":6},"testFespace","- The test finite element space",[],{"_14":296,"_16":297,"_18":298,"_20":298,"_21":299,"_31":303,"_33":304},"mfem.block.BlockMatrix.createSquare","mfem.block.BlockMatrix.createSquare(offsets)","Create a square BlockMatrix with the same offsets for rows and columns.",[300],{"_14":301,"_20":302,"_26":6},"offsets","- Block offsets array (used for both rows and columns)","Promise",[],{"_14":306,"_16":307,"_18":308,"_20":308,"_21":309,"_31":303,"_33":316},"mfem.block.BlockMatrix.create","mfem.block.BlockMatrix.create(rowOffsets, colOffsets)","Create a rectangular BlockMatrix with different row and column offsets.",[310,313],{"_14":311,"_20":312,"_26":6},"rowOffsets","- Row block offsets array",{"_14":314,"_20":315,"_26":6},"colOffsets","- Column block offsets array",[],{"_14":318,"_16":319,"_18":320,"_20":321,"_21":322,"_31":303,"_33":326},"mfem.block.BlockMatrix.fromPointer","mfem.block.BlockMatrix.fromPointer(ptr)","Creates a BlockMatrix from an existing WASM pointer.\r","Creates a BlockMatrix from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[323],{"_14":324,"_20":325,"_26":6},"ptr","- WASM pointer to an existing MFEM BlockMatrix",[],{"_14":328,"_16":329,"_18":330,"_20":330,"_21":331,"_31":333,"_33":334},"mfem.block.BlockOperator.createSquare","mfem.block.BlockOperator.createSquare(offsets)","Create a square BlockOperator with the same offsets for rows and columns.",[332],{"_14":301,"_20":302,"_26":6},"Promise",[],{"_14":336,"_16":337,"_18":338,"_20":338,"_21":339,"_31":333,"_33":342},"mfem.block.BlockOperator.create","mfem.block.BlockOperator.create(rowOffsets, colOffsets)","Create a rectangular BlockOperator with different row and column offsets.",[340,341],{"_14":311,"_20":312,"_26":6},{"_14":314,"_20":315,"_26":6},[],{"_14":344,"_16":345,"_18":346,"_20":347,"_21":348,"_31":333,"_33":351},"mfem.block.BlockOperator.fromPointer","mfem.block.BlockOperator.fromPointer(ptr)","Creates a BlockOperator from an existing WASM pointer.\r","Creates a BlockOperator from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[349],{"_14":324,"_20":350,"_26":6},"- WASM pointer to an existing MFEM BlockOperator",[],{"_14":353,"_16":354,"_18":355,"_20":355,"_21":356,"_31":359,"_33":360},"mfem.block.BlockVector.create","mfem.block.BlockVector.create(offsets)","Create a new BlockVector with the specified block offsets.",[357],{"_14":301,"_20":358,"_26":6},"- Array where offsets[i+1] - offsets[i] defines block i size","Promise",[],{"_14":362,"_16":363,"_18":364,"_20":365,"_21":366,"_31":359,"_33":371},"mfem.block.BlockVector.fromPointer","mfem.block.BlockVector.fromPointer(ptr, offsets)","Creates a BlockVector from an existing WASM pointer.\r","Creates a BlockVector from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[367,369],{"_14":324,"_20":368,"_26":6},"- WASM pointer to an existing MFEM BlockVector",{"_14":301,"_20":370,"_26":6},"- Block offsets array",[],{"_14":373,"_16":374,"_18":375,"_20":375,"_21":376,"_31":389,"_33":390},"mfem.boundaryConditions.addBoundaryRobinIntegrator","mfem.boundaryConditions.addBoundaryRobinIntegrator(blf, lf, alpha, g, bdrAttrs)","Add Robin boundary condition integrator (legacy name)",[377,379,382,384,386],{"_14":56,"_20":378,"_26":6},"BilinearForm",{"_14":380,"_20":381,"_26":6},"lf","LinearForm",{"_14":74,"_20":383,"_26":6},"number | CoefficientLike_15",{"_14":385,"_20":383,"_26":6},"g",{"_14":387,"_20":388,"_26":6},"bdrAttrs","number[]","Promise",[],{"_14":392,"_16":393,"_18":394,"_20":395,"_21":396,"_31":389,"_33":407},"mfem.boundaryConditions.addRobinBC","mfem.boundaryConditions.addRobinBC(bf, lf, alpha, g, bdrAttrs)","Add Robin boundary condition: alpha*u + du/dn = g\r","Add Robin boundary condition: alpha*u + du/dn = g\r\n\r\nThis function adds the necessary integrators to both the bilinear form\r\nand linear form to implement Robin boundary conditions on specified\r\nboundary attributes.",[397,399,401,403,405],{"_14":398,"_20":57,"_26":6},"bf",{"_14":380,"_20":400,"_26":6},"- LinearForm instance",{"_14":74,"_20":402,"_26":6},"- Coefficient for u term (scalar value or CoefficientLike)",{"_14":385,"_20":404,"_26":6},"- RHS coefficient g (scalar value or CoefficientLike)",{"_14":387,"_20":406,"_26":6},"- Array of boundary attributes where Robin BC applies",[],{"_14":409,"_16":410,"_18":411,"_20":412,"_21":413,"_31":61,"_33":424},"mfem.boundaryConditions.applyEssentialBC","mfem.boundaryConditions.applyEssentialBC(blf, essentialDofs, x, b)","Apply essential boundary conditions to a linear system.\r","Apply essential boundary conditions to a linear system.\r\nThis modifies the RHS vector to account for known Dirichlet values.",[414,416,418,421],{"_14":56,"_20":415,"_26":6},"- BilinearForm instance (system matrix)",{"_14":235,"_20":417,"_26":6},"- Array of essential DOF indices",{"_14":419,"_20":420,"_26":6},"x","- GridFunction with Dirichlet values set",{"_14":422,"_20":423,"_26":6},"b","- LinearForm (RHS) to modify",[],{"_14":426,"_16":427,"_18":428,"_20":429,"_21":430,"_31":436,"_33":437},"mfem.boundaryConditions.createBdrMarkerArray","mfem.boundaryConditions.createBdrMarkerArray(mesh, bdrAttrs)","Create a boundary marker array from a mesh and list of boundary attributes.\r","Create a boundary marker array from a mesh and list of boundary attributes.\r\n\r\nThis function creates an array where each element corresponds to a boundary\r\nattribute. The value is 1 if the attribute is in the given list, 0 otherwise.",[431,434],{"_14":432,"_20":433,"_26":6},"mesh","- Mesh instance",{"_14":387,"_20":435,"_26":6},"- Array of boundary attribute numbers to mark (1-based)","Int32Array",[],{"_14":439,"_16":440,"_18":441,"_20":442,"_21":443,"_31":61,"_33":449},"mfem.boundaryConditions.eliminateEssentialBC","mfem.boundaryConditions.eliminateEssentialBC(blf, essentialDofs, diagPolicy?)","Eliminate essential boundary conditions from a bilinear form.\r","Eliminate essential boundary conditions from a bilinear form.\r\nModifies the system matrix to enforce the essential BCs.",[444,445,446],{"_14":56,"_20":57,"_26":6},{"_14":235,"_20":417,"_26":6},{"_14":447,"_20":448,"_26":30},"diagPolicy","- Diagonal policy (default: DIAG_ONE)",[],{"_14":451,"_16":452,"_18":453,"_20":453,"_21":454,"_31":388,"_33":458},"mfem.boundaryConditions.getEssentialTrueDofs","mfem.boundaryConditions.getEssentialTrueDofs(fespace, bdrAttrs)","Get essential true DOF indices for given boundary attributes.",[455,456],{"_14":223,"_20":224,"_26":6},{"_14":387,"_20":457,"_26":6},"- Array of boundary attribute numbers",[],{"_14":460,"_16":461,"_18":462,"_20":463,"_21":464,"_31":470,"_33":471},"mfem.boundaryConditions.getPeriodicDofMapping","mfem.boundaryConditions.getPeriodicDofMapping(fespace, options)","Get periodic DOF correspondence for a finite element space.\r","Get periodic DOF correspondence for a finite element space.\r\n\r\nThis function computes which DOFs are identified as equivalent due to\r\nperiodicity, based on the provided translation vectors. DOFs whose\r\ncoordinates differ by a translation vector (within tolerance) are\r\nidentified as master/slave pairs.\r\n\r\n**Note:** In MFEM, periodic DOF identification is often handled internally\r\nthrough mesh vertex mapping when `Mesh::MakePeriodic` is called. This\r\nfunction provides explicit DOF mapping when needed for custom handling.",[465,467],{"_14":223,"_20":466,"_26":6},"- FiniteElementSpace (typically on a periodic mesh)",{"_14":468,"_20":469,"_26":6},"options","- Configuration including translation vectors and tolerance","Promise",[],{"_14":473,"_16":474,"_18":475,"_20":476,"_21":477,"_31":486,"_33":487},"mfem.boundaryConditions.createPeriodicMesh","mfem.boundaryConditions.createPeriodicMesh(mesh, translations, tol?)","Create a periodic mesh from translation vectors.\r","Create a periodic mesh from translation vectors.\r\n\r\nThis function identifies vertices that should be treated as equivalent\r\nunder the given translations and creates a new mesh with these vertices\r\nmerged. The result is a mesh suitable for periodic boundary conditions.",[478,480,483],{"_14":432,"_20":479,"_26":6},"- Original mesh",{"_14":481,"_20":482,"_26":6},"translations","- Array of translation vectors defining periodicity.\r\n For 2D: `[[Lx, 0], [0, Ly]]` for x and y periodicity\r\n For 3D: `[[Lx, 0, 0], [0, Ly, 0], [0, 0, Lz]]`",{"_14":484,"_20":485,"_26":30},"tol","- Tolerance for vertex matching (relative to mesh diameter).\r\n Default is 1e-8.","Promise",[],{"_14":489,"_16":490,"_18":491,"_20":491,"_21":492,"_31":495,"_33":498},"mfem.boundaryConditions.makePeriodic","mfem.boundaryConditions.makePeriodic(_fespace, _mesh)","Create periodic finite element space (legacy name).",[493,496],{"_14":494,"_20":495,"_26":6},"_fespace","unknown",{"_14":497,"_20":495,"_26":6},"_mesh",[],{"_14":500,"_16":501,"_18":502,"_20":503,"_21":504,"_31":510,"_33":511},"mfem.boundaryConditions.createPeriodicVertexMapping","mfem.boundaryConditions.createPeriodicVertexMapping(mesh, translations, tol?)","Create periodic vertex mapping from translation vectors.\r","Create periodic vertex mapping from translation vectors.\r\n\r\nThis function identifies which vertices should be treated as equivalent\r\nunder the given translations. The returned mapping array can be used\r\nwith `makePeriodic` for advanced use cases.\r\n\r\nFor most use cases, prefer `createPeriodicMesh` which handles both\r\nthe mapping and mesh creation in one step.",[505,507,509],{"_14":432,"_20":506,"_26":6},"- Mesh to analyze",{"_14":481,"_20":508,"_26":6},"- Array of translation vectors defining periodicity",{"_14":484,"_20":485,"_26":30},"Promise",[],{"_14":513,"_16":514,"_18":515,"_20":515,"_21":516,"_31":61,"_33":521},"mfem.boundaryConditions.makePeriodicVertices","mfem.boundaryConditions.makePeriodicVertices(_mesh, _v2v)","Set periodic vertex mapping on mesh (legacy name).",[517,518],{"_14":497,"_20":495,"_26":6},{"_14":519,"_20":520,"_26":6},"_v2v","number[][]",[],{"_14":523,"_16":524,"_18":525,"_20":525,"_21":526,"_31":530,"_33":531},"mfem.coefficients.constant","mfem.coefficients.constant(value)","Create a constant scalar coefficient.",[527],{"_14":528,"_20":529,"_26":6},"value","- Constant value","Promise",[],{"_14":533,"_16":534,"_18":535,"_20":535,"_21":536,"_31":543,"_33":544},"mfem.coefficients.crossProduct","mfem.coefficients.crossProduct(v1, v2)","Create a cross product coefficient from two vector coefficients.",[537,540],{"_14":538,"_20":539,"_26":6},"v1","- First vector coefficient (must be 3D)",{"_14":541,"_20":542,"_26":6},"v2","- Second vector coefficient (must be 3D)","Promise",[],{"_14":546,"_16":547,"_18":548,"_20":548,"_21":549,"_31":553,"_33":554},"mfem.coefficients.curl","mfem.coefficients.curl(gf)","Create a curl vector coefficient from a vector GridFunction.",[550],{"_14":551,"_20":552,"_26":6},"gf","- Vector GridFunction instance","Promise",[],{"_14":556,"_16":557,"_18":558,"_20":558,"_21":559,"_31":566,"_33":567},"mfem.coefficients.delta","mfem.coefficients.delta(center, weight?)","Create a Dirac delta coefficient (point source).",[560,563],{"_14":561,"_20":562,"_26":6},"center","- Center point of the delta function",{"_14":564,"_20":565,"_26":30},"weight","- Weight (scale) of the delta function (defaults to 1.0)","Promise",[],{"_14":569,"_16":570,"_18":571,"_20":571,"_21":572,"_31":576,"_33":577},"mfem.coefficients.diagonal","mfem.coefficients.diagonal(values)","Create a diagonal matrix coefficient from an array of values.",[573],{"_14":574,"_20":575,"_26":6},"values","- Array of diagonal values","Promise",[],{"_14":579,"_16":580,"_18":581,"_20":581,"_21":582,"_31":584,"_33":585},"mfem.coefficients.divergence","mfem.coefficients.divergence(gf)","Create a divergence scalar coefficient from a vector GridFunction.",[583],{"_14":551,"_20":552,"_26":6},"Promise",[],{"_14":587,"_16":588,"_18":589,"_20":589,"_21":590,"_31":593,"_33":594},"mfem.coefficients.functionCoefficient","mfem.coefficients.functionCoefficient(fn)","Create a coefficient from a JavaScript function.",[591],{"_14":24,"_20":592,"_26":6},"- Function (x, y, z) => number","Promise",[],{"_14":596,"_16":597,"_18":598,"_20":598,"_21":599,"_31":602,"_33":603},"mfem.coefficients.gradient","mfem.coefficients.gradient(gf)","Create a gradient vector coefficient from a scalar GridFunction.",[600],{"_14":551,"_20":601,"_26":6},"- Scalar GridFunction instance","Promise",[],{"_14":605,"_16":606,"_18":607,"_20":607,"_21":608,"_31":614,"_33":615},"mfem.coefficients.gridFunctionCoefficient","mfem.coefficients.gridFunctionCoefficient(gf, component?)","Create a coefficient from a GridFunction.",[609,611],{"_14":551,"_20":610,"_26":6},"- GridFunction instance",{"_14":612,"_20":613,"_26":30},"component","- Component to use (1-based, for vector GridFunctions)","Promise",[],{"_14":617,"_16":618,"_18":619,"_20":619,"_21":620,"_31":623,"_33":624},"mfem.coefficients.identity","mfem.coefficients.identity(dim)","Create an identity matrix coefficient.",[621],{"_14":28,"_20":622,"_26":6},"- Dimension of the identity matrix","Promise",[],{"_14":626,"_16":627,"_18":628,"_20":628,"_21":629,"_31":634,"_33":635},"mfem.coefficients.innerProduct","mfem.coefficients.innerProduct(v1, v2)","Create an inner product coefficient from two vector coefficients.",[630,632],{"_14":538,"_20":631,"_26":6},"- First vector coefficient",{"_14":541,"_20":633,"_26":6},"- Second vector coefficient","Promise",[],{"_14":637,"_16":638,"_18":639,"_20":639,"_21":640,"_31":644,"_33":645},"mfem.coefficients.inverse","mfem.coefficients.inverse(m)","Create an inverse of a matrix coefficient.",[641],{"_14":642,"_20":643,"_26":6},"m","- Matrix coefficient to invert","Promise",[],{"_14":647,"_16":648,"_18":649,"_20":649,"_21":650,"_31":653,"_33":654},"mfem.coefficients.matrixConstant","mfem.coefficients.matrixConstant(values)","Create a constant matrix coefficient.",[651],{"_14":574,"_20":652,"_26":6},"- 2D array of values (row-major)","Promise",[],{"_14":656,"_16":657,"_18":658,"_20":658,"_21":659,"_31":668,"_33":669},"mfem.coefficients.matrixFunction","mfem.coefficients.matrixFunction(fn, height, width?)","Create a matrix coefficient from a JavaScript function.",[660,662,665],{"_14":24,"_20":661,"_26":6},"- Function (x, y, z) => number[][]",{"_14":663,"_20":664,"_26":6},"height","- Number of rows",{"_14":666,"_20":667,"_26":30},"width","- Number of columns (defaults to height)","Promise",[],{"_14":671,"_16":672,"_18":673,"_20":673,"_21":674,"_31":680,"_33":681},"mfem.coefficients.matrixProduct","mfem.coefficients.matrixProduct(a, b)","Create a matrix product coefficient from two matrix coefficients.",[675,678],{"_14":676,"_20":677,"_26":6},"a","- First matrix coefficient",{"_14":422,"_20":679,"_26":6},"- Second matrix coefficient","Promise",[],{"_14":683,"_16":684,"_18":685,"_20":685,"_21":686,"_31":690,"_33":691},"mfem.coefficients.normalizedVector","mfem.coefficients.normalizedVector(v)","Create a normalized vector coefficient from a vector coefficient.",[687],{"_14":688,"_20":689,"_26":6},"v","- Vector coefficient to normalize","Promise",[],{"_14":693,"_16":694,"_18":695,"_20":695,"_21":696,"_31":699,"_33":700},"mfem.coefficients.outerProduct","mfem.coefficients.outerProduct(a, b)","Create an outer product coefficient from two vector coefficients.",[697,698],{"_14":676,"_20":631,"_26":6},{"_14":422,"_20":633,"_26":6},"Promise",[],{"_14":702,"_16":703,"_18":704,"_20":704,"_21":705,"_31":708,"_33":709},"mfem.coefficients.piecewiseConstant","mfem.coefficients.piecewiseConstant(values)","Create a piecewise constant coefficient by element attribute.",[706],{"_14":574,"_20":707,"_26":6},"- Map of attribute number (1-based) to value","Promise",[],{"_14":711,"_16":712,"_18":713,"_20":713,"_21":714,"_31":717,"_33":718},"mfem.coefficients.position","mfem.coefficients.position(dim?)","Create a position vector coefficient that returns the spatial position x.",[715],{"_14":28,"_20":716,"_26":30},"- Spatial dimension (1, 2, or 3). Defaults to 3.","Promise",[],{"_14":720,"_16":721,"_18":722,"_20":722,"_21":723,"_31":730,"_33":731},"mfem.coefficients.power","mfem.coefficients.power(c, exponent)","Create a power of a coefficient.",[724,727],{"_14":725,"_20":726,"_26":6},"c","- Base coefficient",{"_14":728,"_20":729,"_26":6},"exponent","- Exponent value","Promise",[],{"_14":733,"_16":734,"_18":735,"_20":735,"_21":736,"_31":743,"_33":744},"mfem.coefficients.product","mfem.coefficients.product(c1, c2)","Create a product of two coefficients.",[737,740],{"_14":738,"_20":739,"_26":6},"c1","- First coefficient",{"_14":741,"_20":742,"_26":6},"c2","- Second coefficient","Promise",[],{"_14":746,"_16":747,"_18":748,"_20":748,"_21":749,"_31":753,"_33":754},"mfem.coefficients.quadratureFunctionCoefficient","mfem.coefficients.quadratureFunctionCoefficient(qf)","Create a coefficient from a scalar quadrature function.",[750],{"_14":751,"_20":752,"_26":6},"qf","- The quadrature function (vdim=1)","Promise",[],{"_14":756,"_16":757,"_18":758,"_20":758,"_21":759,"_31":762,"_33":763},"mfem.coefficients.vectorQuadratureFunctionCoefficient","mfem.coefficients.vectorQuadratureFunctionCoefficient(qf)","Create a vector coefficient from a quadrature function.",[760],{"_14":751,"_20":761,"_26":6},"- The quadrature function","Promise",[],{"_14":765,"_16":766,"_18":767,"_20":767,"_21":768,"_31":775,"_33":776},"mfem.coefficients.restricted","mfem.coefficients.restricted(baseCoeff, attributes)","Create a restricted coefficient from a base coefficient.",[769,772],{"_14":770,"_20":771,"_26":6},"baseCoeff","- The base coefficient to restrict",{"_14":773,"_20":774,"_26":6},"attributes","- Array of mesh attributes where the coefficient is active (1-based)","Promise",[],{"_14":778,"_16":779,"_18":780,"_20":780,"_21":781,"_31":787,"_33":788},"mfem.coefficients.scalarVectorProduct","mfem.coefficients.scalarVectorProduct(s, v)","Create a scalar-vector product coefficient.",[782,785],{"_14":783,"_20":784,"_26":6},"s","- Scalar coefficient",{"_14":688,"_20":786,"_26":6},"- Vector coefficient","Promise",[],{"_14":790,"_16":791,"_18":792,"_20":792,"_21":793,"_31":800,"_33":801},"mfem.coefficients.sum","mfem.coefficients.sum(c1, c2, alpha?, beta?)","Create a sum of two coefficients.",[794,795,796,798],{"_14":738,"_20":739,"_26":6},{"_14":741,"_20":742,"_26":6},{"_14":74,"_20":797,"_26":30},"- Scale factor for c1 (default 1.0)",{"_14":132,"_20":799,"_26":30},"- Scale factor for c2 (default 1.0)","Promise",[],{"_14":803,"_16":804,"_18":805,"_20":805,"_21":806,"_31":811,"_33":812},"mfem.coefficients.symmetric","mfem.coefficients.symmetric(fn, dim)","Create a symmetric matrix coefficient from a JavaScript function.",[807,809],{"_14":24,"_20":808,"_26":6},"- Function (position: number[]) => number[][]",{"_14":28,"_20":810,"_26":6},"- Dimension of the symmetric matrix","Promise",[],{"_14":814,"_16":815,"_18":816,"_20":816,"_21":817,"_31":822,"_33":823},"mfem.coefficients.transformed","mfem.coefficients.transformed(coeff, fn)","Create a transformed coefficient that applies a function to another coefficient.",[818,820],{"_14":59,"_20":819,"_26":6},"- Source coefficient to transform",{"_14":24,"_20":821,"_26":6},"- Transformation function (value) => transformedValue","Promise",[],{"_14":825,"_16":826,"_18":827,"_20":827,"_21":828,"_31":831,"_33":832},"mfem.coefficients.transpose","mfem.coefficients.transpose(m)","Create a transpose of a matrix coefficient.",[829],{"_14":642,"_20":830,"_26":6},"- Matrix coefficient to transpose","Promise",[],{"_14":834,"_16":835,"_18":836,"_20":836,"_21":837,"_31":841,"_33":842},"mfem.coefficients.vectorArray","mfem.coefficients.vectorArray(coeffs)","Create a vector coefficient from an array of scalar coefficients.",[838],{"_14":839,"_20":840,"_26":6},"coeffs","- Array of scalar coefficients for each component","Promise",[],{"_14":844,"_16":845,"_18":846,"_20":846,"_21":847,"_31":850,"_33":851},"mfem.coefficients.vectorConstant","mfem.coefficients.vectorConstant(values)","Create a constant vector coefficient.",[848],{"_14":574,"_20":849,"_26":6},"- Array of constant values","Promise",[],{"_14":853,"_16":854,"_18":855,"_20":855,"_21":856,"_31":861,"_33":862},"mfem.coefficients.vectorDelta","mfem.coefficients.vectorDelta(center, direction)","Create a vector Dirac delta coefficient (directional point source).",[857,858],{"_14":561,"_20":562,"_26":6},{"_14":859,"_20":860,"_26":6},"direction","- Direction vector of the source","Promise",[],{"_14":864,"_16":865,"_18":866,"_20":866,"_21":867,"_31":870,"_33":871},"mfem.coefficients.vectorRotProduct","mfem.coefficients.vectorRotProduct(a, b)","Create a 2D cross product (rotation product) of two vector coefficients.",[868,869],{"_14":676,"_20":631,"_26":6},{"_14":422,"_20":633,"_26":6},"Promise",[],{"_14":873,"_16":874,"_18":875,"_20":875,"_21":876,"_31":530,"_33":879},"mfem.coefficients.ConstantCoefficient.create","mfem.coefficients.ConstantCoefficient.create(value)","Creates a new constant coefficient with the specified value.",[877],{"_14":528,"_20":878,"_26":6},"- The constant value",[],{"_14":881,"_16":882,"_18":883,"_20":883,"_21":884,"_31":553,"_33":887},"mfem.coefficients.CurlCoefficient.create","mfem.coefficients.CurlCoefficient.create(gf)","Creates a new curl coefficient from a vector GridFunction.",[885],{"_14":551,"_20":886,"_26":6},"- The vector GridFunction whose curl to compute",[],{"_14":889,"_16":890,"_18":891,"_20":891,"_21":892,"_31":566,"_33":896},"mfem.coefficients.DeltaCoefficient.create","mfem.coefficients.DeltaCoefficient.create(center, weight?)","Creates a new delta coefficient (point source).",[893,895],{"_14":561,"_20":894,"_26":6},"- Center point of the delta function [x] or [x, y] or [x, y, z]",{"_14":564,"_20":565,"_26":30},[],{"_14":898,"_16":899,"_18":900,"_20":900,"_21":901,"_31":576,"_33":904},"mfem.coefficients.DiagonalMatrixCoefficient.create","mfem.coefficients.DiagonalMatrixCoefficient.create(values)","Creates a new diagonal matrix coefficient.",[902],{"_14":574,"_20":903,"_26":6},"- Array of diagonal values. The length determines the matrix dimension.",[],{"_14":906,"_16":907,"_18":908,"_20":908,"_21":909,"_31":584,"_33":912},"mfem.coefficients.DivergenceCoefficient.create","mfem.coefficients.DivergenceCoefficient.create(gf)","Creates a new divergence coefficient from a vector GridFunction.",[910],{"_14":551,"_20":911,"_26":6},"- The vector GridFunction whose divergence to compute",[],{"_14":914,"_16":915,"_18":916,"_20":916,"_21":917,"_31":593,"_33":920},"mfem.coefficients.FunctionCoefficient.create","mfem.coefficients.FunctionCoefficient.create(fn)","Creates a new function coefficient with the specified evaluation function.",[918],{"_14":24,"_20":919,"_26":6},"- Function that takes (x, y, z) coordinates and returns a scalar value",[],{"_14":922,"_16":923,"_18":924,"_20":924,"_21":925,"_31":602,"_33":928},"mfem.coefficients.GradientCoefficient.create","mfem.coefficients.GradientCoefficient.create(gf)","Creates a new gradient coefficient from a scalar GridFunction.",[926],{"_14":551,"_20":927,"_26":6},"- The scalar GridFunction whose gradient to compute",[],{"_14":930,"_16":931,"_18":932,"_20":932,"_21":933,"_31":614,"_33":938},"mfem.coefficients.GridFunctionCoefficient.create","mfem.coefficients.GridFunctionCoefficient.create(gf, component?)","Creates a new GridFunction coefficient.",[934,936],{"_14":551,"_20":935,"_26":6},"- The GridFunction to evaluate",{"_14":612,"_20":937,"_26":30},"- Component to use for vector GridFunctions (1-based, default 1)",[],{"_14":940,"_16":941,"_18":942,"_20":942,"_21":943,"_31":653,"_33":950},"mfem.coefficients.MatrixConstantCoefficient.create","mfem.coefficients.MatrixConstantCoefficient.create(values, height?, width?)","Creates a new constant matrix coefficient with the specified values.",[944,946,948],{"_14":574,"_20":945,"_26":6},"- 2D array of values (row-major) or 1D array with explicit dimensions",{"_14":663,"_20":947,"_26":30},"- Number of rows (required if values is 1D array)",{"_14":666,"_20":949,"_26":30},"- Number of columns (required if values is 1D array)",[],{"_14":952,"_16":953,"_18":954,"_20":954,"_21":955,"_31":668,"_33":961},"mfem.coefficients.MatrixFunctionCoefficient.create","mfem.coefficients.MatrixFunctionCoefficient.create(fn, height, width?)","Creates a new matrix function coefficient.",[956,958,959],{"_14":24,"_20":957,"_26":6},"- Function that takes (x, y, z) and returns a 2D array",{"_14":663,"_20":664,"_26":6},{"_14":666,"_20":960,"_26":30},"- Number of columns (defaults to height for square matrices)",[],{"_14":963,"_16":964,"_18":965,"_20":965,"_21":966,"_31":680,"_33":969},"mfem.coefficients.MatrixProductCoefficient.create","mfem.coefficients.MatrixProductCoefficient.create(a, b)","Creates a new matrix product coefficient: A * B",[967,968],{"_14":676,"_20":677,"_26":6},{"_14":422,"_20":679,"_26":6},[],{"_14":971,"_16":972,"_18":973,"_20":973,"_21":974,"_31":690,"_33":976},"mfem.coefficients.NormalizedVectorCoefficient.create","mfem.coefficients.NormalizedVectorCoefficient.create(v)","Creates a new normalized vector coefficient: v / ||v||",[975],{"_14":688,"_20":689,"_26":6},[],{"_14":978,"_16":979,"_18":980,"_20":980,"_21":981,"_31":708,"_33":984},"mfem.coefficients.PWConstCoefficient.create","mfem.coefficients.PWConstCoefficient.create(values)","Creates a new piecewise constant coefficient.",[982],{"_14":574,"_20":983,"_26":6},"- Array of values for each attribute (index i corresponds to attribute i+1)",[],{"_14":986,"_16":987,"_18":988,"_20":988,"_21":989,"_31":708,"_33":993},"mfem.coefficients.PWConstCoefficient.createFromMap","mfem.coefficients.PWConstCoefficient.createFromMap(attrValues)","Creates a new piecewise constant coefficient from a Map.",[990],{"_14":991,"_20":992,"_26":6},"attrValues","- Map of attribute numbers (1-based) to values",[],{"_14":995,"_16":996,"_18":997,"_20":997,"_21":998,"_31":717,"_33":1000},"mfem.coefficients.PositionVectorCoefficient.create","mfem.coefficients.PositionVectorCoefficient.create(dim?)","Creates a new position vector coefficient.",[999],{"_14":28,"_20":716,"_26":30},[],{"_14":1002,"_16":1003,"_18":1004,"_20":1004,"_21":1005,"_31":730,"_33":1009},"mfem.coefficients.PowerCoefficient.create","mfem.coefficients.PowerCoefficient.create(c, exponent)","Creates a new power coefficient: c^p",[1006,1007],{"_14":725,"_20":726,"_26":6},{"_14":728,"_20":1008,"_26":6},"- Power exponent",[],{"_14":1011,"_16":1012,"_18":1013,"_20":1013,"_21":1014,"_31":743,"_33":1017},"mfem.coefficients.ProductCoefficient.create","mfem.coefficients.ProductCoefficient.create(c1, c2)","Creates a new product coefficient: c1 * c2",[1015,1016],{"_14":738,"_20":739,"_26":6},{"_14":741,"_20":742,"_26":6},[],{"_14":1019,"_16":1020,"_18":1021,"_20":1021,"_21":1022,"_31":753,"_33":1025},"mfem.coefficients.QuadratureFunctionCoefficient.create","mfem.coefficients.QuadratureFunctionCoefficient.create(qf)","Creates a new coefficient from a scalar quadrature function.",[1023],{"_14":751,"_20":1024,"_26":6},"- The quadrature function (must have vdim=1)",[],{"_14":1027,"_16":1028,"_18":1029,"_20":1029,"_21":1030,"_31":762,"_33":1032},"mfem.coefficients.VectorQuadratureFunctionCoefficient.create","mfem.coefficients.VectorQuadratureFunctionCoefficient.create(qf)","Creates a new vector coefficient from a quadrature function.",[1031],{"_14":751,"_20":761,"_26":6},[],{"_14":1034,"_16":1035,"_18":1036,"_20":1036,"_21":1037,"_31":775,"_33":1040},"mfem.coefficients.RestrictedCoefficient.create","mfem.coefficients.RestrictedCoefficient.create(baseCoeff, attributes)","Creates a new restricted coefficient.",[1038,1039],{"_14":770,"_20":771,"_26":6},{"_14":773,"_20":774,"_26":6},[],{"_14":1042,"_16":1043,"_18":1044,"_20":1044,"_21":1045,"_31":787,"_33":1048},"mfem.coefficients.ScalarVectorProductCoefficient.create","mfem.coefficients.ScalarVectorProductCoefficient.create(s, v)","Creates a new scalar-vector product coefficient: s * v",[1046,1047],{"_14":783,"_20":784,"_26":6},{"_14":688,"_20":786,"_26":6},[],{"_14":1050,"_16":1051,"_18":1052,"_20":1052,"_21":1053,"_31":800,"_33":1058},"mfem.coefficients.SumCoefficient.create","mfem.coefficients.SumCoefficient.create(c1, c2, alpha?, beta?)","Creates a new sum coefficient: alpha * c1 + beta * c2",[1054,1055,1056,1057],{"_14":738,"_20":739,"_26":6},{"_14":741,"_20":742,"_26":6},{"_14":74,"_20":797,"_26":30},{"_14":132,"_20":799,"_26":30},[],{"_14":1060,"_16":1061,"_18":1062,"_20":1062,"_21":1063,"_31":811,"_33":1067},"mfem.coefficients.SymmetricMatrixCoefficient.create","mfem.coefficients.SymmetricMatrixCoefficient.create(fn, dim)","Creates a new symmetric matrix function coefficient.",[1064,1066],{"_14":24,"_20":1065,"_26":6},"- Function that takes position [x, y, z] and returns a symmetric 2D array",{"_14":28,"_20":810,"_26":6},[],{"_14":1069,"_16":1070,"_18":1071,"_20":1071,"_21":1072,"_31":822,"_33":1075},"mfem.coefficients.TransformedCoefficient.create","mfem.coefficients.TransformedCoefficient.create(coeff, fn)","Creates a new transformed coefficient: F(Q)",[1073,1074],{"_14":59,"_20":819,"_26":6},{"_14":24,"_20":821,"_26":6},[],{"_14":1077,"_16":1078,"_18":1079,"_20":1079,"_21":1080,"_31":841,"_33":1083},"mfem.coefficients.VectorArrayCoefficient.create","mfem.coefficients.VectorArrayCoefficient.create(dim)","Creates a new vector array coefficient of the specified dimension.",[1081],{"_14":28,"_20":1082,"_26":6},"- Vector dimension",[],{"_14":1085,"_16":1086,"_18":1087,"_20":1087,"_21":1088,"_31":850,"_33":1091},"mfem.coefficients.VectorConstantCoefficient.create","mfem.coefficients.VectorConstantCoefficient.create(values)","Creates a new constant vector coefficient with the specified values.",[1089],{"_14":574,"_20":1090,"_26":6},"- Array of constant values for each component",[],{"_14":1093,"_16":1094,"_18":1095,"_20":1095,"_21":1096,"_31":861,"_33":1100},"mfem.coefficients.VectorDeltaCoefficient.create","mfem.coefficients.VectorDeltaCoefficient.create(center, direction)","Creates a new vector delta coefficient (directional point source).",[1097,1098],{"_14":561,"_20":894,"_26":6},{"_14":859,"_20":1099,"_26":6},"- Direction vector of the source (must match spatial dimension)",[],{"_14":1102,"_16":1103,"_18":1104,"_20":1104,"_21":1105,"_31":32,"_33":1110},"mfem.coefficients.VectorFunctionCoefficient.create","mfem.coefficients.VectorFunctionCoefficient.create(fn, dim)","Creates a new vector function coefficient.",[1106,1108],{"_14":24,"_20":1107,"_26":6},"- Function that takes (x, y, z) and returns a vector",{"_14":28,"_20":1109,"_26":6},"- Output vector dimension",[],{"_14":1112,"_16":1113,"_18":1114,"_20":1114,"_21":1115,"_31":870,"_33":1118},"mfem.coefficients.VectorRotProductCoefficient.create","mfem.coefficients.VectorRotProductCoefficient.create(a, b)","Creates a new VectorRotProductCoefficient: A_x * B_y - A_y * B_x",[1116,1117],{"_14":676,"_20":631,"_26":6},{"_14":422,"_20":633,"_26":6},[],{"_14":1120,"_16":1121,"_18":1122,"_20":1123,"_21":1124,"_31":1131,"_33":1132},"mfem.eigenvalue.getEigenvalues","mfem.eigenvalue.getEigenvalues(solver, numEigs?)","Get computed eigenvalues after solve.\r","Get computed eigenvalues after solve.\r\n\r\nCall this after solve() to retrieve the computed eigenvalues.\r\nIf numEigs is not specified, returns all converged eigenvalues.",[1125,1128],{"_14":1126,"_20":1127,"_26":6},"solver","- LOBPCG solver instance with solved eigenvalues",{"_14":1129,"_20":1130,"_26":30},"numEigs","- Number of eigenvalues to retrieve (defaults to number of converged)","Float64Array",[],{"_14":1134,"_16":1135,"_18":1136,"_20":1137,"_21":1138,"_31":1142,"_33":1143},"mfem.eigenvalue.getEigenvectors","mfem.eigenvalue.getEigenvectors(eigenvectorMatrix)","getEigenvectors","",[1139],{"_14":1140,"_20":1141,"_26":6},"eigenvectorMatrix","DenseMatrix","Float64Array[]",[],{"_14":1145,"_16":1146,"_18":1147,"_20":1148,"_21":1149,"_31":61,"_33":1155},"mfem.eigenvalue.setNumModes","mfem.eigenvalue.setNumModes(solver, numModes)","Set the number of eigenvalues/eigenvectors to compute.\r","Set the number of eigenvalues/eigenvectors to compute.\r\n\r\nThis should match the number of columns in the eigenvector DenseMatrix\r\npassed to solve().",[1150,1152],{"_14":1126,"_20":1151,"_26":6},"- LOBPCG solver instance",{"_14":1153,"_20":1154,"_26":6},"numModes","- Number of eigenpairs to compute",[],{"_14":1157,"_16":1158,"_18":1159,"_20":1160,"_21":1161,"_31":61,"_33":1169},"mfem.eigenvalue.setOperators","mfem.eigenvalue.setOperators(solver, A, B?)","Set A and B operators for generalized eigenvalue problem Ax = λBx.\r","Set A and B operators for generalized eigenvalue problem Ax = λBx.\r\n\r\nFor standard eigenvalue problems (Ax = λx), only pass A.\r\nFor generalized problems (Ax = λBx), pass both A and B.",[1162,1163,1166],{"_14":1126,"_20":1151,"_26":6},{"_14":1164,"_20":1165,"_26":6},"A","- Stiffness matrix/operator A (e.g., SparseMatrix, BilinearForm)",{"_14":1167,"_20":1168,"_26":30},"B","- Mass matrix/operator B for generalized problem (optional)",[],{"_14":1171,"_16":1172,"_18":1173,"_20":1174,"_21":1175,"_31":61,"_33":1181},"mfem.eigenvalue.solve","mfem.eigenvalue.solve(solver, eigenvectors)","Solve the eigenvalue problem using LOBPCG.\r","Solve the eigenvalue problem using LOBPCG.\r\n\r\nSolves: Ax = λBx (generalized) or Ax = λx (standard if B is not set)\r\n\r\nThe eigenvectors will be stored as columns in the provided DenseMatrix.\r\nThe matrix should be pre-allocated with dimensions [nDofs × numModes].",[1176,1178],{"_14":1126,"_20":1177,"_26":6},"- LOBPCG solver instance (must have operators set)",{"_14":1179,"_20":1180,"_26":6},"eigenvectors","- DenseMatrix to store computed eigenvectors (columns are eigenvectors)",[],{"_14":1183,"_16":1184,"_18":1185,"_20":1186,"_21":1187,"_31":1191,"_33":1192},"mfem.eigenvalue.DenseMatrix.create","mfem.eigenvalue.DenseMatrix.create(height, width)","Creates a new dense matrix of specified dimensions.\r","Creates a new dense matrix of specified dimensions.\r\nElements are uninitialized.",[1188,1189],{"_14":663,"_20":664,"_26":6},{"_14":666,"_20":1190,"_26":6},"- Number of columns","Promise",[],{"_14":1194,"_16":1195,"_18":1196,"_20":1196,"_21":1197,"_31":1191,"_33":1200},"mfem.eigenvalue.DenseMatrix.zeros","mfem.eigenvalue.DenseMatrix.zeros(height, width)","Creates a zero matrix of specified dimensions.",[1198,1199],{"_14":663,"_20":664,"_26":6},{"_14":666,"_20":1190,"_26":6},[],{"_14":1202,"_16":1203,"_18":1204,"_20":1204,"_21":1205,"_31":1191,"_33":1209},"mfem.eigenvalue.DenseMatrix.identity","mfem.eigenvalue.DenseMatrix.identity(n)","Creates an identity matrix of size n x n.",[1206],{"_14":1207,"_20":1208,"_26":6},"n","- Matrix dimension",[],{"_14":1211,"_16":1212,"_18":1213,"_20":1213,"_21":1214,"_31":1191,"_33":1218},"mfem.eigenvalue.DenseMatrix.fromArray","mfem.eigenvalue.DenseMatrix.fromArray(data)","Creates a DenseMatrix from a 2D array.",[1215],{"_14":1216,"_20":1217,"_26":6},"data","- 2D array in row-major order (data[row][col])",[],{"_14":1220,"_16":1221,"_18":1222,"_20":1223,"_21":1224,"_31":1191,"_33":1230},"mfem.eigenvalue.DenseMatrix.fromPointer","mfem.eigenvalue.DenseMatrix.fromPointer(ptr, ownsMemory?)","Creates a DenseMatrix from an existing WASM pointer.\r","Creates a DenseMatrix from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[1225,1227],{"_14":324,"_20":1226,"_26":6},"- WASM pointer to an existing MFEM DenseMatrix",{"_14":1228,"_20":1229,"_26":30},"ownsMemory","- Whether this wrapper owns the memory (default: false)",[],{"_14":1232,"_16":1233,"_18":1234,"_20":1234,"_21":1235,"_31":1236,"_33":1237},"mfem.eigenvalue.LOBPCGSolver.create","mfem.eigenvalue.LOBPCGSolver.create()","Creates a new LOBPCG solver.",[],"Promise",[],{"_14":1239,"_16":1240,"_18":1241,"_20":1242,"_21":1243,"_31":1252,"_33":1253},"mfem.fespace.createDG","mfem.fespace.createDG(mesh, order, vdim?)","Creates a Discontinuous Galerkin (DG) finite element space.\r","Creates a Discontinuous Galerkin (DG) finite element space.\r\n\r\nThis is an alias for . DG spaces are L2 spaces used in\r\nDiscontinuous Galerkin methods, where numerical fluxes connect elements.\r\n\r\nDG methods are popular for:\r\n- Hyperbolic conservation laws\r\n- Advection-dominated transport\r\n- Problems with sharp gradients or shocks\r\n- hp-adaptivity",[1244,1246,1249],{"_14":432,"_20":1245,"_26":6},"- The mesh on which to define the space",{"_14":1247,"_20":1248,"_26":6},"order","- Polynomial order (0 = piecewise constant, 1 = linear, etc.)",{"_14":1250,"_20":1251,"_26":30},"vdim","- Vector dimension (default 1 for scalar fields)","Promise",[],{"_14":1255,"_16":1256,"_18":1257,"_20":1258,"_21":1259,"_31":1252,"_33":1264},"mfem.fespace.createH1","mfem.fespace.createH1(mesh, order, vdim?)","Creates an H1 (continuous Lagrange) finite element space.\r","Creates an H1 (continuous Lagrange) finite element space.\r\n\r\nH1 spaces use continuous piecewise polynomial functions that are globally\r\nconforming in H1 (functions with square-integrable first derivatives).\r\nThey are the most common choice for:\r\n- Scalar problems (heat transfer, Poisson equation)\r\n- Vector problems (elasticity, Stokes flow)",[1260,1261,1263],{"_14":432,"_20":1245,"_26":6},{"_14":1247,"_20":1262,"_26":6},"- Polynomial order (1 = linear, 2 = quadratic, 3 = cubic, etc.)",{"_14":1250,"_20":1251,"_26":30},[],{"_14":1266,"_16":1267,"_18":1268,"_20":1269,"_21":1270,"_31":1252,"_33":1275},"mfem.fespace.createH1Positive","mfem.fespace.createH1Positive(mesh, order, vdim?)","Creates an H1 finite element space with positive (Bernstein) basis.\r","Creates an H1 finite element space with positive (Bernstein) basis.\r\n\r\nBernstein basis functions are non-negative and form a partition of unity,\r\nmaking them ideal for applications requiring positivity preservation:\r\n- Concentration fields that must remain positive\r\n- Probability distributions\r\n- NURBS-like representations\r\n\r\nThe space has the same approximation properties as standard H1 but with\r\ndifferent basis function properties.",[1271,1272,1274],{"_14":432,"_20":1245,"_26":6},{"_14":1247,"_20":1273,"_26":6},"- Polynomial order (1 = linear, 2 = quadratic, etc.)",{"_14":1250,"_20":1251,"_26":30},[],{"_14":1277,"_16":1278,"_18":1279,"_20":1280,"_21":1281,"_31":1252,"_33":1286},"mfem.fespace.createHcurl","mfem.fespace.createHcurl(mesh, order)","Creates an H(curl) (Nedelec) finite element space.\r","Creates an H(curl) (Nedelec) finite element space.\r\n\r\nH(curl) spaces are designed for vector fields where the curl is well-defined\r\nand square-integrable. They are essential for:\r\n- Electromagnetics (electric field, magnetic vector potential)\r\n- Maxwell's equations\r\n- Edge element discretizations\r\n\r\nThe tangential component is continuous across element faces while the\r\nnormal component may be discontinuous.",[1282,1284],{"_14":432,"_20":1283,"_26":6},"- The mesh on which to define the space (must be 2D or 3D)",{"_14":1247,"_20":1285,"_26":6},"- Polynomial order (1 = lowest order Nedelec, etc.)",[],{"_14":1288,"_16":1289,"_18":1290,"_20":1291,"_21":1292,"_31":1252,"_33":1296},"mfem.fespace.createHdiv","mfem.fespace.createHdiv(mesh, order)","Creates an H(div) (Raviart-Thomas) finite element space.\r","Creates an H(div) (Raviart-Thomas) finite element space.\r\n\r\nH(div) spaces are designed for vector fields where the divergence is\r\nwell-defined and square-integrable. They are essential for:\r\n- Fluid flow (velocity fields)\r\n- Mixed finite element methods\r\n- Darcy flow and porous media\r\n- Magnetic flux density in electromagnetics\r\n\r\nThe normal component is continuous across element faces while the\r\ntangential component may be discontinuous.",[1293,1294],{"_14":432,"_20":1283,"_26":6},{"_14":1247,"_20":1295,"_26":6},"- Polynomial order (0 = lowest order RT, etc.)",[],{"_14":1298,"_16":1299,"_18":1300,"_20":1301,"_21":1302,"_31":1252,"_33":1306},"mfem.fespace.createL2","mfem.fespace.createL2(mesh, order, vdim?)","Creates an L2 (discontinuous) finite element space.\r","Creates an L2 (discontinuous) finite element space.\r\n\r\nL2 spaces use piecewise polynomial functions with no continuity constraints\r\nacross element boundaries. This allows for:\r\n- Discontinuous Galerkin (DG) methods\r\n- Higher accuracy for advection-dominated problems\r\n- Local conservation properties\r\n- Representation of discontinuous fields\r\n\r\nL2 spaces have more DOFs than H1 spaces for the same mesh and order,\r\nas each element has its own independent polynomial representation.",[1303,1304,1305],{"_14":432,"_20":1245,"_26":6},{"_14":1247,"_20":1248,"_26":6},{"_14":1250,"_20":1251,"_26":30},[],{"_14":1308,"_16":1309,"_18":1310,"_20":1311,"_21":1312,"_31":1252,"_33":1316},"mfem.fespace.createND","mfem.fespace.createND(mesh, order)","Creates a Nedelec (ND) finite element space.\r","Creates a Nedelec (ND) finite element space.\r\n\r\nThis is an alias for . Nedelec elements are edge elements\r\nthat conform to H(curl), named after Jean-Claude Nédélec who introduced them.\r\n\r\nCommon applications:\r\n- Electric field in electromagnetics\r\n- Magnetic vector potential\r\n- Any vector field where curl is the primary differential operator",[1313,1314],{"_14":432,"_20":1283,"_26":6},{"_14":1247,"_20":1315,"_26":6},"- Polynomial order (1 = lowest order, etc.)",[],{"_14":1318,"_16":1319,"_18":1320,"_20":1321,"_21":1322,"_31":1328,"_33":1329},"mfem.fespace.createNURBS","mfem.fespace.createNURBS(mesh, order?, vdim?)","Creates a NURBS finite element space.\r","Creates a NURBS finite element space.\r\n\r\nNURBS (Non-Uniform Rational B-Splines) spaces are used for isogeometric\r\nanalysis (IGA), where the same basis functions used for CAD geometry\r\nrepresentation are used for the finite element analysis. This provides\r\nexact geometry representation and higher continuity across elements.\r\n\r\nThe mesh must be a NURBS mesh (created from NURBS patch data). Standard\r\nmeshes created with `makeCartesian2D` or similar functions cannot be used.",[1323,1325,1327],{"_14":432,"_20":1324,"_26":6},"- A NURBS mesh instance (must have NURBS extension)",{"_14":1247,"_20":1326,"_26":30},"- Polynomial order. Use -1 or 0 for variable order (uses\r\n the mesh's native NURBS order from each patch)",{"_14":1250,"_20":1251,"_26":30},"FiniteElementSpace",[],{"_14":1331,"_16":1332,"_18":1333,"_20":1334,"_21":1335,"_31":1252,"_33":1339},"mfem.fespace.createRT","mfem.fespace.createRT(mesh, order)","Creates a Raviart-Thomas (RT) finite element space.\r","Creates a Raviart-Thomas (RT) finite element space.\r\n\r\nThis is an alias for . Raviart-Thomas elements are face\r\nelements that conform to H(div), named after Pierre-Arnaud Raviart and\r\nJean-Marie Thomas who introduced them.\r\n\r\nCommon applications:\r\n- Velocity in mixed formulations\r\n- Flux variables in conservation laws\r\n- Magnetic flux density",[1336,1337],{"_14":432,"_20":1283,"_26":6},{"_14":1247,"_20":1338,"_26":6},"- Polynomial order (0 = lowest order, etc.)",[],{"_14":1341,"_16":1342,"_18":1343,"_20":1344,"_21":1345,"_31":1347,"_33":1348},"mfem.fespace.getAllDofCoordinates","mfem.fespace.getAllDofCoordinates(fespace)","Gets the physical coordinates for all degrees of freedom in a finite element space.\r","Gets the physical coordinates for all degrees of freedom in a finite element space.\r\n\r\nThis function iterates over all elements in the mesh and collects the physical\r\ncoordinates of each DOF. For DOFs shared between elements, the coordinates from\r\nthe first encountered element are used.\r\n\r\n**Performance note:** This function allocates temporary WASM memory and iterates\r\nover all elements. For large meshes, consider caching the result.",[1346],{"_14":223,"_20":281,"_26":6},"Promise>",[],{"_14":1350,"_16":1351,"_18":1352,"_20":1353,"_21":1354,"_31":388,"_33":1359},"mfem.fespace.getBoundaryDofs","mfem.fespace.getBoundaryDofs(fespace, bdrAttr)","Gets the DOF indices on a boundary with a specific attribute.\r","Gets the DOF indices on a boundary with a specific attribute.\r\n\r\nReturns the true (global) DOF indices that lie on boundary elements\r\nwith the specified attribute. This is useful for applying Dirichlet\r\nboundary conditions on specific parts of the domain boundary.",[1355,1356],{"_14":223,"_20":281,"_26":6},{"_14":1357,"_20":1358,"_26":6},"bdrAttr","- The boundary attribute (1-based, as defined in the mesh)",[],{"_14":1361,"_16":1362,"_18":1363,"_20":1364,"_21":1365,"_31":436,"_33":1370},"mfem.fespace.getDofMap","mfem.fespace.getDofMap(fespace, elemIndex)","Gets the DOF indices for a specific element.\r","Gets the DOF indices for a specific element.\r\n\r\nReturns the global DOF indices associated with the specified element.\r\nThis is useful for assembling local element contributions into global\r\nmatrices and vectors.",[1366,1367],{"_14":223,"_20":281,"_26":6},{"_14":1368,"_20":1369,"_26":6},"elemIndex","- The element index (0-based)",[],{"_14":1372,"_16":1373,"_18":1374,"_20":1375,"_21":1376,"_31":388,"_33":1380},"mfem.fespace.getEssentialDofs","mfem.fespace.getEssentialDofs(fespace, bdrAttrs)","Gets the essential (Dirichlet) DOF indices for specified boundary attributes.\r","Gets the essential (Dirichlet) DOF indices for specified boundary attributes.\r\n\r\nReturns the true (global) DOF indices that should be constrained for\r\nDirichlet boundary conditions on the specified boundary attributes.\r\nMultiple boundary attributes can be specified to get DOFs from several\r\nboundary regions at once.",[1377,1378],{"_14":223,"_20":281,"_26":6},{"_14":387,"_20":1379,"_26":6},"- Array of boundary attributes (1-based, as defined in the mesh)",[],{"_14":1382,"_16":1383,"_18":1384,"_20":1385,"_21":1386,"_31":1388,"_33":1389},"mfem.fespace.order","mfem.fespace.order(fespace)","Gets the maximum polynomial order of the finite element space.\r","Gets the maximum polynomial order of the finite element space.\r\n\r\nFor spaces with variable order (hp-adaptivity), this returns the\r\nmaximum order across all elements.",[1387],{"_14":223,"_20":281,"_26":6},"number",[],{"_14":1391,"_16":1392,"_18":1257,"_20":1393,"_21":1394,"_31":1252,"_33":1399},"mfem.fespace.FiniteElementSpace.createH1","mfem.fespace.FiniteElementSpace.createH1(mesh, order, vdim?)","Creates an H1 (continuous Lagrange) finite element space.\r\n\r\nH1 spaces use continuous piecewise polynomial functions. They are the most\r\ncommon choice for scalar problems like heat transfer, and for vector problems\r\nlike elasticity.\r\n\r\n**Basis functions:**\r\n- Order 1: Linear (nodal values at vertices)\r\n- Order 2: Quadratic (nodal values at vertices and edge midpoints)\r\n- Order p: Polynomial of degree p",[1395,1396,1397],{"_14":432,"_20":1245,"_26":6},{"_14":1247,"_20":1273,"_26":6},{"_14":1250,"_20":1398,"_26":30},"- Vector dimension (default 1 for scalar fields, 2 or 3 for vector fields)",[],{"_14":1401,"_16":1402,"_18":1403,"_20":1404,"_21":1405,"_31":1388,"_33":1411},"mfem.gridfunction.computeError","mfem.gridfunction.computeError(gf, exactValue)","Computes the L2 error between a grid function and a constant exact solution.\r","Computes the L2 error between a grid function and a constant exact solution.\r\n\r\nThe L2 error is defined as:\r\n```\r\n||u - u_exact||_L2 = sqrt( ∫_Ω |u(x) - u_exact|² dx )\r\n```\r\n\r\nThis is useful for verifying solutions against known manufactured solutions\r\nor for convergence studies.",[1406,1408],{"_14":551,"_20":1407,"_26":6},"- GridFunction (numerical solution)",{"_14":1409,"_20":1410,"_26":6},"exactValue","- The constant exact solution value",[],{"_14":1413,"_16":1414,"_18":1415,"_20":1416,"_21":1417,"_31":1388,"_33":1426},"mfem.gridfunction.computeH1Error","mfem.gridfunction.computeH1Error(gf, coeffPtr?, dcoeffPtr?)","Computes the H1 error between a grid function and an exact solution.\r","Computes the H1 error between a grid function and an exact solution.\r\n\r\nThe H1 error combines the L2 error of the function and its gradient:\r\n||u - u_exact||_H1 = sqrt(||u - u_exact||²_L2 + ||∇u - ∇u_exact||²_L2)\r\n\r\nYou can provide either or both of:\r\n- The exact solution coefficient (for the L2 part)\r\n- The gradient of the exact solution (for the gradient part)",[1418,1420,1423],{"_14":551,"_20":1419,"_26":6},"- The grid function (numerical solution)",{"_14":1421,"_20":1422,"_26":30},"coeffPtr","- Pointer to Coefficient for exact solution (or 0 to skip L2 part)",{"_14":1424,"_20":1425,"_26":30},"dcoeffPtr","- Pointer to VectorCoefficient for exact gradient (or 0 to skip gradient part)",[],{"_14":1428,"_16":1429,"_18":1430,"_20":1431,"_21":1432,"_31":1388,"_33":1436},"mfem.gridfunction.computeL2ErrorCoeff","mfem.gridfunction.computeL2ErrorCoeff(gf, coeffPtr)","Computes the L2 error between a grid function and an exact solution\r","Computes the L2 error between a grid function and an exact solution\r\nrepresented as a scalar coefficient.\r\n\r\nThe L2 error is defined as:\r\n||u - u_exact||_L2 = sqrt(∫ |u(x) - u_exact(x)|² dx)",[1433,1434],{"_14":551,"_20":1419,"_26":6},{"_14":1421,"_20":1435,"_26":6},"- Pointer to a Coefficient representing the exact solution",[],{"_14":1438,"_16":1439,"_18":1440,"_20":1441,"_21":1442,"_31":1388,"_33":1448},"mfem.gridfunction.computeL2ErrorVCoeff","mfem.gridfunction.computeL2ErrorVCoeff(gf, vcoeffPtr)","Computes the L2 error between a vector grid function and an exact solution\r","Computes the L2 error between a vector grid function and an exact solution\r\nrepresented as a vector coefficient.\r\n\r\nThe L2 error is defined as:\r\n||u - u_exact||_L2 = sqrt(∫ |u(x) - u_exact(x)|² dx)\r\n\r\nwhere |·| is the Euclidean norm of the vector difference.",[1443,1445],{"_14":551,"_20":1444,"_26":6},"- The vector grid function (numerical solution)",{"_14":1446,"_20":1447,"_26":6},"vcoeffPtr","- Pointer to a VectorCoefficient representing the exact solution",[],{"_14":1450,"_16":1451,"_18":1452,"_20":1453,"_21":1454,"_31":1388,"_33":1457},"mfem.gridfunction.computeMaxError","mfem.gridfunction.computeMaxError(gf, coeffPtr)","Computes the maximum (L-infinity) error between a grid function and\r","Computes the maximum (L-infinity) error between a grid function and\r\nan exact solution represented as a coefficient.\r\n\r\nThe max error is defined as:\r\n||u - u_exact||_L∞ = max_x |u(x) - u_exact(x)|\r\n\r\nThis is useful for checking pointwise accuracy of a solution.",[1455,1456],{"_14":551,"_20":1419,"_26":6},{"_14":1421,"_20":1435,"_26":6},[],{"_14":1459,"_16":1460,"_18":1461,"_20":1462,"_21":1463,"_31":1388,"_33":1472},"mfem.gridfunction.computeW11Error","mfem.gridfunction.computeW11Error(gf, coeffPtr?, dcoeffPtr?, normType?)","Computes the W^{1,1} error between a grid function and an exact solution.\r","Computes the W^{1,1} error between a grid function and an exact solution.\r\n\r\nThe W^{1,1} norm uses L1 integrals instead of L2:\r\n||u - u_exact||_{W^{1,1}} = ∫ |u - u_exact| dx + ∫ |∇u - ∇u_exact| dx\r\n\r\nThis error measure is more robust to outliers than L2-based errors.",[1464,1465,1467,1469],{"_14":551,"_20":1419,"_26":6},{"_14":1421,"_20":1466,"_26":30},"- Pointer to Coefficient for exact solution (or 0 to skip)",{"_14":1424,"_20":1468,"_26":30},"- Pointer to VectorCoefficient for exact gradient (or 0 to skip)",{"_14":1470,"_20":1471,"_26":30},"normType","- Which components to include (default: BOTH)",[],{"_14":1474,"_16":1475,"_18":1476,"_20":1477,"_21":1478,"_31":1483,"_33":1484},"mfem.gridfunction.fromBinary","mfem.gridfunction.fromBinary(fespace, data)","Loads a grid function from a base64-encoded binary string with an existing FE space.\r","Loads a grid function from a base64-encoded binary string with an existing FE space.\r\n\r\nThis is the inverse of . The base64 string is decoded\r\nand parsed as an MFEM format grid function. You must provide the\r\nFiniteElementSpace that matches the saved data.",[1479,1481],{"_14":223,"_20":1480,"_26":6},"- The finite element space for the grid function",{"_14":1216,"_20":1482,"_26":6},"- Base64-encoded string containing grid function data","Promise",[],{"_14":1486,"_16":1487,"_18":1488,"_20":1489,"_21":1490,"_31":1483,"_33":1494},"mfem.gridfunction.fromBinaryWithMesh","mfem.gridfunction.fromBinaryWithMesh(mesh, data)","Loads a grid function from a base64-encoded binary string with auto-detected FE space.\r","Loads a grid function from a base64-encoded binary string with auto-detected FE space.\r\n\r\nThis is the inverse of . The base64 string is decoded\r\nand parsed as an MFEM format grid function. The FE space is automatically\r\nreconstructed from the saved header information.\r\n\r\nThe returned GridFunction owns its FESpace.",[1491,1493],{"_14":432,"_20":1492,"_26":6},"- The mesh for the grid function",{"_14":1216,"_20":1482,"_26":6},[],{"_14":1496,"_16":1497,"_18":1498,"_20":1499,"_21":1500,"_31":1483,"_33":1505},"mfem.gridfunction.fromCoefficient","mfem.gridfunction.fromCoefficient(fespace, value)","Creates a new grid function initialized with a constant value.\r","Creates a new grid function initialized with a constant value.\r\n\r\nThis is a convenience function that creates a grid function and projects\r\na constant coefficient onto it. For more complex coefficients, create a\r\ngrid function manually and use projection functions.",[1501,1503],{"_14":223,"_20":1502,"_26":6},"- The finite element space on which to define the function",{"_14":528,"_20":1504,"_26":6},"- The constant value to project",[],{"_14":1507,"_16":1508,"_18":1509,"_20":1510,"_21":1511,"_31":1483,"_33":1515},"mfem.gridfunction.fromFunction","mfem.gridfunction.fromFunction(fespace, fn)","Creates a new grid function initialized by evaluating a function at DOF locations.\r","Creates a new grid function initialized by evaluating a function at DOF locations.\r\n\r\nThe function is evaluated at the physical coordinates of each degree of freedom\r\n(node) in the finite element space. For Lagrange elements, these are the nodal\r\ninterpolation points.\r\n\r\n**Note:** This performs nodal interpolation, not L2 projection. For smoother\r\nresults with non-smooth functions, consider using L2 projection methods.",[1512,1513],{"_14":223,"_20":1502,"_26":6},{"_14":24,"_20":1514,"_26":6},"- Function that takes coordinates [x, y?, z?] and returns a scalar value",[],{"_14":1517,"_16":1518,"_18":1519,"_20":1520,"_21":1521,"_31":1483,"_33":1525},"mfem.gridfunction.fromMFEM","mfem.gridfunction.fromMFEM(fespace, data)","Loads a grid function from an MFEM format string into an existing GridFunction.\r","Loads a grid function from an MFEM format string into an existing GridFunction.\r\n\r\nThe GridFunction must already have an associated FiniteElementSpace that\r\nmatches the data being loaded. Use this when you already know the FE type\r\nand have created the space.",[1522,1523],{"_14":223,"_20":1480,"_26":6},{"_14":1216,"_20":1524,"_26":6},"- MFEM format grid function string",[],{"_14":1527,"_16":1528,"_18":1529,"_20":1530,"_21":1531,"_31":1483,"_33":1534},"mfem.gridfunction.fromMFEMWithMesh","mfem.gridfunction.fromMFEMWithMesh(mesh, data)","Creates a grid function from an MFEM format string with auto-detected FE space.\r","Creates a grid function from an MFEM format string with auto-detected FE space.\r\n\r\nThis function parses the FE collection information from the saved data header\r\nand automatically creates the appropriate FiniteElementSpace. Use this when\r\nloading a solution where you don't know the FE type in advance.\r\n\r\nThe returned GridFunction owns its FESpace, which will be destroyed when\r\nthe GridFunction is destroyed.",[1532,1533],{"_14":432,"_20":1492,"_26":6},{"_14":1216,"_20":1524,"_26":6},[],{"_14":1536,"_16":1537,"_18":1538,"_20":1539,"_21":1540,"_31":1131,"_33":1545},"mfem.gridfunction.getAllNodalValues","mfem.gridfunction.getAllNodalValues(gf, vdim?)","Gets the values of a grid function at all vertices of the mesh.\r","Gets the values of a grid function at all vertices of the mesh.\r\n\r\nThis returns one value per vertex for the entire mesh, which is useful\r\nfor visualization or post-processing. For vector-valued grid functions,\r\nyou can specify which component to extract.",[1541,1543],{"_14":551,"_20":1542,"_26":6},"- The grid function to evaluate",{"_14":1250,"_20":1544,"_26":30},"- Vector component to extract (1-based, default 1 for scalar)",[],{"_14":1547,"_16":1548,"_18":1549,"_20":1550,"_21":1551,"_31":388,"_33":1560},"mfem.gridfunction.getCurl","mfem.gridfunction.getCurl(gf, elemIdx, ip)","Computes the curl of a vector grid function at a point within an element.\r","Computes the curl of a vector grid function at a point within an element.\r\n\r\nThe curl is computed in physical coordinates:\r\n- In 3D: curl = [∂Fz/∂y - ∂Fy/∂z, ∂Fx/∂z - ∂Fz/∂x, ∂Fy/∂x - ∂Fx/∂y]\r\n- In 2D: curl is a scalar (z-component of the 3D curl)\r\n\r\nThis is typically used with H(curl) finite element spaces (Nedelec elements).",[1552,1554,1557],{"_14":551,"_20":1553,"_26":6},"- Vector GridFunction (e.g., from H(curl) space)",{"_14":1555,"_20":1556,"_26":6},"elemIdx","- Index of the element containing the point (0-based)",{"_14":1558,"_20":1559,"_26":6},"ip","- Integration point in reference coordinates",[],{"_14":1562,"_16":1563,"_18":1564,"_20":1565,"_21":1566,"_31":61,"_33":1578},"mfem.gridfunction.getDerivative","mfem.gridfunction.getDerivative(gf, comp, derComp, destGf)","Computes the derivative of a grid function component in a specified direction\r","Computes the derivative of a grid function component in a specified direction\r\nand projects it onto another grid function.\r\n\r\nThis computes ∂u_comp/∂x_derComp where comp is the component of a\r\nvector-valued function and derComp is the spatial direction.",[1567,1569,1572,1575],{"_14":551,"_20":1568,"_26":6},"- The source grid function",{"_14":1570,"_20":1571,"_26":6},"comp","- Component to differentiate (1-based: 1, 2, or 3)",{"_14":1573,"_20":1574,"_26":6},"derComp","- Direction of differentiation (1=x, 2=y, 3=z)",{"_14":1576,"_20":1577,"_26":6},"destGf","- Destination grid function (must be pre-created on same mesh)",[],{"_14":1580,"_16":1581,"_18":1582,"_20":1583,"_21":1584,"_31":1388,"_33":1589},"mfem.gridfunction.getDivergence","mfem.gridfunction.getDivergence(gf, elemIdx, ip)","Computes the divergence of a vector grid function at a point within an element.\r","Computes the divergence of a vector grid function at a point within an element.\r\n\r\nThe divergence is computed in physical coordinates:\r\ndiv(F) = ∂Fx/∂x + ∂Fy/∂y + ∂Fz/∂z\r\n\r\nThis is typically used with H(div) finite element spaces (Raviart-Thomas elements).",[1585,1587,1588],{"_14":551,"_20":1586,"_26":6},"- Vector GridFunction (e.g., from H(div) space)",{"_14":1555,"_20":1556,"_26":6},{"_14":1558,"_20":1559,"_26":6},[],{"_14":1591,"_16":1592,"_18":1593,"_20":1594,"_21":1595,"_31":388,"_33":1600},"mfem.gridfunction.getGradient","mfem.gridfunction.getGradient(gf, elemIdx, ip)","Computes the gradient of a scalar grid function at a point within an element.\r","Computes the gradient of a scalar grid function at a point within an element.\r\n\r\nThe gradient is computed in physical (not reference) coordinates. The result\r\nis a vector with components [∂f/∂x, ∂f/∂y, ∂f/∂z] (depending on dimension).",[1596,1598,1599],{"_14":551,"_20":1597,"_26":6},"- Scalar GridFunction to differentiate",{"_14":1555,"_20":1556,"_26":6},{"_14":1558,"_20":1559,"_26":6},[],{"_14":1602,"_16":1603,"_18":1604,"_20":1605,"_21":1606,"_31":1613,"_33":1614},"mfem.gridfunction.getGradients","mfem.gridfunction.getGradients(gf, elemIdx, points)","Computes gradients of a grid function at multiple integration points\r","Computes gradients of a grid function at multiple integration points\r\nwithin an element.\r\n\r\nThis is more efficient than calling multiple times\r\nwhen you need gradients at many points in the same element.",[1607,1608,1610],{"_14":551,"_20":1542,"_26":6},{"_14":1555,"_20":1609,"_26":6},"- Element index (0-based)",{"_14":1611,"_20":1612,"_26":6},"points","- Array of integration points in reference element coordinates","GradientsResult",[],{"_14":1616,"_16":1617,"_18":1618,"_20":1619,"_21":1620,"_31":1625,"_33":1626},"mfem.gridfunction.getHessian","mfem.gridfunction.getHessian(gf, elemIdx, ip)","Computes the Hessian matrix of a grid function at a point within an element.\r","Computes the Hessian matrix of a grid function at a point within an element.\r\n\r\nThe Hessian is the matrix of second partial derivatives:\r\n```\r\nH = | ∂²u/∂x² ∂²u/∂x∂y ∂²u/∂x∂z |\r\n | ∂²u/∂y∂x ∂²u/∂y² ∂²u/∂y∂z |\r\n | ∂²u/∂z∂x ∂²u/∂z∂y ∂²u/∂z² |\r\n```",[1621,1622,1623],{"_14":551,"_20":1542,"_26":6},{"_14":1555,"_20":1609,"_26":6},{"_14":1558,"_20":1624,"_26":6},"- Integration point in reference element coordinates","HessianResult",[],{"_14":1628,"_16":1629,"_18":1630,"_20":1631,"_21":1632,"_31":1388,"_33":1638},"mfem.gridfunction.getLaplacian","mfem.gridfunction.getLaplacian(gf, elemIdx, ip, vdim?)","Computes the Laplacian of a grid function at a point within an element.\r","Computes the Laplacian of a grid function at a point within an element.\r\n\r\nThe Laplacian is the sum of second partial derivatives:\r\nΔu = ∂²u/∂x² + ∂²u/∂y² + ∂²u/∂z²",[1633,1634,1635,1636],{"_14":551,"_20":1542,"_26":6},{"_14":1555,"_20":1609,"_26":6},{"_14":1558,"_20":1624,"_26":6},{"_14":1250,"_20":1637,"_26":30},"- Vector component (1-based, default 1 for scalar)",[],{"_14":1640,"_16":1641,"_18":1642,"_20":1643,"_21":1644,"_31":388,"_33":1648},"mfem.gridfunction.getNodalValues","mfem.gridfunction.getNodalValues(gf, elemIdx, vdim?)","Gets the values of a grid function at the vertices of a specific element.\r","Gets the values of a grid function at the vertices of a specific element.\r\n\r\nThis is simpler than using for extracting vertex values,\r\nas it directly returns all nodal values for an element without requiring\r\nintegration point coordinates.",[1645,1646,1647],{"_14":551,"_20":1542,"_26":6},{"_14":1555,"_20":1609,"_26":6},{"_14":1250,"_20":1544,"_26":30},[],{"_14":1650,"_16":1651,"_18":1652,"_20":1653,"_21":1654,"_31":1388,"_33":1659},"mfem.gridfunction.getValue","mfem.gridfunction.getValue(gf, elemIdx, ip)","Evaluates a grid function at a point within a specific element.\r","Evaluates a grid function at a point within a specific element.\r\n\r\nThe point is specified in reference (local) coordinates of the element.\r\nFor most elements, these coordinates range from 0 to 1.",[1655,1657,1658],{"_14":551,"_20":1656,"_26":6},"- GridFunction to evaluate",{"_14":1555,"_20":1556,"_26":6},{"_14":1558,"_20":1559,"_26":6},[],{"_14":1661,"_16":1662,"_18":1663,"_20":1664,"_21":1665,"_31":1131,"_33":1670},"mfem.gridfunction.getVectorFieldNodalValues","mfem.gridfunction.getVectorFieldNodalValues(gf, component)","Gets the values of a specific component of a vector-valued grid function\r","Gets the values of a specific component of a vector-valued grid function\r\nat all vertices of the mesh.\r\n\r\nThis is useful for extracting individual components (e.g., x-velocity,\r\ny-velocity) from a vector field for visualization or analysis.",[1666,1668],{"_14":551,"_20":1667,"_26":6},"- The vector GridFunction to evaluate",{"_14":612,"_20":1669,"_26":6},"- Component index (1-based: 1=x, 2=y, 3=z)",[],{"_14":1672,"_16":1673,"_18":1674,"_20":1675,"_21":1676,"_31":388,"_33":1680},"mfem.gridfunction.getVectorValue","mfem.gridfunction.getVectorValue(gf, elemIdx, ip)","Evaluates a vector-valued grid function at a point within an element.\r","Evaluates a vector-valued grid function at a point within an element.\r\n\r\nThis is the vector analog of . It returns all components\r\nof the vector field at the specified point.",[1677,1678,1679],{"_14":551,"_20":1667,"_26":6},{"_14":1555,"_20":1609,"_26":6},{"_14":1558,"_20":1624,"_26":6},[],{"_14":1682,"_16":1683,"_18":1684,"_20":1685,"_21":1686,"_31":1690,"_33":1691},"mfem.gridfunction.getVectorValues","mfem.gridfunction.getVectorValues(gf, elemIdx, points)","Evaluates a vector-valued grid function at multiple integration points within an element.\r","Evaluates a vector-valued grid function at multiple integration points within an element.\r\n\r\nThis is more efficient than calling multiple times\r\nwhen you need values at many points in the same element.",[1687,1688,1689],{"_14":551,"_20":1667,"_26":6},{"_14":1555,"_20":1609,"_26":6},{"_14":1611,"_20":1612,"_26":6},"VectorValuesResult",[],{"_14":1693,"_16":1694,"_18":1695,"_20":1696,"_21":1697,"_31":1388,"_33":1700},"mfem.gridfunction.normH1","mfem.gridfunction.normH1(gf)","Computes the H1 norm of a grid function.\r","Computes the H1 norm of a grid function.\r\n\r\nThe H1 norm is defined as:\r\n```\r\n||u||_H1 = sqrt( ||u||²_L2 + ||∇u||²_L2 )\r\n = sqrt( ∫_Ω |u(x)|² dx + ∫_Ω |∇u(x)|² dx )\r\n```\r\n\r\nThis norm measures both the function values and their derivatives,\r\nmaking it suitable for error analysis in elliptic PDEs.\r\n\r\n**Note:** This function returns the H1 seminorm (gradient norm only).\r\nTo get the full H1 norm, combine with the L2 norm:\r\n`sqrt(normL2(gf)**2 + normH1(gf)**2)`",[1698],{"_14":551,"_20":1699,"_26":6},"- GridFunction to compute norm of",[],{"_14":1702,"_16":1703,"_18":1704,"_20":1705,"_21":1706,"_31":1388,"_33":1708},"mfem.gridfunction.normL2","mfem.gridfunction.normL2(gf)","Computes the L2 norm of a grid function.\r","Computes the L2 norm of a grid function.\r\n\r\nThe L2 norm is defined as:\r\n```\r\n||u||_L2 = sqrt( ∫_Ω |u(x)|² dx )\r\n```\r\n\r\nThis is computed using numerical quadrature over all elements in the mesh.",[1707],{"_14":551,"_20":1699,"_26":6},[],{"_14":1710,"_16":1711,"_18":1712,"_20":1713,"_21":1714,"_31":1388,"_33":1716},"mfem.gridfunction.normLinf","mfem.gridfunction.normLinf(gf)","Computes the L-infinity (maximum) norm of a grid function.\r","Computes the L-infinity (maximum) norm of a grid function.\r\n\r\nThe L-infinity norm is defined as:\r\n```\r\n||u||_∞ = max |u(x)| over all x in Ω\r\n```\r\n\r\nIn practice, this is computed as the maximum absolute value of the DOF coefficients.",[1715],{"_14":551,"_20":1699,"_26":6},[],{"_14":1718,"_16":1719,"_18":1720,"_20":1721,"_21":1722,"_31":61,"_33":1729},"mfem.gridfunction.projectBdrCoefficient","mfem.gridfunction.projectBdrCoefficient(gf, value, bdrAttrs)","Projects a constant value onto boundary DOFs for specified boundary attributes.\r","Projects a constant value onto boundary DOFs for specified boundary attributes.\r\n\r\nThis sets the DOF values on the specified boundaries to the given constant value.\r\nIt is useful for applying Dirichlet boundary conditions where the boundary\r\nvalue is known.\r\n\r\nOnly DOFs that lie on boundary elements with the specified attributes are modified.\r\nInterior DOFs remain unchanged.",[1723,1725,1727],{"_14":551,"_20":1724,"_26":6},"- GridFunction to modify",{"_14":528,"_20":1726,"_26":6},"- The constant value to project on boundary",{"_14":387,"_20":1728,"_26":6},"- Array of boundary attributes (1-based) to apply the value to",[],{"_14":1731,"_16":1732,"_18":1733,"_20":1734,"_21":1735,"_31":61,"_33":1742},"mfem.gridfunction.projectBdrVectorCoefficient","mfem.gridfunction.projectBdrVectorCoefficient(gf, vcoeffPtr, bdrAttrs)","Projects a vector coefficient onto boundary DOFs of a grid function.\r","Projects a vector coefficient onto boundary DOFs of a grid function.\r\n\r\nThis sets the values of the grid function at boundary DOFs to match\r\nthe given vector coefficient. Interior DOFs are not modified.",[1736,1738,1740],{"_14":551,"_20":1737,"_26":6},"- The grid function to modify",{"_14":1446,"_20":1739,"_26":6},"- Pointer to a VectorCoefficient in WASM memory",{"_14":387,"_20":1741,"_26":6},"- Array of boundary attribute markers (1 = apply, 0 = skip)",[],{"_14":1744,"_16":1745,"_18":1746,"_20":1747,"_21":1748,"_31":61,"_33":1751},"mfem.gridfunction.projectCoefficient","mfem.gridfunction.projectCoefficient(gf, value)","Projects a constant coefficient onto a grid function.\r","Projects a constant coefficient onto a grid function.\r\n\r\nThis sets all DOF values such that the grid function represents\r\nthe constant function f(x) = value everywhere in the domain.\r\nThis is equivalent to calling `gf.projectConstant(value)`.",[1749,1750],{"_14":551,"_20":1724,"_26":6},{"_14":528,"_20":1504,"_26":6},[],{"_14":1753,"_16":1754,"_18":1755,"_20":1756,"_21":1757,"_31":61,"_33":1764},"mfem.gridfunction.projectDiscCoefficient","mfem.gridfunction.projectDiscCoefficient(gf, coeffPtr, avgType?)","Projects a discontinuous coefficient onto a grid function with averaging.\r","Projects a discontinuous coefficient onto a grid function with averaging.\r\n\r\nWhen a coefficient has different values on different sides of an element\r\ninterface, this function uses the specified averaging type to determine\r\nthe value at shared DOFs.",[1758,1759,1761],{"_14":551,"_20":1737,"_26":6},{"_14":1421,"_20":1760,"_26":6},"- Pointer to a Coefficient in WASM memory",{"_14":1762,"_20":1763,"_26":30},"avgType","- Averaging type for interface values (default: ARITHMETIC)",[],{"_14":1766,"_16":1767,"_18":1768,"_20":1769,"_21":1770,"_31":389,"_33":1773},"mfem.gridfunction.projectFunction","mfem.gridfunction.projectFunction(gf, fn)","Projects a JavaScript function onto a grid function using nodal interpolation.\r","Projects a JavaScript function onto a grid function using nodal interpolation.\r\n\r\nThe function is evaluated at the physical coordinates of each degree of freedom\r\nto determine the DOF values. For standard Lagrange elements, this corresponds\r\nto interpolation at the nodal points.\r\n\r\n**Note:** This function is async because it needs to compute DOF coordinates.",[1771,1772],{"_14":551,"_20":1724,"_26":6},{"_14":24,"_20":1514,"_26":6},[],{"_14":1775,"_16":1776,"_18":1777,"_20":1778,"_21":1779,"_31":61,"_33":1785},"mfem.gridfunction.projectGridFunction","mfem.gridfunction.projectGridFunction(destGf, srcGf)","Projects a source grid function onto a destination grid function.\r","Projects a source grid function onto a destination grid function.\r\n\r\nThis is useful for transferring solutions between different finite element\r\nspaces on the same mesh, or for initializing a grid function from an\r\nexisting solution.",[1780,1782],{"_14":1576,"_20":1781,"_26":6},"- The destination grid function to modify",{"_14":1783,"_20":1784,"_26":6},"srcGf","- The source grid function to project from",[],{"_14":1787,"_16":1788,"_18":1789,"_20":1790,"_21":1791,"_31":1794,"_33":1795},"mfem.gridfunction.save","mfem.gridfunction.save(gf)","Exports a grid function to MFEM format string.\r","Exports a grid function to MFEM format string.\r\n\r\nThe returned string can be saved to a file and later loaded back using\r\nMFEM's GridFunction constructor that takes a mesh and input stream.\r\n\r\nThe format includes the finite element collection type, ordering,\r\nand all DOF values.",[1792],{"_14":551,"_20":1793,"_26":6},"- GridFunction to export","string",[],{"_14":1797,"_16":1798,"_18":1799,"_20":1800,"_21":1801,"_31":1794,"_33":1804},"mfem.gridfunction.toBinary","mfem.gridfunction.toBinary(gf)","Exports a grid function to a base64-encoded binary string.\r","Exports a grid function to a base64-encoded binary string.\r\n\r\nThis provides a compact representation of the grid function suitable for\r\nstorage in JSON, localStorage, or transmission. The grid function is first\r\nserialized to MFEM format (including FE space info) and then base64-encoded.",[1802],{"_14":551,"_20":1803,"_26":6},"- The grid function to export",[],{"_14":1806,"_16":1807,"_18":1808,"_20":1809,"_21":1810,"_31":1794,"_33":1814},"mfem.gridfunction.toVTK","mfem.gridfunction.toVTK(gf, options?)","Exports a grid function to VTK format string for visualization.\r","Exports a grid function to VTK format string for visualization.\r\n\r\nThe returned string contains VTK data for the grid function values.\r\n**Note:** This exports only the field data. For complete VTK output,\r\nyou also need to export the mesh using `mesh.toVTK()`.\r\n\r\nFor visualization in ParaView or similar tools, combine the mesh\r\nand field data into a complete VTK file.",[1811,1812],{"_14":551,"_20":1793,"_26":6},{"_14":468,"_20":1813,"_26":30},"- Export options",[],{"_14":1816,"_16":1817,"_18":1818,"_20":1819,"_21":1820,"_31":1131,"_33":1823},"mfem.gridfunction.getTrueDofs","mfem.gridfunction.getTrueDofs(gf)","Gets the true DOF values from a grid function.\r","Gets the true DOF values from a grid function.\r\n\r\nFor conforming meshes, this returns the same as `getData()`.\r\nFor non-conforming meshes, this returns only the independent DOF values,\r\nwhich may be fewer than the total number of DOFs.",[1821],{"_14":551,"_20":1822,"_26":6},"- The grid function to query",[],{"_14":1825,"_16":1826,"_18":1827,"_20":1828,"_21":1829,"_31":1388,"_33":1831},"mfem.gridfunction.getTrueVectorSize","mfem.gridfunction.getTrueVectorSize(gf)","Gets the size of the true DOF vector.\r","Gets the size of the true DOF vector.\r\n\r\nFor conforming meshes, this equals the total number of DOFs.\r\nFor non-conforming meshes, this may be smaller.",[1830],{"_14":551,"_20":1822,"_26":6},[],{"_14":1833,"_16":1834,"_18":1835,"_20":1836,"_21":1837,"_31":61,"_33":1843},"mfem.gridfunction.setFromTrueDofs","mfem.gridfunction.setFromTrueDofs(gf, trueDofs)","Sets grid function values from true DOF values.\r","Sets grid function values from true DOF values.\r\n\r\nThis applies the prolongation operator to populate all DOFs from\r\nthe independent true DOFs. For conforming meshes, this is equivalent\r\nto `setData()`. For non-conforming meshes, this properly distributes\r\nvalues to hanging nodes.",[1838,1840],{"_14":551,"_20":1839,"_26":6},"- The grid function to update",{"_14":1841,"_20":1842,"_26":6},"trueDofs","- Array of true DOF values",[],{"_14":1845,"_16":1846,"_18":1847,"_20":1848,"_21":1849,"_31":61,"_33":1851},"mfem.gridfunction.setTrueVector","mfem.gridfunction.setTrueVector(gf)","Extracts true DOFs from the grid function to internal storage.\r","Extracts true DOFs from the grid function to internal storage.\r\n\r\nFor conforming meshes, this is a no-op. For non-conforming meshes\r\n(with hanging nodes), this extracts the independent DOF values.\r\nCall this before solving to prepare the true DOF vector.",[1850],{"_14":551,"_20":1839,"_26":6},[],{"_14":1853,"_16":1854,"_18":1855,"_20":1856,"_21":1857,"_31":1483,"_33":1859},"mfem.gridfunction.GridFunction.create","mfem.gridfunction.GridFunction.create(fespace)","Creates a new grid function on the specified finite element space.\r","Creates a new grid function on the specified finite element space.\r\n\r\nThe grid function is initialized with unspecified values. Use\r\n| projectConstant() or\r\n| setData() to initialize the values.",[1858],{"_14":223,"_20":1502,"_26":6},[],{"_14":1861,"_16":1862,"_18":1863,"_20":1863,"_21":1864,"_31":1131,"_33":1868},"mfem.linalg.createDoubleArray","mfem.linalg.createDoubleArray(size)","Create a zero-initialized Float64Array.",[1865],{"_14":1866,"_20":1867,"_26":6},"size","- Array size",[],{"_14":1870,"_16":1871,"_18":1872,"_20":1873,"_21":1874,"_31":436,"_33":1876},"mfem.linalg.createIntArray","mfem.linalg.createIntArray(size)","Array utility functions for creating typed arrays.\r","Array utility functions for creating typed arrays.\r\n\r\nThese are pure JavaScript utilities that don't require WASM.",[1875],{"_14":1866,"_20":1867,"_26":6},[],{"_14":1878,"_16":1879,"_18":1880,"_20":1881,"_21":1882,"_31":436,"_33":1887},"mfem.linalg.createMarkerArray","mfem.linalg.createMarkerArray(size, markedIndices)","Create a marker array (0/1 values) with specified indices marked as 1.\r","Create a marker array (0/1 values) with specified indices marked as 1.\r\n\r\nThis is useful for creating boundary marker arrays or element selection arrays.",[1883,1884],{"_14":1866,"_20":1867,"_26":6},{"_14":1885,"_20":1886,"_26":6},"markedIndices","- Indices to mark as 1",[],{"_14":1889,"_16":1890,"_18":298,"_20":298,"_21":1891,"_31":303,"_33":1893},"mfem.linalg.BlockMatrix.createSquare","mfem.linalg.BlockMatrix.createSquare(offsets)",[1892],{"_14":301,"_20":302,"_26":6},[],{"_14":1895,"_16":1896,"_18":308,"_20":308,"_21":1897,"_31":303,"_33":1900},"mfem.linalg.BlockMatrix.create","mfem.linalg.BlockMatrix.create(rowOffsets, colOffsets)",[1898,1899],{"_14":311,"_20":312,"_26":6},{"_14":314,"_20":315,"_26":6},[],{"_14":1902,"_16":1903,"_18":320,"_20":321,"_21":1904,"_31":303,"_33":1906},"mfem.linalg.BlockMatrix.fromPointer","mfem.linalg.BlockMatrix.fromPointer(ptr)",[1905],{"_14":324,"_20":325,"_26":6},[],{"_14":1908,"_16":1909,"_18":330,"_20":330,"_21":1910,"_31":333,"_33":1912},"mfem.linalg.BlockOperator.createSquare","mfem.linalg.BlockOperator.createSquare(offsets)",[1911],{"_14":301,"_20":302,"_26":6},[],{"_14":1914,"_16":1915,"_18":338,"_20":338,"_21":1916,"_31":333,"_33":1919},"mfem.linalg.BlockOperator.create","mfem.linalg.BlockOperator.create(rowOffsets, colOffsets)",[1917,1918],{"_14":311,"_20":312,"_26":6},{"_14":314,"_20":315,"_26":6},[],{"_14":1921,"_16":1922,"_18":346,"_20":347,"_21":1923,"_31":333,"_33":1925},"mfem.linalg.BlockOperator.fromPointer","mfem.linalg.BlockOperator.fromPointer(ptr)",[1924],{"_14":324,"_20":350,"_26":6},[],{"_14":1927,"_16":1928,"_18":355,"_20":355,"_21":1929,"_31":359,"_33":1931},"mfem.linalg.BlockVector.create","mfem.linalg.BlockVector.create(offsets)",[1930],{"_14":301,"_20":358,"_26":6},[],{"_14":1933,"_16":1934,"_18":364,"_20":365,"_21":1935,"_31":359,"_33":1938},"mfem.linalg.BlockVector.fromPointer","mfem.linalg.BlockVector.fromPointer(ptr, offsets)",[1936,1937],{"_14":324,"_20":368,"_26":6},{"_14":301,"_20":370,"_26":6},[],{"_14":1940,"_16":1941,"_18":1185,"_20":1186,"_21":1942,"_31":1191,"_33":1945},"mfem.linalg.DenseMatrix.create","mfem.linalg.DenseMatrix.create(height, width)",[1943,1944],{"_14":663,"_20":664,"_26":6},{"_14":666,"_20":1190,"_26":6},[],{"_14":1947,"_16":1948,"_18":1196,"_20":1196,"_21":1949,"_31":1191,"_33":1952},"mfem.linalg.DenseMatrix.zeros","mfem.linalg.DenseMatrix.zeros(height, width)",[1950,1951],{"_14":663,"_20":664,"_26":6},{"_14":666,"_20":1190,"_26":6},[],{"_14":1954,"_16":1955,"_18":1204,"_20":1204,"_21":1956,"_31":1191,"_33":1958},"mfem.linalg.DenseMatrix.identity","mfem.linalg.DenseMatrix.identity(n)",[1957],{"_14":1207,"_20":1208,"_26":6},[],{"_14":1960,"_16":1961,"_18":1213,"_20":1213,"_21":1962,"_31":1191,"_33":1964},"mfem.linalg.DenseMatrix.fromArray","mfem.linalg.DenseMatrix.fromArray(data)",[1963],{"_14":1216,"_20":1217,"_26":6},[],{"_14":1966,"_16":1967,"_18":1222,"_20":1223,"_21":1968,"_31":1191,"_33":1971},"mfem.linalg.DenseMatrix.fromPointer","mfem.linalg.DenseMatrix.fromPointer(ptr, ownsMemory?)",[1969,1970],{"_14":324,"_20":1226,"_26":6},{"_14":1228,"_20":1229,"_26":30},[],{"_14":1973,"_16":1974,"_18":1975,"_20":1975,"_21":1976,"_31":1979,"_33":1980},"mfem.linalg.SparseMatrix.create","mfem.linalg.SparseMatrix.create(height, width)","Creates a new empty sparse matrix of the specified dimensions.",[1977,1978],{"_14":663,"_20":664,"_26":6},{"_14":666,"_20":1190,"_26":6},"Promise",[],{"_14":1982,"_16":1983,"_18":1984,"_20":1985,"_21":1986,"_31":1979,"_33":1991},"mfem.linalg.SparseMatrix.fromPointer","mfem.linalg.SparseMatrix.fromPointer(ptr, ownsMemory?)","Creates a SparseMatrix from an existing WASM pointer.\r","Creates a SparseMatrix from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[1987,1989],{"_14":324,"_20":1988,"_26":6},"- WASM pointer to an existing MFEM SparseMatrix",{"_14":1228,"_20":1990,"_26":30},"- If true, destroy() will free the memory; if false, it won't",[],{"_14":1993,"_16":1994,"_18":1995,"_20":1995,"_21":1996,"_31":1999,"_33":2000},"mfem.linalg.Vector.create","mfem.linalg.Vector.create(size)","Creates a new vector of the specified size.",[1997],{"_14":1866,"_20":1998,"_26":6},"- The number of elements in the vector","Promise",[],{"_14":2002,"_16":2003,"_18":2004,"_20":2005,"_21":2006,"_31":1999,"_33":2009},"mfem.linalg.Vector.fromPointer","mfem.linalg.Vector.fromPointer(ptr)","Creates a Vector from an existing WASM pointer.\r","Creates a Vector from an existing WASM pointer.\r\nUse with caution - the caller is responsible for pointer validity.",[2007],{"_14":324,"_20":2008,"_26":6},"- WASM pointer to an existing MFEM Vector",[],{"_14":2011,"_16":2012,"_18":2013,"_20":2013,"_21":2014,"_31":1388,"_33":2017},"mfem.linear.getFinalNorm","mfem.linear.getFinalNorm(solver)","Get the final residual norm from the last solve.",[2015],{"_14":1126,"_20":2016,"_26":6},"- Iterative solver instance",[],{"_14":2019,"_16":2020,"_18":2021,"_20":2021,"_21":2022,"_31":1388,"_33":2024},"mfem.linear.getNumIterations","mfem.linear.getNumIterations(solver)","Get the number of iterations from the last solve.",[2023],{"_14":1126,"_20":2016,"_26":6},[],{"_14":2026,"_16":2027,"_18":2028,"_20":2028,"_21":2029,"_31":61,"_33":2035},"mfem.linear.mult","mfem.linear.mult(solver, b, x)","Solve the linear system Ax = b.",[2030,2031,2033],{"_14":1126,"_20":2016,"_26":6},{"_14":422,"_20":2032,"_26":6},"- Right-hand side vector",{"_14":419,"_20":2034,"_26":6},"- Solution vector (modified in place)",[],{"_14":2037,"_16":2038,"_18":2039,"_20":2039,"_21":2040,"_31":61,"_33":2045},"mfem.linear.setMaxIterations","mfem.linear.setMaxIterations(solver, max)","Set maximum number of iterations for an iterative solver.",[2041,2042],{"_14":1126,"_20":2016,"_26":6},{"_14":2043,"_20":2044,"_26":6},"max","- Maximum iterations",[],{"_14":2047,"_16":2048,"_18":2049,"_20":2049,"_21":2050,"_31":61,"_33":2055},"mfem.linear.setPreconditioner","mfem.linear.setPreconditioner(solver, prec)","Set preconditioner for an iterative solver.",[2051,2052],{"_14":1126,"_20":2016,"_26":6},{"_14":2053,"_20":2054,"_26":6},"prec","- Preconditioner (Solver)",[],{"_14":2057,"_16":2058,"_18":2059,"_20":2059,"_21":2060,"_31":61,"_33":2065},"mfem.linear.setPrintLevel","mfem.linear.setPrintLevel(solver, level)","Set verbosity level for an iterative solver.",[2061,2062],{"_14":1126,"_20":2016,"_26":6},{"_14":2063,"_20":2064,"_26":6},"level","- Print level (0=silent, 1=summary, 2=iteration details)",[],{"_14":2067,"_16":2068,"_18":2069,"_20":2069,"_21":2070,"_31":61,"_33":2078},"mfem.linear.setTolerance","mfem.linear.setTolerance(solver, rtol, atol?)","Set convergence tolerances for an iterative solver.",[2071,2072,2075],{"_14":1126,"_20":2016,"_26":6},{"_14":2073,"_20":2074,"_26":6},"rtol","- Relative tolerance",{"_14":2076,"_20":2077,"_26":30},"atol","- Absolute tolerance (optional)",[],{"_14":2080,"_16":2081,"_18":2082,"_20":2082,"_21":2083,"_31":2084,"_33":2085},"mfem.linear.BiCGSTABSolver.create","mfem.linear.BiCGSTABSolver.create()","Creates a new BiCGSTAB solver.",[],"Promise",[],{"_14":2087,"_16":2088,"_18":2089,"_20":2089,"_21":2090,"_31":2099,"_33":2100},"mfem.linear.BlockILU.create","mfem.linear.BlockILU.create(matrixPtr, blockSize?, options?)","Creates a new BlockILU preconditioner.",[2091,2094,2097],{"_14":2092,"_20":2093,"_26":6},"matrixPtr","- Pointer to SparseMatrix or Operator",{"_14":2095,"_20":2096,"_26":30},"blockSize","- Block size for ILU factorization. Default: 1",{"_14":468,"_20":2098,"_26":30},"- Optional configuration options","Promise",[],{"_14":2102,"_16":2103,"_18":2104,"_20":2104,"_21":2105,"_31":2106,"_33":2107},"mfem.linear.CGSolver.create","mfem.linear.CGSolver.create()","Creates a new CG solver.",[],"Promise",[],{"_14":2109,"_16":2110,"_18":2111,"_20":2111,"_21":2112,"_31":2115,"_33":2116},"mfem.linear.ChebyshevSmoother.create","mfem.linear.ChebyshevSmoother.create(options)","Creates a new Chebyshev smoother with explicit maximum eigenvalue.",[2113],{"_14":468,"_20":2114,"_26":6},"- Smoother configuration options","Promise",[],{"_14":2118,"_16":2119,"_18":2120,"_20":2121,"_21":2122,"_31":2115,"_33":2124},"mfem.linear.ChebyshevSmoother.createAuto","mfem.linear.ChebyshevSmoother.createAuto(options)","Creates a new Chebyshev smoother with automatic eigenvalue estimation.\r","Creates a new Chebyshev smoother with automatic eigenvalue estimation.\r\nUses power iteration to estimate the maximum eigenvalue.",[2123],{"_14":468,"_20":2114,"_26":6},[],{"_14":2126,"_16":2127,"_18":2128,"_20":2128,"_21":2129,"_31":2136,"_33":2137},"mfem.linear.DirectSubBlockSolver.create","mfem.linear.DirectSubBlockSolver.create(APtr, blockDofPtr)","Creates a new DirectSubBlockSolver.",[2130,2133],{"_14":2131,"_20":2132,"_26":6},"APtr","- Pointer to the system SparseMatrix",{"_14":2134,"_20":2135,"_26":6},"blockDofPtr","- Pointer to SparseMatrix defining block-DOF membership","Promise",[],{"_14":2139,"_16":2140,"_18":2141,"_20":2141,"_21":2142,"_31":2146,"_33":2147},"mfem.linear.DSmoother.create","mfem.linear.DSmoother.create(matrixPtr, options?)","Creates a new DSmoother.",[2143,2145],{"_14":2092,"_20":2144,"_26":6},"- Pointer to SparseMatrix",{"_14":468,"_20":2098,"_26":30},"Promise",[],{"_14":2149,"_16":2150,"_18":2151,"_20":2151,"_21":2152,"_31":2156,"_33":2157},"mfem.linear.FGMRESSolver.create","mfem.linear.FGMRESSolver.create(kdim?)","Creates a new Flexible GMRES solver.",[2153],{"_14":2154,"_20":2155,"_26":30},"kdim","- Krylov space dimension (restart parameter, default 50)","Promise",[],{"_14":2159,"_16":2160,"_18":2161,"_20":2161,"_21":2162,"_31":2164,"_33":2165},"mfem.linear.GMRESSolver.create","mfem.linear.GMRESSolver.create(kdim?)","Creates a new GMRES solver.",[2163],{"_14":2154,"_20":2155,"_26":30},"Promise",[],{"_14":2167,"_16":2168,"_18":2169,"_20":2169,"_21":2170,"_31":2178,"_33":2179},"mfem.linear.GSSmoother.create","mfem.linear.GSSmoother.create(matrixPtr, type?, iterations?)","Creates a new Gauss-Seidel smoother.",[2171,2172,2175],{"_14":2092,"_20":2144,"_26":6},{"_14":2173,"_20":2174,"_26":30},"type","- Type of GS iteration (default: SYMMETRIC)",{"_14":2176,"_20":2177,"_26":30},"iterations","- Number of iterations (default: 1)","Promise",[],{"_14":2181,"_16":2182,"_18":2183,"_20":2183,"_21":2184,"_31":2188,"_33":2189},"mfem.linear.JacobiSmoother.create","mfem.linear.JacobiSmoother.create(matrixPtr, essentialDofs?)","Creates a new Jacobi smoother.",[2185,2186],{"_14":2092,"_20":2144,"_26":6},{"_14":235,"_20":2187,"_26":30},"- Optional array of essential DOF indices to exclude","Promise",[],{"_14":2191,"_16":2192,"_18":2193,"_20":2193,"_21":2194,"_31":2195,"_33":2196},"mfem.linear.KLUSolver.isAvailable","mfem.linear.KLUSolver.isAvailable()","Checks if KLU (SuiteSparse) is available.",[],"Promise",[],{"_14":2198,"_16":2199,"_18":2200,"_20":2200,"_21":2201,"_31":2202,"_33":2203},"mfem.linear.KLUSolver.create","mfem.linear.KLUSolver.create()","Creates a new KLU solver.",[],"Promise",[],{"_14":2205,"_16":2206,"_18":2207,"_20":2207,"_21":2208,"_31":2209,"_33":2210},"mfem.linear.MINRESSolver.create","mfem.linear.MINRESSolver.create()","Creates a new MINRES solver.",[],"Promise",[],{"_14":2212,"_16":2213,"_18":2214,"_20":2214,"_21":2215,"_31":2216,"_33":2217},"mfem.linear.OrthoSolver.create","mfem.linear.OrthoSolver.create()","Creates a new orthogonalizing solver wrapper.",[],"Promise",[],{"_14":2219,"_16":2220,"_18":2221,"_20":2221,"_21":2222,"_31":2231,"_33":2232},"mfem.linear.ProductSolver.create","mfem.linear.ProductSolver.create(s0Ptr, s1Ptr, options?)","Creates a new product solver: S = S1 * S0.",[2223,2226,2229],{"_14":2224,"_20":2225,"_26":6},"s0Ptr","- Pointer to first solver (applied first)",{"_14":2227,"_20":2228,"_26":6},"s1Ptr","- Pointer to second solver (applied second)",{"_14":468,"_20":2230,"_26":30},"- Ownership options","Promise",[],{"_14":2219,"_16":2234,"_18":2221,"_20":2221,"_21":2235,"_31":2231,"_33":2243},"mfem.linear.ProductSolver.create(s0, s1, options?)",[2236,2239,2242],{"_14":2237,"_20":2238,"_26":6},"s0","- First solver (applied first)",{"_14":2240,"_20":2241,"_26":6},"s1","- Second solver (applied second)",{"_14":468,"_20":2230,"_26":30},[],{"_14":2245,"_16":2246,"_18":2247,"_20":2247,"_21":2248,"_31":2249,"_33":2250},"mfem.linear.SLISolver.create","mfem.linear.SLISolver.create()","Creates a new SLI solver.",[],"Promise",[],{"_14":2252,"_16":2253,"_18":2254,"_20":2254,"_21":2255,"_31":2195,"_33":2256},"mfem.linear.UMFPackSolver.isAvailable","mfem.linear.UMFPackSolver.isAvailable()","Checks if UMFPack (SuiteSparse) is available.",[],[],{"_14":2258,"_16":2259,"_18":2260,"_20":2260,"_21":2261,"_31":2262,"_33":2263},"mfem.linear.UMFPackSolver.create","mfem.linear.UMFPackSolver.create()","Creates a new UMFPack solver.",[],"Promise",[],{"_14":2265,"_16":2266,"_18":2267,"_20":2268,"_21":2269,"_31":61,"_33":2275},"mfem.linearForms.addBoundaryFluxIntegrator","mfem.linearForms.addBoundaryFluxIntegrator(lf, coeff, bdrAttrs?)","Add a VectorFE boundary flux integrator for H(div) spaces.\r","Add a VectorFE boundary flux integrator for H(div) spaces.\r\n\r\nComputes: ∫_∂Ω f * (v · n) ds",[2270,2271,2273],{"_14":380,"_20":400,"_26":6},{"_14":59,"_20":2272,"_26":6},"- Scalar flux coefficient",{"_14":387,"_20":2274,"_26":30},"- Optional boundary attributes to restrict to",[],{"_14":2277,"_16":2278,"_18":2279,"_20":2280,"_21":2281,"_31":61,"_33":2286},"mfem.linearForms.addBoundaryIntegrator","mfem.linearForms.addBoundaryIntegrator(lf, coeff, bdrAttrs?)","Add a boundary integrator (g, v) to the linear form.\r","Add a boundary integrator (g, v) to the linear form.\r\n\r\nComputes: ∫_∂Ω g * v ds",[2282,2283,2285],{"_14":380,"_20":400,"_26":6},{"_14":59,"_20":2284,"_26":6},"- Boundary source coefficient",{"_14":387,"_20":2274,"_26":30},[],{"_14":2288,"_16":2289,"_18":2290,"_20":2291,"_21":2292,"_31":61,"_33":2296},"mfem.linearForms.addBoundaryNormalIntegrator","mfem.linearForms.addBoundaryNormalIntegrator(lf, coeff, bdrAttrs?)","Add a boundary normal integrator (F · n, v) to the linear form.\r","Add a boundary normal integrator (F · n, v) to the linear form.\r\n\r\nComputes: ∫_∂Ω (F · n) * v ds",[2293,2294,2295],{"_14":380,"_20":400,"_26":6},{"_14":59,"_20":786,"_26":6},{"_14":387,"_20":2274,"_26":30},[],{"_14":2298,"_16":2299,"_18":2300,"_20":2301,"_21":2302,"_31":61,"_33":2306},"mfem.linearForms.addBoundaryTangentialIntegrator","mfem.linearForms.addBoundaryTangentialIntegrator(lf, coeff, bdrAttrs?)","Add a boundary tangential integrator (F × n, v) to the linear form.\r","Add a boundary tangential integrator (F × n, v) to the linear form.\r\nFor 2D: takes the tangential component of the vector field.\r\n\r\nComputes: ∫_∂Ω (F · t) * v ds",[2303,2304,2305],{"_14":380,"_20":400,"_26":6},{"_14":59,"_20":786,"_26":6},{"_14":387,"_20":2274,"_26":30},[],{"_14":2308,"_16":2309,"_18":2310,"_20":2311,"_21":2312,"_31":61,"_33":2320},"mfem.linearForms.addDGDirichletIntegrator","mfem.linearForms.addDGDirichletIntegrator(lf, coeff, sigma, kappa)","Add a DG Dirichlet boundary integrator for discontinuous Galerkin methods.\r","Add a DG Dirichlet boundary integrator for discontinuous Galerkin methods.\r\n\r\nNote: This integrator is not yet implemented in the WASM bindings.\r\nIt requires additional C++ support for DG-specific integrators.",[2313,2314,2316,2318],{"_14":380,"_20":400,"_26":6},{"_14":59,"_20":2315,"_26":6},"- Dirichlet value coefficient",{"_14":96,"_20":2317,"_26":6},"- Symmetry parameter (-1 for SIPG, 0 for IIPG, 1 for NIPG)",{"_14":99,"_20":2319,"_26":6},"- Penalty parameter",[],{"_14":2322,"_16":2323,"_18":2324,"_20":2325,"_21":2326,"_31":61,"_33":2329},"mfem.linearForms.addDomainGradientIntegrator","mfem.linearForms.addDomainGradientIntegrator(lf, coeff)","Add a domain gradient integrator (F, ∇v) to the linear form.\r","Add a domain gradient integrator (F, ∇v) to the linear form.\r\n\r\nComputes: ∫ F · ∇v dx",[2327,2328],{"_14":380,"_20":400,"_26":6},{"_14":59,"_20":786,"_26":6},[],{"_14":2331,"_16":2332,"_18":2333,"_20":2334,"_21":2335,"_31":61,"_33":2339},"mfem.linearForms.addDomainIntegrator","mfem.linearForms.addDomainIntegrator(lf, coeff)","Add a domain integrator (f, v) to the linear form.\r","Add a domain integrator (f, v) to the linear form.\r\n\r\nComputes: ∫ f * v dx",[2336,2337],{"_14":380,"_20":400,"_26":6},{"_14":59,"_20":2338,"_26":6},"- Source coefficient",[],{"_14":2341,"_16":2342,"_18":2343,"_20":2344,"_21":2345,"_31":61,"_33":2348},"mfem.linearForms.addVectorDomainIntegrator","mfem.linearForms.addVectorDomainIntegrator(lf, coeff)","Add a vector domain integrator (F, v) to the linear form.\r","Add a vector domain integrator (F, v) to the linear form.\r\nFor vector-valued test functions.\r\n\r\nComputes: ∫ F · v dx",[2346,2347],{"_14":380,"_20":400,"_26":6},{"_14":59,"_20":786,"_26":6},[],{"_14":2350,"_16":2351,"_18":2352,"_20":2352,"_21":2353,"_31":61,"_33":2355},"mfem.linearForms.assemble","mfem.linearForms.assemble(lf)","Assemble the linear form into a vector.",[2354],{"_14":380,"_20":400,"_26":6},[],{"_14":2357,"_16":2358,"_18":2359,"_20":2359,"_21":2360,"_31":1131,"_33":2362},"mfem.linearForms.getVector","mfem.linearForms.getVector(lf)","Get the assembled vector data from the linear form.",[2

Name	Description
fn	- Function (x, y, z) => number[]
dim(optional)	- Output vector dimension (defaults to 3)

mfem.coefficients.vectorFunction

Syntax

Description

Parameters

Returns