protected override void Evaluate(int i0, int Length, QuadRule rule, MultidimensionalArray EvalResult)
{
NodeSet Nodes = rule.Nodes;
int F = m_fields.Length;
int D = GridDat.SpatialDimension;
for (int f = 0; f < F; f++)
{
m_fields[f].Evaluate(i0, Length, Nodes, evalRes[f]);
}
GridDat.TransformLocal2Global(Nodes, i0, Length, X, 0);
int NoOfNodes = Nodes.NoOfNodes;
double[] _x = new double[D];
double[] args = new double[F];
for (int i = 0; i < Length; i++)
{
for (int n = 0; n < NoOfNodes; n++)
{
for (int f = 0; f < F; f++)
{
args[f] = evalRes[f][i, n];
}
for (int d = 0; d < D; d++)
{
_x[d] = X[i, n, d];
}
EvalResult[i, n, 0] = m_f(_x, args, i + i0);
}
}
}
void PlotCell0()
{
BoundingBox BB = new BoundingBox(2);
GridDat.Cells.GetCellBoundingBox(0, BB);
int Nx = 50;
int Ny = 55;
var xNodes = Grid1D.Linspace(BB.Min[0], BB.Max[0], Nx);
var yNodes = Grid1D.Linspace(BB.Min[1], BB.Max[1], Ny);
var GlobalNodes = MultidimensionalArray.Create(Nx, Ny, 2);
for (int i = 0; i < Nx; i++)
{
for (int j = 0; j < Ny; j++)
{
GlobalNodes[i, j, 0] = xNodes[i];
GlobalNodes[i, j, 1] = yNodes[j];
}
}
var GlobalNodes_C = GlobalNodes.ResizeShallow(Nx * Ny, 2);
var LocalNodes = MultidimensionalArray.Create(1, Nx * Ny, 2);
GridDat.TransformGlobal2Local(GlobalNodes_C, LocalNodes, 0, 1, 0);
var Values = MultidimensionalArray.Create(1, Nx, Ny);
var Values_ = Values.ResizeShallow(1, Nx * Ny);
var Gradients = MultidimensionalArray.Create(1, Nx, Ny, 2);
var Gradients_ = Gradients.ResizeShallow(1, Nx * Ny, 2);
var NodeSet = GridDat.NSC.CreateContainer(LocalNodes.ExtractSubArrayShallow(0, -1, -1), 0);
var lh = GridDat.NSC.LockNodeSetFamily(NodeSet);
f1.Evaluate(0, 1, 0, Values_);
f1.EvaluateGradient(0, 1, 0, Gradients_);
GridDat.NSC.UnlockNodeSetFamily(lh);
xNodes.SaveToTextFile("C:\\tmp\\xNodes.txt");
yNodes.SaveToTextFile("C:\\tmp\\yNodes.txt");
FullMatrix output1 = new FullMatrix(Values.ExtractSubArrayShallow(0, -1, -1));
output1.ToTxtFile("C:\\tmp\\f.txt");
FullMatrix output2 = new FullMatrix(Gradients.ExtractSubArrayShallow(0, -1, -1, 0));
output2.ToTxtFile("C:\\tmp\\df.txt");
}
/// <summary>
/// Integrand evaluation.
/// </summary>
protected override void Evaluate(int i0, int Length, QuadRule rule, MultidimensionalArray EvalResult)
{
NodeSet NodesUntransformed = rule.Nodes;
int M = NodesUntransformed.GetLength(0);
int D = NodesUntransformed.GetLength(1);
// evaluate scalar function ans store result in 'EvalResult'
// =========================================================
Debug.Assert(!((m_func != null) && (m_funcEx != null)));
if (m_func != null || m_Map != null)
{
GridDat.TransformLocal2Global(NodesUntransformed, i0, Length, m_NodesTransformed, 0);
}
if (m_func != null)
{
MultidimensionalArray inp = m_NodesTransformed.ResizeShallow(new int[] { Length *M, D });
MultidimensionalArray outp = EvalResult.ResizeShallow(new int[] { Length *M });
m_func(inp, outp);
Debug.Assert(m_funcEx == null);
}
if (m_funcEx != null)
{
m_funcEx(i0, Length, NodesUntransformed, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
Debug.Assert(m_func == null);
}
if (m_Map == null)
{
// L2 error branch
// +++++++++++++++
MultidimensionalArray fieldvals = EvalResult.ResizeShallow(new int[] { Length, NodesUntransformed.GetLength(0) });
m_Owner.Evaluate(i0, Length, NodesUntransformed, fieldvals, -1.0);
for (int j = 0; j < Length; j++)
{
for (int m = 0; m < M; m++)
{
double e;
e = EvalResult[j, m, 0];
EvalResult[j, m, 0] = e * e;
}
}
}
else
{
// arbitrary mapping branch
// ++++++++++++++++++++++++
MultidimensionalArray fieldvals = MultidimensionalArray.Create(new int[] { Length, NodesUntransformed.GetLength(0) });
m_Owner.Evaluate(i0, Length, NodesUntransformed, fieldvals, -1.0);
double[] X = new double[D];
for (int j = 0; j < Length; j++)
{
for (int m = 0; m < M; m++)
{
double e;
e = EvalResult[j, m, 0];
for (int d = 0; d < D; d++)
{
X[d] = m_NodesTransformed[j, m, d];
}
EvalResult[j, m, 0] = this.m_Map(X, fieldvals[j, m], e);
}
}
}
}
