Uses of Class mathcomp.gridgeom.Node

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Class
mathcomp.gridgeom.Node

Packages that use Node
mathcomp.assemble	Contains essential assembler classes.
mathcomp.assemble.cfd	Provides the assembly of Stokes and Navier-Stokes equations using Mini-Elements.
mathcomp.assemble.convdiff	Convection diffusion problems.
mathcomp.assemble.discontinuousgalerkin	Discontinuous galerkin problems.
mathcomp.assemble.filament	Combines the Immersed Boundary Method with FEM to treat filaments in fluid flow.
mathcomp.assemble.laplace	Laplace problems.
mathcomp.assemble.minimalsurface	Minimal surface problems.
mathcomp.gridgeom	Contains the geometric architecture and refinement.
mathcomp.gridgeom.refinements	Contains all refinement strategies.
mathcomp.gui	GUI-Implementation.
mathcomp.gui.cfd	Provides GUI features for flow problems.
mathcomp.la	Contains Linear Algebra Classes and the `Index` Infrastructure.
mathcomp.util.cfd	Provides some utils for flow problems.

Uses of Node in mathcomp.assemble

Methods in mathcomp.assemble with parameters of type Node
`double[]`	`MiniAssembler.evalApproxGradient(Node n, Triangle t, Vector x)`
`double[]`	`LagrangeSquareAssembler.evalApproxGradient(Node gaussRef, Triangle t, Vector x)`
`double[]`	`LagrangeLinearAssembler.evalApproxGradient(Node n, Triangle t, Vector x)` For linear functions we add the gradients of the scaled basisfunction on real
`double[]`	`Assembler.evalApproxGradient(Node n, Triangle t, Vector x)` For H1 error calculations we need to know the gradient of the approximated solution in a node n.
`double`	`MiniAssembler.evalApproxSolution(Node n, Triangle t, Vector x)`
`double`	`LagrangeSquareAssembler.evalApproxSolution(Node n, Triangle t, Vector x)`
`double`	`LagrangeLinearAssembler.evalApproxSolution(Node n, Triangle t, Vector x)`
`abstract double`	`Assembler.evalApproxSolution(Node n, Triangle t, Vector x)` Evaluates the FEM solution in a Node.
`double`	`MiniAssembler.evalBasisFuncOnRef(Node u, int localBasisNumber)` Returns the value of the linear basis function with the local number `localBasisNumber` at the Node u on the standart-triangle.
`double`	`LagrangeSquareAssembler.evalBasisFuncOnRef(Node u, int localBasisNumber)` Returns the value of the Node u on the quadratic Basisfunktion with the local number `localBasisNumber` on the standart-triangle.
`double`	`LagrangeLinearAssembler.evalBasisFuncOnRef(Node u, int localBasisNumber)` Returns the value of the linear basis function with the local number `localBasisNumber` at the Node u on the standart-triangle.
`double[]`	`Assembler.evalExactGradient(Node n)` For H1 error calculations we need to know the exact gradient of a problem.
`double`	`Assembler.evalExactSolution(Node n)` For error calculations we need to know the exact solution of a problem.
`abstract double`	`Assembler.evalF(Node n)` Evaluates the right hand side function f on the Node n
`double`	`MiniAssembler.evalGradXBasisFuncOnRef(Node u, int localBasisNumber)`
`double`	`LagrangeSquareAssembler.evalGradXBasisFuncOnRef(Node u, int localBasisNumber)`
`double`	`LagrangeLinearAssembler.evalGradXBasisFuncOnRef(Node n, int localBasisNumber)` Returns the value of the partial derivation of the basis function with the local number `localBasisNumber` by x at the Node u on the standart-triangle.
`double`	`MiniAssembler.evalGradYBasisFuncOnRef(Node u, int localBasisNumber)`
`double`	`LagrangeSquareAssembler.evalGradYBasisFuncOnRef(Node u, int localBasisNumber)`
`double`	`LagrangeLinearAssembler.evalGradYBasisFuncOnRef(Node n, int localBasisNumber)` Returns the value of the partial derivation of the basis function with the local number `localBasisNumber` by y at the Node u on the standart-triangle.
`Triangle`	`ErrorCalculator.findTriangle(Node n)`
`double`	`Assembler.getExactPartialX(Node n)` Direct access to partialX
`double`	`Assembler.getExactPartialY(Node n)` Direct access to partialY
`int`	`MiniAssembler.getLocalNodeNumber(Triangle t, Node n)`
`int`	`LagrangeSquareAssembler.getLocalNodeNumber(Triangle t, Node n)` Gets the local Node number to a Node on a quadratic triangle element.

