void DirectAscent::inner_loop()
{
double sshx_before_inner = sshx;
sphShipPos.r = target_radius;
bool b3D = true;
double velModule;
Spherical localsphShipPos;
Vect3 localShPos;
Vect3 localShVel;
double magMulPos;
{
velModule = max_xvel;
localsphShipPos = sphShipPos;
localsphShipPos.theta += PI/2;
localShPos = ConvertSpherical2Cartesian( localsphShipPos );
magMulPos = target_radius / len(localShPos);
localShPos = mul( localShPos, magMulPos ); // keep me at the radius please
localShVel = - cross( norm(localShPos), norm(shPlaneN) );
}
do
{
++inner_iter;
Point shVel(vel[1], vel[0]);
double true_azimuth = CalcTrueAzimuth( sshy_prev / target_radius, tgtParam.incl, shVel, mi, target_radius );
{
localsphShipPos = sphShipPos;
localsphShipPos.theta += PI/2;
double magMulVel = velModule / len(localShVel);
localShVel = mul( localShVel, magMulVel );
// got all the basic data
// simulate acceleration in other direction
// see http://www.euclideanspace.com/maths/geometry/rotations/theory/inaPlane/index.htm
// create a plane of reference, rotating along the ship,
// on which the ship's velocity vector is flat
Spherical sphShipPlusQuarter = localsphShipPos;
sphShipPlusQuarter.phi += PI/2;
sphShipPlusQuarter.theta = PI/2; // equator
Vect3 x = norm( ConvertSpherical2Cartesian( sphShipPlusQuarter ) );
Vect3 z; z.x = 0; z.y = 0; z.z = -1;
if ( tgtParam.azFlag == SOUTHERN_AZIMUTH )
z.z = -z.z;
// convert to 2D space where it's easier to add velocity
double v2Dx = x.x * localShVel.x + x.y * localShVel.y + x.z * localShVel.z;
double v2Dy = z.x * localShVel.x + z.y * localShVel.y + z.z * localShVel.z;
double v2DxAdd = initialAccel * t * sin(true_azimuth);
double v2DyAdd = initialAccel * t * cos(true_azimuth);
v2Dx += v2DxAdd;
v2Dy += v2DyAdd;
// convert back to 3D space
localShVel.x = x.x * v2Dx + z.x * v2Dy;
localShVel.y = x.y * v2Dx + z.y * v2Dy;
localShVel.z = x.z * v2Dx + z.z * v2Dy;
velModule = len(localShVel);
Vect3 vel2Add = mul(localShVel, t);
localShPos = localShPos + vel2Add;
magMulPos = target_radius / len(localShPos);
localShPos = mul( localShPos, magMulPos ); // keep me at the radius please
sphShipPos = ConvertCartesian2Spherical( localShPos );
sphShipPos.theta -= PI/2;
Point pos = ConvertSpherical2Point( sphShipPos );
vel[1] = v2Dx;
vel[0] = v2Dy;
sshx = sshx_prev = pos.x;
sshy = sshy_prev = pos.y;
}
total_t += t;
s_y.push_back(sshy);
s_x.push_back(sshx);
} while (vel_module(vel[0],vel[1]) < tgt_orbit_v2_ref_module); // while final vel not reached
sshx_fix4fuzzy = (sshx - sshx_before_inner);
}
)?
In the definition of a fuzzy autopilot, there's too much error possible, and except maybe for significant linguistic control, like "if some specific value or combination of values, do this", there's little exact (rough) control of values and a limited ability for fine tuning. In Orbiter, the rules of control are simple and I need more value control than rule control. Also, we know that in Orbiter, unlike in reality, you can increase the time acceleration up to 100x (maximal reasonable value for autopilots), and by doing it, you demand the controller to be 100x more accurate, which was too much for the fuzzy autopilot.
It's animated Great Circle zooming. See attachment.
