public TestModel(double t0, double t1, double dt)
{
this.t0 = t0;
this.t1 = t1;
SamplingIncrement = dt;
gsX0 = new TVector(new double[] { 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();
}
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));
}
// Умножение на число
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);
}
// Умножение на вектор (Векторное произв.)
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);
}
// Скалярное произведение
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);
}
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);
}
// Сумма векторов
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);
}
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);
}
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();
}
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));
}
// Умножение на вектор
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);
}
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()));
}
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));
}
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();
}
public static KeplerElements VecToOsc(TVector vector)
{
throw new Exception();//
}
public static TVector GeoToHelio(TVector X, TVector EarthX)
{
return(EarthX + X);
}
public TVector Concat(TVector B)
{
return(new TVector(this.Vector.Concat(B.Vector).ToArray()));
}
public override TVector RightParts(TVector X, double t)
{
return(new TVector(new double[] { Math.Cos(t) }));
}
