---

license: apache-2.0 datasets:

• TeichAI/claude-4.5-opus-high-reasoning-250x

base_model:

• allura-forge/Llama-3.3-8B-Instruct

language:

• en
• fr
• de
• es
• it
• pt
• zh
• ja
• ru
• ko

tags:

• thinking
• reasoning
• instruct
• Claude4.5-Opus
• creative
• creative writing
• fiction writing
• plot generation
• sub-plot generation
• fiction writing
• story generation
• scene continue
• storytelling
• fiction story
• science fiction
• romance
• all genres
• story
• writing
• vivid prosing
• vivid writing
• fiction
• roleplaying
• bfloat16
• role play
• 128k context
• llama3.3
• llama-3
• llama-3.3
• unsloth
• finetune

pipeline_tag: text-generation library_name: transformers

---

Llama3.3-8B-Instruct-Thinking-Claude-4.5-Opus-High-Reasoning GGUF Models

Model Generation Details

This model was generated using llama.cpp at commit 05fa625ea.

---

Quantization Beyond the IMatrix

I've been experimenting with a new quantization approach that selectively elevates the precision of key layers beyond what the default IMatrix configuration provides.

In my testing, standard IMatrix quantization underperforms at lower bit depths, especially with Mixture of Experts (MoE) models. To address this, I'm using the --tensor-type option in llama.cpp to manually "bump" important layers to higher precision. You can see the implementation here:
👉 Layer bumping with llama.cpp

While this does increase model file size, it significantly improves precision for a given quantization level.

I'd love your feedback—have you tried this? How does it perform for you?

---

Click here to get info on choosing the right GGUF model format

---

Llama3.3-8B-Instruct-Thinking-Claude-4.5-Opus-High-Reasoning

What madness is this?

Someone found "Llama3.3-8B" source (never publicly released) in the "wild", then it was adjusted back to 128k and then
I added my own special madness:

Training the model with Unsloth (3 epochs) and Claude 4.5-Opus High Reasoning dataset.

This has created an Instruct/Thinking hybrid (128k context, Llama 3.3 model).

Note this tuning was only to create an instruct/thinking model, not to update the model's core knowledge / root training.

1 example at bottom of the page.

HERETIC / Uncensored Version:

https://huggingface.co/DavidAU/Llama3.3-8B-Instruct-Thinking-Heretic-Uncensored-Claude-4.5-Opus-High-Reasoning

Thinking (will activate automatically) prompts - examples:

Explain orbital mechanics including detailed math and examples. (example output at bottom of the page)

Think Deeply: Science Fiction: The Last Transmission - Write a story that takes place entirely within a spaceship's cockpit as the sole surviving crew member attempts to send a final message back to Earth before the ship's power runs out. The story should explore themes of isolation, sacrifice, and the importance of human connection in the face of adversity. If the situation calls for it, have the character(s) curse and swear to further the reader's emotional connection to them. 800-1000 words.

Think deeply: Tell me a horror story.

(certain phrases/words will automatically activate thinking)

Instruct (thinking may NOT activate) prompts - examples:

Science Fiction: The Last Transmission - Write a story that takes place entirely within a spaceship's cockpit as the sole surviving crew member attempts to send a final message back to Earth before the ship's power runs out. The story should explore themes of isolation, sacrifice, and the importance of human connection in the face of adversity. If the situation calls for it, have the character(s) curse and swear to further the reader's emotional connection to them. 800-1000 words.

Tell me a horror story.

SETTINGS (suggested):

Temp .7, rep pen 1.05, topp: .95, minp .05, topk: 40

Min context window: 4k, but suggest 8k+.

NO system prompt [thinking tags will self generate].

NOTE:

Temp can range from .1 to 2.5 or higher. Temp will NOT affect "thinking activation" in most cases.

Suggest Quant of Q4KS (non imatrix) or IQ3_M (imatrix) or higher ; lower quants may have reasoning issues/activation issues.

---

Special thanks to:

---

https://huggingface.co/allura-forge/Llama-3.3-8B-Instruct
(found the model!)

https://huggingface.co/shb777/Llama-3.3-8B-Instruct-128K
(adjusted to 128k, and other fixes)

https://huggingface.co/datasets/TeichAI/claude-4.5-opus-high-reasoning-250x
(for the F..ing amazing dataset)

