protected override NodeSetController.NodeSetContainer[] CreateNodeSetFamily(Platform.MultidimensionalArray NodesUntransformed)
{
Simplex volSimplx = m_Context.Grid.GridSimplex;
int NoOfEdgesPerSimplex = volSimplx.NoOfEdges;
int NoOfTrafos = m_Context.GridDat.InterCellTransformations.Length;
int NoOfNodes = NodesUntransformed.GetLength(0);
int D = m_Context.Grid.SpatialDimension;
//// ======
//// create
//// ======
//for (int i = 0; i < m_TestFunctions_1stCell.GetLength(0); i++) {
// m_NodesUntransfomedVolCoord_1stEdge[i] = MultidimensionalArray.CreateEmpty(2);
// for (int _k = 0; _k < m_NodesUntransfomedVolCoord_2ndEdge.GetLength(1); _k++)
// m_NodesUntransfomedVolCoord_2ndEdge[i, _k] = MultidimensionalArray.CreateEmpty(2);
//}
//// ==========================
//// allocate storage structure
//// ==========================
//for (int e = 0; e < NoOfEdgesPerSimplex; e++) {
// m_NodesUntransfomedVolCoord_1stEdge[e].Allocate(NoOfNodes, D);
// for (int k = 0; k < NoOfTrafos; k++) {
// m_NodesUntransfomedVolCoord_2ndEdge[e, k].Allocate(NoOfNodes, D);
// }
//}
// ================================================================================
// transform quadrature nodes from edge simplex to volume simplex coordinate system
// ================================================================================
NodeSetController.NodeSetContainer[] nodeSetFamily = new NodeSetController.NodeSetContainer[NoOfEdgesPerSimplex * (NoOfTrafos + 1)];
int NoOftrafos = m_Context.GridDat.InterCellTransformations.Length;
for (int e = 0; e < NoOfEdgesPerSimplex; e++)
{
var nodes = MultidimensionalArray.Create(NoOfNodes, D);
volSimplx.EdgeToVolumeCoordinates(e, NodesUntransformed, nodes);
nodeSetFamily[e] = m_Context.NSC.CreateContainer(nodes, 0.0);
for (int _k = 0; _k < NoOftrafos; _k++)
{
var nodes2 = MultidimensionalArray.Create(NoOfNodes, D);
m_Context.GridDat.InterCellTransformations[_k].Transform(nodes, nodes2);
nodeSetFamily[NodeSetIndex(e, _k)] = m_Context.NSC.CreateContainer(nodes2, 0.0);
}
}
return(nodeSetFamily);
}
void OrthonormalityTest()
{
Basis B = f1.Basis;
int N = B.Length;
var Mtx = new FullMatrix(N, N);
double TotErrSum = 0.0;
CellQuadrature.GetQuadrature(new int[] { N, N }, this.GridDat,
(new CellQuadratureScheme(true)).Compile(GridDat, Math.Min(B.Degree * 2, 16)),
delegate(MultidimensionalArray NodesUntransformed, int iKref) {
var ret = new NodeSetController.NodeSetContainer[] {
GridDat.NSC.CreateContainer(NodesUntransformed, iKref)
};
return(ret);
},
delegate(int i0, int Length, int NoOfNodes, MultidimensionalArray EvalResult) { // void Del_Evaluate
var BasisVal = B.CellEval(0, i0, Length);
EvalResult.Multiply(1.0, BasisVal, BasisVal, 0.0, "jknm", "jkn", "jkm");
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) { // SaveIntegrationResults
for (int i = 0; i < Length; i++)
{
var MassMtx = ResultsOfIntegration.ExtractSubArrayShallow(i, -1, -1);
double errsum = 0;
for (int n = 0; n < N; n++)
{
for (int m = 0; m < N; m++)
{
double soll = (n == m) ? 1.0 : 0.0;
errsum += Math.Abs(MassMtx[m, n] - soll);
}
}
TotErrSum += errsum;
}
}).Execute();
Console.WriteLine("orthonormality error sum:" + TotErrSum);
}
public QuadRule GetCutCellQuadRule(LevelSet levelSet, int baseOrder, int cell)
{
// Build tree
subdivisionTree.ResetToSavePoint();
NestedVertexSet currentSet = baseVertexSet;
for (int i = minLevels; i < maxLevels; i++)
{
if (currentSet.LocalNumberOfVertices == 0)
{
// No new vertices were added during last subdivision
break;
}
NodeSetController.NodeSetContainer nsc = context.NSC.CreateContainer(currentSet.Vertices, -1.0);
uint lh = context.NSC.LockNodeSetFamily(nsc);
MultidimensionalArray levelSetValues = MultidimensionalArray.Create(1, nsc.NodeSet.GetLength(0));
levelSet.Evaluate(cell, 1, 0, levelSetValues);
context.NSC.UnlockNodeSetFamily(lh);
subdivisionTree.ReadLevelSetValues(levelSetValues.ExtractSubArrayShallow(0, -1));
currentSet = new NestedVertexSet(currentSet);
subdivisionTree.Subdivide(currentSet, true);
}
// Read level set values of leaves (only if IsCut is used!)
if (currentSet.Vertices != null)
{
NodeSetController.NodeSetContainer nsc2 = context.NSC.CreateContainer(currentSet.Vertices, -1.0);
uint lh2 = context.NSC.LockNodeSetFamily(nsc2);
MultidimensionalArray levelSetValues2 = MultidimensionalArray.Create(1, nsc2.NodeSet.GetLength(0));
levelSet.Evaluate(cell, 1, 0, levelSetValues2);
context.NSC.UnlockNodeSetFamily(lh2);
subdivisionTree.ReadLevelSetValues(levelSetValues2.ExtractSubArrayShallow(0, -1));
}
// Construct rule
List <double[]> nodes = new List <double[]>();
List <double> weights = new List <double>();
foreach (SimplexSubdivisionTree.Node leave in subdivisionTree.Leaves)
{
double det = leave.TransformationFromRoot.Matrix.Determinat();
QuadRule rule;
if (leave.IsCut)
{
rule = GetStandardQuadRule(baseOrder);
}
else
{
rule = GetStandardQuadRule(1);
}
for (int i = 0; i < rule.NoOfNodes; i++)
{
double[] vertex = ArrayTools.GetRow(rule.Nodes, i);
nodes.Add(leave.TransformationFromRoot.Transform(vertex));
weights.Add(det * rule.Weights[i]);
}
}
QuadRule result = new QuadRule();
result.Nodes = NodesToRectangularArray(nodes);
result.Weights = weights.ToArray();
return(result);
}