Uses of Node in mathcomp.assemble.cfd

Methods in mathcomp.assemble.cfd with parameters of type Node
`double[]`	`NSMiniAssembler.evalApproxGradientU1(Node n, Triangle t, Vector x)`
`double[]`	`NSMiniAssembler.evalApproxGradientU2(Node n, Triangle t, Vector x)`
`double`	`NSMiniAssembler.evalApproxSolutionPressure(Node n, Triangle t, Vector x)`
`double`	`NSMiniAssembler.evalApproxSolutionU1(Node n, Triangle t, Vector x)`
`double`	`NSMiniAssembler.evalApproxSolutionU2(Node n, Triangle t, Vector x)`
`double`	`NSMiniAssembler.evalBasisFuncOnRefPressure(Node u, int localBasisNumber)`
`double`	`NSMiniAssembler.evalBasisFuncOnRefVelocity(Node u, int localBasisNumber)`
`double[]`	`NSMiniAssembler.evalBasisGradOnRefVelocity(Node u, int localBasisNumber)`
`double[]`	`NSMini_BUCanal.evalExactGradientU1(Node n)`
`double[]`	`NSMiniTimeSI.evalExactGradientU1(Node n)`
`double[]`	`NSMiniOseen.evalExactGradientU1(Node n)`
`double[]`	`NSMiniTube.evalExactGradientU1(Node n)`
`double[]`	`NSMiniHomogen.evalExactGradientU1(Node n)`
`double[]`	`NSMiniDuct.evalExactGradientU1(Node n)`
`double[]`	`StokesTimeTester.evalExactGradientU1(Node n)`
`double[]`	`NSTimeDrivenCavity.evalExactGradientU1(Node n)`
`double[]`	`NSMiniOseenTesterA.evalExactGradientU1(Node n)`
`double[]`	`NSMiniOseenTesterB.evalExactGradientU1(Node n)`
`double[]`	`NSMini_BUCanal.evalExactGradientU2(Node n)`
`double[]`	`NSMiniTimeSI.evalExactGradientU2(Node n)`
`double[]`	`NSMiniOseen.evalExactGradientU2(Node n)`
`double[]`	`NSMiniTube.evalExactGradientU2(Node n)`
`double[]`	`NSMiniHomogen.evalExactGradientU2(Node n)`
`double[]`	`NSMiniDuct.evalExactGradientU2(Node n)`
`double[]`	`StokesTimeTester.evalExactGradientU2(Node n)`
`double[]`	`NSTimeDrivenCavity.evalExactGradientU2(Node n)`
`double[]`	`NSMiniOseenTesterA.evalExactGradientU2(Node n)`
`double[]`	`NSMiniOseenTesterB.evalExactGradientU2(Node n)`
`double`	`NSMini_BUCanal.evalExactSolutionPressure(Node n)`
`double`	`NSMiniTimeSI.evalExactSolutionPressure(Node n)`
`double`	`NSMiniOseen.evalExactSolutionPressure(Node n)`
`double`	`NSMiniTube.evalExactSolutionPressure(Node n)`
`double`	`NSMiniHomogen.evalExactSolutionPressure(Node n)`
`double`	`NSMiniDuct.evalExactSolutionPressure(Node n)`
`double`	`StokesTimeTester.evalExactSolutionPressure(Node n)`
`double`	`NSTimeDrivenCavity.evalExactSolutionPressure(Node n)`
`double`	`NSMiniOseenTesterA.evalExactSolutionPressure(Node n)`
`double`	`NSMiniOseenTesterB.evalExactSolutionPressure(Node n)`
`double`	`NSMini_BUCanal.evalExactSolutionU1(Node n)`
`double`	`NSMiniTimeSI.evalExactSolutionU1(Node n)`
`double`	`NSMiniOseen.evalExactSolutionU1(Node n)`
`double`	`NSMiniTube.evalExactSolutionU1(Node n)`
`double`	`NSMiniHomogen.evalExactSolutionU1(Node n)`
`double`	`NSMiniDuct.evalExactSolutionU1(Node n)`
`double`	`StokesTimeTester.evalExactSolutionU1(Node n)`
`double`	`NSTimeDrivenCavity.evalExactSolutionU1(Node n)`
`double`	`NSMiniOseenTesterA.evalExactSolutionU1(Node n)`
`double`	`NSMiniOseenTesterB.evalExactSolutionU1(Node n)`
`double`	`NSMini_BUCanal.evalExactSolutionU2(Node n)`
`double`	`NSMiniTimeSI.evalExactSolutionU2(Node n)`
`double`	`NSMiniOseen.evalExactSolutionU2(Node n)`
`double`	`NSMiniTube.evalExactSolutionU2(Node n)`
`double`	`NSMiniHomogen.evalExactSolutionU2(Node n)`
`double`	`NSMiniDuct.evalExactSolutionU2(Node n)`
`double`	`StokesTimeTester.evalExactSolutionU2(Node n)`
`double`	`NSTimeDrivenCavity.evalExactSolutionU2(Node n)`
`double`	`NSMiniOseenTesterA.evalExactSolutionU2(Node n)`
`double`	`NSMiniOseenTesterB.evalExactSolutionU2(Node n)`
`double`	`NSMini_BUCanal.evalF1(Node n)`
`double`	`NSMiniOseenTesterD.evalF1(Node n)`
`double`	`NSMiniTimeSI.evalF1(Node n)`
`double`	`NSMiniOseen.evalF1(Node n)`
`double`	`NSMiniTube.evalF1(Node n)`
`double`	`NSMiniHomogen.evalF1(Node n)`
`double`	`NSMiniDuct.evalF1(Node n)`
`double`	`StokesTimeTester.evalF1(Node n)`
`double`	`NSTimeDrivenCavity.evalF1(Node n)`
`double`	`NSMiniOseenTesterA.evalF1(Node n)`
`double`	`NSMiniOseenTesterB.evalF1(Node n)`
`double`	`NSMini_BUCanal.evalF2(Node n)`
`double`	`NSMiniOseenTesterD.evalF2(Node n)`
`double`	`NSMiniTimeSI.evalF2(Node n)`
`double`	`NSMiniOseen.evalF2(Node n)`
`double`	`NSMiniTube.evalF2(Node n)`
`double`	`NSMiniHomogen.evalF2(Node n)`
`double`	`NSMiniDuct.evalF2(Node n)`
`double`	`StokesTimeTester.evalF2(Node n)`
`double`	`NSTimeDrivenCavity.evalF2(Node n)`
`double`	`NSMiniOseenTesterA.evalF2(Node n)`
`double`	`NSMiniOseenTesterB.evalF2(Node n)`
`int`	`NSMiniAssembler.getLocalNodeNumber(Triangle t, Node n)` Returns the local Node number to a Node on triangle element.

