Example #1
0
        /*
         * private void DrawResult(IResult numericalResult, IEnumerable<IFiniteElement> elements)
         * {
         *  double time = 0;
         *  FillResultPicture(numericalResult, elements, time);
         *  while (true)
         *  {
         *      FillResultPicture(numericalResult, elements, time);
         *      time+=0.01;
         *      Thread.Sleep(50);
         *  }
         * }
         *
         * private void FillResultPicture(IResult numericalResult, IEnumerable<IFiniteElement> elements, double t)
         * {
         *  List<Shape> shapes = new List<Shape>();
         *  foreach (FiniteElementRectangle fe in elements)
         *  {
         *      shapes.Add(ConvertFiniteElementToShape(fe, numericalResult, t));
         *  }
         *  if (Application.Current != null)
         *  {
         *      Application.Current.Dispatcher.BeginInvoke(new Action(() =>
         *      {
         *          Figures.Clear();
         *          foreach (Shape shape in shapes)
         *          {
         *              Figures.Add(shape);
         *          }
         *      }));
         *  }
         *  else
         *  {
         *      Thread.CurrentThread.Abort();
         *  }
         * }
         *
         * private Shape ConvertFiniteElementToShape(FiniteElementRectangle fe, IResult numericalResult, double t)
         * {
         *  Rectangle rectangle = new Rectangle(fe.Node1.Point.X, fe.Node1.Point.Y, fe.Node3.Point.Y - fe.Node1.Point.Y, fe.Node3.Point.X - fe.Node1.Point.X);
         *  foreach (FEMLibrary.SolidMechanics.Geometry.Point point in rectangle.Points)
         *  {
         *      MatrixLibrary.Vector numericalResultAtPoint = numericalResult.GetResultAtPoint(point, t);
         *      if (numericalResultAtPoint != null)
         *      {
         *          point.X = point.X + numericalResultAtPoint[0];
         *          point.Y = point.Y + numericalResultAtPoint[2];
         *      }
         *  }
         *  return rectangle;
         * }
         *
         */

        private void fillResultGrid(IResult analiticalResult, IResult numericalResult, IEnumerable <FEMLibrary.SolidMechanics.Geometry.Point> points)
        {
            GridResults.Clear();
            foreach (FEMLibrary.SolidMechanics.Geometry.Point point in points)
            {
                ResultItem resultItem = new ResultItem();
                resultItem.Alfa1 = point.X;
                //Point point = new Point(node.Point.X, 0);//(-1)*(rectangle.Height/2));
                MatrixLibrary.Vector numericalResultAtPoint = numericalResult.GetResultAtPoint(point, 0);
                //MatrixLibrary.Vector analiticalResultAtPoint = analiticalResult.GetResultAtPoint(point, 0);

                if (numericalResultAtPoint != null)
                {
                    resultItem.U1Numeric = numericalResultAtPoint[0];
                    resultItem.U3Numeric = numericalResultAtPoint[2];
                }

                /*if (analiticalResultAtPoint != null)
                 * {
                 *  resultItem.U1Analitical = analiticalResultAtPoint[0];
                 *  resultItem.U3Analitical = analiticalResultAtPoint[2];
                 * }*/

                GridResults.Add(resultItem);
            }
        }
        public static bool IsResultsEqual(IEnumerable<Point> points, IResult result1, IResult result2, double t, double error)
        {
            double norm = 0;
            foreach (Point point in points)
            {
                norm += Vector.Norm(result1.GetResultAtPoint(point, t) - result2.GetResultAtPoint(point, t));
            }

            return (norm < error);
        }
Example #3
0
        public static bool IsResultsEqual(IEnumerable <Point> points, IResult result1, IResult result2, double t, double error)
        {
            double norm = 0;

            foreach (Point point in points)
            {
                norm += Vector.Norm(result1.GetResultAtPoint(point, t) - result2.GetResultAtPoint(point, t));
            }

            return(norm < error);
        }
        /*
        private void DrawResult(IResult numericalResult, IEnumerable<IFiniteElement> elements)
        {
            double time = 0;
            FillResultPicture(numericalResult, elements, time);
            while (true)
            {
                FillResultPicture(numericalResult, elements, time);
                time+=0.01;
                Thread.Sleep(50);
            }
        }

        private void FillResultPicture(IResult numericalResult, IEnumerable<IFiniteElement> elements, double t)
        {
            List<Shape> shapes = new List<Shape>();
            foreach (FiniteElementRectangle fe in elements) 
            {
                shapes.Add(ConvertFiniteElementToShape(fe, numericalResult, t));
            }
            if (Application.Current != null)
            {
                Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    Figures.Clear();
                    foreach (Shape shape in shapes)
                    {
                        Figures.Add(shape);
                    }
                }));
            }
            else 
            {
                Thread.CurrentThread.Abort();
            }
        }

        private Shape ConvertFiniteElementToShape(FiniteElementRectangle fe, IResult numericalResult, double t)
        {
            Rectangle rectangle = new Rectangle(fe.Node1.Point.X, fe.Node1.Point.Y, fe.Node3.Point.Y - fe.Node1.Point.Y, fe.Node3.Point.X - fe.Node1.Point.X);
            foreach (FEMLibrary.SolidMechanics.Geometry.Point point in rectangle.Points) 
            {
                MatrixLibrary.Vector numericalResultAtPoint = numericalResult.GetResultAtPoint(point, t);
                if (numericalResultAtPoint != null)
                {
                    point.X = point.X + numericalResultAtPoint[0];
                    point.Y = point.Y + numericalResultAtPoint[2];
                }
            }
            return rectangle;
        }

        */

        private void fillResultGrid(IResult analiticalResult, IResult numericalResult, IEnumerable<FEMLibrary.SolidMechanics.Geometry.Point> points)
        {
            GridResults.Clear();
            foreach (FEMLibrary.SolidMechanics.Geometry.Point point in points)
            {
                ResultItem resultItem = new ResultItem();
                resultItem.Alfa1 = point.X;
                //Point point = new Point(node.Point.X, 0);//(-1)*(rectangle.Height/2));
                MatrixLibrary.Vector numericalResultAtPoint = numericalResult.GetResultAtPoint(point, 0);
                //MatrixLibrary.Vector analiticalResultAtPoint = analiticalResult.GetResultAtPoint(point, 0);

                if (numericalResultAtPoint != null)
                {
                    resultItem.U1Numeric = numericalResultAtPoint[0];
                    resultItem.U3Numeric = numericalResultAtPoint[2];
                }
                /*if (analiticalResultAtPoint != null)
                {
                    resultItem.U1Analitical = analiticalResultAtPoint[0];
                    resultItem.U3Analitical = analiticalResultAtPoint[2];
                }*/

                GridResults.Add(resultItem);
            }
        }