protected override double RunSolverOneStep(int TimestepNo, double phystime, double dt)
{
//phystime = 1.8;
LsUpdate(phystime);
// operator-matrix assemblieren
OperatorMatrix = new BlockMsrMatrix(ProblemMapping);
AltOperatorMatrix = new MsrMatrix(ProblemMapping);
double[] Affine = new double[OperatorMatrix.RowPartitioning.LocalLength];
MultiphaseCellAgglomerator Agg;
// Agglomerator setup
//Agg = new MultiphaseCellAgglomerator(new CutCellMetrics(MomentFittingVariant, m_quadOrder, LsTrk, LsTrk.GetSpeciesId("B")), this.THRESHOLD, false);
Agg = LsTrk.GetAgglomerator(new SpeciesId[] { LsTrk.GetSpeciesId("B") }, m_quadOrder, __AgglomerationTreshold: this.THRESHOLD);
Console.WriteLine("Inter-Process agglomeration? " + Agg.GetAgglomerator(LsTrk.GetSpeciesId("B")).AggInfo.InterProcessAgglomeration);
// operator matrix assembly
//Op.ComputeMatrixEx(LsTrk,
// ProblemMapping, null, ProblemMapping,
// OperatorMatrix, Affine, false, 0.0, true,
// Agg.CellLengthScales, null, null,
// LsTrk.SpeciesIdS.ToArray());
XSpatialOperatorMk2.XEvaluatorLinear mtxBuilder = Op.GetMatrixBuilder(base.LsTrk, ProblemMapping, null, ProblemMapping, LsTrk.SpeciesIdS.ToArray());
mtxBuilder.time = 0.0;
mtxBuilder.ComputeMatrix(OperatorMatrix, Affine);
Agg.ManipulateMatrixAndRHS(OperatorMatrix, Affine, this.ProblemMapping, this.ProblemMapping);
//Op.ComputeMatrixEx(LsTrk,
// ProblemMapping, null, ProblemMapping,
// AltOperatorMatrix, Affine, false, 0.0, true,
// Agg.CellLengthScales, null, null,
// LsTrk.SpeciesIdS.ToArray());
mtxBuilder.ComputeMatrix(AltOperatorMatrix, Affine);
Agg.ManipulateMatrixAndRHS(AltOperatorMatrix, Affine, this.ProblemMapping, this.ProblemMapping);
int nnz = this.OperatorMatrix.GetTotalNoOfNonZeros();
Console.WriteLine("Number of non-zeros in matrix: " + nnz);
int nnz2 = this.AltOperatorMatrix.GetTotalNoOfNonZeros();
Assert.IsTrue(nnz == nnz2, "Number of non-zeros in matrix different for " + OperatorMatrix.GetType() + " and " + AltOperatorMatrix.GetType());
Console.WriteLine("Number of non-zeros in matrix (reference): " + nnz2);
MsrMatrix Comp = AltOperatorMatrix.CloneAs();
Comp.Acc(-1.0, OperatorMatrix);
double CompErr = Comp.InfNorm();
double Denom = Math.Max(AltOperatorMatrix.InfNorm(), OperatorMatrix.InfNorm());
double CompErrRel = Denom > Math.Sqrt(double.Epsilon) ? CompErr / Denom : CompErr;
Console.WriteLine("Comparison: " + CompErrRel);
Assert.LessOrEqual(CompErrRel, 1.0e-7, "Huge difference between MsrMatrix and BlockMsrMatrix.");
base.TerminationKey = true;
return(0.0);
}
public override void OnDraw(Agg.Graphics2D graphics2D)
{
RectangleDouble Bounds = LocalBounds;
RoundedRect rectBorder = new RoundedRect(Bounds, this.borderRadius);
graphics2D.Render(rectBorder, borderColor);
RectangleDouble insideBounds = Bounds;
insideBounds.Inflate(-this.borderWidth);
RoundedRect rectInside = new RoundedRect(insideBounds, Math.Max(this.borderRadius - this.borderWidth, 0));
graphics2D.Render(rectInside, this.fillColor);
if (this.isUnderlined)
{
//Printer.TypeFaceStyle.DoUnderline = true;
RectangleDouble underline = new RectangleDouble(LocalBounds.Left, LocalBounds.Bottom, LocalBounds.Right, LocalBounds.Bottom);
graphics2D.Rectangle(underline, buttonText.TextColor);
}
base.OnDraw(graphics2D);
}
static void Main(string[] args)
{
Store myStore = new Store();
// Add aggs to store
int aggCode = HashCode.Combine(1, 2, 3, 4, 2, 3, 4, 5);
Agg myAgg = new Agg(5, aggCode, "Agg Corp.", 10, Color.Grey);
myStore.AddProduct(myAgg, 20);
// Add apples to store
int appleCode = HashCode.Combine(2, 2, 3, 4, 2, 3, 4, 5);
Apple myApple = new Apple(3.5, appleCode, "Apple Inc.");
myStore.AddProduct(myApple, 100);
// Add bread to store
int breadCode = HashCode.Combine(2, 2, 5, 4, 4, 3, 4, 5);
Bread myBread = new Bread(6, breadCode, "Tom's Bakery");
myStore.AddProduct(myBread, 35);
// Add sugar to store
int sugarCode = HashCode.Combine(2, 2, 3, 4, 2, 9, 8, 5);
Sugar mySugar = new Sugar(2.5, sugarCode, "BelSugar");
myStore.AddProduct(mySugar, 55);
// Add sugar to store
int milkCode = HashCode.Combine(9, 2, 1, 4, 2, 3, 4, 3);
Milk myMilk = new Milk(2.5, milkCode, "BestMilk Inc.", 1.0, 12.5);
myStore.AddProduct(myMilk, 67);
// Show all product in the store
myStore.Print();
}
private FlowLayoutWidget CreateSelectionContainer(string labelText, string validationMessage, Agg.UI.DropDownList selector)
{
var sectionLabel = new TextWidget(labelText, 0, 0, 12)
{
TextColor = ActiveTheme.Instance.PrimaryTextColor,
HAnchor = HAnchor.ParentLeftRight,
Margin = elementMargin
};
var validationTextWidget = new TextWidget(validationMessage, 0, 0, 10)
{
TextColor = ActiveTheme.Instance.SecondaryAccentColor,
HAnchor = HAnchor.ParentLeftRight,
Margin = elementMargin
};
selector.SelectionChanged += (s, e) =>
{
validationTextWidget.Visible = selector.SelectedLabel.StartsWith("-"); // The default values have "- Title -"
};
var container = new FlowLayoutWidget(FlowDirection.TopToBottom)
{
Margin = new BorderDouble(0, 5),
HAnchor = HAnchor.ParentLeftRight
};
container.AddChild(sectionLabel);
container.AddChild(selector);
container.AddChild(validationTextWidget);
return container;
}
public override void OnDraw(Agg.Graphics2D graphics2D)
{
base.OnDraw(graphics2D);
graphics2D.Rectangle(LocalBounds, borderColor);
}
public override void OnDraw(Agg.Graphics2D graphics2D)
{
base.OnDraw(graphics2D);
}
public override void OnDraw(Agg.Graphics2D graphics2D)
{
base.OnDraw(graphics2D);
if (this.isUnderlined)
{
//Printer.TypeFaceStyle.DoUnderline = true;
RectangleDouble underline = new RectangleDouble(LocalBounds.Left, LocalBounds.Bottom, LocalBounds.Right, LocalBounds.Bottom);
graphics2D.Rectangle(underline, this.TextColor);
}
}
public static OId OutLT(string name, int from, int?to = null, Agg layerAgg = Agg.NONE, Agg timeAgg = Agg.AVG)
{
return(new OId {
Name = name, From = from, To = to, LayerAgg = layerAgg, TimeAgg = timeAgg
});
}
public static OId OutT(string name, Agg agg = Agg.AVG)
{
return(new OId {
Name = name, TimeAgg = agg
});
}
public void SetUp()
{
Isource = MockRepository.GenerateMock <ISource>();
agg = new Agg(new [Isource]);
protected override double RunSolverOneStep(int TimestepNo, double phystime, double dt)
{
LsUpdate(phystime);
// operator-matrix assemblieren
OperatorMatrix = new BlockMsrMatrix(MG_Mapping.ProblemMapping);
AltOperatorMatrix = new MsrMatrix(MG_Mapping.ProblemMapping);
double[] Affine = new double[OperatorMatrix.RowPartitioning.LocalLength];
MultiphaseCellAgglomerator Agg;
Agg = LsTrk.GetAgglomerator(this.LsTrk.SpeciesIdS.ToArray(), m_quadOrder, __AgglomerationTreshold: this.THRESHOLD);
XSpatialOperatorMk2.XEvaluatorLinear mtxBuilder = Op.GetMatrixBuilder(base.LsTrk, MG_Mapping.ProblemMapping, null, MG_Mapping.ProblemMapping);
mtxBuilder.time = 0.0;
mtxBuilder.ComputeMatrix(OperatorMatrix, Affine);
Agg.ManipulateMatrixAndRHS(OperatorMatrix, Affine, MG_Mapping.ProblemMapping, MG_Mapping.ProblemMapping);
foreach (var S in this.LsTrk.SpeciesNames)
{
Console.WriteLine(" Species {0}: no of agglomerated cells: {1}",
S, Agg.GetAgglomerator(this.LsTrk.GetSpeciesId(S)).AggInfo.SourceCells.NoOfItemsLocally);
}
MGOp = new MultigridOperator(XAggB, map,
OperatorMatrix,
this.massFact.GetMassMatrix(map, false),
OpConfig, null);
Debug.Assert(MGOp.OperatorMatrix != null);
Debug.Assert(MGOp.Mapping != null);
someVec = GetRHS(Affine, OperatorMatrix);
mtxBuilder.ComputeMatrix(AltOperatorMatrix, Affine);
Agg.ManipulateMatrixAndRHS(AltOperatorMatrix, Affine, MG_Mapping.ProblemMapping, MG_Mapping.ProblemMapping);
//LsTrk.GetSpeciesName(((XdgAggregationBasis)MGOp.Mapping.AggBasis[0]).UsedSpecies[1]);
//LsTrk.GetSpeciesName(((XdgAggregationBasis)MGOp.Mapping.AggBasis[0]).UsedSpecies[0]);
int nnz = this.OperatorMatrix.GetTotalNoOfNonZeros();
Console.WriteLine("Number of non-zeros in matrix: " + nnz);
int nnz2 = this.AltOperatorMatrix.GetTotalNoOfNonZeros();
Assert.IsTrue(nnz == nnz2, "Number of non-zeros in matrix different for " + OperatorMatrix.GetType() + " and " + AltOperatorMatrix.GetType());
Console.WriteLine("Number of non-zeros in matrix (reference): " + nnz2);
MsrMatrix Comp = AltOperatorMatrix.CloneAs();
Comp.Acc(-1.0, OperatorMatrix);
double CompErr = Comp.InfNorm();
double Denom = Math.Max(AltOperatorMatrix.InfNorm(), OperatorMatrix.InfNorm());
double CompErrRel = Denom > Math.Sqrt(double.Epsilon) ? CompErr / Denom : CompErr;
Console.WriteLine("Comparison: " + CompErrRel);
Assert.LessOrEqual(CompErrRel, 1.0e-7, "Huge difference between MsrMatrix and BlockMsrMatrix.");
base.TerminationKey = true;
return(0.0);
}
public override void OnMouseWheel(Agg.UI.MouseEventArgs mouseEvent)
{
CameraZoom = mouseEvent.WheelDelta * .2f;
base.OnMouseWheel(mouseEvent);
}
public override void OnMouseMove(Agg.UI.MouseEventArgs mouseEvent)
{
CameraRotX = -mouseEvent.X * .5f;
CameraRotY = mouseEvent.Y * .5f;
base.OnMouseMove(mouseEvent);
}
//
// The order of the points in the filament were established by the algorithm
// Recursively seek smaller and smaller circular regions.
//
// Returns the set of atomic regions characterized by the largest circle (containing all the other atoms).
private Agg MakeRegions(UndirectedPlanarGraph.PlanarGraph graph, List <Circle> circles, int beginIndex, int endIndex)
{
if (memoized[beginIndex, endIndex] != null)
{
return(memoized[beginIndex, endIndex]);
}
//
// Find the circle for these given points.
//
Circle outerCircle = null;
foreach (Circle circle in circles)
{
if (circle.PointLiesOn(points[beginIndex]) && circle.PointLiesOn(points[endIndex]))
{
outerCircle = circle;
}
}
//
// Base Case: Gap between the given indices is 1.
//
if (endIndex - beginIndex == 1)
{
return(new Agg(beginIndex, endIndex, -1, outerCircle, HandleConnection(graph, circles, points[beginIndex], points[endIndex])));
}
//
// Look at all combinations of indices from beginIndex to endIndex; start with larger gaps between indices -> small gaps
//
Agg maxLeftCoveredAgg = null;
Agg maxRightCoveredAgg = null;
int maxCoveredNodes = 0;
for (int gap = endIndex - beginIndex - 1; gap > 0; gap--)
{
for (int index = beginIndex; index < endIndex; index++)
{
Agg left = MakeRegions(graph, circles, index, index + gap);
Agg right = MakeRegions(graph, circles, index + gap, endIndex);
// Check for new maxmimum coverage.
if (left.coveredPoints + right.coveredPoints > maxCoveredNodes)
{
maxLeftCoveredAgg = left;
maxRightCoveredAgg = right;
}
// Found complete coverage
if (left.coveredPoints + right.coveredPoints == endIndex - beginIndex + 1)
{
maxCoveredNodes = endIndex - beginIndex + 1;
break;
}
}
}
//
// We have the two maximal circles: create the new regions.
//
// The atoms from the left / right.
List <AtomicRegion> atoms = new List <AtomicRegion>();
atoms.AddRange(maxLeftCoveredAgg.atoms);
atoms.AddRange(maxRightCoveredAgg.atoms);
// New regions are based on this outer circle minus the left / right outer circles.
AtomicRegion newAtomTop = new AtomicRegion();
AtomicRegion newAtomBottom = new AtomicRegion();
// The outer circle.
newAtomTop.AddConnection(points[beginIndex], points[endIndex], ConnectionType.ARC, outerCircle);
newAtomBottom.AddConnection(points[beginIndex], points[endIndex], ConnectionType.ARC, outerCircle);
// The left / right maximal circles.
newAtomTop.AddConnection(points[maxLeftCoveredAgg.beginPointIndex], points[maxLeftCoveredAgg.endPointIndex], ConnectionType.ARC, maxLeftCoveredAgg.outerCircle);
newAtomBottom.AddConnection(points[maxLeftCoveredAgg.beginPointIndex], points[maxLeftCoveredAgg.endPointIndex], ConnectionType.ARC, maxLeftCoveredAgg.outerCircle);
newAtomTop.AddConnection(points[maxRightCoveredAgg.beginPointIndex], points[maxRightCoveredAgg.endPointIndex], ConnectionType.ARC, maxRightCoveredAgg.outerCircle);
newAtomBottom.AddConnection(points[maxRightCoveredAgg.beginPointIndex], points[maxRightCoveredAgg.endPointIndex], ConnectionType.ARC, maxRightCoveredAgg.outerCircle);
atoms.Add(newAtomTop);
atoms.Add(newAtomBottom);
//
// Make / return the new aggregator
//
return(new Agg(beginIndex, endIndex, maxCoveredNodes, outerCircle, atoms));
}
public virtual void Draw2DContent(Agg.Graphics2D graphics2D)
{
}
protected override double RunSolverOneStep(int TimestepNo, double phystime, double dt)
{
Console.WriteLine(" Timestep # " + TimestepNo + ", phystime = " + phystime);
//phystime = 1.8;
LsUpdate(phystime);
// operator-matrix assemblieren
MsrMatrix OperatorMatrix = new MsrMatrix(u.Mapping, u.Mapping);
double[] Affine = new double[OperatorMatrix.RowPartitioning.LocalLength];
MultiphaseCellAgglomerator Agg;
MassMatrixFactory Mfact;
// Agglomerator setup
int quadOrder = Op.QuadOrderFunction(new int[] { u.Basis.Degree }, new int[0], new int[] { u.Basis.Degree });
//Agg = new MultiphaseCellAgglomerator(new CutCellMetrics(MomentFittingVariant, quadOrder, LsTrk, ), this.THRESHOLD, false);
Agg = LsTrk.GetAgglomerator(new SpeciesId[] { LsTrk.GetSpeciesId("B") }, quadOrder, this.THRESHOLD);
Console.WriteLine("Inter-Process agglomeration? " + Agg.GetAgglomerator(LsTrk.GetSpeciesId("B")).AggInfo.InterProcessAgglomeration);
if (this.THRESHOLD > 0.01)
{
TestAgglomeration_Extraploation(Agg);
TestAgglomeration_Projection(quadOrder, Agg);
}
// operator matrix assembly
Op.ComputeMatrixEx(LsTrk,
u.Mapping, null, u.Mapping,
OperatorMatrix, Affine, false, 0.0, true,
Agg.CellLengthScales,
LsTrk.GetSpeciesId("B"));
Agg.ManipulateMatrixAndRHS(OperatorMatrix, Affine, u.Mapping, u.Mapping);
// mass matrix factory
Mfact = LsTrk.GetXDGSpaceMetrics(new SpeciesId[] { LsTrk.GetSpeciesId("B") }, quadOrder, 1).MassMatrixFactory;// new MassMatrixFactory(u.Basis, Agg);
// Mass matrix/Inverse Mass matrix
//var MassInv = Mfact.GetMassMatrix(u.Mapping, new double[] { 1.0 }, true, LsTrk.GetSpeciesId("B"));
var Mass = Mfact.GetMassMatrix(u.Mapping, new double[] { 1.0 }, false, LsTrk.GetSpeciesId("B"));
Agg.ManipulateMatrixAndRHS(Mass, default(double[]), u.Mapping, u.Mapping);
var MassInv = Mass.InvertBlocks(OnlyDiagonal: true, Subblocks: true, ignoreEmptyBlocks: true, SymmetricalInversion: false);
// test that operator depends only on B-species values
double DepTest = LsTrk.Regions.GetSpeciesSubGrid("B").TestMatrixDependency(OperatorMatrix, u.Mapping, u.Mapping);
Console.WriteLine("Matrix dependency test: " + DepTest);
Assert.LessOrEqual(DepTest, 0.0);
// diagnostic output
Console.WriteLine("Number of Agglomerations (all species): " + Agg.TotalNumberOfAgglomerations);
Console.WriteLine("Number of Agglomerations (species 'B'): " + Agg.GetAgglomerator(LsTrk.GetSpeciesId("B")).AggInfo.SourceCells.NoOfItemsLocally.MPISum());
// operator auswerten:
double[] x = new double[Affine.Length];
BLAS.daxpy(x.Length, 1.0, Affine, 1, x, 1);
OperatorMatrix.SpMVpara(1.0, u.CoordinateVector, 1.0, x);
MassInv.SpMV(1.0, x, 0.0, du_dx.CoordinateVector);
Agg.GetAgglomerator(LsTrk.GetSpeciesId("B")).Extrapolate(du_dx.Mapping);
// markieren, wo ueberhaupt A und B sind
Bmarker.AccConstant(1.0, LsTrk.Regions.GetSpeciesSubGrid("B").VolumeMask);
Amarker.AccConstant(+1.0, LsTrk.Regions.GetSpeciesSubGrid("A").VolumeMask);
Xmarker.AccConstant(+1.0, LsTrk.Regions.GetSpeciesSubGrid("X").VolumeMask);
// compute error
ERR.Clear();
ERR.Acc(1.0, du_dx_Exact, LsTrk.Regions.GetSpeciesSubGrid("B").VolumeMask);
ERR.Acc(-1.0, du_dx, LsTrk.Regions.GetSpeciesSubGrid("B").VolumeMask);
double L2Err = ERR.L2Norm(LsTrk.Regions.GetSpeciesSubGrid("B").VolumeMask);
Console.WriteLine("L2 Error: " + L2Err);
XERR.Clear();
XERR.GetSpeciesShadowField("B").Acc(1.0, ERR, LsTrk.Regions.GetSpeciesSubGrid("B").VolumeMask);
double xL2Err = XERR.L2Norm();
Console.WriteLine("L2 Error (in XDG space): " + xL2Err);
// check error
if (this.THRESHOLD > 0.01)
{
// without agglomeration, the error in very tiny cut-cells may be large over the whole cell
// However, the error in the XDG-space should be small under all circumstances
Assert.LessOrEqual(L2Err, 1.0e-6);
}
Assert.LessOrEqual(xL2Err, 1.0e-6);
bool IsPassed = ((L2Err <= 1.0e-6 || this.THRESHOLD <= 0.01) && xL2Err <= 1.0e-7);
if (IsPassed)
{
Console.WriteLine("Test PASSED");
}
else
{
Console.WriteLine("Test FAILED: check errors.");
}
// return/Ende
base.NoOfTimesteps = 17;
//base.NoOfTimesteps = 2;
dt = 0.3;
return(dt);
}
public static OId OutL(string name, int from, int?to = null, Agg agg = Agg.NONE)
{
return(new OId {
Name = name, From = from, To = to, LayerAgg = agg
});
}
