Esempio n. 1
0
        public void SaveRiverData(RiverParams river, List <MapParams> mapParams)
        {
            mapParams.ForEach(t => t.RiverParamsId = river.Id);
            if (river.Id == 0)
            {
                river.MapParamsList = mapParams;
                riverRepository.Create(river);
            }
            else
            {
                var deleteMaps = mapRepository.Set.Where(t => t.RiverParamsId == river.Id).ToList();
                foreach (var map in deleteMaps)
                {
                    mapRepository.Delete(map.Id);
                }
                foreach (var createMap in mapParams)
                {
                    mapRepository.Create(createMap);
                }


                riverRepository.Update(river);
            }

            riverRepository.SaveChanges();
        }
Esempio n. 2
0
        private double dFj(double x, RiverParams riverModel)
        {
            double kr  = riverModel.LengthByX / riverModel.SplitsNumberByX;
            int    nom = (int)(x / kr);

            return(FF[2 * nom] * dFi(nom, x, riverModel) + FF[2 * (nom + 1)] * dFi(nom + 1, x, riverModel));
        }
Esempio n. 3
0
        private double dUj(double x, RiverParams riverModel)
        {
            double kr  = riverModel.LengthByX / riverModel.SplitsNumberByX;
            int    nom = (int)(x / kr);

            nom = nom >= riverModel.SplitsNumberByX ? riverModel.SplitsNumberByX - 1 : nom;
            return(FF[2 * nom + 1] * dFi(nom, x, riverModel) + FF[2 * (nom + 1) + 1] * dFi(nom + 1, x, riverModel));
        }
Esempio n. 4
0
        private double dFi(int i, double x, RiverParams riverModel)
        {
            double x1, x2, x3;

            x1 = riverModel.LengthByX * (i - 1) / riverModel.SplitsNumberByX;
            x2 = riverModel.LengthByX * i / riverModel.SplitsNumberByX;
            x3 = riverModel.LengthByX * (i + 1) / riverModel.SplitsNumberByX;
            if ((x >= x1) && (x <= x2))
            {
                return(riverModel.SplitsNumberByX / riverModel.LengthByX);
            }
            else if ((x >= x2) && (x <= x3))
            {
                return((-1) * riverModel.SplitsNumberByX / riverModel.LengthByX);
            }
            return(0);
        }
Esempio n. 5
0
        private void FormatMatr(double tim, RiverParams riverModel, TaskParams taskParams)
        {
            double length = riverModel.LengthByX / riverModel.SplitsNumberByX;
            double x1, x2, xkv, zn, iser;

            for (int i = 0; i < Fun.Length; i++)
            {
                Fun[i] = 0;
            }

            for (int i = 0; i < MatrC.Length; i++)
            {
                MatrC[i] = 0;
            }

            for (int i = 0; i <= riverModel.SplitsNumberByX - 1; i++)
            {
                x1 = i * riverModel.LengthByX / riverModel.SplitsNumberByX;
                x2 = (i + 1) * riverModel.LengthByX / riverModel.SplitsNumberByX;

                if (i < (riverModel.SplitsNumberByX - 1) / 2)
                {
                    iser = taskParams.AngleOfInclinationSine;
                }
                else
                {
                    iser = taskParams.AngleSine;
                }
                for (int it = 0; it <= 3; it++)
                {
                    for (int j = 0; j <= 1; j++)
                    {
                        xkv = (x1 + x2) / 2 + KvadrX[it] * (x2 - x1) / 2;
                        for (int k = 0; k <= 1; k++)
                        {
                            zn = length * KvadrC[it] * (Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) +
                                                        beta * timeIncrease * (Uj(xkv, riverModel) * dFi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) +
                                                                               dUj(xkv, riverModel) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel)));

                            MatrC[GetNum(2 * (i + k), 2 * (i + j))] = MatrC[GetNum(2 * (i + k), 2 * (i + j))] + zn;

                            zn = beta * timeIncrease * length * KvadrC[it] * (Fj(xkv, riverModel) * dFi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) +
                                                                              dFj(xkv, riverModel) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel));

                            MatrC[GetNum(2 * (i + k), 2 * (i + j) + 1)] = MatrC[GetNum(2 * (i + k), 2 * (i + j) + 1)] + zn;

                            zn = length * KvadrC[it] * (beta * timeIncrease * dFi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) / taskParams.FreeSurfaceWidth + ((taskParams.Alpha - 1) * (Uj(xkv, riverModel) /
                                                                                                                                                                                                  Fj(xkv, riverModel)) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel)) / taskParams.GravityAcceleration);

                            MatrC[GetNum(2 * (i + k) + 1, 2 * (i + j))] = MatrC[GetNum(2 * (i + k) + 1, 2 * (i + j))] + zn;

                            zn = length * KvadrC[it] * (Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) / taskParams.GravityAcceleration +
                                                        beta * timeIncrease * (taskParams.Alpha / taskParams.GravityAcceleration * dUj(xkv, riverModel) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) +
                                                                               1 / taskParams.GravityAcceleration * Uj(xkv, riverModel) * dFi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel) +
                                                                               (2 / (taskParams.ShaziCoefficient * taskParams.ShaziCoefficient * taskParams.ChannelHydraulicRadius)) * Uj(xkv, riverModel) * Fi(i + j, xkv, riverModel) * Fi(i + k, xkv, riverModel)));


                            MatrC[GetNum(2 * (i + k) + 1, 2 * (i + j) + 1)] = MatrC[GetNum(2 * (i + k) + 1, 2 * (i + j) + 1)] + zn;
                        }

                        zn = -length * KvadrC[it] * (Fj(xkv, riverModel) * dUj(xkv, riverModel) * Fi(i + j, xkv, riverModel) +
                                                     dFj(xkv, riverModel) * Uj(xkv, riverModel) * Fi(i + j, xkv, riverModel));
                        Fun[2 * (i + j)] = Fun[2 * (i + j)] + zn;
                        zn = -length * KvadrC[it] * (dFj(xkv, riverModel) * Fi(i + j, xkv, riverModel) / taskParams.FreeSurfaceWidth + taskParams.Alpha / taskParams.GravityAcceleration * Uj(xkv, riverModel) *
                                                     dUj(xkv, riverModel) * Fi(i + j, xkv, riverModel) - iser * Fi(i + j, xkv, riverModel) + Uj(xkv, riverModel) * Uj(xkv, riverModel) * Fi(i + j, xkv, riverModel) /
                                                     (taskParams.ShaziCoefficient * taskParams.ShaziCoefficient * taskParams.ChannelHydraulicRadius));

                        Fun[2 * (i + j) + 1] = Fun[2 * (i + j) + 1] + zn;
                    }
                }
            }
            for (int i = 0; i < Fun.Length; i++)
            {
                FF[i] = Fun[i];
            }

            MatrC[GetNum(0, 0)] = mnoz;
            MatrC[GetNum(1, 1)] = mnoz;
            FF[0] = Gr_umF * mnoz;
            FF[1] = Gr_umU * mnoz;
        }