Uses of Node in mathcomp.assemble.convdiff

Fields in mathcomp.assemble.convdiff declared as Node
`Node`	`AbstractCDA_Square.a`
`Node`	`AbstractCDA_Square.b`
`Node`	`AbstractCDA_Square.c`

Methods in mathcomp.assemble.convdiff that return Node
`Node`	`SkewAdvection_RFB.getXminus(Triangle t, Node z)`
`Node`	`RotFlow_RFB.getXminus(Triangle t, Node z)`
`Node`	`CDH_RFB.getXminus(Triangle t, Node z)`

Methods in mathcomp.assemble.convdiff with parameters of type Node
`double`	`AbstractCDA.approxConvectionIntegral(Triangle t, Node v, Node u)` Important that to the (i,j) matrix entry we take the "i-th basisfunc for v" and "jth for u".
`double`	`CDH_EF_Flux.approxLHS(Triangle t, Node u, Node v)`
`double`	`CDH_Weighted.approxLHS(Triangle t, Node u, Node v)`
`double`	`SkewAdvection_RFB.approxLHS(Triangle t, Node u, Node v)`
`double`	`RotFlow_RFB.approxLHS(Triangle t, Node u, Node v)`
`double`	`CDH_WBF.approxLHS(Triangle t, Node u, Node v)`
`double`	`CDH_RFB.approxLHS(Triangle t, Node u, Node v)`
`double`	`AbstractCDA_Square.approxLHS(Triangle t, Node u, Node v)` Important that to the (i,j) matrix entry we take the "i-th basisfunc for v" and "jth for u".
`double`	`AbstractCDA_Mini.approxLHS(Triangle t, Node u, Node v)`
`double`	`AbstractCDA_cV.approxLHS(Triangle t, Node u, Node v)`
`double[]`	`CDH_WBF.evalApproxGradient(Node n, Triangle t, Vector x)` TODO adjust linear to weighted gradients
`double`	`CDH_WBF.evalApproxSolution(Node n, Triangle t, Vector x)`
`double`	`CDH_Weighted.evalBasisFuncOnRef(Node n, int local)`
`double`	`EV_1D_FEM.evalBX(Node n)`
`double`	`ConvDiffBoundary.evalBX(Node n)`
`double`	`SkewAdvection.evalBX(Node n)`
`double`	`RotFlow.evalBX(Node n)`
`double`	`Raithby.evalBX(Node n)`
`double`	`Nochetto.evalBX(Node n)`
`double`	`ConvDiffHomogen.evalBX(Node n)`
`double`	`CDH_Square.evalBX(Node n)`
`double`	`CDH_Mini.evalBX(Node n)`
`double`	`CDH_1D.evalBX(Node n)`
`abstract double`	`AbstractCDA_Square.evalBX(Node n)`
`abstract double`	`AbstractCDA_Mini.evalBX(Node n)`
`abstract double`	`AbstractCDA.evalBX(Node n)`
`double`	`EV_1D_FEM.evalBY(Node n)`
`double`	`ConvDiffBoundary.evalBY(Node n)`
`double`	`SkewAdvection.evalBY(Node n)`
`double`	`RotFlow.evalBY(Node n)`
`double`	`Raithby.evalBY(Node n)`
`double`	`Nochetto.evalBY(Node n)`
`double`	`ConvDiffHomogen.evalBY(Node n)`
`double`	`CDH_Square.evalBY(Node n)`
`double`	`CDH_Mini.evalBY(Node n)`
`double`	`CDH_1D.evalBY(Node n)`
`abstract double`	`AbstractCDA_Square.evalBY(Node n)`
`abstract double`	`AbstractCDA_Mini.evalBY(Node n)`
`abstract double`	`AbstractCDA.evalBY(Node n)`
`double`	`RotFlow.evalExactGradientX(Node n)`
`double`	`RotFlow.evalExactGradientY(Node n)`
`double`	`EV_1D_FEM.evalExactSolution(Node n)`
`double`	`CDH_EF_Flux.evalExactSolution(Node n)`
`double`	`ConvDiffBoundary.evalExactSolution(Node n)`
`double`	`SkewAdvection.evalExactSolution(Node n)`
`double`	`RotFlow.evalExactSolution(Node n)`
`double`	`ConvDiffHomogen.evalExactSolution(Node n)`
`double`	`CDH_Square.evalExactSolution(Node n)`
`double`	`CDH_Mini.evalExactSolution(Node n)`
`double`	`CDH_1D.evalExactSolution(Node n)`
`double`	`EV_1D_FEM.evalF(Node n)`
`double`	`ConvDiffBoundary.evalF(Node n)`
`double`	`SkewAdvection.evalF(Node u)`
`double`	`RotFlow.evalF(Node n)`
`double`	`Raithby.evalF(Node n)`
`double`	`Nochetto.evalF(Node n)`
`double`	`ConvDiffHomogen.evalF(Node n)`
`double`	`CDH_Square.evalF(Node n)`
`double`	`CDH_Mini.evalF(Node n)`
`double`	`CDH_1D.evalF(Node n)`
`double`	`CDH_Weighted.evalLinearBasisFuncOnRef(Node u, int localBasisNumber)`
`double`	`CDH_HVM.evalTau(Triangle t, Node u, Node Xb)`
`double`	`CDH_WBF.evalWeightedBasisFunc(Triangle t, Node n, int local)`
`double`	`CDH_EF_Flux.evalWeightedBasisFuncOnRef(Node n, int local)`
`double`	`EV_1D_FEM.getExactPartialX(Node n)`
`double`	`ConvDiffBoundary.getExactPartialX(Node n)`
`double`	`ConvDiffHomogen.getExactPartialX(Node n)`
`double`	`CDH_Square.getExactPartialX(Node n)`
`double`	`CDH_Mini.getExactPartialX(Node n)`
`double`	`CDH_1D.getExactPartialX(Node n)`
`double`	`EV_1D_FEM.getExactPartialY(Node n)`
`double`	`ConvDiffBoundary.getExactPartialY(Node n)`
`double`	`ConvDiffHomogen.getExactPartialY(Node n)`
`double`	`CDH_Square.getExactPartialY(Node n)`
`double`	`CDH_Mini.getExactPartialY(Node n)`
`double`	`CDH_1D.getExactPartialY(Node n)`
`int`	`CDH_Weighted.getLocalNodeNumber(Triangle t, Node n)`
`double`	`CDH_HVM.getStabilizerTermRight(Triangle t, Node u)`
`double`	`Raithby_SUPG.getStabilizerTermRight(Triangle t, Node u)`
`double`	`CDH_SUPG.getStabilizerTermRight(Triangle t, Node u)`
`double`	`CDH_HVM.getStabTerm(Triangle t, Node u, Node v)`
`Node`	`SkewAdvection_RFB.getXminus(Triangle t, Node z)`
`Node`	`RotFlow_RFB.getXminus(Triangle t, Node z)`
`Node`	`CDH_RFB.getXminus(Triangle t, Node z)`

