public double GetResultsArea(RealPoint point)
        {
            double result = 0.0;

            foreach (var area in this.Areas)
            {
                foreach (var segmentI in area.Segments)
                {
                    int i = 0;
                    foreach (var collPointI in segmentI.CollocationPoints)
                    {
                        var functionT = Function_T.CalculateAreaValue(point, segmentI, collPointI, area.configurationData);
                        var functionq = Function_q.CalculateAreaValue(point, segmentI, collPointI, area.configurationData);

                        result += -functionq * segmentI.TemperatureBoundaryCondition.BoundaryConditionVector[i] + functionT * segmentI.HeatFluxBoundaryCondition.BoundaryConditionVector[i];
                        i++;
                    }
                }
            }
            foreach (var area in this.Areas)
            {
                var initial = InitialCondition.CalculateValue(area, point);
                result += initial;

                if (area.configurationData.addHeatSource)
                {
                    var subAreaIntegrationHelper = new SubAreaIntegrationHelper(4, area.Surfaces.Select(x => x.SurfaceShape).ToList());
                    result += HeatSource.CalculateValue(area, point, subAreaIntegrationHelper);
                }
            }

            return(result);
        }
        public static double CalculateValue(Area Area, RealPoint point, SubAreaIntegrationHelper subAreaIntegrationHelper, int boundarySegmentIndex = 0)
        {
            double value = 0.0;

            foreach (var surface in Area.Surfaces)
            {
                double denominator1 = HeatSource.denominator1(Area.configurationData.GetDiffusionCoefficient(), Area.configurationData.iterationProcess.TimeStep);
                double denominator2 = HeatSource.denominator2(Area.configurationData.GetThermalConductivity());

                for (int subAreaIndex = 0; subAreaIndex < subAreaIntegrationHelper.NumberOfSubSurfaces; subAreaIndex++)
                {
                    foreach (var surfaceIntegrationPoint in surface.HeatSourceSurfaceIntegrationPoints)
                    {
                        if (Area.configurationData.arePropertiesTimeDependent())
                        {
                            denominator1 = HeatSource.denominator1(Area.configurationData.GetDiffusionCoefficient(surfaceIntegrationPoint.TemperatureValue), Area.configurationData.iterationProcess.TimeStep);
                            denominator2 = HeatSource.denominator2(Area.configurationData.GetThermalConductivity(surfaceIntegrationPoint.TemperatureValue));
                        }

                        var subAreaSurfaceIntegrationPoint = subAreaIntegrationHelper.TransformIntegrationPoint(surface.Index, subAreaIndex, boundarySegmentIndex, surfaceIntegrationPoint, point);

                        var parameters = new Dictionary <string, double>();
                        parameters.Add("x", subAreaSurfaceIntegrationPoint.RealPosition.x);
                        parameters.Add("y", subAreaSurfaceIntegrationPoint.RealPosition.y);
                        parameters.Add("t", Area.configurationData.iterationProcess.CurrentTime);
                        var heatSource = surface.heatSourceFunction(parameters);

                        value += CalculateSiglePointFunctionValue(point, denominator1, denominator2, subAreaSurfaceIntegrationPoint) * heatSource;
                    }
                }
            }

            return(value);
        }
        public double GetTemperatureFromSurfaceIntegrationPointConstants(SurfaceIntegrationPoint point)
        {
            double result = 0.0;

            int j = 0;

            foreach (var area in this.Areas)
            {
                foreach (var segment in area.Segments)
                {
                    foreach (var collPoint in segment.CollocationPoints)
                    {
                        result += -point.FunctionqConstantValue[j] * segment.TemperatureBoundaryCondition.BoundaryConditionVector[collPoint.Index] + point.FunctionTConstantValue[j] * segment.HeatFluxBoundaryCondition.BoundaryConditionVector[collPoint.Index];
                        j++;
                    }
                }
            }
            int k = 0;

            foreach (var area in this.Areas)
            {
                //To tradycyjnie
                result += InitialCondition.CalculateValue(area, point.RealPosition);

                //To w przypadku przechowywania parametrów
                //foreach (var surface in this.Surfaces)
                //{
                //    foreach (var surfaceIntegrationPoint in surface.SurfaceIntegrationPoints)
                //    {
                //        value += point.InitialConditionConstantValues[k] * surfaceIntegrationPoint.TemperatureValue;
                //        k++;
                //    }
                //}

                if (area.configurationData.addHeatSource)
                {
                    if (area.configurationData.isHeatSourceTimeDependent)
                    {
                        var subAreaIntegrationHelper = new SubAreaIntegrationHelper(4, area.Surfaces.Select(x => x.SurfaceShape).ToList());

                        result += HeatSource.CalculateValue(area, point.RealPosition, subAreaIntegrationHelper);
                    }
                    else
                    {
                        result += point.HeatSourceConstantValue;
                    }
                }
            }

            return(result);
        }
        public static double[] CalculateBoundaryVector(Area Area)
        {
            var vector = new double[Area.NumberOfCollocationPoints];
            var subAreaIntegrationHelper = new SubAreaIntegrationHelper(3, Area.Surfaces.Select(x => x.SurfaceShape).ToList());

            foreach (var segment in Area.Segments)
            {
                Parallel.ForEach(segment.CollocationPoints, (collPoint) =>
                {
                    var r = Area.Segments.Where(x => x.Index < segment.Index).Sum(x => x.CollocationPoints.Count) + collPoint.Index;

                    vector[r] = CalculateValue(Area, collPoint.RealPosition, subAreaIntegrationHelper, segment.Index);
                });
            }
            return(vector);
        }
        public void CalculateSurfaceIntegrationPointsConstants()
        {
            //double denominator1 = InitialCondition.denominator1(configurationData);
            //double denominator2 = InitialCondition.denominator2(configurationData);
            foreach (var area in this.Areas)
            {
                foreach (var surface in area.Surfaces)
                {
                    Parallel.ForEach(surface.InitialConditionSurfaceIntegrationPoints, (surfaceIntegrationPoint) =>
                    {
                        var sur = surfaceIntegrationPoint;
                        foreach (var area1 in this.Areas)
                        {
                            foreach (var segmentI in area1.Segments)
                            {
                                foreach (var collPointI in segmentI.CollocationPoints)
                                {
                                    surfaceIntegrationPoint.FunctionTConstantValue.Add(Function_T.CalculateAreaValue(surfaceIntegrationPoint.RealPosition, segmentI, collPointI, area1.configurationData));
                                    surfaceIntegrationPoint.FunctionqConstantValue.Add(Function_q.CalculateAreaValue(surfaceIntegrationPoint.RealPosition, segmentI, collPointI, area1.configurationData));
                                }
                            }
                        }

                        //To w przypadku przechowywania parametrów
                        //foreach (var innerSurface in this.Surfaces)
                        //{
                        //    foreach (var innerSurfaceIntegrationPoint in innerSurface.SurfaceIntegrationPoints)
                        //    {
                        //        surfaceIntegrationPoint.InitialConditionConstantValues.Add(InitialCondition.CalculateSiglePointFunctionValue(surfaceIntegrationPoint.RealPosition, denominator1, denominator2, innerSurfaceIntegrationPoint));
                        //    }
                        //}

                        if (area.configurationData.addHeatSource)
                        {
                            if (!area.configurationData.isHeatSourceTimeDependent)
                            {
                                var subAreaIntegrationHelper = new SubAreaIntegrationHelper(4, area.Surfaces.Select(x => x.SurfaceShape).ToList());
                                surfaceIntegrationPoint.HeatSourceConstantValue = HeatSource.CalculateValue(area, surfaceIntegrationPoint.RealPosition, subAreaIntegrationHelper);
                            }
                        }
                    });
                }
            }
        }