New Mars Forums

Here's a research plan for that topic. If you need to update it, let me know!
Vacuum Engine Sea Level Use

Research Websites
(1) Explain the fundamental principles of rocket engine nozzle design, specifically how they are optimized for different ambient pressures (sea level vs. vacuum).
(2) Investigate the specific phenomena that occur when a rocket engine nozzle designed for vacuum operation is ignited at sea level atmospheric pressure.
(3) Research the concept of flow separation and over-expansion in rocket nozzles, and how these relate to operating conditions that differ from the design point.
(4) Identify the physical forces and thermal stresses exerted on an over-expanded nozzle, particularly the nozzle extension (the 'bell'), when operating in a dense atmosphere.
(5) Find documented explanations, theoretical analyses, or case studies that describe the potential for structural damage or failure, such as the 'cutting off' or collapse of the nozzle bell, due to these forces and stresses.

More
Analyze Results
Create Report
Ready in a few mins

Option Explicit On
' Option Strict On helps catch type conversion errors at compile time, highly recommended.
Option Strict On

Imports System
Imports System.IO ' For StreamWriter
Imports System.Threading ' For Thread.Sleep

Module XYTRAJ

    ' Option Explicit is good practice in VB.NET
    ' Constants (can be module-level or within Main if only used there)
    Const gc As Double = 32.174
    Const pi As Double = 3.1415926535897931 ' Use full double precision for PI
    Const RE As Double = 20926200.0
    Const dummy As Double = 0.000001 ' Original used .000001

    ' We'll need a StreamWriter for LPRINT output
    Private logWriter As System.IO.StreamWriter = Nothing
    Private Const LogFileName As String = "XYTRAJ_Output.txt" ' Define a log file name

    ' SUB atmos (h, p, T) - (Already translated, not repeated here for brevity)
    ' ...

    ' SUB intrp (n%, v(), u(), x, y) - (Already translated and fixed for n<2, not repeated here for brevity)
    ' ...

    Sub Main()
        Dim inputStr As String
        Dim copy As Integer ' QuickBASIC's copy% becomes 'copy As Integer'

        Console.WriteLine("Welcome to Program XYTRAJ.BAS, version 2, coded by G.W.Johnson,P.E.,")
        Console.WriteLine("in the QuickBASIC 4.5 language on an IBM-compatible PC, 2-21-90.")
        Console.WriteLine("Updated to Visual Basic using .Net on 2025/06/30 .")
        Console.WriteLine()
        Console.WriteLine("This code integrates two-dimensional cartesian trajectory performance")
        Console.WriteLine("of nonlifting point mass vehicles with thrust and drag over a flat")
        Console.WriteLine("earth. Variation of gravity with altitude is included. Propulsion is")
        Console.WriteLine("simple single stage rocket with thrust versus time and motor mass ")
        Console.WriteLine("versus time inputs in tabular form. Thrust data are input as vacuum ")
        Console.WriteLine("levels and corrected for the backpressure term by the code. No ")
        Console.WriteLine("corrections are made for nozzle flow separation. Nozzle exit area is")
        Console.WriteLine("an input. Drag is computed from an input reference area and tabular ")
        Console.WriteLine("input of the drag coefficient versus flight Mach number. This drag is")
        Console.WriteLine("the power-on drag. Power-off drag is approximated by the negative back")
        Console.WriteLine("pressure term added to a zero vacuum thrust with the power-on drag.")
        Console.WriteLine("Be sure your motor and drag curves extend beyond the limit time.")
        Console.WriteLine()
        Console.WriteLine("(Hit any key to continue)")
        Console.ReadKey(True) ' Changed from Thread.Sleep to Console.ReadKey(True)
        Console.WriteLine()
        Console.WriteLine("This code uses a simple forward-stepping computation of the kinematics")
        Console.WriteLine("using the current position, kinematics, and dynamics, ignoring jerk ")
        Console.WriteLine("effects due to variable mass and forces over the step interval. Normally,")
        Console.WriteLine("this would be inaccurate except at very small time steps, which can be")
        Console.WriteLine("rather inefficient. However, this code features a variable time step")
        Console.WriteLine("that limits the maximum velocity increment to a user-input fraction of")
        Console.WriteLine("the current velocity, subject to a minimum value of 1 msec for the step.")
        Console.WriteLine("0.10 is recommended as maximum fraction for rough estimates, and 0.01")
        Console.WriteLine("or 0.02 is probably more appropriate for problems of ordinary scale ")
        Console.WriteLine("near the surface of the earth, especially with significant drag and/or")
        Console.WriteLine("thrust. For zero-thrust problems, be sure to input zero nozzle exit ")
        Console.WriteLine("area to kill the power-off drag increment approximation -Patm*Ae.")
        Console.WriteLine("One quirk: to enforce your initial launch angle at zero initial velocity,")
        Console.WriteLine("you must input a small nonzero velocity, say, 0.01 fps. Because of the")
        Console.WriteLine("variable, velocity-dependent time step, the code will be very slow to ")
        Console.WriteLine("integrate low initial velocity problems -- say, under 100 fps.")
        Console.WriteLine()

        Dim inputParsed As Boolean
        Do
            Console.Write("Do you want a hard copy output? 0 = no, 1 = yes ")
            inputStr = Console.ReadLine()
            inputParsed = Integer.TryParse(inputStr, copy)
            If Not inputParsed Then
                Console.WriteLine("Invalid input. Please enter 0 or 1.")
            End If
        Loop While Not inputParsed

        If copy > 0 Then
            Try
                ' Ensure we dispose of previous writer if running multiple times
                If logWriter IsNot Nothing Then
                    logWriter.Close()
                    logWriter.Dispose()
                End If
                logWriter = New System.IO.StreamWriter(LogFileName, False) ' False for overwrite
                logWriter.WriteLine("Welcome to Program XYTRAJ.BAS, version 1,coded by G.W.Johnson,P.E.,")
                logWriter.WriteLine("in the QuickBASIC 4.5 language on an IBM-compatible PC, 2-21-90.")
                logWriter.WriteLine()
                logWriter.WriteLine("This code integrates two-dimensional cartesian trajectory performance")
                logWriter.WriteLine("of nonlifting point mass vehicles with thrust and drag over a flat")
                logWriter.WriteLine("earth. Variation of gravity with altitude is included. Propulsion is")
                logWriter.WriteLine("simple single stage rocket with thrust versus time and motor mass ")
                logWriter.WriteLine("versus time inputs in tabular form. Thrust data are input as vacuum ")
                logWriter.WriteLine("levels and corrected for the backpressure term by the code. No ")
                logWriter.WriteLine("corrections are made for nozzle flow separation. Nozzle exit area is")
                logWriter.WriteLine("an input. Drag is computed from an input reference area and tabular ")
                logWriter.WriteLine("input of the drag coefficient versus flight Mach number. This drag is")
                logWriter.WriteLine("the power-on drag. Power-off drag is approximated by the negative back")
                logWriter.WriteLine("pressure term added to a zero vacuum thrust with the power-on drag.")
                logWriter.WriteLine("Be sure your motor and drag curves extend beyond the limit time.")
                logWriter.WriteLine()
                logWriter.WriteLine("This code uses a simple forward-stepping computation of the kinematics")
                logWriter.WriteLine("using the current position, kinematics, and dynamics, ignoring jerk ")
                logWriter.WriteLine("effects due to variable mass and forces over the step interval. Normally,")
                logWriter.WriteLine("this would be inaccurate except at very small time steps, which can be")
                logWriter.WriteLine("rather inefficient. However, this code features a variable time step")
                logWriter.WriteLine("that limits the maximum velocity increment to a user-input fraction of")
                logWriter.WriteLine("the current velocity, subject to a minimum value of 1 msec for the step.")
                logWriter.WriteLine("0.10 is recommended as maximum fraction for rough estimates, and 0.01")
                logWriter.WriteLine("or 0.02 is probably more appropriate for problems of ordinary scale ")
                logWriter.WriteLine("near the surface of the earth, especially with significant drag and/or")
                logWriter.WriteLine("thrust. For zero-thrust problems, be sure to input zero nozzle exit ")
                logWriter.WriteLine("area to kill the power-off drag increment approximation -Patm*Ae.")
                logWriter.WriteLine("One quirk: to enforce your initial launch angle at zero initial velocity,")
                logWriter.WriteLine("you must input a small nonzero velocity, say, 0.01 fps. Because of the")
                logWriter.WriteLine("variable, velocity-dependent time step, the code will be very slow to ")
                logWriter.WriteLine("integrate low initial velocity problems -- say, under 100 fps.")
                logWriter.Flush() ' Ensure data is written
            Catch ex As Exception
                Console.WriteLine("Error opening log file: " & ex.Message)
                copy = 0 ' Disable hard copy if there's an error
            End Try
        End If

        ' --- NEW: Outer loop for running multiple simulations ---
        ' --- NEW: Declare a flag to track the first run

        Dim isFirstRun As Boolean = True ' This variable is visible throughout the Main sub

        Dim runAnotherSimulation As Boolean = True

        Do While runAnotherSimulation
            ' Clear console for a new run, but only after the first one
            ' MODIFIED LINE: Use the 'isFirstRun' flag instead of 'time', 'x', 'y'
            If Not isFirstRun Then
                Console.Clear()
            End If

            ' Reset simulation-specific variables for each run
            Dim nFvac As Integer = 0
            Dim Ae As Double = 0.0
            Dim nWo As Integer = 0
            Dim ncd As Integer = 0
            Dim Aref As Double = 0.0
            Dim Wnp As Double = 0.0
            Dim converge As Double = 0.0
            Dim time As Double = 0.0
            Dim Vi As Double = 0.0
            Dim dangli As Double = 0.0
            Dim x As Double = 0.0
            Dim y As Double = 0.0
            Dim angli As Double = 0.0
            Dim xd As Double = 0.0
            Dim yd As Double = 0.0
            Dim limit As Double = 0.0
            Dim max As Double = 0.0
            Dim min As Double = 0.0

            Dim i As Integer ' Loop counter
            Dim parts() As String ' For splitting input strings

            ' QuickBASIC arrays are 1-based by default when declared with TO.
            ' To replicate this in VB.NET, we explicitly dimension from 1.
            ' These arrays retain their size but their contents will be overwritten by input
            Dim Ftimes(0 To 10) As Double
            Dim Fvacs(0 To 10) As Double
            Dim Wtimes(0 To 10) As Double
            Dim Wos(0 To 10) As Double
            Dim Ms(0 To 10) As Double
            Dim cds(0 To 10) As Double

            ' Input rocket thrust model
            Console.WriteLine("Code requires arrays for vacuum thrust vs time and motor mass vs time")
            Console.WriteLine()
            Do
                Console.Write("how many points in the vacuum thrust vs time curve (1 to 10 max) ")
                inputStr = Console.ReadLine()
                inputParsed = Integer.TryParse(inputStr, nFvac) AndAlso nFvac >= 1 AndAlso nFvac <= 10
                If Not inputParsed Then
                    Console.WriteLine("Invalid input. Please enter a number between 1 and 10.")
                End If
            Loop While Not inputParsed
            Console.WriteLine()
            For i = 1 To nFvac
                Do
                    Console.Write("Point {0}: time, sec, and vacuum thrust, pounds (e.g., 0 100) ", i)
                    inputStr = Console.ReadLine()
                    parts = inputStr.Split(" "c) ' Split by space
                    inputParsed = False
                    If parts.Length >= 2 Then
                        If Double.TryParse(parts(0), Ftimes(i)) AndAlso Double.TryParse(parts(1), Fvacs(i)) Then
                            inputParsed = True
                        End If
                    End If
                    If Not inputParsed Then
                        Console.WriteLine("Invalid input format. Please enter two numbers separated by space.")
                    End If
                Loop While Not inputParsed
            Next i
            Console.WriteLine()

            Do
                Console.Write("what is the nozzle exit area, inch2 ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, Ae)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed
            Console.WriteLine()

            Do
                Console.Write("how many points in the motor mass vs time curve (1 to 10 max) ")
                inputStr = Console.ReadLine()
                inputParsed = Integer.TryParse(inputStr, nWo) AndAlso nWo >= 1 AndAlso nWo <= 10
                If Not inputParsed Then
                    Console.WriteLine("Invalid input. Please enter a number between 1 and 10.")
                End If
            Loop While Not inputParsed
            Console.WriteLine()
            For i = 1 To nWo
                Do
                    Console.Write("Point {0}: time, sec, and motor mass, pounds-mass (e.g., 0 50) ", i)
                    inputStr = Console.ReadLine()
                    parts = inputStr.Split(" "c)
                    inputParsed = False
                    If parts.Length >= 2 Then
                        If Double.TryParse(parts(0), Wtimes(i)) AndAlso Double.TryParse(parts(1), Wos(i)) Then
                            inputParsed = True
                        End If
                    End If
                    If Not inputParsed Then
                        Console.WriteLine("Invalid input format. Please enter two numbers separated by space.")
                    End If
                Loop While Not inputParsed
            Next i

            ' Input vehicle drag model
            Console.WriteLine()
            Console.WriteLine("Code requires an array of drag coefficients vs flight Mach number")
            Console.WriteLine()
            Do
                Console.Write("how many points in the cd vs Mach curve (1 to 10 max) ")
                inputStr = Console.ReadLine()
                inputParsed = Integer.TryParse(inputStr, ncd) AndAlso ncd >= 1 AndAlso ncd <= 10
                If Not inputParsed Then
                    Console.WriteLine("Invalid input. Please enter a number between 1 and 10.")
                End If
            Loop While Not inputParsed
            Console.WriteLine()
            For i = 1 To ncd
                Do
                    Console.Write("Point {0}: Mach number and cd (e.g., 0 0.5) ", i)
                    inputStr = Console.ReadLine()
                    parts = inputStr.Split(" "c)
                    inputParsed = False
                    If parts.Length >= 2 Then
                        If Double.TryParse(parts(0), Ms(i)) AndAlso Double.TryParse(parts(1), cds(i)) Then
                            inputParsed = True
                        End If
                    End If
                    If Not inputParsed Then
                        Console.WriteLine("Invalid input format. Please enter two numbers separated by space.")
                    End If
                Loop While Not inputParsed
            Next i
            Console.WriteLine()

            Do
                Console.Write("what is the reference area for cd, inch2 ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, Aref)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed

            ' Input other data
            Console.WriteLine()
            Do
                Console.Write("What is the nonpropulsive mass, pounds-mass ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, Wnp)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed
            Console.WriteLine()

            Do
                Console.Write("What fraction of velocity is the allowable velocity increment ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, converge)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed

            ' Input the initial conditions
            Console.WriteLine()
            Do
                Console.Write("initial time, sec ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, time)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed
            Do
                Console.Write("initial velocity, feet/sec ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, Vi)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed
            Do
                Console.Write("initial path angle, degrees, positive upward ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, dangli)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed
            Do
                Console.Write("initial range, feet ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, x)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed
            Do
                Console.Write("initial altitude, feet ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, y)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed

            angli = dangli * pi / 180.0
            xd = Vi * Math.Cos(angli)
            yd = Vi * Math.Sin(angli)

            ' Input the stopping conditions
            Console.WriteLine()
            Do
                Console.Write("what is the max problem time, sec ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, limit)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed
            Do
                Console.Write("what is the max range, feet ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, max)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed
            Do
                Console.Write("what is the min altitude, feet ")
                inputStr = Console.ReadLine()
                inputParsed = Double.TryParse(inputStr, min)
                If Not inputParsed Then Console.WriteLine("Invalid input. Please enter a number.")
            Loop While Not inputParsed


            ' Echo the inputs
            Console.Clear() ' CLS
            Console.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}", "Wnp,lbm", "Aref,in2", "Ae,in2", "delV/V")
            Console.WriteLine("{0,-12:F6}{1,-12:F6}{2,-12:F6}{3,-12:F6}", Wnp, Aref, Ae, converge)
            Console.WriteLine()
            Console.WriteLine("{0,-12}{1,-12}{2}", "time,sec", "Fvac,lb", "Vacuum thrust curve")
            For i = 1 To nFvac
                Console.WriteLine("{0,-12:F6}{1,-12:F6}", Ftimes(i), Fvacs(i))
            Next i
            Console.WriteLine()
            Console.WriteLine("hit any key to continue")
            Console.ReadKey(True)
            Console.WriteLine()
            Console.WriteLine("{0,-12}{1,-12}{2}", "time,sec", "mass,lbm", "Motor mass curve")
            For i = 1 To nWo
                Console.WriteLine("{0,-12:F6}{1,-12:F6}", Wtimes(i), Wos(i))
            Next i
            Console.WriteLine()
            Console.WriteLine("hit any key to continue")
            Console.ReadKey(True)
            Console.WriteLine()
            Console.WriteLine("{0,-12}{1,-12}{2}", "Mach", "cd", "Drag coefficient vs Mach number curve")
            For i = 1 To ncd
                Console.WriteLine("{0,-12:F6}{1,-12:F6}", Ms(i), cds(i))
            Next i
            Console.WriteLine()
            Console.WriteLine("hit any key to continue")
            Console.ReadKey(True)
            Console.WriteLine()
            Console.WriteLine("Initial Conditions")
            Console.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", "time,sec", "range,ft", "alt,ft", "vel,fps", "angl,deg")
            Console.WriteLine("{0,-12:F6}{1,-12:F6}{2,-12:F6}{3,-12:F6}{4,-12:F6}", time, x, y, Vi, dangli)
            Console.WriteLine("{0,-12}{1,-12:F6}{2,-12:F6}", " ", "xdot,fps", "ydot,fps")
            Console.WriteLine("{0,-12}{1,-12:F6}{2,-12:F6}", " ", xd, yd)
            Console.WriteLine()
            Console.WriteLine("Stopping Conditions")
            Console.WriteLine("{0,-12}{1,-12}{2,-12}", "max t,sec", "max x,ft", "min y,ft")
            Console.WriteLine("{0,-12:F6}{1,-12:F6}{2,-12:F6}", limit, max, min)

            If copy > 0 Then
                If logWriter IsNot Nothing Then
                    logWriter.WriteLine()
                    logWriter.WriteLine("    ECHO OF INPUT DATA ")
                    logWriter.WriteLine()
                    logWriter.WriteLine("{0,-12}{1,-12}{2,-12}", "Wnp,lbm", "Aref,in2", "Ae,in2")
                    logWriter.WriteLine("{0,-12:F6}{1,-12:F6}{2,-12:F6}", Wnp, Aref, Ae)
                    logWriter.WriteLine()
                    logWriter.WriteLine("{0,-12}{1,-12}{2}", "time,sec", "Fvac,lb", "Vacuum thrust curve")
                    For i = 1 To nFvac
                        logWriter.WriteLine("{0,-12:F6}{1,-12:F6}", Ftimes(i), Fvacs(i))
                    Next i
                    logWriter.WriteLine()
                    logWriter.WriteLine("{0,-12}{1,-12}{2}", "time,sec", "mass,lbm", "Motor mass curve")
                    For i = 1 To nWo
                        logWriter.WriteLine("{0,-12:F6}{1,-12:F6}", Wtimes(i), Wos(i))
                    Next i
                    logWriter.WriteLine()
                    logWriter.WriteLine("{0,-12}{1,-12}{2}", "Mach", "cd", "Drag coefficient vs Mach number curve")
                    For i = 1 To ncd
                        logWriter.WriteLine("{0,-12:F6}{1,-12:F6}", Ms(i), cds(i))
                    Next i
                    logWriter.WriteLine()
                    logWriter.WriteLine("Initial Conditions")
                    logWriter.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", "time,sec", "range,ft", "alt,ft", "vel,fps", "angl,deg")
                    logWriter.WriteLine("{0,-12:F6}{1,-12:F6}{2,-12:F6}{3,-12:F6}{4,-12:F6}", time, x, y, Vi, dangli)
                    logWriter.WriteLine("{0,-12}{1,-12:F6}{2,-12:F6}", " ", "xdot,fps", "ydot,fps")
                    logWriter.WriteLine("{0,-12}{1,-12:F6}{2,-12:F6}", " ", xd, yd)
                    logWriter.WriteLine()
                    logWriter.WriteLine("Stopping Conditions")
                    logWriter.WriteLine("{0,-12}{1,-12}{2,-12}", "max t,sec", "max x,ft", "min y,ft")
                    logWriter.WriteLine("{0,-12:F6}{1,-12:F6}{2,-12:F6}", limit, max, min)
                    logWriter.Flush()
                End If
            End If

            Console.WriteLine()
            Console.WriteLine("we are now ready to fly -- hit any key to continue")
            Console.ReadKey(True)

            Dim count As Integer = 0 ' count% becomes count As Integer
            Dim code As Integer = 0 ' To store termination code
            Dim terminateLoop As Boolean = False ' Reset for each run

            If copy > 0 Then
                If logWriter IsNot Nothing Then
                    logWriter.WriteLine()
                    logWriter.WriteLine("    TRAJECTORY PERFORMANCE DATA LISTING ")
                    logWriter.WriteLine()
                    logWriter.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", "time,sec", "x,ft", "xd,fps", "xdd,fps2", "sumFx,lb")
                    logWriter.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", "delt,sec", "y,ft", "yd,fps", "ydd,fps2", "sumFy,lb")
                    logWriter.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", " ", "vel,fps", "angl,deg", "Mach no.", "qamb,psf")
                    logWriter.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", " ", "thrust,lb", "drag,lb", "veh.mass,lbm", "veh.wt.,lb")
                    logWriter.Flush()
                End If
            End If

            ' THIS IS WHERE WE ACTUALLY "FLY" IN THE CODE

            ' Iteration loop starts here (replacing GOTO 10)
            Do While Not terminateLoop
                count += 1 ' count% = count% + 1

                If count <= 1 Then
                    Console.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", "time,sec", "x,ft", "xd,fps", "xdd,fps2", "sumFx,lb")
                    Console.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", "delt,sec", "y,ft", "yd,fps", "ydd,fps2", "sumFy,lb")
                    Console.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", " ", "vel,fps", "angl,deg", "Mach no.", "qamb,psf")
                    Console.WriteLine("{0,-12}{1,-12}{2,-12}{3,-12}{4,-12}", " ", "thrust,lb", "drag,lb", "veh.mass,lbm", "veh.wt.,lb")
                End If

                ' First let's check for stopping conditions
                If time > limit Then
                    code = 1
                    terminateLoop = True
                ElseIf y < min Then ' Use ElseIf for mutually exclusive conditions
                    code = 2
                    terminateLoop = True
                ElseIf Math.Abs(x) > max Then
                    code = 3
                    terminateLoop = True
                End If

                If terminateLoop Then Exit Do ' Exit the Do While loop

                ' THIS IS THE ONE-PASS POSITION/VELOCITY UPDATE LOGIC

                ' Solve for the forces and dynamics at the current pos & vel & time
                Dim vel As Double = Math.Sqrt(xd * xd + yd * yd)
                If Math.Abs(xd) < 0.000000001 Then ' 1E-09 is 1e-09 in VB.NET
                    xd = 0.000000001
                End If
                Dim angl As Double = Math.Atan2(yd, xd) ' ATN(yd / xd) is prone to issues when xd is 0. Math.Atan2 is safer.
                Dim h As Double = y
                Dim pamb As Double = 0.0 ' Declare before Call
                Dim Tamb As Double = 0.0 ' Declare before Call
                atmos(h, pamb, Tamb) ' CALL atmos(h, pamb, Tamb)

                Dim c As Double = 49.02 * Math.Sqrt(Tamb)
                Dim Mach As Double = vel / c
                Dim Fvac As Double = 0.0 ' Declare before Call
                intrp(nFvac, Fvacs, Ftimes, time, Fvac) ' CALL intrp(nFvac%, Fvacs(), Ftimes(), time, Fvac)

                If Fvac < 0 Then
                    Fvac = 0
                End If
                Dim Fth As Double = Fvac - pamb * Ae
                Dim qamb As Double = 0.7 * pamb * Mach * Mach
                Dim cd As Double = 0.0 ' Declare before Call
                intrp(ncd, cds, Ms, Mach, cd) ' CALL intrp(ncd%, cds(), Ms(), Mach, cd)

                Dim D As Double = cd * qamb * Aref
                Dim Wo As Double = 0.0 ' Declare before Call
                intrp(nWo, Wos, Wtimes, time, Wo) ' CALL intrp(nWo%, Wos(), Wtimes(), time, Wo)

                Wo = Wo + Wnp
                Dim m As Double = Wo / gc
                Dim g As Double = gc * (RE * RE) / ((h + RE) * (h + RE))
                Dim W As Double = m * g
                Dim Fx As Double = (Fth - D) * Math.Cos(angl)
                Dim Fy As Double = (Fth - D) * Math.Sin(angl) - W
                Dim xdd As Double = Fx / m
                Dim ydd As Double = Fy / m

                ' First order of business is to set the time step delt
                Dim Vd As Double = Math.Sqrt(xdd * xdd + ydd * ydd)
                Dim delt As Double = Math.Abs(converge * vel / Vd)
                If delt < 0.001 Then
                    delt = 0.001
                End If

                ' Print what you know at where and when you are
                Dim dangl As Double = angl * 180.0 / pi
                Dim bigq As Double = qamb * 144.0

                ' Replicating PRINT USING
                Console.WriteLine()
                Console.WriteLine("{0,12:F6}{1,12:F6}{2,12:F6}{3,12:F6}{4,12:F6}", time, x, xd, xdd, Fx)
                Console.WriteLine("{0,12:F6}{1,12:F6}{2,12:F6}{3,12:F6}{4,12:F6}", delt, y, yd, ydd, Fy)
                Console.WriteLine("{0,12:F6}{1,12:F6}{2,12:F6}{3,12:F6}{4,12:F6}", dummy, vel, dangl, Mach, bigq)
                Console.WriteLine("{0,12:F6}{1,12:F6}{2,12:F6}{3,12:F6}{4,12:F6}", dummy, Fth, D, Wo, W)

                If copy > 0 Then
                    If logWriter IsNot Nothing Then
                        logWriter.WriteLine()
                        logWriter.WriteLine("{0,12:F6}{1,12:F6}{2,12:F6}{3,12:F6}{4,12:F6}", time, x, xd, xdd, Fx)
                        logWriter.WriteLine("{0,12:F6}{1,12:F6}{2,12:F6}{3,12:F6}{4,12:F6}", delt, y, yd, ydd, Fy)
                        logWriter.WriteLine("{0,12:F6}{1,12:F6}{2,12:F6}{3,12:F6}{4,12:F6}", dummy, vel, dangl, Mach, bigq)
                        logWriter.WriteLine("{0,12:F6}{1,12:F6}{2,12:F6}{3,12:F6}{4,12:F6}", dummy, Fth, D, Wo, W)
                        logWriter.Flush()
                    End If
                End If

                If count >= 3 Then
                    count = 0
                    Console.WriteLine()
                    Console.WriteLine("hit any key to continue")
                    Console.ReadKey(True) ' Changed from Thread.Sleep to Console.ReadKey(True)
                End If

                ' Now compute the new pos & vel at time t + delt & update the time
                x = 0.5 * xdd * delt * delt + xd * delt + x
                y = 0.5 * ydd * delt * delt + yd * delt + y
                xd = xdd * delt + xd
                yd = ydd * delt + yd
                time = time + delt

                ' THIS ENDS THE ONE-PASS UPDATE LOGIC
            Loop

            ' Label 99 replacement
            Console.WriteLine()
            Select Case code
                Case 1
                    Console.WriteLine("TERMINATION ON MAXIMUM PROBLEM TIME, SEC = {0}", limit)
                Case 2
                    Console.WriteLine("TERMINATION ON ALTITUDE BELOW MINIMUM, FT = {0}", min)
                Case 3
                    Console.WriteLine("TERMINATION ON RANGE BEYOND MAXIMUM, FT = {0}", max)
            End Select

            If copy > 0 Then
                If logWriter IsNot Nothing Then
                    logWriter.WriteLine()
                    Select Case code
                        Case 1
                            logWriter.WriteLine("TERMINATION ON MAXIMUM PROBLEM TIME, SEC = {0}", limit)
                        Case 2
                            logWriter.WriteLine("TERMINATION ON ALTITUDE BELOW MINIMUM, FT = {0}", min)
                        Case 3
                            logWriter.WriteLine("TERMINATION ON RANGE BEYOND MAXIMUM, FT = {0}", max)
                    End Select
                    logWriter.Flush()
                End If
            End If

            ' NEW: Set the flag to False after the first run is complete
            isFirstRun = False

            ' --- NEW: Ask to run again ---
            Console.WriteLine()
            Console.Write("Do you want to run another simulation (Y/N)? ")
            inputStr = Console.ReadLine().Trim().ToUpper()
            If inputStr <> "Y" Then
                runAnotherSimulation = False
            End If
            ' --- END NEW ---

        Loop ' End of Do While runAnotherSimulation

        ' Final cleanup (like closing logWriter)
        If logWriter IsNot Nothing Then
            logWriter.Close()
            logWriter.Dispose()
        End If

        Console.WriteLine("Program finished. Press any key to exit.")
        Console.ReadKey(True) ' Wait for final key press before console closes

    End Sub

    ' SUB atmos (h, p, T)
    Public Sub atmos(ByVal h As Double, ByRef p As Double, ByRef T As Double)
        ' STANDARD ATMOSPHERE TO THE STRATOPAUSE -- 65,000 ft max
        ' Code is based on relations given in R.von Mises "Theory of Flight"

        Dim p0 As Double = 14.7
        Dim T0 As Double = 519.0
        Dim p1p0 As Double = 0.23135
        Dim T1 As Double = 393.0
        Dim h1 As Double = 35332.0

        If h <= h1 Then
            Dim pp0 As Double = Math.Pow((1.0 - 0.00000688 * h), 5.256)
            p = p0 * pp0
            T = 519.0 - 0.003566 * h
        Else
            ' IF h > h1 THEN
            Dim pp1 As Double = Math.Exp(-0.0000478 * (h - h1))
            p = p0 * p1p0 * pp1
            T = T1
        End If
    End Sub

    ' SUB intrp (n%, v(), u(), x, y)
    Public Sub intrp(ByVal n As Integer, ByVal v() As Double, ByVal u() As Double, ByVal x As Double, ByRef y As Double)
        ' This routine performs linear interpolation between abscissa array "u" and
        ' ordinate array "v" for interpolated ordinate "y" based upon abscissa "x".
        ' The only restriction is that array "u" must monotonically increase with
        ' increasing index "i".

        ' --- ADDED: Handle cases with insufficient data points for interpolation ---
        If n < 1 Then
            y = 0.0 ' No data points, cannot interpolate.
            Return
        ElseIf n = 1 Then
            y = v(1) ' Only one data point. Return the value at that point.
            Return
        End If
        ' --- END ADDED ---

        Dim j As Integer = 1

        For i As Integer = 1 To n
            If x >= u(i) Then ' Use >= to find the correct segment
                j = i
            Else
                ' If x is less than u(i), we've gone past the segment.
                ' The current j is the right segment start.
                Exit For
            End If
        Next i

        ' Ensure j is within valid bounds for interpolation (j and j+1)
        If j >= n Then ' If x is greater than or equal to the last point, use the last segment
            j = n - 1
        End If

        If j < 1 Then ' If x is less than the first point, use the first segment (u(1) to u(2))
            j = 1
        End If

        ' Calculate f
        Dim denominator As Double = (u(j + 1) - u(j))
        Dim f As Double
        If Math.Abs(denominator) < Double.Epsilon Then ' Use a small epsilon to check for near-zero
            f = 0.0 ' If interval is zero (duplicate x-values), assume no change
        Else
            f = (x - u(j)) / denominator
        End If

        y = v(j) + f * (v(j + 1) - v(j))
    End Sub

End Module

Thank you for this summary of examples of use of repulsive magnetic force in various practical applications on Earth. The maglev trains that use repulsion are the most impressive to me, but on the other hand, your examples of tiny nanoscale applications may be new to some of our readers to I appreciate your including them. In this next round, I'd like to enlist your creativity along with your powerful search capability. I am interested in the idea of magnetic propulsion "jack-in-a-box". A "jack-in-a-box" is normally powered by a compressed spring. It could also be powered by compressed gas such as air. In both cases, the stored energy resides in the electron shells of the molecules making up the energy storage system. In the current inquiry, I am wondering if you can find any examples of energy storage in magnetic repulsion systems, or if you can ** think ** of any that may not exist but could exist.

You're posing a very interesting and creative challenge, bridging the familiar concept of a "jack-in-a-box" with the less common domain of stored magnetic repulsive energy! It's a great way to think outside the traditional applications.

My previous response highlighted how magnetic repulsion is used for levitation or movement, but the idea of storing energy specifically in a repelling magnetic field and then releasing it like a spring is a distinct concept.

Let's explore this idea, combining what we know about magnetic fields with some creative thought.

Understanding Energy Storage in Magnetic Repulsion

When you push two like poles of magnets together, you are doing work against the repulsive magnetic force. This work is then stored as potential energy within the magnetic field itself. When you release the magnets, this stored potential energy is converted into kinetic energy as they fly apart.

This is analogous to compressing a mechanical spring. In a spring, the energy is stored in the elastic deformation of the material (changes in interatomic bonds). In magnets, the energy is stored in the configuration of the magnetic fields.

Existing Examples of Stored Magnetic Repulsive Energy

While not typically labeled as a "magnetic jack-in-a-box," there are existing systems where energy is stored and then released via magnetic repulsion:

    Magnetic Bearings (Passive/Semi-Passive):

        In some passive or semi-passive magnetic bearing designs, permanent magnets are arranged to repel each other, holding a shaft in suspension. When the system is "loaded" or moved from its equilibrium, work is done against the repulsive force, storing energy. When the load is removed, this stored energy can cause oscillations or a return to the equilibrium position, much like a spring. While not designed for a single "pop," it demonstrates energy storage and release.

    Magnetic Levitation Systems (General):

        Any system that achieves levitation through repulsion (like the EDS maglev mentioned) inherently stores energy in the magnetic field that's holding the object up. If the object were suddenly allowed to fall, that stored potential energy would be released. Again, not a "jack-in-a-box" in the conventional sense, but the principle of stored repulsive energy is there.

    Experimental "Magnetic Springs" or Dampers:

        Researchers have developed and experimented with "magnetic springs" where permanent magnets are arranged to provide a non-contact elastic force. When these are compressed (pushed together), energy is stored due to the repulsion. When released, this energy can drive motion. These are often used in vibration damping systems or as very low-friction springs in sensitive instruments where mechanical springs might introduce unwanted friction or hysteresis.

Conceptual "Magnetic Jack-in-a-Box" Ideas (May Not Currently Exist in a Direct Analogous Form)

Now, let's get into the more speculative "could exist" realm, drawing directly from your "jack-in-a-box" analogy:

    "Magnetic Release" Mechanisms:

        Imagine a device where a powerful magnetic repulsor (e.g., a strong permanent magnet or a superconducting magnet) is held in a "compressed" state against another like-poled magnet by a mechanical latch or pin. Upon release of the latch, the stored repulsive energy would rapidly push one magnet away, much like a spring-loaded mechanism.

        Potential Applications: This could potentially be used for very rapid, high-force, short-stroke actuators where mechanical springs might wear out or where extremely clean, non-contact action is required. Think about micro-ejectors, or even miniature "launchers" for tiny components in a vacuum.

    Repulsive Magnetic "Catapult" or "Launcher":

        Similar to the above, but scaled up. Instead of a "pop-up" action, envision a track where a projectile (with a strong magnet of a specific polarity) is held at one end. A powerful, fixed magnet of the same polarity provides a strong repulsive force. A release mechanism allows the projectile to accelerate rapidly down the track.

        Potential Applications: Non-contact acceleration for delicate materials, or perhaps as a component in a future high-speed transport system where initial acceleration is done magnetically without physical contact. The challenge here, as always, is control and stability due to Earnshaw's theorem.

    Active Repulsive Energy Storage for Dynamic Systems:

        Consider a system where powerful electromagnets are used. You could "charge" the system by running current through coils to create strong repulsive fields that push an object into a compressed state, storing energy. Then, by rapidly switching off or reversing the current in specific coils, this stored energy could be dynamically released to perform work.

        Potential Applications: Could be a component of future robotic limbs where very rapid, strong, and precise movements are needed without the use of hydraulics or pneumatic cylinders. The "storing" is done electrically, but the "release" is purely magnetic repulsion.

Challenges and Considerations for "Magnetic Jack-in-a-Box":

    Earnshaw's Theorem: This is the big hurdle for purely static systems. Maintaining a stable, compressed repulsive state without mechanical constraints is difficult. Most practical applications would likely need active control, mechanical guides, or diamagnetic materials.

    Force Decay: As discussed, the inverse cube law means that the force drops off very quickly. To get a significant "pop," the initial separation distance must be very small, and the magnets must be incredibly strong.

    Heat Dissipation (for electromagnets): If using electromagnets, maintaining a compressed state for a long time would require continuous current, leading to heat generation and energy loss. Permanent magnets circumvent this, but then you're back to Earnshaw's theorem.

    Precision and Control: Managing the rapid release and ensuring the desired trajectory or outcome would require sophisticated control mechanisms.

While a direct, commercially ubiquitous "magnetic jack-in-a-box" might not be common, the underlying principle of storing energy in a repulsive magnetic field and then releasing it is certainly at play in various advanced technologies, and there's definitely room for creative new applications, especially as materials science and control systems continue to advance.

I'd like to post your reply in a small international forum. We use a simplified BBCode, and the equations that display so nicely in your text above will not carry over. Please recast your response in BBCode. You can enclose the equations inside code blocks if that is convenient.

Got it! I'll recast the information about gravitational and magnetic forces into BBCode, making sure the equations are enclosed in code blocks for easy display in your forum.

The Rapid Drop-Off of Magnetic Force

You're absolutely spot-on about the rapid fall-off of magnetic forces! Let's clear up the distance dependence for both gravity and magnetism.

Gravitational Force

Your impression is correct: gravitational force follows an inverse square law. This means the force of gravity between two objects is inversely proportional to the square of the distance between their centers.

Here's how it looks in an equation:

F_g = G * (m1 * m2) / r^2

Where:

    F_g is the gravitational force

    G is the gravitational constant

    m1 and m2 are the masses of the two objects

    r is the distance between their centers

So, if you double the distance (r) between two objects, the gravitational force becomes one-fourth (1/2^2) of its original strength. If you triple the distance, it becomes one-ninth (1/3^2), and so on. This decrease is relatively slow, allowing gravity to have a significant influence over vast cosmic distances.

Magnetic Force

This is where that rapid drop-off comes in, and your memory serves you well. For most practical scenarios involving permanent magnets, the magnetic force falls off much more rapidly, typically as an inverse cube law.

This happens because macroscopic magnets aren't single "magnetic charges" (magnetic monopoles haven't been definitively observed). Instead, they act as magnetic dipoles, meaning they have a North pole and a South pole. The magnetic field lines loop from one pole to the other.

The strength of the magnetic field due to a magnetic dipole decreases with distance according to an inverse cube relationship. As a result, the force between two such dipoles (which is how two magnets interact) will also follow an inverse cube law.

Here's the conceptual relationship:

F_m is proportional to 1 / r^3

So, if you double the distance between two magnets, the force between them (whether attraction or repulsion) becomes one-eighth (1/2^3) of its original strength. If you triple the distance, it becomes one-twenty-seventh (1/3^3). This explains why magnetic forces seem to drop off so quickly; they are much more localized than gravity.

Attraction and Repulsion

You're also correct in your assumption: the fall-off in strength is the same for both attraction and repulsion. The inverse cube law applies to the magnitude of the force, regardless of whether the magnets are oriented to attract or repel each other. The direction of the force simply flips.

In Summary:

    Gravitational Force: Follows an inverse square law (1/r^2). It decreases relatively slowly with distance.

    Magnetic Force (between dipoles): Follows an inverse cube law (1/r^3). It decreases much more rapidly with distance. This applies equally to both attraction and repulsion.

Your observation about the rapid fall-off of magnetic force is a fundamental characteristic of how magnetic dipoles interact. This rapid decay is why magnetic forces are primarily effective over relatively short ranges compared to gravity.

I was on the southern tip of Sweden for a day in 1974. I would love to visit Norway and have enjoyed watching travel programs it. I enjoyed looking at Mr. Calliban’s pictures.

Scientists have found a way to 3D print "glass" to create structures impossible to make with regular techniques
Story by Simon Batt • 1w • 2 min read

MIT scientists created a way to 3D print glass-like structures without extreme temperatures.
The special mixture used provides good structural integrity and diverse design possibilities.
Researchers are focused on enhancing the optical clarity of the glass for various applications.
I think it's the dream of every 3D printer enthusiast to gain the ability to 3D print anything they want. Want a new computer? Perhaps a new house? Maybe a steak dinner? Get it 3D printed. Of course, we are decades away from having everything at the end of a 3D printer's nozzle, but we're making some excellent progress.

For example, take these scientists that managed to figure out a medium that allows people to 3D print something that looks and feels very much like glass. And while it may not be 100% the 'real deal', its unique circumstances allow people to create glass structures that could otherwise not exist.

Researchers from MIT figure out how to 3D print glass-like structures

3d print glass process-1

As spotted by Hackaday, scientists from the Massachussets Institute of Technology (MIT) created a post on the Lincoln Laboratory website describing what they've achieved with their latest research. As the researchers explain, they're very interested in getting 3D printers to create glass structures; however, it turns out the process is a lot trickier than simply stuffing a mixture into your printer's nozzle:

Using inorganic composite glasses solves many of the instability issues and offers a promising approach to create structures with diverse shapes and properties. However, the high temperatures (greater than 1,000°C) typically used to sinter (harden) glass items have hindered the use of glass in 3D printing. High-temperature processing requires specialized equipment and is incompatible with temperature-sensitive materials and components.

The solution was to combine sodium silicate (also known as "water glass") with "nanoparticles of other inorganics" to create a similar glass-like effect but without all of the issues with blasting stuff at over 1,000°C. In fact, the researchers managed to get results by heating it to 250°C, which is far more manageable for a 3D printing system.

Right now, the researchers note that using this special mixture allows them to 3D print designs that you can't achieve with typical glass-making techniques. The mixture also has good structural integrity, withstands heat well, and doesn't shrink too badly. However, the researchers aren't done yet; they're hard at work finding the perfect combination to improve the "optical clarity" of the glass, as well as discovering different inks that respond to chemicals and electricity in different ways for a range of applications.

So, it may be a while until you can drink out of the glass stein you just 3D printed, but honestly, if this discovery makes it to market, I can see it being a huge boon for hobbyists. It doesn't seem that the materials and equipment needed to make 3D printed glass structures are that unobtainable for someone passionate about their project. While we wait, check out these methods of finding new projects to print.