Uses of Node in mathcomp.assemble.discontinuousgalerkin

Methods in mathcomp.assemble.discontinuousgalerkin that return Node
`Node`	`DGNode.getNode()`
`Node[]`	`GaulegTri.getNodes()`
`Node[]`	`GaulegDim2.getNodes()`
`Node`	`InnEdge.node(int i)`
`Node`	`BndEdge.node(int i)`

Methods in mathcomp.assemble.discontinuousgalerkin with parameters of type Node
`void`	`GaulegTri.calc(Node a1, Node a2, Node a3)`
`double`	`DGAssembler.evalApproxSolution(Node n, Triangle t, Vector x)`
`double`	`DGAssembler.evalBasisFuncOnRef(Node u, int localBasisNumber)`
`double`	`TimeIndependentExample.evalExactSolution(Node n)`
`double`	`IniL2Interpolation.evalExactSolution(Node n)`
`double`	`DGAssembler.evalExactSolution(Node n)`
`double`	`DGAssembler.evalF(Node n)`
`double`	`TimeIndependentExample.evalG(Node n, double time)`
`double`	`TimeDependentExample2.evalG(Node n, double time)`
`double`	`TimeDependentExample1.evalG(Node n, double time)`
`double`	`IniL2Interpolation.evalG(Node n, double time)`
`abstract double`	`DGAssembler.evalG(Node n, double time)` computes the value of the right hand side coefficient function of the convection-diffusion problem.
`double`	`IniL2Interpolation.evalInitial(Node n)`
`double`	`TimeDependentExample2.evalU0(Node n)`
`double`	`TimeDependentExample1.evalU0(Node n)`
`abstract double`	`TimeDependentAssembler.evalU0(Node n)` Computes the initial value of the convection-diffusion problem at node n
`double`	`TimeIndependentExample.evalUd(Node n, double time)`
`double`	`TimeDependentExample2.evalUd(Node n, double time)`
`double`	`TimeDependentExample1.evalUd(Node n, double time)`
`double`	`IniL2Interpolation.evalUd(Node n, double time)`
`abstract double`	`DGAssembler.evalUd(Node n, double time)` Computes the value of the time dependent Dirichlet data in the point (n, time) of the convection-diffusion problem.

