/// <summary>
/// Add an element to the sequence that begins at time and evolves based on the orbit data provided.
///
/// Orbit elements must be added in increasing time order.
/// </summary>
/// <param name="time"></param>
/// <param name="orbitData"></param>
/// <param name="body"></param>
/// <param name="centerBody"></param>
/// <param name="callback">(Optional) Method to call when sequence starts</param>
/// <returns></returns>
public OrbitUniversal AppendElementOrbitData(double time,
OrbitData orbitData,
NBody body,
NBody centerBody,
ElementStarted callback)
{
if (BadTime(time))
{
return(null);
}
KeplerElement ke = new KeplerElement
{
timeStart = time,
returnToGE = false,
callback = callback
};
OrbitUniversal orbit = orbitsGO.AddComponent <OrbitUniversal>();
orbit.centerNbody = centerBody;
orbit.SetNBody(body);
orbit.InitFromOrbitData(orbitData, time);
orbit.evolveMode = OrbitUniversal.EvolveMode.KEPLERS_EQN;
ke.orbit = orbit;
keplerElements.Add(ke);
return(orbit);
}
private void TestRV(OrbitData od, GameObject planet, NBody starNbody, float orbitRadius)
{
GameObject testPlanet = TestSetupUtils.CreatePlanetInOrbitUniversal(starNbody, 1f, orbitRadius);
OrbitUniversal orbitU = testPlanet.GetComponent <OrbitUniversal>();
// Run init explicitly to update transform details
orbitU.InitFromOrbitData(od, 0);
// Awkward but previously could not add a new object to GE when it is stopped, so re-add all three
// Leave as is, since it works!
GravityEngine ge = GravityEngine.Instance();
ge.Clear();
ge.AddBody(starNbody.gameObject);
ge.AddBody(planet);
ge.AddBody(testPlanet);
ge.Setup();
ge.LogDump();
Vector3 r_od = ge.GetPhysicsPosition(testPlanet.GetComponent <NBody>());
Vector3 v_od = ge.GetVelocity(testPlanet);
Vector3 r_i = ge.GetPhysicsPosition(planet.GetComponent <NBody>());
Vector3 v_i = ge.GetVelocity(planet);
Debug.Log(" r_i=" + r_i + " r_od=" + r_od + " delta=" + Vector3.Distance(r_i, r_od));
Debug.Log(" v_i=" + v_i + " v_od=" + v_od + " delta=" + Vector3.Distance(v_i, v_od));
Assert.IsTrue(GEUnit.FloatEqual(Vector3.Distance(r_i, r_od), 0f, 1E-2));
Assert.IsTrue(GEUnit.FloatEqual(Vector3.Distance(v_i, v_od), 0f, 1E-2));
}
private void OrbitAround(OrbitData orbitData)
{
orbitCentre = orbitData.Midpoint;
orbitSpeedAtBaseDistance = Random.Range(minOrbitSpeedAtBaseDistance, maxOrbitSpeedAtBaseDistance);
isOrbiting = true;
orbitAxis = orbitData.Axis;
}
private void TestRV(OrbitData od, GameObject planet, GameObject star)
{
GameObject testPlanet = TestSetupUtils.CreatePlanetInHyper(star, 1f);
testPlanet.name = "TestPlanet";
OrbitHyper testHyper = testPlanet.GetComponent <OrbitHyper>();
testHyper.InitFromOrbitData(od);
planet.name = "Planet";
// Awkward but cannot add a new object to GE when it is stopped, so re-add all three
GravityEngine ge = GravityEngine.Instance();
ge.Clear();
ge.AddBody(star);
ge.AddBody(planet);
ge.AddBody(testPlanet);
ge.Setup();
ge.LogDump();
Vector3 r_od = ge.GetPhysicsPosition(testPlanet.GetComponent <NBody>());
Vector3 v_od = ge.GetVelocity(testPlanet);
Vector3 r_i = ge.GetPhysicsPosition(planet.GetComponent <NBody>());
Vector3 v_i = ge.GetVelocity(planet);
Debug.Log(" r_i=" + r_i + " r_od=" + r_od + " delta=" + Vector3.Distance(r_i, r_od));
Debug.Log(" v_i=" + v_i + " v_od=" + v_od + " delta=" + Vector3.Distance(v_i, v_od));
Assert.IsTrue(FloatEqual(Vector3.Distance(r_i, r_od), 0f, 5E-2));
Assert.IsTrue(FloatEqual(Vector3.Distance(v_i, v_od), 0f, 5E-2));
}
public OrbitTransfer Circularize()
{
OrbitData shipOrbit = new OrbitData();
shipOrbit.SetOrbitForVelocity(ship, centralMass);
return(new CircularizeXfer(shipOrbit));
}
// Check eccentricity and inclination
public void CheckTestRV()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbit(star, 1f, orbitRadius);
OrbitEllipse orbitEllipse = planet.GetComponent <OrbitEllipse>();
orbitEllipse.ecc = .25f;
orbitEllipse.inclination = 25f;
orbitEllipse.omega_uc = 10f;
orbitEllipse.omega_lc = 20f;
orbitEllipse.phase = 190f;
orbitEllipse.Init();
orbitEllipse.ApplyScale(1f);
orbitEllipse.InitNBody(1f, 1f);
OrbitData od = new OrbitData();
od.a = orbitRadius;
od.ecc = 0.25f;
od.inclination = 25f;
od.omega_uc = 10f;
od.omega_lc = 20f;
od.phase = 190f;
TestRV(od, planet, star, orbitRadius);
}
public void HyperPhaseNoIncl()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
const float orbitPeri = 15f;
GameObject planet = TestSetupUtils.CreatePlanetInHyper(star, 1f);
OrbitHyper orbitHyper = planet.GetComponent <OrbitHyper>();
orbitHyper.ecc = 1.4f;
orbitHyper.perihelion = orbitPeri;
orbitHyper.r_initial = orbitPeri;
// Try some values of om
float[] rinit_values = { orbitPeri, orbitPeri + 2f, orbitPeri + 5f, orbitPeri + 10f, orbitPeri + 20f };
foreach (float rinit in rinit_values)
{
orbitHyper.r_initial = rinit;
TestSetupUtils.SetupGravityEngine(star, planet);
orbitHyper.Log(System.Reflection.MethodBase.GetCurrentMethod().Name);
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("rinit = " + rinit + " od.r_initial=" + od.r_initial);
// Need a bit of leeway at 0 with error
TestRV(od, planet, star);
}
}
private void applyPolygonData()
{
if (this.currentPolygonType == PolygonType.None)
{
return;
}
IShaderData shaderData = null;
switch (this.currentPolygonType)
{
case PolygonType.Sprite:
shaderData = new SpriteData(this.localTransform, this.textureId, this.color, this.clipArea, this.linearFiltering);
break;
case PolygonType.Orbit:
shaderData = new OrbitData(this.minRadius, this.maxRadius, this.color, this.localTransform, this.sprite);
break;
case PolygonType.Sdf:
shaderData = new SdfData(this.localTransform, this.textureId, this.color, this.clipArea);
break;
default:
throw new NotImplementedException(this.currentPolygonType.ToString());
}
this.polygons.Add(new PolygonData(this.z, shaderData, this.vertexData));
//clean up
this.vertexData = new List <float>();
this.localTransform = Matrix4.Identity;
}
/// <summary>
/// Circularize around Moon
/// - currently only onRails is implemented
/// </summary>
private void CircularizeAroundMoon()
{
// check ship is on segment where it near Moon
if (onRails)
{
KeplerSequence keplerSeq = spaceship.GetComponent <KeplerSequence>();
OrbitUniversal orbitU = keplerSeq.GetCurrentOrbit();
if (orbitU.centerNbody == moonBody)
{
// in orbit around the moon - do circularization
OrbitData orbitData = new OrbitData(orbitU);
OrbitTransfer circularizeXfer = new CircularizeXfer(orbitData);
keplerSeq.RemoveFutureSegments();
keplerSeq.AddManeuvers(circularizeXfer.GetManeuvers());
}
}
else
{
// assume we're in orbit around the moon
OrbitData orbitData = new OrbitData();
orbitData.SetOrbitForVelocity(spaceship, moonBody);
OrbitTransfer circularizeXfer = new CircularizeXfer(orbitData);
ge.AddManeuvers(circularizeXfer.GetManeuvers());
}
}
public string ApproachPrediction(string moonName)
{
// @TODO: Too much C&P!
// Step 1: Determine the patched conic xfer
OrbitData shipOrbit = new OrbitData();
NBody shipNbody = spaceshipCtrl.GetNBody();
shipOrbit.SetOrbit(shipNbody, centralMass);
OrbitData moonOrbit = new OrbitData();
NBody moonNbody = GetTargetByName(moonName);
moonOrbit.SetOrbit(moonNbody, centralMass);
//Make a copy of the universe state and evolve forward to find min distance to
// moon.
GravityEngine ge = GravityEngine.Instance();
GravityState gs = ge.GetGravityStateCopy();
// run a simulation and find the closest approach (Expensive!)
LunarCourseCorrection lcc = new LunarCourseCorrection(shipNbody, moonNbody);
// want to be within 10% of Earth-Moon distance, before start checking
courseCorrectionData = new LunarCourseCorrection.CorrectionData();
courseCorrectionData.gravityState = gs;
courseCorrectionData.approachDistance = 0.1f * moonOrbit.a;;
courseCorrectionData.correction = 0;
courseCorrectionData.maxPhysTime = time_to_moon_phys;
lcc.ClosestApproachAsync(courseCorrectionData, MoonPreviewCompleted);
return("Calculation started...\n");
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyUp(KeyCode.H))
{
OrbitData shipOrbit = new OrbitData();
shipOrbit.SetOrbitForVelocity(shipNbody, centerNbody);
OrbitData targetOrbit = new OrbitData();
targetOrbit.SetOrbitForVelocity(targetNbody, centerNbody);
// determine the transfer
orbitTransfer = new HohmannXfer(shipOrbit, targetOrbit, rendezvous);
// If this is a ship with a Kepler sequence take the maneuvers and add them as KeplerSequence elements
// This allows the transfer to be time-reversible if the whole scene is on rails.
if (keplerSeq != null)
{
keplerSeq.AddManeuvers(orbitTransfer.GetManeuvers());
}
else
{
// Nbody evolution (or plain onRails w/o KeplerSequence) use maneuvers
foreach (Maneuver m in orbitTransfer.GetManeuvers())
{
GravityEngine.Instance().AddManeuver(m);
}
}
// Maneuver markers
if (markerPrefab != null)
{
foreach (Maneuver m in orbitTransfer.GetManeuvers())
{
// set maneuver position marker
GameObject marker = Instantiate(markerPrefab, centerNbody.gameObject.transform, true);
marker.transform.position = m.physPosition.ToVector3();
markers.Add(marker);
m.onExecuted = RemoveMarker;
}
}
}
if (Input.GetKeyUp(KeyCode.C))
{
// clear maneuvers
GravityEngine.Instance().ClearManeuvers();
// delete on rails maneuvers
if (keplerSeq != null)
{
keplerSeq.RemoveManeuvers(orbitTransfer.GetManeuvers());
}
foreach (GameObject marker in markers)
{
Destroy(marker);
}
markers.Clear();
}
// optionally report time to next maneuver
// for now just do first maneuver
if ((timeToManeuverText != null) && (orbitTransfer != null))
{
double time = orbitTransfer.GetManeuvers()[0].worldTime - GravityEngine.Instance().GetPhysicalTime();
timeToManeuverText.text = string.Format("Time to Next Maneuver = {0:0.00}", time);
}
}
private void TestRV(OrbitData od, GameObject planet, GameObject star, float orbitRadius)
{
GameObject testPlanet = TestSetupUtils.CreatePlanetInOrbit(star, 1f, orbitRadius);
OrbitEllipse testEllipse = testPlanet.GetComponent <OrbitEllipse>();
// Run init explicitly to update transform details
testEllipse.InitFromOrbitData(od);
// Awkward but cannot add a new object to GE when it is stopped, so re-add all three
GravityEngine ge = GravityEngine.Instance();
ge.Clear();
ge.AddBody(star);
ge.AddBody(planet);
ge.AddBody(testPlanet);
ge.Setup();
ge.LogDump();
Vector3 r_od = ge.GetPhysicsPosition(testPlanet.GetComponent <NBody>());
Vector3 v_od = ge.GetVelocity(testPlanet);
Vector3 r_i = ge.GetPhysicsPosition(planet.GetComponent <NBody>());
Vector3 v_i = ge.GetVelocity(planet);
Debug.Log(" r_i=" + r_i + " r_od=" + r_od + " delta=" + Vector3.Distance(r_i, r_od));
Debug.Log(" v_i=" + v_i + " v_od=" + v_od + " delta=" + Vector3.Distance(v_i, v_od));
Assert.IsTrue(FloatEqual(Vector3.Distance(r_i, r_od), 0f, 1E-2));
Assert.IsTrue(FloatEqual(Vector3.Distance(v_i, v_od), 0f, 1E-2));
}
public void OmegaULEllipseInclined()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbit(star, 1f, orbitRadius);
OrbitEllipse orbitEllipse = planet.GetComponent <OrbitEllipse>();
orbitEllipse.InitNBody(1f, 1f);
orbitEllipse.inclination = 30f;
orbitEllipse.ecc = 0.2f;
orbitEllipse.Init();
orbitEllipse.ApplyScale(1f);
orbitEllipse.InitNBody(1f, 1f);
// Try some values of om
float[] omegaUValues = { 0f, 30f, 45f, 60f, 90f, 135f, 180f, 210f, 310f };
float[] omegaLValues = { 0f, 30f, 45f, 60f, 90f, 135f, 180f, 210f, 310f };
foreach (float omegaU in omegaUValues)
{
foreach (float omegaL in omegaLValues)
{
orbitEllipse.omega_uc = omegaU;
orbitEllipse.omega_lc = omegaL;
TestSetupUtils.SetupGravityEngine(star, planet);
orbitEllipse.Log("OmegaUL inclined:");
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("omegaU = " + omegaU + "omegaL = " + omegaL + " OD:=" + od.LogString());
TestRV(od, planet, star, orbitRadius);
}
}
}
public void CirclePhaseOmegaInclined()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbit(star, 1f, orbitRadius);
OrbitEllipse orbitEllipse = planet.GetComponent <OrbitEllipse>();
orbitEllipse.inclination = 20f;
// Try some values of phase
// omegaU for a circle does not make sense, no axis to relate it to.
float[] phaseValues = { 0f, 30f, 45f, 60f, 90f, 135f, 180f, 210f, 320f };
foreach (float phase in phaseValues)
{
orbitEllipse.phase = phase;
orbitEllipse.omega_uc = 0;
TestSetupUtils.SetupGravityEngine(star, planet);
Debug.LogFormat("Test for phase={0} omegau={1}", phase, 0);
orbitEllipse.Log("Initial circle:");
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("OrbitData: " + od.LogString());
Assert.IsTrue(FloatEqualMod360(phase, od.phase, 0.05));
Assert.IsTrue(FloatEqualMod360(0, od.omega_uc, 0.05));
TestRV(od, planet, star, orbitRadius);
}
}
public void OmegaUNoInclination()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbit(star, 1f, orbitRadius);
OrbitEllipse orbitEllipse = planet.GetComponent <OrbitEllipse>();
orbitEllipse.InitNBody(1f, 1f);
orbitEllipse.ecc = 0.1f;
// Try some values of om
float[] omegaValues = { 0f, 30f, 45f, 60f, 90f, 135f, 180f, 210f, 320f };
foreach (float omega in omegaValues)
{
orbitEllipse.omega_uc = omega;
orbitEllipse.Init();
orbitEllipse.ApplyScale(1f);
orbitEllipse.InitNBody(1f, 1f);
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("omega = " + omega + " od.omega_lc=" + od.omega_lc);
Assert.IsTrue(FloatEqual(omega, od.omega_lc, 0.4));
}
}
/// <summary>
/// Raise a circular orbit by the specified percent
/// - only on-rail is implemented
/// </summary>
/// <param name="percentRaise"></param>
private void NewCircularOrbit(float percentRaise)
{
if (onRails)
{
KeplerSequence keplerSeq = spaceship.GetComponent <KeplerSequence>();
OrbitUniversal orbitU = keplerSeq.GetCurrentOrbit();
// check orbit is circular
if (orbitU.eccentricity < 1E-2)
{
// circular, ok to proceed
OrbitData fromOrbit = new OrbitData(orbitU);
OrbitData toOrbit = new OrbitData(fromOrbit);
toOrbit.a = percentRaise * fromOrbit.a;
const bool rendezvous = false;
OrbitTransfer hohmannXfer = new HohmannXfer(fromOrbit, toOrbit, rendezvous);
keplerSeq.RemoveFutureSegments();
keplerSeq.AddManeuvers(hohmannXfer.GetManeuvers());
}
}
else
{
// assume we're in orbit around the moon
OrbitData orbitData = new OrbitData();
orbitData.SetOrbitForVelocity(spaceship, moonBody);
OrbitData toOrbit = new OrbitData(orbitData);
toOrbit.a = percentRaise * orbitData.a;
const bool rendezvous = false;
OrbitTransfer hohmannXfer = new HohmannXfer(orbitData, toOrbit, rendezvous);
ge.AddManeuvers(hohmannXfer.GetManeuvers());
}
}
private bool ValidateOrbitType(OrbitData obData, OrbitGeneratorFactory factory)
{
if (obData.orbitType == OrbitType.KOLNIYA && !CelestialUtilities.CanBodyBeKolniya(obData.targetBody))
{
string error = string.Format("Cannot use a Kolniya orbit with {0}.", obData.targetBody.theName);
if (factory != null)
{
LoggingUtil.LogError(factory, factory.ErrorPrefix() + ": " + error);
return(false);
}
else
{
throw new ArgumentException(error);
}
}
else if (obData.orbitType == OrbitType.TUNDRA && !CelestialUtilities.CanBodyBeTundra(obData.targetBody))
{
string error = string.Format("Cannot use a tundra orbit with {0}.", obData.targetBody.theName);
if (factory != null)
{
LoggingUtil.LogError(factory, factory.ErrorPrefix() + ": " + error);
return(false);
}
else
{
throw new ArgumentException(error);
}
}
return(true);
}
private void ComputeTransfer()
{
shipData = new OrbitData();
shipData.centralMass = starNBody;
shipData.SetOrbitForVelocity(spaceshipNBody, starNBody);
targetData = new OrbitData(targetEllipses[selectedEllipse].orbitData);
targetData.phase = targetEllipses[selectedEllipse].manueverPhase;
// compute the min energy path (this will be in the short path direction)
lambertU = new LambertUniversal(shipData, targetData, shortPath);
// apply any time of flight change
transferTime = tflightFactor * lambertU.GetTMin();
bool reverse = !shortPath;
// recompute with updated time
const bool df = false;
const int nrev = 0;
int error = lambertU.ComputeXfer(reverse, df, nrev, transferTime);
if (error != 0)
{
Debug.LogWarning("Lambert failed to find solution.");
maneuverSegment.gameObject.SetActive(false);
return;
}
Vector3 vel = lambertU.GetTransferVelocity();
maneuverOrbitPredictor.SetVelocity(vel);
maneuverSegment.SetVelocity(vel);
maneuverOrbitPredictor.gameObject.SetActive(true);
maneuverSegment.gameObject.SetActive(true);
}
private void ComputeTransfer()
{
Vector3d r_from = GravityEngine.Instance().GetPositionDoubleV3(spaceship);
Vector3d r_to = new Vector3d(targetPoint.transform.position);
OrbitData shipOrbit = new OrbitData();
shipOrbit.SetOrbitForVelocity(spaceship, centralMass);
// compute the min energy path (this will be in the short path direction)
lambertU = new LambertUniversal(shipOrbit, r_from, r_to, shortPath);
// apply any time of flight change
double t_flight = tflightFactor * lambertU.GetTMin();
bool reverse = !shortPath;
const bool df = false;
const int nrev = 0;
int error = lambertU.ComputeXfer(reverse, df, nrev, t_flight);
if (error != 0)
{
Debug.LogWarning("Lambert failed to find solution.");
maneuverSegment.gameObject.SetActive(false);
return;
}
Vector3 dv = lambertU.GetTransferVelocity() - GravityEngine.Instance().GetVelocity(spaceship);
dvText.text = string.Format("dV = {0:00.00} Time={1:00.00}", dv.magnitude, t_flight);
maneuverOrbitPredictor.SetVelocity(lambertU.GetTransferVelocity());
maneuverSegment.gameObject.SetActive(true);
maneuverSegment.SetDestination(r_to.ToVector3());
maneuverSegment.SetVelocity(lambertU.GetTransferVelocity());
}
/// <summary>
/// Callback to compute the launch transfer times and display them in the scene.
/// </summary>
public void Compute()
{
int itemNo = destDropdown.value;
NBody toNbody = destinations[itemNo].GetComponent <NBody>();
OrbitData fromOrbit = new OrbitData();
fromOrbit.SetOrbit(fromNbody, centerNbody);
OrbitData toOrbit = new OrbitData();
toOrbit.SetOrbit(toNbody, centerNbody);
HohmannXfer hohmannXfer = new HohmannXfer(fromOrbit, toOrbit, true);
// Find launch windows
double[] times = hohmannXfer.LaunchTimes(numWindows);
List <Dropdown.OptionData> items = new List <Dropdown.OptionData>();
foreach (double t in times)
{
Dropdown.OptionData item = new Dropdown.OptionData();
item.text = GravityScaler.GetWorldTimeFormatted(t, GravityScaler.Units.SOLAR);
items.Add(item);
}
launchTimes.ClearOptions();
launchTimes.AddOptions(items);
}
public void HyperOmegaUInclNoPhase()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
GameObject planet = TestSetupUtils.CreatePlanetInHyper(star, 1f);
OrbitHyper orbitHyper = planet.GetComponent <OrbitHyper>();
orbitHyper.ecc = 1.4f;
orbitHyper.perihelion = 20f;
orbitHyper.r_initial = 20f;
orbitHyper.inclination = 35f;
// Try some values of om
float[] omegaValues = { 30f, 45f, 60f, 90f, 135f, 180f, 210f, 275f, 355f };
foreach (float omega in omegaValues)
{
orbitHyper.omega_uc = omega;
TestSetupUtils.SetupGravityEngine(star, planet);
orbitHyper.Log(System.Reflection.MethodBase.GetCurrentMethod().Name);
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("omega = " + omega + " od.omega_uc=" + od.omega_uc);
// Need a bit of leeway at 0 with error
Assert.IsTrue(FloatEqualMod360(omega, od.omega_uc, 0.05));
}
}
// Use this for initialization
void Start()
{
nbody = body.GetComponent <NBody>();
if (nbody == null)
{
Debug.LogWarning("Cannot show orbit - Body requires NBody component");
return;
}
aroundNBody = centerBody.GetComponent <NBody>();
if (aroundNBody == null)
{
Debug.LogWarning("Cannot show orbit - centerBody requires NBody component");
return;
}
initOk = true;
lineR = GetComponent <LineRenderer>();
lineR.numPositions = numPoints;
orbitData = new OrbitData();
ellipseBase = transform.gameObject.AddComponent <EllipseBase>();
ellipseBase.centerObject = centerBody;
orbitHyper = transform.gameObject.AddComponent <OrbitHyper>();
orbitHyper.centerObject = centerBody;
}
public void HyperInclination()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
GameObject planet = TestSetupUtils.CreatePlanetInHyper(star, 1f);
OrbitHyper orbitHyper = planet.GetComponent <OrbitHyper>();
orbitHyper.ecc = 1.4f;
orbitHyper.r_initial = 20f;
// Try some values of om
float[] inclValues = { 30f, 45f, 60f, 90f, 135f, 180f, 0f };
foreach (float incl in inclValues)
{
orbitHyper.inclination = incl;
TestSetupUtils.SetupGravityEngine(star, planet);
orbitHyper.Log(System.Reflection.MethodBase.GetCurrentMethod().Name);
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("incl = " + incl + " od.incl=" + od.inclination);
// Need a bit of leeway at 0 with error
Assert.IsTrue(FloatEqual(incl, od.inclination, 0.02));
}
}
// Update is called once per frame
void Update()
{
if (xferRequested)
{
return;
}
if (Input.GetKeyUp(KeyCode.T))
{
OrbitData od1 = new OrbitData();
od1.SetOrbitForVelocity(orbit1, centerBody);
OrbitData od2 = new OrbitData();
od2.SetOrbitForVelocity(orbit2, centerBody);
OrbitTransfer transfer = new CircularInclinationAndAN(od1, od2);
// Update for as many markers as provided
List <Maneuver> maneuvers = transfer.GetManeuvers();
for (int i = 0; i < commonPointMarker.Length; i++)
{
commonPointMarker[i].transform.position = maneuvers[i].physPosition.ToVector3();
}
GravityEngine.instance.AddManeuvers(transfer.GetManeuvers());
xferRequested = true;
}
}
public void OmegaUCircleInclination()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
NBody starNbody = star.GetComponent <NBody>();
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbitUniversal(starNbody, 1f, orbitRadius);
OrbitUniversal orbitU = planet.GetComponent <OrbitUniversal>();
orbitU.eccentricity = 0.0f;
orbitU.inclination = 5;
orbitU.SetMajorAxisInspector(orbitRadius);
// Try some values of om
float[] omegaValues = { 0f, 30f, 45f, 60f, 90f, 135f, 180f, 210f, 320f };
foreach (float omega in omegaValues)
{
orbitU.omega_uc = omega;
TestSetupUtils.SetupGravityEngine(star, planet);
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("Omega = " + omega + " od.omega_lc=" + od.omega_lc + " od:" + od.LogString());
Assert.IsTrue(GEUnit.FloatEqual(omega, od.omega_uc, 0.1));
}
}
public void PhaseRetrogradeEllipse()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbit(star, 1f, orbitRadius);
OrbitEllipse orbitEllipse = planet.GetComponent <OrbitEllipse>();
orbitEllipse.ecc = 0.4f;
orbitEllipse.inclination = 180f;
// Try some values of om
float[] phaseValues = { 30f, 45f, 60f, 90f, 135f, 180f, 0f };
foreach (float phase in phaseValues)
{
orbitEllipse.phase = phase;
orbitEllipse.Init();
orbitEllipse.ApplyScale(1f);
orbitEllipse.InitNBody(1f, 1f);
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("phase = " + phase + " od.phase=" + od.phase);
// Need a bit of leeway at 0 with error
Assert.IsTrue(FloatEqual(phase, od.phase, 0.02));
TestRV(od, planet, star, orbitRadius);
}
}
// Check eccentricity and inclination
public void CheckTestRV()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
NBody starNbody = star.GetComponent <NBody>();
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbitUniversal(starNbody, 1f, orbitRadius);
OrbitUniversal orbitU = planet.GetComponent <OrbitUniversal>();
orbitU.eccentricity = .25f;
orbitU.inclination = 25f;
orbitU.omega_uc = 10f;
orbitU.omega_lc = 20f;
orbitU.phase = 190f;
orbitU.SetMajorAxisInspector(orbitRadius);
OrbitData od = new OrbitData();
od.a = orbitRadius;
od.ecc = 0.25f;
od.inclination = 25f;
od.omega_uc = 10f;
od.omega_lc = 20f;
od.phase = 190f;
od.centralMass = starNbody;
GravityEngine.Instance().UnitTestAwake();
Debug.LogFormat("major-axis: {0} vs {1}", orbitU.GetMajorAxisInspector(), orbitRadius);
Assert.AreEqual(orbitU.GetMajorAxisInspector(), orbitRadius);
TestRV(od, planet, starNbody, orbitRadius);
}
public void CirclePhaseOmegaInclined()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbit(star, 1f, orbitRadius);
OrbitEllipse orbitEllipse = planet.GetComponent <OrbitEllipse>();
orbitEllipse.inclination = 20f;
// Try some values of phase
float[] phaseValues = { 0f, 30f, 45f, 60f, 90f, 135f, 180f, 210f, 320f };
float[] omegaUValues = { 0f, 30f, 45f, 60f, 90f, 135f, 180f, 210f, 320f };
foreach (float phase in phaseValues)
{
foreach (float omegau in omegaUValues)
{
orbitEllipse.phase = phase;
orbitEllipse.omega_uc = omegau;
orbitEllipse.Init();
orbitEllipse.ApplyScale(1f);
orbitEllipse.InitNBody(1f, 1f);
orbitEllipse.Log("Initial circle:");
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
Debug.Log("TEST: phase = " + phase + " od.phase=" + od.phase +
" omegaU = " + omegau + " od.omegau=" + od.omega_uc);
TestRV(od, planet, star, orbitRadius);
}
}
}
//trae de acuerdo a la orbita la cantidad maxima de electrones
public OrbitData GetOrbitDataByNumber(int orbitNumber)
{
OrbitData orbitData = null;
using (IDbConnection dbConnection = new SqliteConnection(connectionString))
{
dbConnection.Open();
using (IDbCommand command = dbConnection.CreateCommand())
{
string sqlQuery = "SELECT nro_orbita, nombre_capa, max_electrones FROM elementos_orbitas WHERE nro_orbita ="
+ orbitNumber + ";";
command.CommandText = sqlQuery;
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
int number = reader.GetInt32(0);
string name = reader.GetString(1);
int maxElectrons = reader.GetInt32(2);
orbitData = new OrbitData(number, name, maxElectrons);
}
dbConnection.Close();
reader.Close();
}
}
}
return(orbitData);
}
public void OmegasEllipseInclination()
{
const float mass = 1000f;
GameObject star = TestSetupUtils.CreateNBody(mass, new Vector3(0, 0, 0));
const float orbitRadius = 10f;
GameObject planet = TestSetupUtils.CreatePlanetInOrbit(star, 1f, orbitRadius);
OrbitEllipse orbitEllipse = planet.GetComponent <OrbitEllipse>();
orbitEllipse.InitNBody(1f, 1f);
orbitEllipse.inclination = 35f;
orbitEllipse.ecc = 0.25f;
orbitEllipse.Init();
orbitEllipse.ApplyScale(1f);
orbitEllipse.InitNBody(1f, 1f);
// Try some values of om
float[] omegaValues = { 0f, 30f, 45f, 60f, 90f, 135f, 180f };
foreach (float omega in omegaValues)
{
orbitEllipse.omega_uc = omega;
orbitEllipse.Init();
orbitEllipse.InitNBody(1f, 1f);
OrbitData od = new OrbitData();
od.SetOrbitForVelocity(planet.GetComponent <NBody>(), star.GetComponent <NBody>());
TestRV(od, planet, star, orbitRadius);
}
}
public OrbitData(OrbitData orig, Contract contract)
{
type = orig.type;
name = orig.name;
orbitType = orig.orbitType;
index = orig.index;
count = orig.count;
targetBody = orig.targetBody;
altitudeFactor = orig.altitudeFactor;
inclinationFactor = orig.inclinationFactor;
eccentricity = orig.eccentricity;
deviationWindow = orig.deviationWindow;
// Lazy copy of orbit - only really used to store the orbital parameters, so not
// a huge deal.
orbit = orig.orbit;
}
protected override void OnLoad(ConfigNode configNode)
{
base.OnLoad(configNode);
foreach (ConfigNode child in configNode.GetNodes("ORBIT_DETAIL"))
{
// Read all the orbit data
OrbitData obData = new OrbitData();
obData.type = child.GetValue("type");
obData.contract = contract;
obData.orbit = new OrbitSnapshot(child.GetNode("ORBIT")).Load();
obData.SetupRenderer();
// Add to the global list
orbits.Add(obData);
}
}
public static OrbitGenerator Create(ConfigNode configNode, OrbitGeneratorFactory factory)
{
OrbitGenerator obGenerator = new OrbitGenerator();
bool valid = true;
int index = 0;
foreach (ConfigNode child in ConfigNodeUtil.GetChildNodes(configNode))
{
DataNode dataNode = new DataNode("ORBIT_" + index++, factory.dataNode, factory);
try
{
ConfigNodeUtil.SetCurrentDataNode(dataNode);
OrbitData obData = new OrbitData(child.name);
// Get settings that differ by type
if (child.name == "FIXED_ORBIT")
{
valid &= ConfigNodeUtil.ParseValue<Orbit>(child, "ORBIT", x => obData.orbit = x, factory);
}
else if (child.name == "RANDOM_ORBIT")
{
valid &= ConfigNodeUtil.ParseValue<OrbitType>(child, "type", x => obData.orbitType = x, factory);
valid &= ConfigNodeUtil.ParseValue<int>(child, "count", x => obData.count = x, factory, 1, x => Validation.GE(x, 1));
valid &= ConfigNodeUtil.ParseValue<double>(child, "altitudeFactor", x => obData.altitudeFactor = x, factory, 0.8, x => Validation.Between(x, 0.0, 1.0));
valid &= ConfigNodeUtil.ParseValue<double>(child, "inclinationFactor", x => obData.inclinationFactor = x, factory, 0.8, x => Validation.Between(x, 0.0, 1.0));
valid &= ConfigNodeUtil.ParseValue<double>(child, "eccentricity", x => obData.eccentricity = x, factory, 0.0, x => Validation.GE(x, 0.0));
valid &= ConfigNodeUtil.ParseValue<double>(child, "deviationWindow", x => obData.deviationWindow = x, factory, 10.0, x => Validation.GE(x, 0.0));
}
else
{
throw new ArgumentException("Unrecognized orbit node: '" + child.name + "'");
}
// Use an expression to default - then it'll work for dynamic contracts
if (!child.HasValue("targetBody"))
{
child.AddValue("targetBody", "@/targetBody");
}
valid &= ConfigNodeUtil.ParseValue<CelestialBody>(child, "targetBody", x => obData.targetBody = x, factory);
// Check for unexpected values
valid &= ConfigNodeUtil.ValidateUnexpectedValues(child, factory);
// Add to the list
obGenerator.orbits.Add(obData);
}
finally
{
ConfigNodeUtil.SetCurrentDataNode(factory.dataNode);
}
}
allOrbitGenerators.Add(obGenerator);
return valid ? obGenerator : null;
}
protected override void OnLoad(ConfigNode configNode)
{
base.OnLoad(configNode);
// Register the orbit drawing class
if (MapView.MapCamera.gameObject.GetComponent<OrbitRenderer>() == null)
{
MapView.MapCamera.gameObject.AddComponent<OrbitRenderer>();
}
foreach (ConfigNode child in configNode.GetNodes("ORBIT_DETAIL"))
{
// Read all the orbit data
OrbitData obData = new OrbitData();
obData.type = child.GetValue("type");
obData.name = child.GetValue("name");
obData.index = Convert.ToInt32(child.GetValue("index"));
obData.orbit = new OrbitSnapshot(child.GetNode("ORBIT")).Load();
// Add to the global list
orbits.Add(obData);
}
allOrbitGenerators.Add(this);
}
private bool ValidateOrbitType(OrbitData obData, OrbitGeneratorFactory factory)
{
if (obData.orbitType == OrbitType.KOLNIYA && !CelestialUtilities.CanBodyBeKolniya(obData.targetBody))
{
string error = string.Format("Cannot use a Kolniya orbit with {0}.", obData.targetBody.theName);
if (factory != null)
{
LoggingUtil.LogError(factory, factory.ErrorPrefix() + ": " + error);
return false;
}
else
{
throw new ArgumentException(error);
}
}
else if (obData.orbitType == OrbitType.TUNDRA && !CelestialUtilities.CanBodyBeTundra(obData.targetBody))
{
string error = string.Format("Cannot use a tundra orbit with {0}.", obData.targetBody.theName);
if (factory != null)
{
LoggingUtil.LogError(factory, factory.ErrorPrefix() + ": " + error);
return false;
}
else
{
throw new ArgumentException(error);
}
}
return true;
}
