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 }); }