示例#1
0
 public TestModel(double t0, double t1, double dt)
 {
     this.t0           = t0;
     this.t1           = t1;
     SamplingIncrement = dt;
     gsX0 = new TVector(new double[] { 0 });
 }
示例#2
0
 public override void AddResult(TVector X, double t)
 {
     if (!FileCreated())
     {
         sw = new StreamWriter("result.txt");
     }
     sw.WriteLine(X[0].ToString() + ' ' + t.ToString());
     sw.Flush();
 }
示例#3
0
        public override TVector RightParts(TVector X, double t)
        {
            var result = new double[X.Length()];

            for (int i = 0; i < result.Length; i++)
            {
                result[i] = i < 3 ? X[i + 3] : -mu * X[i - 3] / Math.Pow(Math.Sqrt(X[0] * X[0] + X[1] * X[1] + X[2] * X[2]), 3);
            }
            return(new TVector(result));
        }
示例#4
0
        // Умножение на число
        public TVector Mult(double a)
        {
            double[] result = new double[Vector.Length];
            for (int i = 0; i < Vector.Length; i++)
            {
                result[i] = a * Vector[i];
            }
            TVector ResultVector = new TVector(result);

            return(ResultVector);
        }
示例#5
0
        // Умножение на вектор (Векторное произв.)
        public TVector Mult(TVector Vector2)
        {
            double[] result = new double[Vector.Length];
            if (Vector.Length == 3 & Vector2.Vector.Length == 3)
            {
                result[0] = Vector[1] * Vector2.Vector[2] - Vector[2] * Vector2.Vector[1];
                result[1] = Vector[2] * Vector2.Vector[0] - Vector[0] * Vector2.Vector[2];
                result[2] = Vector[0] * Vector2.Vector[1] - Vector[1] * Vector2.Vector[0];
            }
            TVector ResultVector = new TVector(result);

            return(ResultVector);
        }
示例#6
0
        // Скалярное произведение
        public double MultScalar(TVector Vector2)
        {
            double result = 0;

            if (Vector.Length == Vector2.Vector.Length)
            {
                for (int i = 0; i < Vector.Length; i++)
                {
                    result = result + Vector[i] * Vector2.Vector[i];
                }
            }
            return(result);
        }
示例#7
0
        public MoonModel(double t0, double t1, double h)
        {
            this.t0 = t0;
            this.t1 = t1;
            this.SamplingIncrement = h;
            var X0 = new double[6];

            X0[0] = -0.00080817732791148419 * Converter.aeToKm;
            X0[1] = -0.00199463000162039941 * Converter.aeToKm;
            X0[2] = -0.00108726266083810178 * Converter.aeToKm;
            X0[3] = 0.00060108481665912983 * Converter.aedayToKmSec;
            X0[4] = -0.00016744546061515148 * Converter.aedayToKmSec;
            X0[5] = -0.00008556214497398616 * Converter.aedayToKmSec;
            gsX0  = new TVector(X0);
        }
示例#8
0
        // Сумма векторов
        public TVector Sum(TVector Vector2)
        {
            TVector ResultVector;

            double[] result = new double[Vector.Length];
            if (result.Length == Vector2.Length())
            {
                for (int i = 0; i < result.Length; i++)
                {
                    result[i] = Vector[i] + Vector2.Vector[i];
                }
            }
            ResultVector = new TVector(result);
            return(ResultVector);
        }
示例#9
0
        public EarthModel(double t0, double t1, double h)
        {
            this.t0 = t0;
            this.t1 = t1;
            this.SamplingIncrement = h;
            var X0 = new double[6];

            X0[0] = -2.566123740124270e7;
            X0[1] = 1.339350231544666e8;
            X0[2] = 5.805149372446711e7;
            X0[3] = -2.983549561177192 * 10;
            X0[4] = -4.846747552523134;
            X0[5] = -2.100585886567924;
            gsX0  = new TVector(X0);
        }
示例#10
0
        public override void AddResult(TVector x, double t)
        {
            if (!FileCreated())
            {
                sw = new StreamWriter("result.txt");
            }
            string str = String.Empty;

            foreach (var e in x.Vector)
            {
                str = String.Concat(str + e.ToString()) + " ";
            }
            str = String.Concat(str + t.ToString());
            sw.WriteLine(str);
            sw.Flush();
        }