Constructors in mathcomp.assemble.discontinuousgalerkin with parameters of type Node
`DGNode(Node node, int i)`

Uses of Node in mathcomp.assemble.filament

Subclasses of Node in mathcomp.assemble.filament
`class`	`GhostNode`

Fields in mathcomp.assemble.filament declared as Node
`Node[]`	`Filament.nodes`
`Node[]`	`Filament.oldNodes`

Methods in mathcomp.assemble.filament that return Node
`Node`	`Filament.getNodeAt(int i)`

Methods in mathcomp.assemble.filament with parameters of type Node
`double[]`	`FilamentAssembler.evalExactGradientU1(Node n)`
`double[]`	`FilamentAssembler.evalExactGradientU2(Node n)`
`double`	`FilamentAssembler.evalExactSolutionPressure(Node n)`
`double`	`FilamentAssembler.evalExactSolutionU1(Node n)`
`double`	`FilamentAssembler.evalExactSolutionU2(Node n)`
`double`	`FilamentAssembler.evalF1(Node n)`
`double`	`FilamentAssembler.evalF2(Node n)`
`Triangle`	`FilamentAssembler.getTriangleFromNode(Node n)`
`void`	`Filament.setNodeAt(Node n, int i)`
`void`	`Filament.setNodes(Node[] nodes)`