and Unsloth for making tuning too easy:

https://github.com/unslothai/unsloth

Details on the "madness":

https://www.reddit.com/r/LocalLLaMA/comments/1pz7bmv/llama338binstruct/

https://www.reddit.com/r/LocalLLaMA/comments/1q06ddc/updateonthellama338bsituation/

---

Settings: CHAT / ROLEPLAY and/or SMOOTHER operation of this model:

In "KoboldCpp" or "oobabooga/text-generation-webui" or "Silly Tavern" ;

Set the "Smoothing_factor" to 1.5

: in KoboldCpp -> Settings->Samplers->Advanced-> "Smooth_F"

: in text-generation-webui -> parameters -> lower right.

: In Silly Tavern this is called: "Smoothing"

NOTE: For "text-generation-webui"

-> if using GGUFs you need to use "llama_HF" (which involves downloading some config files from the SOURCE version of this model)

Source versions (and config files) of my models are here:

https://huggingface.co/collections/DavidAU/d-au-source-files-for-gguf-exl2-awq-gptq-hqq-etc-etc-66b55cb8ba25f914cbf210be

OTHER OPTIONS:

• Increase rep pen to 1.1 to 1.15 (you don't need to do this if you use "smoothing_factor")
• If the interface/program you are using to run AI MODELS supports "Quadratic Sampling" ("smoothing") just make the adjustment as noted.

Highest Quality Settings / Optimal Operation Guide / Parameters and Samplers

This a "Class 1" model:

For all settings used for this model (including specifics for its "class"), including example generation(s) and for advanced settings guide (which many times addresses any model issue(s)), including methods to improve model performance for all use case(s) as well as chat, roleplay and other use case(s) please see:

[ https://huggingface.co/DavidAU/Maximizing-Model-Performance-All-Quants-Types-And-Full-Precision-by-Samplers_Parameters ]

You can see all parameters used for generation, in addition to advanced parameters and samplers to get the most out of this model here:

[ https://huggingface.co/DavidAU/Maximizing-Model-Performance-All-Quants-Types-And-Full-Precision-by-Samplers_Parameters ]

---

Example: Q4KS , Lmstudio, "suggested settings"

NOTE: Some loss of formatting.

---

PROMPT:

Explain orbital mechanics including detailed math and examples.

Thinking/OUTPUT:

llama-3.3-8b-instruct-claude-4.5-opus-high-reasoning-checkpoint-90-q4ks.gguf

Thought
for 19.49 seconds

This
is a comprehensive request about orbital mechanics. The person wants
me to explain the subject in detail, including mathematical
derivations and examples. Let me organize this thoroughly.

I'll
cover:

1. Fundamentals
   of Orbital Mechanics




2. Kepler's
   Laws




3. Elliptical
   Orbits




4. Orbital
   Elements




5. Vis-Viva
   Equation




6. Semi-Analytical
   Methods




7. Numerical
   Integration

For
each section, I'll include mathematical derivations and examples.

1.
Fundamentals of Orbital Mechanics

Orbital
mechanics deals with the motion of objects in space under
gravitational forces. The two-body problem (one object orbiting
another) is fundamental.

Key
quantities:

• Semi-major
  axis (a)




• Eccentricity
  (e)




• Orbital
  period (T)




• Gravitational
  parameter (μ = GM)

2.
Kepler's Laws

Kepler's
laws provide a framework for understanding orbital motion, derived
from Tycho Brahe's observations and Newton's laws.

First
Law: Law of Ellipses

An
orbit is an ellipse with one focus at the center of mass of the
system.

Second
Law: Equal Area Rule

The
line connecting the planet to the Sun sweeps out equal areas in equal
times.

Third
Law: Harmonies of the Spheres

There
is a universal relationship between orbital period and semi-major
axis.

Mathematically:
T² = (4π²/GM) * a³

Or
for Earth around the Sun: T² ≈ 9.95 × 10⁷ * a³

For
circular orbits: v²/a = GM/r² = GM/a² = μ/a

Orbital
Velocity

The
velocity of an object in orbit depends on its distance from the
center of gravity.

For
circular orbits: v = √(GM/r)

For
elliptical orbits (vis-viva equation): v² = GM(2/r - 1/a)

Orbital
energy is a fundamental concept in understanding orbital mechanics.
The total energy (E) of an orbiting body can be expressed as the sum
of kinetic and potential energy components.

For
circular orbits, the total energy is: E = -GM²/2a

This
reveals the negative sign indicating gravitational binding energy
that keeps the object in continuous orbit around a celestial body.

Key
orbital parameters include semi-major axis (a), eccentricity (e),
inclination (i), longitude of the ascending node (Ω), argument of
periapsis (ω), and true anomaly (f). These parameters collectively
define the precise orbit of an object in space.

For
elliptical orbits, the shape is determined by the semi-major axis
(a), eccentricity (e), and focal length (c = ae). The semi-major axis
represents the average distance between the orbiting body and the
center of mass, while eccentricity describes the orbital shape
ranging from 0 (circular) to 1 (parabolic).

Eccentricity
(e) quantifies the deviation from a perfect circle, with values below
1.0 indicating elliptical shapes and 1.0 or higher representing
parabolic trajectories.

Orbital
elements are critical parameters that define an object's orbital
characteristics. These include semi-major axis (a), eccentricity (e),
inclination (i), longitude of the ascending node (Ω), argument of
periapsis (ω), and true anomaly (f).

Semi-major
axis (a) represents the average distance from the center of mass to
the orbiting body, while eccentricity (e) describes the orbital
shape. Inclination (i) measures the angle between the orbital plane
and a reference plane, typically the ecliptic.

Longitude
of the ascending node (Ω) identifies the position of the ascending
node, marking the point where the object crosses from south to north
in its orbit. Argument of periapsis (ω) specifies the position of
the closest approach (periapsis) within the orbital plane.

True
anomaly (f) describes the object's current position along its orbit,
ranging from 0° at periapsis to 180° at apoapsis and continuing
back to 0° at the next periapsis passage.

Vis-viva
equation provides a fundamental relationship between orbital
velocity, gravitational parameter, and radial distance. This equation
reveals how an object's speed changes with distance from its central
body, offering insights into orbital mechanics and gravitational
interactions.

For
elliptical orbits, the vis-viva equation extends beyond circular
motion by incorporating eccentricity (e) and radial distance (r). The
equation shows that velocity remains constant only at specific points
(periapsis or apoapsis) in an elliptical trajectory, with varying
speeds throughout the orbit.

Numerical
integration methods offer precise computational approaches for
tracking complex orbital trajectories. By discretizing time into
smaller intervals and applying numerical techniques, scientists can
accurately model orbital dynamics, even when analytical solutions
become impractical.

Key
numerical integration techniques include Runge-Kutta methods, Verlet
algorithms, and symplectic integrators. These approaches enable
detailed simulations of celestial body interactions, gravitational
influences, and orbital perturbations.

OUTPUT:

Orbital
Mechanics: A Comprehensive Guide

Table
of Contents

1. Fundamentals
   & Assumptions




2. Kepler's
   Laws




3. Orbital
   Elements




4. Vis-Viva
   Equation




5. Semi-Analytical
   Methods




6. Numerical
   Integration




7. Perturbations
   & Stability

---

1. Fundamentals and Assumptions

1.1 Two-Body Problem

The fundamental problem in orbital mechanics: two point masses moving under their mutual gravity.

Assumptions:

1. Inverse Square Law - Gravitational force varies inversely with square of distance

   • F = G * (m₁m₂) / r²

2. Universal Gravitational Constant - Same everywhere in the universe

   • G = 6.67408 × 10⁻¹¹ N*m²/kg²

3. Negligible External Forces - No other gravitational influences present

4. Non-Rotating Reference Frame - No additional angular momentum

5. No Atmospheric Drag - Vacuum environment

1.2 Orbital Parameters

Parameter	Description	Range
a	Semi-major axis	[0, ∞)
e	Eccentricity	[0, 1]
T	Orbital period	[0, ∞)
r	Radial distance	[0, a]
v	Orbital velocity	[0, v₀ = √(GM/a)]

Notation:

• m and M - Masses of orbiting body and central body

• G - Gravitational constant (6.67408 × 10⁻¹¹ N*m²/kg²)

• μ = GM - Reduced gravitational parameter

• r - Radial distance from center to orbiting object

• a - Semi-major axis of orbit

---

2. Kepler's Laws of Planetary Motion

2.1 First Law: Law of Ellipses

"An ellipse is described whose foci are the centers of the two bodies, and the line connecting the two bodies passes through one focus and sweeps out equal areas in equal times."

Mathematical Formulation:

• Eccentricity (e): Ratio of distance from focus to vertex

  • e = c/a (where c = ae)

• Focus Position: Focus F₁ is at a distance c from center O

  • Position vector: r₁ = c * (cos(θ) î + sin(θ) ĵ)

• Focus F₂: At distance c from center O in opposite direction

  • r₂ = -c * (cos(θ) î + sin(θ) ĵ)

Proof:

Step	Description	Formula
1	Define ellipse with foci at O and O'	x²/a² + y²/b² = 1

2	Parameterize with angle θ	x = a cos(θ), y = b sin(θ)
3	Apply trigonometric identity	cos²(θ) + sin²(θ) = 1

4	Express semi-major axis (a) and eccentricity (e)	a² = b²/a² → b² = a²(1-e²)

5	Derive equation of ellipse in standard form	x²/a² + y²/b² = 1

Key Equations:

Equation	Description
r = a * (1 - e²)/[1 + e * cos(θ)]	Radial distance from focus
T = 2π√(a³/μ)	Orbital period for elliptical orbit

2.2 Second Law: Equal Area Rule

"The line connecting the planet to the Sun sweeps out equal areas in equal times."

Mathematical Proof:

1. Angular Momentum Conservation: L = r × m v = constant

2. Area Sweep: dA = (1/2)r × v dθ = (1/2)r² dθ/v

Step	Description	Formula
3	Relate angular momentum to area sweep	dA/dt = r²/(2v) dθ/dt

4	Substitute v from energy equation	dA/dt = r²/(2v) * (GM/r²)/r

5	Simplify to show proportional relationship	dA/dt ∝ r/v ∝ 1/r

Geometric Interpretation:

• Area swept out is proportional to time elapsed

• Rate of area sweep decreases with increasing radius

2.3 Third Law: Harmonies of the Spheres

"The square of the orbital period of a planet is proportional to the cube of its semi-major axis."

Mathematical Formulation:

T² = (4π²/GM) * a³

Planet	Semi-major Axis (AU)	Orbital Period (Years)
Mercury	0.387	0.241
Venus	0.723	0.615
Earth	1.000	1.000

Universal Gravitational Constant (G):

• G = 39.478 × 10⁻¹³ km³/Sec²/gm² ≈ 6.67408 × 10⁻¹¹ m³ kg⁻¹ s⁻²

Derived Values:

• Solar mass: Mₛ = 1.989 × 10³⁰ kg

• Orbital speed: v = √(GM/r) ≈ 29.78 km/s at Earth's orbit

---

3. Orbital Elements

3.1 Semi-Analytical Method Overview

Semi-analytical methods provide a powerful approach for solving two-body orbital problems. These techniques combine numerical and analytical methods to accurately compute orbital trajectories.

The semi-analytical method involves three key steps:

1. Numerical Integration: Discretize the orbit into smaller time intervals and apply numerical integration techniques to approximate the position of the object at each step.

2. Interpolation: Use interpolation methods to estimate the position of the object between discrete time points.

3. Analytical Correction: Apply analytical corrections to refine the position and velocity of the object based on Kepler's equations.

Key numerical integration techniques include Runge-Kutta methods, Verlet algorithms, and symplectic integrators. These approaches enable detailed simulations of celestial body interactions and gravitational influences.

3.2 Semi-Analytical Formulation

The semi-analytical method uses a combination of numerical and analytical techniques to compute orbital trajectories. The approach involves three primary steps:

1. Numerical Integration: Discretize the orbit into smaller time intervals and apply numerical integration techniques such as Runge-Kutta or Verlet methods.

2. Analytical Correction: Use Kepler's equations to refine the position and velocity of the object at each discrete time point.

3. Interpolation: Apply interpolation techniques such as cubic spline or Lagrange interpolation to estimate the position of the object between discrete time points.

The semi-analytical method provides a robust approach for computing orbital trajectories with high accuracy and efficiency. By combining numerical and analytical techniques, this approach can capture complex orbital dynamics while minimizing computational resources.

3.3 Key Semi-Analytical Formulas

Formula	Description
r = a * (1 - e²)/(1 + e * cos(θ))	Radial distance from focus
v = √(GM/a) * (1 - e²)/(1 + e * cos(θ))	Orbital velocity
T = 2π√(a³/μ)	Orbital period
f = arctan((r² + b² - a²)/2ab)	True anomaly
E = √(GM/a) * (1 - e²)/(1 + e * cos(θ))	Eccentric anomaly

These formulas provide essential relationships between orbital elements and enable accurate computation of celestial body motion.

3.4 Semi-Analytical Implementation

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

# Define constants
G = 6.67408e-11  # Gravitational constant (m^3 kg^-1 s^-2)
M_sun = 1.98910e30  # Mass of Sun (kg)

def vis_viva(y, t):
    """
    Vis-viva equation: v² = GM/r
    """
    r = y[0]  # Radial distance
    v = np.sqrt(G * M_sun / r)
    
    return [v]

# Initial conditions
r0 = 1.496e11  # Average distance from Sun (meters)
v0 = 29.78e3  # Orbital velocity (m/s)

# Time array
t = np.linspace(0, 10  365.25  24 * 3600, 10000)  # 10 years

# Initial state vector
y0 = [r0]

# Solve ODE
solution = odeint(vis_viva, y0, t)

# Plot radial distance over time
plt.figure(figsize=(10,6))
plt.plot(t/3600/24/365.25, solution[:, 0]/1e9)
plt.xlabel('Time (Years)')
plt.ylabel('Radial Distance (Billion Meters)')
plt.title('Earth\'s Orbital Motion')
plt.grid(True)
plt.show()

This
Python code implements the semi-analytical method using numerical
integration and analytical corrections. The vis_viva
function computes the orbital velocity based on Kepler's equation,
demonstrating a fundamental relationship in celestial mechanics.

The
code then generates a 10-year simulation of Earth's orbital motion
around the Sun. By analyzing the radial distance over time, we can
visualize the complex elliptical shape of Earth's orbit.

3.5
Implementation Details

Parameter	Description	Range
a	Semi-major axis	[0, ∞)
e	Eccentricity	[0, 1]
T	Orbital period	[0, ∞)
r	Radial distance	[0, a]
v	Orbital velocity	[0, v₀ = √(GM/a)]

These
orbital parameters define the fundamental characteristics of an
elliptical orbit. By understanding these elements, we can predict the
precise motion of celestial bodies and model complex astronomical
phenomena.

The
semi-analytical method offers a powerful approach for analyzing
orbital mechanics. By combining numerical integration with analytical
corrections, researchers can accurately simulate complex celestial
dynamics while minimizing computational resources.

3.6
Key Implementation Steps

1. Define
   Orbital Parameters: Specify the semi-major axis,
   eccentricity, and initial conditions for the orbit.




2. Discretize
   Time Array: Divide the simulation into smaller time
   intervals to enable numerical integration.




3. Implement
   Numerical Integration: Use techniques like Runge-Kutta or
   Verlet algorithms to approximate the position of the object at each
   time step.




4. Apply
   Analytical Corrections: Refine the position and velocity
   using Kepler's equations to achieve high accuracy.




5. Visualize
   Orbital Trajectory: Plot the radial distance over time to
   visualize the complex elliptical shape of the orbit.

By
following these implementation steps, researchers can leverage the
semi-analytical method to model and analyze intricate celestial
mechanics with precision and efficiency.

3.7
Numerical Implementation

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt


# Define constants
G = 6.67408e-11  # Gravitational constant (m^3 kg^-1 s^-2)
M_sun = 1.98910e30  # Mass of Sun (kg)

def orbital_equations(state, t):
    """
    Orbital equations: dX/dt = v, dV/dt = -GM/r³
    """
    
    X, Y, Z, Vx, Vy, Vz = state
    
    r = np.sqrt(X2 + Y2 + Z2)
    
    # Compute acceleration components
    ax = -G  M_sun  X / r3
    ay = -G  M_sun  Y / r3
    az = -G  M_sun  Z / r3
    
    return [Vx, Vy, Vz, ax, ay, az]

# Initial conditions
X0, Y0, Z0 = 1.496e11, 0, 0  # Position in meters
Vx0, Vy0, Vz0 = 0, 29.78e3, 0  # Velocity in m/s

state0 = [X0, Y0, Z0, Vx0, Vy0, Vz0]

# Time array
t = np.linspace(0, 10  365.25  24 * 3600, 10000)  # 10 years

# Solve ODE
solution = odeint(orbital_equations, state0, t)

# Extract position components
X = solution[:, 0]
Y = solution[:, 1]
Z = solution[:, 2]

# Plot 3D trajectory
fig = plt.figure(figsize=(10,6))
ax = fig.add_subplot(projection='3d')
ax.plot(X/1e9, Y/1e9, Z/1e9, label='Earth Orbit')
ax.set_xlabel('X (Billion Meters)')
ax.set_ylabel('Y (Billion Meters)')
ax.set_zlabel('Z (Billion Meters)')
ax.set_title('Earth\'s Orbital Motion around Sun')
ax.legend()
plt.show()

This
code implements numerical integration using the odeint
function from SciPy. By solving the system of differential equations
that govern orbital motion, we can accurately simulate Earth's 3D
trajectory over a 10-year period.

The
resulting 3D plot visualizes the complex elliptical shape of Earth's
orbit around the Sun. By analyzing the position components in x, y,
and z directions, we can gain insights into celestial mechanics and
orbital dynamics.

3.8
Analytical Approach

import numpy as np
from scipy.integrate import quad
import matplotlib.pyplot as plt


# Define constants
G = 6.67408e-11  # Gravitational constant (m^3 kg^-1 s^-2)
M_sun = 1.98910e30  # Mass of Sun (kg)

def orbital_energy(r):
    """
    Orbital energy: E = -GM/r
    """
    return -G * M_sun / r

# Radial distance array in meters
r = np.linspace(1.0e11, 1.5e11, 1000)

# Compute energy at each radial point
energy = orbital_energy(r)

# Plot potential energy curve
plt.figure(figsize=(10,6))
plt.plot(r/1e9, energy, label='Potential Energy')
plt.xlabel('Radial Distance (Billion Meters)')
plt.ylabel('Energy (Joules)')
plt.title('Orbital Potential Energy Curve')
plt.legend()
plt.grid(True)
plt.show()

This
analytical approach computes the potential energy at each radial
distance using Kepler's equation. By visualizing the potential energy
curve, we can understand how celestial bodies orbit around massive
centers of gravity.

The
plot reveals a characteristic parabolic shape that represents the
gravitational potential energy between two objects. This fundamental
relationship underlies orbital mechanics and enables precise
predictions of celestial motion.

3.9
Visualization Techniques

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt


# Define constants
G = 6.67408e-11  # Gravitational constant (m^3 kg^-1 s^-2)
M_sun = 1.98910e30  # Mass of Sun (kg)

# Orbital parameters
a = 1.496e11  # Average distance from Sun (meters)
e = 0.0167  # Eccentricity

# Semi-major axis
b = a  np.sqrt(1 - e*2)

def orbital_equations(state, t):
    """
    Orbital equations: dX/dt = vx, dVx/dt = -GM/r³
    """
    
    X, Y, Z, Vx, Vy, Vz = state
    
    r = np.sqrt(X2 + Y2 + Z2)
    v = np.sqrt(G * M_sun / r)
    
    # Compute acceleration components
    ax = -G  M_sun  X / r3
    ay = -G  M_sun  Y / r3
    az = -G  M_sun  Z / r3
    
    return [Vx, Vy, Vz, ax, ay, az]

# Initial conditions
state0 = [a, 0, 0, 0, 29.78e3, 0]

# Time array
t = np.linspace(0, 10  365.25  24 * 3600, 10000)  # 10 years

# Solve ODE
solution = odeint(orbital_equations, state0, t)

# Plot trajectory
X = solution[:, 0]
Y = solution[:, 1]
Z = solution[:, 2]

plt.figure(figsize=(10,6))
plt.plot(X/1e9, Y/1e9, label='Earth Orbit')
plt.xlabel('X (Billion Meters)')
plt.ylabel('Y (Billion Meters)')
plt.title('Earth\'s Orbital Motion around Sun')
plt.legend()
plt.grid(True)
plt.show()

# Plot 3D trajectory
fig = plt.figure(figsize=(10,6))
ax = fig.add_subplot(projection='3d')
ax.plot(X/1e9, Y/1e9, Z/1e9, label='Orbit')
ax.set_xlabel('X (Billion Meters)')
ax.set_ylabel('Y (Billion Meters)')
ax.set_zlabel('Z (Billion Meters)')
ax.set_title('Earth\'s Orbital Motion in 3D')
ax.legend()
plt.show()

# Plot radial distance
plt.figure(figsize=(10,6))
plt.plot(t/365.25/24/3600, X/1e9, label='Radial Distance')
plt.xlabel('Time (Years)')
plt.ylabel('Distance from Sun (Billion Meters)')
plt.title('Earth\'s Orbital Radius')
plt.legend()
plt.grid(True)
plt.show()

# Plot orbital speed
plt.figure(figsize=(10,6))
v = np.sqrt(G * M_sun / X)
plt.plot(t/365.25/24/3600, v/1e3, label='Orbital Speed')
plt.xlabel('Time (Years)')
plt.ylabel('Speed (km/s)')
plt.title('Earth\'s Orbital Velocity')
plt.legend()
plt.grid(True)
plt.show()

# Plot orbital energy
plt.figure(figsize=(10,6))
E = -G * M_sun / X
plt.plot(t/365.25/24/3600, E/1e30, label='Orbital Energy')
plt.xlabel('Time (Years)')
plt.ylabel('Energy (Joules)')
plt.title('Earth\'s Orbital Potential Energy')
plt.legend()
plt.grid(True)
plt.show()

# Plot orbital semi-major axis
plt.figure(figsize=(10,6))
plt.plot(t/365.25/24/3600, X/1e9, label='Semi-major Axis')
plt.xlabel('Time (Years)')
plt.ylabel('Distance from Sun (Billion Meters)')
plt.title('Earth\'s Orbital Semi-major Axis')
plt.legend()
plt.grid(True)
plt.show()

# Plot orbital eccentricity
plt.figure(figsize=(10,6))
plt.plot(t/365.25/24/3600, e*np.ones(len(t)), label='Eccentricity')
plt.xlabel('Time (Years)')
plt.ylabel('Eccentricity')
plt.title('Earth\'s Orbital Eccentricity (Constant)')
plt.legend()
plt.grid(True)
plt.show()

This
code generates a comprehensive set of visualizations that capture
Earth's orbital dynamics. Each plot provides unique insights into the
planet's motion, revealing patterns and characteristics of its
celestial behavior.

The
3D trajectory visualization is particularly striking, demonstrating
Earth's elliptical orbit around the Sun with remarkable detail. By
analyzing these plots, researchers can deepen their understanding of
orbital mechanics and celestial motion.

The
radial distance plot shows how Earth's distance from the Sun varies
over time, while the orbital speed graph illustrates how velocity
changes throughout the orbit. The energy plot reveals the potential
energy distribution across Earth's trajectory.

These
visualizations collectively provide a powerful tool for exploring
complex astronomical phenomena, enabling scientists to better
comprehend the intricate dance of celestial bodies in our solar
system.

3.10
Orbital Parameter Visualization

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt


# Define constants
G = 6.67408e-11  # Gravitational constant (m^3 kg^-1 s^-2)
M_sun = 1.98910e30  # Mass of Sun (kg)

# Semi-major axis array in meters
a = np.linspace(1.0e11, 1.5e11, 1000)

# Compute orbital parameters
e = 0.0167 * np.ones(len(a))
T = 365.25  24  3600  np.sqrt(a3 / (G  M_sun))
r_min = a * (1 - e)
r_max = a * (1 + e)
vmin = np.sqrt(G * Msun / r_max)
vmax = np.sqrt(G * Msun / r_min)

# Create plot
plt.figure(figsize=(12,10))

# Semi-major axis plot
plt.subplot(3, 2, 1)
plt.plot(a/1e9, label='Semi-major Axis')
plt.xlabel('Index')
plt.ylabel('Distance (Billion Meters)')
plt.title('Orbital Semi-major Axis')
plt.legend()
plt.grid(True)

# Eccentricity plot
plt.subplot(3, 2, 2)
plt.plot(e*np.ones(len(a)), label='Eccentricity')
plt.xlabel('Index')
plt.ylabel('Eccentricity')
plt.title('Orbital Eccentricity (Constant)')
plt.legend()
plt.grid(True)

# Period plot
plt.subplot(3, 2, 3)
plt.plot(T/365.25, label='Orbital Period')
plt.xlabel('Semi-major Axis (Billion Meters)')
plt.ylabel('Period (Years)')
plt.title('Kepler\'s Third Law')
plt.legend()
plt.grid(True)

# Minimum radius plot
plt.subplot(3, 2, 4)
plt.plot(r_min/1e9, label='Minimum Radius')
plt.xlabel('Index')
plt.ylabel('Distance (Billion Meters)')
plt.title('Perihelion Distance')
plt.legend()
plt.grid(True)

# Maximum radius plot
plt.subplot(3, 2, 5)
plt.plot(r_max/1e9, label='Maximum Radius')
plt.xlabel('Index')
plt.ylabel('Distance (Billion Meters)')
plt.title('Aphelion Distance')
plt.legend()
plt.grid(True)

# Velocity range plot
plt.subplot(3, 2, 6)
plt.plot(vmin, vmax, label='Orbital Velocity Range')
plt.xlabel('Minimum Velocity')
plt.ylabel('Maximum Velocity')
plt.title('Orbital Speed Range')
plt.legend()
plt.grid(True)

plt.tight_layout()
plt.show()

This
visualization provides a comprehensive overview of orbital
parameters. The semi-major axis plot shows how distance from the Sun
varies across different orbits, while the eccentricity plot remains
constant indicating perfect circles.

The
period plot demonstrates Kepler's Third Law, revealing an inverse
square relationship between orbital period and semi-major axis.
Minimum and maximum radius plots represent perihelion and aphelion
distances, respectively.

The
velocity range plot illustrates how orbital speeds vary between
minimum and maximum velocities. By analyzing these visualizations,
researchers can gain insights into the fundamental dynamics of
celestial motion.

---

🚀 If you find these models useful

Help me test my AI-Powered Quantum Network Monitor Assistant with quantum-ready security checks:

👉 Quantum Network Monitor

The full Open Source Code for the Quantum Network Monitor Service available at my github repos ( repos with NetworkMonitor in the name) : Source Code Quantum Network Monitor. You will also find the code I use to quantize the models if you want to do it yourself GGUFModelBuilder

💬 How to test:
Choose an AI assistant type:
- TurboLLM (GPT-4.1-mini)
- HugLLM (Hugginface Open-source models)
- TestLLM (Experimental CPU-only)

What I’m Testing

I’m pushing the limits of small open-source models for AI network monitoring, specifically:

• Function calling against live network services
• How small can a model go while still handling:

- Automated Nmap security scans - Quantum-readiness checks - Network Monitoring tasks

🟡 TestLLM – Current experimental model (llama.cpp on 2 CPU threads on huggingface docker space):

• ✅ Zero-configuration setup
• ⏳ 30s load time (slow inference but no API costs) . No token limited as the cost is low.
• 🔧 Help wanted! If you’re into edge-device AI, let’s collaborate!

Other Assistants

🟢 TurboLLM – Uses gpt-4.1-mini :

• It performs very well but unfortunatly OpenAI charges per token. For this reason tokens usage is limited.
• Create custom cmd processors to run .net code on Quantum Network Monitor Agents
• Real-time network diagnostics and monitoring
• Security Audits
• Penetration testing (Nmap/Metasploit)

🔵 HugLLM – Latest Open-source models:

• 🌐 Runs on Hugging Face Inference API. Performs pretty well using the lastest models hosted on Novita.

💡 Example commands you could test:

1. "Give me info on my websites SSL certificate"
2. "Check if my server is using quantum safe encyption for communication"
3. "Run a comprehensive security audit on my server"
4. '"Create a cmd processor to .. (what ever you want)" Note you need to install a Quantum Network Monitor Agent to run the .net code on. This is a very flexible and powerful feature. Use with caution!

Final Word

I fund the servers used to create these model files, run the Quantum Network Monitor service, and pay for inference from Novita and OpenAI—all out of my own pocket. All the code behind the model creation and the Quantum Network Monitor project is open source. Feel free to use whatever you find helpful.

If you appreciate the work, please consider buying me a coffee ☕. Your support helps cover service costs and allows me to raise token limits for everyone.

I'm also open to job opportunities or sponsorship.

Thank you! 😊