protected override void InternalCompute()
{
var cancelManager = this.Services.CancelManager;
this.matrix = new DoubleDenseMatrix(this.VisitedGraph.VertexCount, this.VisitedGraph.VertexCount);
this.vertexIndices = new Dictionary <TVertex, int>(this.VisitedGraph.VertexCount);
int index = 0;
foreach (var v in this.VisitedGraph.Vertices)
{
if (cancelManager.IsCancelling)
{
break;
}
this.vertexIndices.Add(v, index++);
}
foreach (var v in this.VisitedGraph.Vertices)
{
if (cancelManager.IsCancelling)
{
break;
}
int source = this.VertexIndices[v];
foreach (var edge in this.VisitedGraph.OutEdges(v))
{
int target = this.VertexIndices[edge.Target];
matrix[source, target] = 1;
}
}
}
public MatrixProvider(int polynomialOrder)
{
if (polynomialOrder < 1 || polynomialOrder > 4)
{
throw new NotSupportedException(nameof(polynomialOrder));
}
_polynomialOrder = polynomialOrder;
if (polynomialOrder == 1)
{
_coordinates = new DoubleDenseMatrix(polynomialOrder + 1, 1
, new double[] { -1, 1 });
}
else if (polynomialOrder == 2)
{
_coordinates = new DoubleDenseMatrix(polynomialOrder + 1, 1
, new double[] { -1, 0, 1 });
}
else if (polynomialOrder == 3)
{
_coordinates = new DoubleDenseMatrix(polynomialOrder + 1, 1
, new double[] { -1, -0.447213595499958, 0.447213595499958, 1 });
}
else if (polynomialOrder == 4)
{
_coordinates = new DoubleDenseMatrix(polynomialOrder + 1, 1
, new double[] { -1, -0.654653670707977, 0, 0.654653670707977, 1 });
}
}
/// <summary>
/// Judge the stability of the given eigenmode.
/// </summary>
/// <param name="v">The eigenvector corresponding to the eigenmode.</param>
/// <returns>Return false if the mode includes oscillation.</returns>
private static bool IsStable(DoubleDenseMatrix v)
{
var max = v.Max();
var min = v.Min();
return(max * min > 0);
}
public FRUniformMatrixAssembler(int numberOfElements, int polynomialOrder)
{
_numberOfElements = numberOfElements;
_numberOfSolutionPoints = polynomialOrder + 1;
_localMatrixProvider = new MatrixProvider(polynomialOrder);
_dcoef = _localMatrixProvider.GetLocalAdvectionMatrix();
}
protected override void InternalCompute()
{
this.matrix = new DoubleDenseMatrix(this.VisitedGraph.VertexCount, this.VisitedGraph.VertexCount);
this.vertexIndices = new Dictionary <TVertex, int>(this.VisitedGraph.VertexCount);
int index = 0;
foreach (TVertex v in this.VisitedGraph.Vertices)
{
if (this.IsAborting)
{
return;
}
this.vertexIndices.Add(v, index++);
}
foreach (TVertex v in this.VisitedGraph.Vertices)
{
if (this.IsAborting)
{
return;
}
int source = this.VertexIndices[v];
foreach (TEdge edge in this.VisitedGraph.OutEdges(v))
{
int target = this.VertexIndices[edge.Target];
matrix[source, target] = 1;
}
}
}
public MatrixSizeMistmatchException(
DoubleDenseMatrix left,
DoubleDenseMatrix right)
: this(String.Format("Matrix size ({0}x{1}) does not match ({2}x{3})",
left.RowCount, left.ColumnCount, right.RowCount, right.ColumnCount))
{
}
protected ShapeFunctionBase(Element element, int dimension)
{
_element = element;
_phi = new DoubleDenseMatrix(_element.NumberOfNodesInAnElement, 1);
_dphi = new DoubleDenseMatrix(_element.NumberOfNodesInAnElement, dimension);
_J = new DoubleDenseMatrix(dimension, dimension);
}
public DoubleDenseMatrix EvaluateRHS(DoubleDenseMatrix u)
{
var yield = new DoubleDenseMatrix(_numberOfSolutionPoints, _numberOfElements);
for (var k = 0; k < _numberOfElements; k++)
{
// compute discontinuous derivative.
var dfdx = _dcoef * u.SubMatrix(0, k, _numberOfSolutionPoints - 1, k);
{
// left flux correction procedure.
var minusElementIndex = k == 0 ? _numberOfElements - 1 : k - 1;
var commonFluxLeftBoundary = 0.5 * (u[_numberOfSolutionPoints - 1, minusElementIndex] + u[0, k]);
var corrctionFluxLeft = commonFluxLeftBoundary - u[0, k];
for (var i = 0; i < _numberOfSolutionPoints; i++)
{
dfdx[i, 0] += _correctionFuncLeft[i, 0] * corrctionFluxLeft;
}
}
{
// right flux correction procedure.
var plusElementIndex = k == _numberOfElements - 1 ? 0 : k + 1;
var commonFluxRightBoundary = 0.5 * (u[0, plusElementIndex] + u[_numberOfSolutionPoints - 1, k]);
var corrctionFluxRight = commonFluxRightBoundary - u[_numberOfSolutionPoints - 1, k];
for (var i = 0; i < _numberOfSolutionPoints; i++)
{
dfdx[i, 0] += _correctionFuncRight[i, 0] * corrctionFluxRight;
}
}
yield.SubMatrix(dfdx, 0, k, _numberOfSolutionPoints - 1, k);
}
return(-yield);
}
public DoubleDenseMatrix GetLocalAdvectionMatrix()
{
if (_differentiate == null)
{
_differentiate = CreateDifferentiationMatrix();
}
return(_differentiate);
}
internal static double Interpolate(Element element, DoubleDenseMatrix src)
{
element.Shape.SetCoordinate(Axis.X, 0.0);
element.Shape.SetCoordinate(Axis.Y, 0.0);
var Phi = element.Shape.Phi;
return(Interpolate(element, src, Phi));
}
public Advection1D(MatrixProvider provider, int numberOfElements, int numberOfSolutionPoints)
{
_dcoef = provider.GetLocalAdvectionMatrix();
_correctionFuncLeft = provider.GetLeftCorrectionFunc();
_correctionFuncRight = provider.GetRightCorrectionFunc();
_numberOfElements = numberOfElements;
_numberOfSolutionPoints = numberOfSolutionPoints;
}
public DoubleDenseMatrix Chain()
{
DoubleDenseMatrix m = new DoubleDenseMatrix(3, 3);
m[0, 1] = 1;
m[1, 2] = 1;
return(m);
}
internal static double Interpolate(Element element, DoubleDenseMatrix src, DoubleDenseMatrix Phi)
{
var yield = 0.0;
foreach (var node in element.Nodes)
{
yield += src[node.GlobalIndex] * Phi[node.LocalIndex];
}
return(yield);
}
public void SelfSimilarity([PexAssumeNotNull] DoubleDenseMatrix matrix)
{
Console.WriteLine("Matrix");
matrix.WriteMatrix(Console.Out);
Console.WriteLine("Similarity");
DoubleDenseMatrix similarity = DoubleDenseMatrix.Similarity(matrix, matrix, 0.001);
similarity.WriteMatrix(Console.Out);
}
public static DoubleDenseMatrix DiffLagrange(DoubleDenseMatrix points)
{
var yield = new DoubleDenseMatrix(points.RowNum, points.RowNum);
for (var i = 0; i < points.RowNum; i++)
{
var subset = DiffLagrange(points, points[i, 0]);
yield.SubMatrix(subset.Transpose(), i, 0, i, points.RowNum - 1);
}
return(yield);
}
public DoubleDenseMatrix GetLeftCorrectionFunc()
{
if (_cfLeft == null)
{
_cfLeft = new DoubleDenseMatrix(_polynomialOrder + 1, 1);
GetRightCorrectionFunc();
for (var i = 0; i < _polynomialOrder + 1; i++)
{
_cfLeft[_polynomialOrder - i, 0] = -(_cfRight[i, 0]);
}
}
return(_cfLeft);
}
public DoubleDenseMatrix GetRightCorrectionFunc()
{
if (_cfRight == null)
{
_cfRight = new DoubleDenseMatrix(_polynomialOrder + 1, 1);
for (var i = 0; i < _polynomialOrder + 1; i++)
{
var deriv = Polynomials.Derivation(Polynomials.LeftRadau, _polynomialOrder + 1, _coordinates[i, 0]);
_cfRight[i, 0] = deriv;
}
}
return(_cfRight);
}
public DoubleDenseMatrix Evenly23()
{
DoubleDenseMatrix m = new DoubleDenseMatrix(2, 3);
int k = 0;
for (int i = 0; i < m.RowCount; ++i)
{
for (int j = 0; j < m.ColumnCount; ++j)
{
m[i, j] = k++;
}
}
return(m);
}
public static DoubleDenseMatrix Integrate(Func <Element, double, double, double, double, DoubleDenseMatrix> function, INumericalIntegration integrator, Element element)
{
var yield = new DoubleDenseMatrix(element.NumberOfNodesInAnElement, element.NumberOfNodesInAnElement);
for (var p = 0; p < integrator.NumberOfIntegrationPoints; p++)
{
for (var q = 0; q < integrator.NumberOfIntegrationPoints; q++)
{
yield += function(element,
integrator.IntegrationPoint(p),
integrator.Weight(p),
integrator.IntegrationPoint(q),
integrator.Weight(q));
}
}
return(yield);
}
public static DoubleDenseMatrix Lagrange(DoubleDenseMatrix points, double xi)
{
var l = new DoubleDenseMatrix(points.RowNum, 1);
for (var i = 0; i < points.RowNum; i++)
{
l[i, 0] = 1.0;
for (var j = 0; j < points.RowNum; j++)
{
if (i != j)
{
l[i, 0] *= ((xi - points[j, 0]) / (points[i, 0] - points[j, 0]));
}
}
}
return(l);
}
internal static DoubleDenseMatrix Stiffness(Element element)
{
var yield = new DoubleDenseMatrix(element.NumberOfNodesInAnElement, element.NumberOfNodesInAnElement);
var dPhi = element.Shape.dPhi;
var InvJ = element.Shape.InverseOfJacobianMatrix;
var detJ = element.Shape.Determinant;
for (var i = 0; i < element.NumberOfNodesInAnElement; i++)
{
var dPhiidX = InvJ[0, 0] * dPhi[i, 0] + InvJ[0, 1] * dPhi[i, 1];
var dPhiidY = InvJ[1, 0] * dPhi[i, 0] + InvJ[1, 1] * dPhi[i, 1];
for (var j = 0; j < element.NumberOfNodesInAnElement; j++)
{
var dPhijdX = InvJ[0, 0] * dPhi[j, 0] + InvJ[0, 1] * dPhi[j, 1];
var dPhijdY = InvJ[1, 0] * dPhi[j, 0] + InvJ[1, 1] * dPhi[j, 1];
yield[i, j] = dPhiidX * dPhijdX + dPhiidY * dPhijdY;
}
}
yield *= detJ;
return(yield);
}
static void Main()
{
const int polyOrder = 2;
const int numberOfElements = 100;
var adv1d = new FR.Tests.Advection1D(new FR.MatrixProvider(polyOrder), numberOfElements, polyOrder + 1);
var rho = new DoubleDenseMatrix(polyOrder + 1, numberOfElements);
{
for (var k = 0; k < numberOfElements; k++)
{
for (var i = 0; i < polyOrder + 1; i++)
{
var x = k * 2.0 + i - 1.0;
rho[i, k] = Math.Sin(0.2 * Math.PI * x);
}
}
}
foreach (var it in System.Linq.Enumerable.Range(0, 1000))
{
rho = RK4(adv1d.EvaluateRHS, rho, 1.0e-1);
Console.WriteLine($"MAX: {rho.ToArray().Max().ToString("0.00")}, MIN: {rho.ToArray().Min().ToString("0.00")}");
}
}
public void Solve()
{
if (_solverJ == null)
{
var A = _assembler.GetStiffnessMatrix(_epsilonR);
foreach (var boundary in _potentials)
{
_boundary.ImposeFirstKindBoundaryCondition(A, boundary.Key);
}
_solverJ.SetMatrix(A);
}
if (_solverM == null)
{
_M = _assembler.GetMassMatrix();
_solverM.SetMatrix(_M);
}
var rhsVector = _M * _rhs;
foreach (var boundary in _potentials)
{
_boundary.ImposeFirstKindBoundaryCondition(rhsVector, boundary.Key, boundary.Value);
}
_phi = _solverJ.Solve(rhsVector);
}
public void SetRightHandSideVector(DoubleDenseMatrix value)
{
_rhs = value;
}
public void SetLeftHandSideVector(DoubleDenseMatrix value)
{
_epsilonR = value;
}
public static DoubleDenseMatrix DiffLagrange(DoubleDenseMatrix points, double xi)
{
return((Lagrange(points, xi + _eps) - Lagrange(points, xi - _eps)) / (2.0 * _eps));
}
/// <summary> /// 生成行列を返します。 /// </summary> protected abstract void AssembleSourceMatrix(DoubleSparseMatrix S, Func <Axis, DoubleDenseMatrix> vhandle, DoubleDenseMatrix diffusion, DoubleDenseMatrix source);
/// <summary> /// 質量行列を返します。 /// </summary> /// <param name="M"></param> protected abstract void AssembleMassMatrix(DoubleSparseMatrix M, Func <Axis, DoubleDenseMatrix> vhandle, DoubleDenseMatrix diffusion);
public void ToString([PexAssumeNotNull] DoubleDenseMatrix matrix)
{
Console.WriteLine(matrix);
}
public void WriteMatrix([PexAssumeNotNull] DoubleDenseMatrix matrix)
{
matrix.WriteMatrix(Console.Out);
}