Constructors in mathcomp.assemble.filament with parameters of type Node
`GhostNode(Node n, int index)`

Uses of Node in mathcomp.assemble.laplace

Methods in mathcomp.assemble.laplace with parameters of type Node
`double[]`	`SquareLaplaceAssembler.evalExactGradient(Node n)`
`double[]`	`MiniLaplaceAssembler.evalExactGradient(Node n)`
`double[]`	`LaplaceAssemblerLSing.evalExactGradient(Node n)`
`double[]`	`LaplaceAssemblerLReg.evalExactGradient(Node n)`
`double[]`	`LaplaceAssembler.evalExactGradient(Node n)`
`double`	`SquareLaplaceAssembler.evalExactSolution(Node n)`
`double`	`MiniLaplaceAssembler.evalExactSolution(Node n)`
`double`	`LaplaceAssemblerLSing.evalExactSolution(Node n)`
`double`	`LaplaceAssemblerLReg.evalExactSolution(Node n)`
`double`	`LaplaceAssembler.evalExactSolution(Node n)`
`double`	`SquareLaplaceAssembler.evalF(Node n)`
`double`	`MiniLaplaceAssembler.evalF(Node n)`
`double`	`LaplaceAssemblerLSing.evalF(Node n)`
`double`	`LaplaceAssemblerLReg.evalF(Node n)`
`double`	`LaplaceAssembler.evalF(Node n)`

Uses of Node in mathcomp.assemble.minimalsurface

Methods in mathcomp.assemble.minimalsurface with parameters of type Node
`double[]`	`MinimalSurfaceAssembler.evalExactGradient(Node n)`
`double`	`MinimalSurfaceAssembler.evalExactInitial(Node n)` returns the initial value for the node n
`double`	`MinimalSurfaceAssembler.evalExactSolution(Node n)`
`double`	`L2Interpolation.evalExactSolution(Node n)`
`double`	`MinimalSurfaceAssembler.evalF(Node n)`

Uses of Node in mathcomp.gridgeom

Fields in mathcomp.gridgeom declared as Node
`static Node[]`	`Transformation.gaussPoints`

Methods in mathcomp.gridgeom that return Node
`Node`	`Grid.getCenterNode()`
`Node`	`Triangle.getMiddleNode()`
`Node`	`Edge.getMiddleNode()`
`Node`	`Grid.getMiddleNode(Node a, Node b)` Calculates average of `a` and `b`.
`Node`	`Grid.getMiddleNodeForEdge(Triangle t, int index)`
`Node`	`Triangle.getNode(int i)` Returns the knot.
`Node`	`Edge.getNode(int i)`
`Node`	`Edge.getOtherNode(Node node)`
`static Node`	`Transformation.getRealFromRef(Triangle t, Node v_onRef)` Returns the coordinates of v_onRef in x coordinates.
`static Node`	`Transformation.getRealFromRefEdge(Edge e, double d_onRef)` Returns the coordinates of d_onRef in [-1,1] mapped on the Edge e.
`static Node`	`Transformation.getRefFromReal(Triangle t, Node v_onReal)` Returns the coordinates of v_onReal in eta coordinates.
`Node`	`Grid.getSchwerpunkt(Triangle t)` Calculates the average of the nodes of `t`.
`Node`	`Triangle.node(int i)`
`Node`	`Node.node(int i)`
`Node`	`Geometric.node(int i)` Returns the `i`-th node.
`Node`	`Edge.node(int i)`

Methods in mathcomp.gridgeom with parameters of type Node
`Triangle`	`Grid.addNewTriangle(Node[] nodes)` Adds a new Triangle based on `nodes`.
`static int`	`GeometricComparator.compareNodes(Node n1, Node n2)`
`boolean`	`Edge.contains(Node n)`
`boolean`	`Triangle.containsNode(Node node)`
`double`	`Node.getDistanceTo(Node k)` Calculates euclidian distance to `k`.
`static double`	`AdaptiveRefiner.getGradientLength(Node n, Triangle t, Vector x)`
`java.lang.String`	`Grid.getInfo(Node n)`
`int`	`Triangle.getLocalNodeNumber(Node node)`
`Node`	`Grid.getMiddleNode(Node a, Node b)` Calculates average of `a` and `b`.
`Node`	`Edge.getOtherNode(Node node)`
`static Node`	`Transformation.getRealFromRef(Triangle t, Node v_onRef)` Returns the coordinates of v_onRef in x coordinates.
`static Node`	`Transformation.getRefFromReal(Triangle t, Node v_onReal)` Returns the coordinates of v_onReal in eta coordinates.
`void`	`GridRefiner.move(Node k, Triangle t, int i)`
`void`	`Grid.setCenterNode(Node centerNode)`