示例#11
0
        public override TVector RightParts(TVector X, double t)
        {
            double  mus            = 132712440018;
            TVector objectVector   = new TVector(X.Vector.Take(X.Length() - 6).ToArray());
            TVector earthVector    = new TVector(X.Vector.Skip(X.Length() - 6).ToArray());
            TVector bufDecoratedRP = decorated.RightParts(objectVector, t);
            TVector bufEarthRP     = earth.RightParts(earthVector, t);
            TVector HelioVector    = Converter.GeoToHelio(objectVector.Take(3), earthVector.Take(3));
            double  distance       = HelioVector.Norm();
            double  R = Math.Pow(earthVector.Take(3).Norm(), 3);

            for (int i = 3; i < 6; i++)
            {
                bufDecoratedRP[i] += mus * (HelioVector[i - 3] / Math.Pow(distance, 3) - (earthVector[i - 3] / R));
            }
            return(bufDecoratedRP.Concat(bufEarthRP));
        }
示例#12
0
        // Умножение на вектор
        public TVector Mult(TVector B)
        {
            TVector ResultVector;

            double[] result = new double[B.Vector.GetLength(0)];
            if (matrix.GetLength(0) == B.Vector.GetLength(0))
            {
                for (int i = 0; i < matrix.GetLength(0); i++)
                {
                    for (int k = 0; k < matrix.GetLength(0); k++)
                    {
                        result[i] = result[i] + matrix[i, k] * B.Vector[k];
                    }
                }
            }
            ResultVector = new TVector(result);
            return(ResultVector);
        }
示例#13
0
        public static TVector OscToVec(KeplerElements elements)
        {
            var     A    = TransformMatrix(elements);
            var     p    = elements.a * (1 - Math.Pow(elements.ecc, 2));
            TVector bufR = new TVector(new double[] {
                p / (1 + elements.ecc * Math.Cos(elements.v))
                , 0
                , 0
            });
            TVector bufV = new TVector(new double[] {
                Math.Sqrt(mu / p) * elements.ecc * Math.Sin(elements.v)
                , Math.Sqrt(mu / p) * (1 + elements.ecc * Math.Cos(elements.v))
                , 0
            });
            var r = A * bufR;
            var v = A * bufV;

            return(new TVector(r.Vector.Concat(v.Vector).ToArray()));
        }
示例#14
0
        public override TVector RightParts(TVector X, double t)
        {
            double muMoon = 4902.8000;

            TVector objectVector = new TVector(X.Vector.Take(X.Length() - 6)
                                               .ToArray());
            TVector moonVector = new TVector(X.Vector.Skip(X.Length() - 6)
                                             .Take(6)
                                             .ToArray());
            TVector bufDecoratedRP = decorated.RightParts(objectVector, t);
            TVector bufMoonRP      = moon.RightParts(moonVector, t);
            TVector delta          = moonVector.Take(3) - objectVector.Take(3);
            double  R        = moonVector.Take(3).Norm();
            double  distance = delta.Norm();

            for (int i = 3; i < 6; i++)
            {
                bufDecoratedRP[i] += muMoon * (delta[i - 3] / Math.Pow(distance, 3) - moonVector[i - 3] / Math.Pow(R, 3));
            }
            return(bufDecoratedRP.Concat(bufMoonRP));
        }
