public override Vector CalculateDV()
{
SolverLogger.Log("Current : V = " + s.V + " POS = " + s.S);
Vector nextV;
Vector nextPos;
Physics.Forecast(s.S, s.V, Vector.Zero, out nextPos, out nextV);
SolverLogger.Log("Forecast: V = " + nextV + " POS = " + nextPos);
double r0 = Math.Sqrt(s.Sx * s.Sx + s.Sy * s.Sy);
double r1 = s.TargetOrbitR;
double desirableV;
if (algoState == HohmannAlgoState.ReadyToJump)
{
//desirableV = GetDvForFirstJump(r1, r0);
//algoState = HohmannAlgoState.Jumping;
//var dv = GetDV(desirableV);
//avk
algoState = HohmannAlgoState.Jumping;
desirableV = Math.Sqrt(2 * Physics.mu * r1 / (r0 * (r0 + r1)));
var dv = (1 - desirableV / s.V.Len()) * s.V;
SolverLogger.Log("IMPULSE 1 " + dv.x + ", " + dv.y + "\r\n");
return(dv);
}
if ((Math.Abs(r0 - r1) < 500) && algoState == HohmannAlgoState.Jumping)
{
algoState = HohmannAlgoState.Finishing;
desirableV = GetDvForSecondJump(nextPos.Len()) * 0.71;
var dv = GetDV(desirableV);
//avk
//algoState = HohmannAlgoState.Finishing;
//desirableV = Math.Sqrt(Physics.mu / r0);
//var desirableVector = new Vector(desirableV * s.Sy / s.S.Len(), -desirableV * s.Sx / s.S.Len());
//var dv = s.V - desirableVector;
SolverLogger.Log("IMPULSE 2 " + dv.x + ", " + dv.y + "\r\n");
return(dv);
}
return(new Vector(0, 0));
}
public override Vector CalculateDV()
{
//проверить, что крутимся в одну сторону
Vector nextV;
Vector nextPos;
Physics.Forecast(s.S, s.V, Vector.Zero, out nextPos, out nextV);
double r0 = s.CurrentOrbitR;
double r1 = s.TargetOrbitR;
if (algoState == HohmannAlgoState.ReadyToJump)
{
double tmp = (r0 + r1) / (2 * r1);
var tau = Math.Sqrt(tmp * tmp * tmp);
double desiredPhi = r1 > r0 ? Math.PI * (1 - tau) : Math.PI * (tau - 1);
var thetaS = s.S.PolarAngle;
if (thetaS < 0)
{
thetaS += 2 * Math.PI;
}
var thetaT = s.T.PolarAngle;
if (thetaT < 0)
{
thetaT += 2 * Math.PI;
}
var actualPhi = r1 > r0 ? thetaS - thetaT : thetaT - thetaS;
if (actualPhi < 0)
{
actualPhi += 2 * Math.PI;
}
SolverLogger.Log(string.Format("DesiredPhi: {0}, ActualPhi: {1}, Diff=: {2}", desiredPhi * 180 / Math.PI,
actualPhi * 180 / Math.PI, desiredPhi - actualPhi));
if (algoState == HohmannAlgoState.ReadyToJump && Math.Abs(desiredPhi - actualPhi) < Eps)
{
SolverLogger.Log(string.Format("My POS: {0}, V: {1}", s.S, s.V));
SolverLogger.Log(string.Format("Target POS: {0}", s.T));
algoState = HohmannAlgoState.Jumping;
double desirableV = Math.Sqrt(2 * Physics.mu * r1 / (r0 * (r0 + r1)));
//var dv = GetDV(desirableV);
return((1 - desirableV / s.V.Len()) * s.V);
}
}
if (algoState == HohmannAlgoState.Jumping)
{
if (((int)s.ST.Len() < 500))
{
algoState = HohmannAlgoState.Finishing;
return(GetStabilizingJump(s.V, s.S));
}
else
{
SolverLogger.Log("DISTANCE TO = " + s.ST.Len());
}
}
if (algoState == HohmannAlgoState.Finishing)
{
double myOrbit = s.S.Len();
double myOrbitV = Math.Sqrt(Physics.mu / myOrbit);
double myV = s.V.Len();
double hisOrbitV = Math.Sqrt(Physics.mu / s.TargetOrbitR);
SolverLogger.Log(string.Format("Gagarin: {0} Orbit={1} V={2} OrbitV={3}", s.S, myOrbit, myV, myOrbitV));
SolverLogger.Log(string.Format("Target : {0} Orbit={1} V={2}", s.T, s.TargetOrbitR, hisOrbitV));
SolverLogger.Log(string.Format("Summary: ErrV = {0} ErrOrbit={1} DistanceToTarget={2}",
s.V.Len() - myOrbitV,
myOrbit - s.TargetOrbitR,
s.ST.Len()
));
}
return(new Vector(0, 0));
}