Constructors in mathcomp.gridgeom with parameters of type Node
`Edge(Node a, Node b)`
`GridRefiner.NodeRefinementList(Node k)`
`Triangle(Node[] nodes)`

Uses of Node in mathcomp.gridgeom.refinements

Methods in mathcomp.gridgeom.refinements that return Node
`abstract Node`	`MovingRefinerDesc.getMiddleNode(Edge e)`
`Node`	`DistortionRefinement.getMiddleNode(Edge e)`

Methods in mathcomp.gridgeom.refinements with parameters of type Node
`double`	`DistortionRefinement.getCenterDistance(Node n)`

Uses of Node in mathcomp.gui

Methods in mathcomp.gui that return Node
`static Node`	`Util.doIntersect(Node n1, Node n2, Node e1, Node e2)`

Methods in mathcomp.gui with parameters of type Node
`static Node`	`Util.doIntersect(Node n1, Node n2, Node e1, Node e2)`
`static void`	`Util.ensureEdge(Triangle currentTriangle, Node n, double EPS, double R2_DAMPER, boolean output)`
`static Triangle`	`Util.findTriangle(Grid g, Node n)`
`static GhostNode`	`Util.getValidGhostNode(Triangle t, Node n_in, Node n_out)`
`static boolean`	`Util.inside(Triangle t, Node n)`

Uses of Node in mathcomp.gui.cfd

Methods in mathcomp.gui.cfd that return Node
`Node`	`Branch.getNodeAt(int i)`

Methods in mathcomp.gui.cfd with parameters of type Node
`void`	`Branch.addNodeWithDiam(Node n, double diam)`
`void`	`Skeleton.addPoint(Node n, double diam)`
`float`	`GradientGridRenderer.evalApproxFunction(Node n, Triangle t, float d0, float d1, float d2)`
`double`	`GradientGridRenderer.evalBasisFuncOnRefPressure(Node u, int localBasisNumber)`
`void`	`Branch.insertNewDataAfter(Node n, double diam, int index)`
`void`	`Branch.insertNodeAt(Node n, double diam, int index)`
`void`	`Branch.scaleWithRespectTo(double factor, Node anchor)`
`void`	`Branch.setNodeAt(Node n, int i)`
`void`	`Skeleton.updateNode(Node n, double diam, int selectedBranch, int selectedID)`
`void`	`Skeleton.updateNode(Node n, int selectedBranch, int selectedID)`

Uses of Node in mathcomp.la

Methods in mathcomp.la that return Node
`Node`	`GeometricWithNumber.node(int i)`

Uses of Node in mathcomp.util.cfd

Fields in mathcomp.util.cfd declared as Node
`Node[]`	`MatlabImport.nodes`

Methods in mathcomp.util.cfd that return Node
`Node[]`	`MatlabImport.getNodes()`

Methods in mathcomp.util.cfd with parameters of type Node
`double`	`ParticlePath.evalApproxSolution(Node n, Triangle t, int comp)`
`static double`	`SolutionAnalyzer.evalApproxSolution(Node n, Triangle t, Vector x, int component)`
`static double`	`SolutionAnalyzer.evalBasisFuncOnRefPressure(Node u, int localBasisNumber)`
`double`	`ParticlePath.evalBasisFuncOnRefVelocity(Node u, int localBasisNumber)`
`static double`	`SolutionAnalyzer.evalBasisFuncOnRefVelocity(Node u, int localBasisNumber)`
`double`	`SolutionAnalyzer.getAbsComponentMax(Node[] nodes, Vector sol1, Vector sol2, int component)`
`void`	`ParticlePath.runFrom(Node n, int steps)`

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Classmathcomp.gridgeom.Node

Uses of Class
mathcomp.gridgeom.Node