示例#15
0
        public override void Run(Model model)
        {
            double // Это время для интегрирования (увеличивается на величину шага интегрирования)
                t = model.t0,
            // Это время для выдачи (увеличивается дискретно на величину плотности)
                t_out = t,
            // Это конечное время
                t1 = model.t1,
            // Это шаг интегрирования
                h,
            // Это шаг после коррекции (инициализируются плотностью выдачи результатов)
                h_new = model.SamplingIncrement,
            // Это ошибка на шаге интегрирования
                e = 0;

            TVector // это вектор состояния на конец шага интегрирования
                X = model.gsX0,
            // это вектор состояния на конец шага интегрирования (решение 4-го порядка)
                X1,
            // Это вектор состояния на конец шага для коррекции величины шага (решение 5-го порядка)
                X2,
            // Это вектор для выдачи рез-тов
                Xout;



            // Счётчик количества сделанных шагов
            int N = 0;

            // Главный цикл
            while (t < t1)
            {
                // Устанавливаем шаг на итерацию
                h = h_new;

                // Вычисляем коэф-ты К
                K[0] = model.RightParts(X, t);
                K[1] = model.RightParts(X + (K[0] * h * a[1][0]), t + c[1] * h);
                K[2] = model.RightParts(X + (K[0] * a[2][0] + K[1] * a[2][1]) * h, t + c[2] * h);
                K[3] = model.RightParts(X + (K[0] * a[3][0] + K[1] * a[3][1] + K[2] * a[3][2]) * h, t + c[3] * h);
                K[4] = model.RightParts(X + (K[0] * a[4][0] + K[1] * a[4][1] + K[2] * a[4][2] + K[3] * a[4][3]) * h, t + c[4] * h);
                K[5] = model.RightParts(X + (K[0] * a[5][0] + K[1] * a[5][1] + K[2] * a[5][2] + K[3] * a[5][3] + K[4] * a[5][4]) * h, t + c[5] * h);
                K[6] = model.RightParts(X + (K[0] * a[6][0] + K[1] * a[6][1] + K[2] * a[6][2] + K[3] * a[6][3] + K[4] * a[6][4] + K[5] * a[6][5]) * h, t + c[6] * h);
                // Вычисляем решения 4-го и 5-го порядков
                X1 = X;
                X2 = X;
                for (int i = 0; i < 7; i++)
                {
                    X1 = X1 + K[i] * h * b1[i];
                    X2 = X2 + K[i] * h * b2[i];
                }

                // Вычисляем значение локальной ошибки

                e = 0;

                for (int i = 0; i < X.Vector.Length; i++)
                {
                    double[] buf1 = new double[2]
                    {
                        Math.Abs(X.Vector[i]), Math.Abs(X1.Vector[i])
                    };
                    double[] buf2 = new double[2]
                    {
                        1e-5, 0.25 * u / eps
                    };
                    double[] buf = new double[2]
                    {
                        buf1.Max(), buf2.Max()
                    };


                    e += Math.Pow(h * (X1.Vector[i] - X2.Vector[i]) / buf.Max(), 2);
                }
                e = Math.Sqrt(e / X.Vector.Length);

                // вычисляем новое значение шага
                double[] buf3 = new double[2]
                {
                    5.0, Math.Pow(e / eps, 0.1) / 0.5
                };

                double   den_h = buf3.Min();
                double[] buf4  = new double[2]
                {
                    0.1, den_h
                };
                double den = buf4.Max();
                h_new = h / den;


                // Если локальная ошибка превышает установленную величину, пытаемся сделать шаг заново
                if (e > eps)
                {
                    continue;
                }

                // Формирование рез-тов при помощи механизмов плотной выдачи
                while ((t_out < t + h) && (t_out <= t1))
                {
                    double   theta = (t_out - t) / h;
                    double[] b     = new double[6];
                    // Расчитываем коэф-ты плотной выдачи
                    b[0] = theta * (1 + theta * (-1337.0 / 480 + theta * (1039.0 / 360.0) + theta * (-1163.0 / 1152.0)));
                    b[1] = 0.0;
                    b[2] = 100.0 * theta * theta * (1054.0 / 9275.0 + theta * (-4682.0 / 27825.0 + theta * (379.0 / 5565.0))) / 3.0;
                    b[3] = -5.0 * theta * theta * (27.0 / 40.0 + theta * (-9.0 / 5.0 + theta * (83.0 / 96.0))) / 2.0;
                    b[4] = 18225.0 * theta * theta * (-3.0 / 250.0 + theta * (22.0 / 375.0 + theta * (-37.0 / 600.0))) / 848.0;
                    b[5] = -22.0 * theta * theta * (-3.0 / 10.0 + theta * (29.0 / 30.0 + theta * (-17.0 / 24.0))) / 7.0;

                    // Получаем рез-тат для выдачи

                    TVector mult = new TVector((K[0] * b[0]).Vector);
                    for (int i = 1; i < 6; i++)
                    {
                        mult = mult + (K[i] * b[i]);
                    }
                    Xout = X + mult * h;

                    // Передача рез-тов в модель
                    //

                    model.AddResult(Xout, t_out);
                    // Наращиваем время выдачи

                    t_out = t_out + model.SamplingIncrement;
                }

                // Обновлем Х решением 5-го порядка и наращиваем время на величину сделанного шага
                X  = X1;
                t += h;


                // Считаем количество итераций для вычисления глобальной погрешности
                N++;
            }
            model.CloseFile();
        }
示例#16
0
 public static KeplerElements VecToOsc(TVector vector)
 {
     throw new Exception();//
 }
示例#17
0
 public static TVector GeoToHelio(TVector X, TVector EarthX)
 {
     return(EarthX + X);
 }
示例#18
0
 public TVector Concat(TVector B)
 {
     return(new TVector(this.Vector.Concat(B.Vector).ToArray()));
 }
示例#19
0
 public override TVector RightParts(TVector X, double t)
 {
     return(new TVector(new double[] { Math.Cos(t) }));
 }