/// <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; }