curvesimulator 0.1.0__tar.gz

curvesimulator-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: curvesimulator
+Version: 0.1.0
+Summary: Curvesimulator calculates the movements and eclipses of celestial bodies and produces a video of this and of the resulting lightcurve.
+Home-page: https://github.com/lichtgestalter/curvesimulator
+Author: Uli Scheuss
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: configparser
+
+# curvesim
+A Star System and Lightcurve Simulator<br>
+<br>
+Curvesim produces a video of the movements and eclipses of celestial bodies and of the resulting lightcurve.<br>
+<br>
+Curvesim is fast and the videos use little disk space. A video takes about the same time to produce as its playing time and uses less than 0.5 MB disc space per minute.<br>
+<br>
+Specify mass, radius, orbital elements and other properties of some stars and planets in a configuration file.<br>
+Then run "curvesim.py <configfilename>" to produce the video.
+The video shows simultanously a view of the star system from the top and from the side and
+the lightcurve of the system's total luminosity over time.<br>
+<br>
+Usually you do not need to look at or even modify the python code. Instead control the program's
+outcome with the config file. The meaning of all program parameters is documented in the config file.<br>
+<br>
+Curvesim uses ffmpeg to convert the data into a video. <br> 
+Download ffmpeg from https://www.ffmpeg.org/download.html. <br>
+Extract the zip file and (on Windows) add "<yourdriveandpath>\FFmpeg\bin" to the environment variable PATH.<br>
+<br>
+For questions and comments just open an issue on https://github.com/lichtgestalter/curvesim/issues to get my attention :)<br>

curvesimulator-0.1.0/README.md

@@ -0,0 +1,20 @@
+# curvesim
+A Star System and Lightcurve Simulator<br>
+<br>
+Curvesim produces a video of the movements and eclipses of celestial bodies and of the resulting lightcurve.<br>
+<br>
+Curvesim is fast and the videos use little disk space. A video takes about the same time to produce as its playing time and uses less than 0.5 MB disc space per minute.<br>
+<br>
+Specify mass, radius, orbital elements and other properties of some stars and planets in a configuration file.<br>
+Then run "curvesim.py <configfilename>" to produce the video.
+The video shows simultanously a view of the star system from the top and from the side and
+the lightcurve of the system's total luminosity over time.<br>
+<br>
+Usually you do not need to look at or even modify the python code. Instead control the program's
+outcome with the config file. The meaning of all program parameters is documented in the config file.<br>
+<br>
+Curvesim uses ffmpeg to convert the data into a video. <br> 
+Download ffmpeg from https://www.ffmpeg.org/download.html. <br>
+Extract the zip file and (on Windows) add "<yourdriveandpath>\FFmpeg\bin" to the environment variable PATH.<br>
+<br>
+For questions and comments just open an issue on https://github.com/lichtgestalter/curvesim/issues to get my attention :)<br>

curvesimulator-0.1.0/curvesimulator/__init__.py

@@ -0,0 +1,2 @@
+# __init__.py
+from .curvesim import curvesim

curvesimulator-0.1.0/curvesimulator/cs_animation.py

@@ -0,0 +1,120 @@
+import math
+import time
+import matplotlib
+import numpy as np
+import matplotlib.pyplot as plt  # from matplotlib import pyplot as plt
+
+
+class CurveSimAnimation:
+
+    def __init__(self, p, bodies, lightcurve):
+        sampled_lightcurve = np.take(lightcurve, range(0, p.iterations, p.sampling_rate))  # Use only some of the calculated positions for the animation because it is so slow.
+        self.fig, ax_right, ax_left, ax_lightcurve, self.red_dot = CurveSimAnimation.init_plot(p, sampled_lightcurve, lightcurve)  # Adjust constants in section [Plot] of config file to fit your screen.
+        for body in bodies:  # Circles represent the bodies in the animation. Set their colors and add them to the matplotlib axis.
+            body.circle_right.set_color(body.color)
+            body.circle_left.set_color(body.color)
+            ax_right.add_patch(body.circle_right)
+            ax_left.add_patch(body.circle_left)
+        self.render(p, bodies, lightcurve)
+
+    @staticmethod
+    def tic_delta(scope):
+        """Returns a distance between two tics on an axis so that the total
+        number of tics on that axis is between 5 and 10."""
+        if scope <= 0:  # no or constant values
+            return 1
+        delta = 10 ** np.floor(math.log10(scope))
+        if scope / delta < 5:
+            if scope / delta < 2:
+                return delta / 5
+            else:
+                return delta / 2
+        else:
+            return delta
+
+    @staticmethod
+    def init_plot(p, sampled_lightcurve, lightcurve):
+        """Initialize the matplotlib figure containing 3 axis:
+        Top left: projection (x,y,z) -> (x,z), order = -y.
+        Top right: projection (x,y,z) -> (x,y), order = z.
+        Bottom: lightcurve"""
+        fig = plt.figure()
+        fig.set_figwidth(p.figure_width)
+        fig.set_figheight(p.figure_height)
+        fig.set_facecolor("black")  # background color outside of ax_left and ax_lightcurve
+        buffer = 0
+        fig.subplots_adjust(left=buffer, right=1.0 - buffer, bottom=buffer, top=1 - buffer)  # Positions of the subplots edges, as a fraction of the figure width.
+
+        ax_left = plt.subplot2grid(shape=(5, 2), loc=(0, 0), rowspan=4, colspan=1)
+        ax_left.set_xlim(-p.xlim, p.xlim)
+        ax_left.set_ylim(-p.ylim, p.ylim)
+        ax_left.set_aspect('equal')
+        ax_left.set_facecolor("black")  # background color
+        # ax_left.get_xaxis().set_visible(False)
+        # ax_left.get_yaxis().set_visible(False)
+
+        ax_right = plt.subplot2grid(shape=(5, 2), loc=(0, 1), rowspan=4, colspan=1)
+        ax_right.set_xlim(-p.xlim, p.xlim)
+        ax_right.set_ylim(-p.ylim, p.ylim)
+        ax_right.set_aspect('equal')
+        ax_right.set_facecolor("black")  # background color
+
+        ax_lightcurve = plt.subplot2grid(shape=(5, 1), loc=(4, 0), rowspan=1, colspan=1)
+        ax_lightcurve.set_facecolor("black")  # background color
+
+        ax_lightcurve.tick_params(axis='x', colors='grey')
+        xmax = p.iterations * p.dt / p.x_unit_value
+        ax_lightcurve.set_xlim(0, xmax)
+        xvalues = [x * CurveSimAnimation.tic_delta(xmax) for x in range(round(xmax / CurveSimAnimation.tic_delta(xmax)))]
+        xlabels = [f'{round(x, 4)} {p.x_unit_name}' for x in xvalues]
+        ax_lightcurve.set_xticks(xvalues, labels=xlabels)
+
+        ax_lightcurve.tick_params(axis='y', colors='grey')
+        minl = lightcurve.min(initial=None)
+        maxl = lightcurve.max(initial=None)
+        if minl == maxl:
+            minl *= 0.99
+        scope = maxl - minl
+        buffer = 0.05 * scope
+        ax_lightcurve.set_ylim(minl - buffer, maxl + buffer)
+
+        ticdelta = CurveSimAnimation.tic_delta(maxl - minl)
+        yvalues = [1 - y * ticdelta for y in range(round(float((maxl - minl) / ticdelta)))]
+        ylabels = [f'{round(100 * y, 10)} %' for y in yvalues]
+        ax_lightcurve.set_yticks(yvalues, labels=ylabels)
+
+        time_axis = np.arange(0, round(p.iterations * p.dt), round(p.sampling_rate * p.dt), dtype=float)
+        time_axis /= p.x_unit_value
+        ax_lightcurve.plot(time_axis, sampled_lightcurve[0:len(time_axis)], color="white")
+
+        red_dot = matplotlib.patches.Ellipse((0, 0), p.iterations * p.dt * p.red_dot_width / p.x_unit_value, scope * p.red_dot_height)  # matplotlib patch
+        red_dot.set(zorder=2)  # Dot in front of lightcurve.
+        red_dot.set_color((1, 0, 0))  # red
+        ax_lightcurve.add_patch(red_dot)
+        plt.tight_layout()  # Automatically adjust padding horizontally as well as vertically.
+        return fig, ax_right, ax_left, ax_lightcurve, red_dot
+
+    @staticmethod
+    def next_frame(frame, p, bodies, red_dot, lightcurve):
+        """Update patches. Send new circle positions to animation function.
+        First parameter comes from iterator frames (a parameter of FuncAnimation).
+        The other parameters are given to this function via the parameter fargs of FuncAnimation."""
+        for body in bodies:  # right view: projection (x,y,z) -> (x,y), order = z (z-axis points to viewer)
+            body.circle_right.set(zorder=body.positions[frame * p.sampling_rate][2])
+            body.circle_right.center = body.positions[frame * p.sampling_rate][0] / p.scope_right, body.positions[frame * p.sampling_rate][1] / p.scope_right
+        for body in bodies:  # left view: projection (x,y,z) -> (x,z), order = -y (y-axis points away from viewer)
+            body.circle_left.set(zorder=-body.positions[frame * p.sampling_rate][1])
+            body.circle_left.center = body.positions[frame * p.sampling_rate][0] / p.scope_left, body.positions[frame * p.sampling_rate][2] / p.scope_left
+        red_dot.center = p.dt * p.sampling_rate * frame / p.x_unit_value, lightcurve[frame * p.sampling_rate]
+        if frame >= 10 and frame % int(round(p.frames / 10)) == 0:  # Inform user about program's progress.
+            print(f'{round(frame / p.frames * 10) * 10:3d}% ', end="")
+
+    def render(self, p, bodies, lightcurve):
+        """Calls next_frame() for each frame and saves the video."""
+        print(f'Animating {p.frames:8d} frames:     ', end="")
+        tic = time.perf_counter()
+        anim = matplotlib.animation.FuncAnimation(self.fig, CurveSimAnimation.next_frame, fargs=(p, bodies, self.red_dot, lightcurve), interval=1000 / p.fps, frames=p.frames, blit=False)
+        anim.save(p.video_file, fps=p.fps, metadata={"title": " "}, extra_args=['-vcodec', 'libx264'])  # https://www.ffmpeg.org/libavcodec.html
+        toc = time.perf_counter()
+        print(f' {toc - tic:7.2f} seconds  ({p.frames / (toc - tic):.0f} frames/second)')
+        print(f'{p.video_file} saved.')

curvesimulator-0.1.0/curvesimulator/cs_bodies.py

@@ -0,0 +1,160 @@
+import configparser
+import math
+import time
+import matplotlib
+import matplotlib.animation
+import numpy as np
+
+from cs_body import CurveSimBody
+from cs_lightcurve import CurveSimLightcurve
+from cs_physics import CurveSimPhysics
+
+
+class CurveSimBodies(list):
+
+    # noinspection PyUnusedLocal
+    def __init__(self, p, debug_L=-1):
+        """Initialize instances of physical bodies.
+        Read program parameters and properties of the bodies from config file.
+        Initialize the circles in the animation (matplotlib patches)"""
+        # For ease of use of these constants in the config file they are additionally defined here without the prefix "p.".
+        g, au, r_sun, m_sun, l_sun = p.g, p.au, p.r_sun, p.m_sun, p.l_sun
+        r_jup, m_jup, r_earth, m_earth, v_earth = p.r_jup, p.m_jup, p.r_earth, p.m_earth, p.v_earth
+        config = configparser.ConfigParser(inline_comment_prefixes='#')
+        config.read(p.configfilename)  # Read config file. (This time the physical objects.)
+        super().__init__()  # create object by calling the constructor of class list
+
+        # Physical bodies
+        for section in config.sections():
+            if section not in p.standard_sections:  # section describes a physical object
+                self.append(CurveSimBody(p=p,
+                                         name=section,
+                                         body_type=config.get(section, "body_type"),
+                                         mass=eval(config.get(section, "mass")),
+                                         radius=eval(config.get(section, "radius")),
+                                         luminosity=None if config.get(section, "luminosity", fallback=None) is None else eval(config.get(section, "luminosity")),
+                                         startposition=config.get(section, "startposition", fallback=None),
+                                         velocity=config.get(section, "velocity", fallback=None),
+                                         a=None if config.get(section, "a", fallback=None) is None else eval(config.get(section, "a")),  # a bit long-winded because eval() cannot handle None
+                                         e=None if config.get(section, "e", fallback=None) is None else eval(config.get(section, "e")),
+                                         i=None if config.get(section, "i", fallback=None) is None else eval(config.get(section, "i")),
+                                         Ω=None if config.get(section, "longitude_of_ascending_node", fallback=None) is None else eval(config.get(section, "longitude_of_ascending_node")),
+                                         ω=None if config.get(section, "argument_of_periapsis", fallback=None) is None else eval(config.get(section, "argument_of_periapsis")),
+                                         ϖ=None if config.get(section, "longitude_of_periapsis", fallback=None) is None else eval(config.get(section, "longitude_of_periapsis")),
+                                         L=None if config.get(section, "L", fallback=None) is None else eval(config.get(section, "L")),
+                                         ma=None if config.get(section, "ma", fallback=None) is None else eval(config.get(section, "ma")),
+                                         ea=None if config.get(section, "ea", fallback=None) is None else eval(config.get(section, "ea")),
+                                         nu=None if config.get(section, "nu", fallback=None) is None else eval(config.get(section, "nu")),
+                                         T=None if config.get(section, "T", fallback=None) is None else eval(config.get(section, "T")),
+                                         t=None if config.get(section, "t", fallback=None) is None else eval(config.get(section, "t")),
+                                         beta=eval(config.get(section, "beta")),
+                                         color=tuple([eval(x) for x in config.get(section, "color").split(",")])))
+        # Checking parameters of physical bodies
+        if len(self) < 1:
+            raise Exception("No physical bodies specified.")
+        for body in self:
+            if body.radius <= 0:
+                raise Exception(f'{body.name} has invalid radius {body.radius}.')
+            if body.mass <= 0:
+                raise Exception(f'{body.name} has invalid mass {body.mass}.')
+            if body.luminosity < 0:
+                raise Exception(f'{body.name} has invalid luminosity {body.luminosity}.')
+            if body.luminosity > 0 >= body.beta:  # if body.luminosity > 0 and body.beta <= 0:
+                raise Exception(f'{body.name} has invalid limb darkening parameter beta {body.beta}.')
+            for c in body.color:
+                if c < 0 or c > 1:
+                    raise Exception(f'{body.name} has invalid color value {c}.')
+            if debug_L >= 0 and body.name == "Test":
+                body.L = debug_L/180.0 * math.pi
+            body.calc_state_vectors(p, self)
+        self.generate_patches(p)
+
+    def __repr__(self):
+        names = "CurveSimBodies: "
+        for body in self:
+            names += body.name + ", "
+        return names[:-2]
+
+    def total_luminosity(self, stars, iteration):
+        """"Add luminosity of all stars in the system while checking for eclipses.
+        Does not yet work correctly for eclipsed eclipses (three or more bodies in line of sight at the same time)."""
+        luminosity = 0.0
+        for star in stars:
+            luminosity += star.luminosity
+            for body in self:
+                if body != star:  # an object cannot eclipse itself :)
+                    eclipsed_area, relative_radius = star.eclipsed_by(body, iteration)
+                    if eclipsed_area != 0:
+                        luminosity -= star.brightness * eclipsed_area * CurveSimPhysics.limbdarkening(relative_radius, star.beta)
+        return luminosity
+
+    def calc_positions_eclipses_luminosity(self, p):
+        """Calculate distances, forces, accelerations, velocities of the bodies for each iteration.
+        The resulting body positions and the lightcurve are stored for later use in the animation.
+        Body motion calculations inspired by https://colab.research.google.com/drive/1YKjSs8_giaZVrUKDhWLnUAfebuLTC-A5."""
+        stars = [body for body in self if body.body_type == "star"]
+        lightcurve = CurveSimLightcurve(p.iterations)  # Initialize lightcurve (essentially a np.ndarray)
+        lightcurve[0] = self.total_luminosity(stars, 0)
+        for iteration in range(1, p.iterations):
+            for body1 in self:
+                force = np.array([0.0, 0.0, 0.0])
+                for body2 in self:
+                    if body1 != body2:
+                        # Calculate distances between bodies:
+                        distance_xyz = body2.positions[iteration - 1] - body1.positions[iteration - 1]
+                        distance = math.sqrt(np.dot(distance_xyz, distance_xyz))
+                        force_total = p.g * body1.mass * body2.mass / distance ** 2  # Use law of gravitation to calculate force acting on body.
+                        # Compute the force of attraction in each direction:
+                        x, y, z = distance_xyz[0], distance_xyz[1], distance_xyz[2]
+                        polar_angle = math.acos(z / distance)
+                        azimuth_angle = math.atan2(y, x)
+                        force[0] += math.sin(polar_angle) * math.cos(azimuth_angle) * force_total
+                        force[1] += math.sin(polar_angle) * math.sin(azimuth_angle) * force_total
+                        force[2] += math.cos(polar_angle) * force_total
+                acceleration = force / body1.mass  # Compute the acceleration in each direction.
+                body1.velocity += acceleration * p.dt  # Compute the velocity in each direction.
+                # Update positions:
+                movement = body1.velocity * p.dt - 0.5 * acceleration * p.dt ** 2
+                body1.positions[iteration] = body1.positions[iteration - 1] + movement
+            lightcurve[iteration] = self.total_luminosity(stars, iteration)  # Update lightcurve.
+            if iteration % int(round(p.iterations / 10)) == 0:  # Inform user about program's progress.
+                print(f'{round(iteration / p.iterations * 10) * 10:3d}% ', end="")
+        return lightcurve, self
+
+    def calc_physics(self, p):
+        """Calculate body positions and the resulting lightcurve."""
+        print(f'Producing {p.frames / p.fps:.0f} seconds long video, covering {p.dt * p.iterations / 60 / 60 / 24:5.2f} '
+              f'earth days. ({p.dt * p.sampling_rate * p.fps / 60 / 60 / 24:.2f} earth days per video second.)')
+        print(f'Calculating {p.iterations:6d} iterations: ', end="")
+        tic = time.perf_counter()
+        lightcurve, bodies = self.calc_positions_eclipses_luminosity(p)
+        lightcurve /= lightcurve.max(initial=None)  # Normalize flux.
+        toc = time.perf_counter()
+        print(f' {toc - tic:7.2f} seconds  ({p.iterations / (toc - tic):.0f} iterations/second)')
+        return lightcurve
+
+    def calc_patch_radii(self, p):
+        """If autoscaling is on, this function calculates the radii of the circles (matplotlib patches) of the animation."""
+        logs = [math.log10(body.radius) for body in self]  # log10 of all radii
+        radii_out = [(p.max_radius - p.min_radius) * (i - min(logs)) / (max(logs) - min(logs)) + p.min_radius for i in logs]  # linear transformation to match the desired minmum and maximum radii
+        # print(f'patch radii:', end="  ")
+        for body, radius in zip(self, radii_out):
+            body.patch_radius = radius
+        #     print(f'{body.name}: {body.patch_radius:.4f} ', end="   ")
+        # print()
+
+    def generate_patches(self, p):
+        """Generates the circles (matplotlib patches) of the animation."""
+        if p.autoscaling:
+            self.calc_patch_radii(p)
+            for body in self:
+                body.circle_right = matplotlib.patches.Circle(xy=(0, 0), radius=body.patch_radius)  # Matplotlib patch for right view
+                body.circle_left = matplotlib.patches.Circle(xy=(0, 0), radius=body.patch_radius)  # Matplotlib patch for left view
+        else:
+            for body in self:
+                if body.body_type == "planet":
+                    extrascale_left, extrascale_right = p.planet_scale_left, p.planet_scale_right  # Scale radius in plot.
+                else:
+                    extrascale_left, extrascale_right = p.star_scale_left, p.star_scale_right  # It's a star. Scale radius in plot accordingly.
+                body.circle_right = matplotlib.patches.Circle((0, 0), radius=body.radius * extrascale_right / p.scope_right)  # Matplotlib patch for right view
+                body.circle_left = matplotlib.patches.Circle((0, 0), radius=body.radius * extrascale_left / p.scope_left)  # Matplotlib patch for left view

curvesimulator-0.1.0/curvesimulator/cs_body.py

@@ -0,0 +1,298 @@
+import math
+import numpy as np
+
+from cs_physics import CurveSimPhysics
+
+
+# noinspection NonAsciiCharacters,PyPep8Naming,PyUnusedLocal
+class CurveSimBody:
+
+    def __init__(self, p, name, body_type, mass, radius, luminosity, startposition, velocity, a, e, i, Ω, ω, ϖ, L, ma, ea,
+                 nu, T, t, beta, color):
+        """Initialize instance of physical body."""
+        # For ease of use of constants in the config file they are additionally defined here without the prefix "p.".
+        g, au, r_sun, m_sun, l_sun = p.g, p.au, p.r_sun, p.m_sun, p.l_sun
+        r_jup, m_jup, r_earth, m_earth, v_earth = p.r_jup, p.m_jup, p.r_earth, p.m_earth, p.v_earth
+        self.name = name  # name
+        self.body_type = body_type  # "star" or "planet"
+        self.mass = mass  # [kg]
+        self.radius = radius  # [m]
+        self.area_2d = math.pi * radius ** 2  # [m**2]
+        self.luminosity = luminosity  # [W]
+        self.brightness = luminosity / self.area_2d  # luminosity per (apparent) area [W/m**2]
+        self.positions = np.zeros((p.iterations, 3), dtype=float)  # position for each frame
+        self.color = color  # (R, G, B)  each between 0 and 1
+
+        if body_type == "planet":
+            self.a = a  # [m] semi-major axis
+            self.e = e  # [1] eccentricity
+            self.i = None if i is None else math.radians(i)  # [deg] inclination
+            self.Ω = None if Ω is None else math.radians(Ω)  # [deg] longitude of ascending node
+            self.ω = None if ω is None else math.radians(ω)  # [deg] argument of periapsis
+            self.ϖ = None if ϖ is None else math.radians(ϖ)  # [deg] longitude of periapsis
+            self.L = None if L is None else math.radians(L)  # [deg] mean longitude
+            self.ma = None if ma is None else math.radians(ma)  # [deg] mean anomaly
+            self.ea = None if ea is None else math.radians(ea)  # [deg] eccentric anomaly
+            self.nu = None if nu is None else math.radians(nu)  # [deg] true anomaly. Per definition = 270° at the time of an exoplanet's primary transit.
+            self.T = T  # [s] Time of periapsis
+            self.t = t  # [s] time since last time of transit
+            self.ma, self.ea, self.T = None, None, None  # [rad] Only true anomaly or mean_anomaly or eccentric_anomaly or time_of_periapsis has to be provided.
+            self.mu = None  # Gravitational Parameter. Depends on the masses of at least 2 bodies.
+            self.beta = None  # unnecessary line of code?
+
+        if body_type == "star":
+            self.beta = beta  # [1] limb darkening
+
+        if startposition is not None and velocity is not None:  # State vectors are already in config file.
+            pos = []
+            for x in startposition.split(","):
+                pos.append(eval(x))
+            vel = []
+            for x in velocity.split(","):
+                vel.append(eval(x))
+            self.positions[0] = np.array(pos, dtype=float)  # [m] initial position
+            self.velocity = np.array(vel, dtype=float)  # [m/s]
+        else:  # State vectors are not in config file. They will be calculated from Kepler orbit parameters later on after all bodies are initialized.
+            self.velocity = None
+
+        # Used for calculation of eclipsed area in function eclipsed_by.
+        self.d, self.h, self.angle, self.eclipsed_area = 0.0, 0.0, 0.0, 0.0
+
+    def __repr__(self):
+        return f'CurveSimBody: {self.name}'
+
+    # noinspection NonAsciiCharacters,PyPep8Naming,PyUnusedLocal
+    def keplerian_elements_to_state_vectors_debug_new(self):
+        """
+        Version of keplerian_elements_to_state_vectors() using alternative formulas from source [f] instead of [b] for the initial position.
+        [f]: https://www.researchgate.net/publication/232203657_Orbital_Ephemerides_of_the_Sun_Moon_and_Planets, Section 8.10
+        """
+        a, e, i, Ω, ω, ϖ, L = self.a, self.e, self.i, self.Ω, self.ω, self.ϖ, self.L  # for readability of formulas
+        ma, ea, nu, T, t, mu = self.ma, self.ea, self.nu, self.T, self.t, self.mu  # for readability of formulas
+
+        ω = ϖ - Ω  # [f]8-30
+        ma = L - ϖ  # [f]8-30
+
+        ea = CurveSimPhysics.kepler_equation_root_debug(e, ma, ea_guess=ma)  # [d], [e]. Maybe implement alternative version from [f]8-31 and [f]8.10.2???
+
+        x_ = a * (math.cos(ea) - e)  # [f]8-32
+        y_ = a * math.sqrt(1 - e * e) * math.sin(ea)  # [f]8-32
+        z_ = 0  # [f]8-32
+        x = x_ * (math.cos(Ω) * math.cos(ω) - math.sin(Ω) * math.sin(ω) * math.cos(i))    # [f]8-34  maybe replace ω with ω everywhere in [f]8-34?
+        x += y_ * (-math.sin(ω) * math.cos(Ω) - math.cos(ω) * math.sin(Ω) * math.cos(i))  # [f]8-34
+        y = x_ * (math.sin(Ω) * math.cos(ω) + math.cos(Ω) * math.sin(ω) * math.cos(i))  # [f]8-34
+        y += y_ * (-math.sin(ω) * math.sin(Ω) + math.cos(ω) * math.cos(Ω) * math.cos(i))  # [f]8-34
+        z = x_ * math.sin(i) * math.sin(ω)  # [f]8-34
+        z += y_ * math.cos(ω) * math.sin(i)  # [f]8-34
+
+        nu = 2 * math.atan(math.sqrt((1 + e) / (1 - e)) * math.tan(ea / 2))  # 3b: true anomaly (from eccentric anomaly)
+        r = a * (1 - e * math.cos(ea))  # 4b: radius r
+        h = math.sqrt(mu * a * (1 - e ** 2))  # 5b: specific angular momentum h
+
+        p = a * (1 - e ** 2)  # 7b: Semi-latus rectum. Used in velocity calculation.
+        dx = (x * h * e / (r * p)) * math.sin(nu) - (h / r) * (math.cos(Ω) * math.sin(ω + nu) + math.sin(Ω) * math.cos(ω + nu) * math.cos(i))  # 7b: velocity component x
+        dy = (y * h * e / (r * p)) * math.sin(nu) - (h / r) * (math.sin(Ω) * math.sin(ω + nu) - math.cos(Ω) * math.cos(ω + nu) * math.cos(i))  # 7b: velocity component y
+        dz = (z * h * e / (r * p)) * math.sin(nu) + (h / r) * (math.cos(ω + nu) * math.sin(i))  # 7b: velocity component z
+        return np.array([x, y, z]), np.array([dx, dy, dz]), nu, ma, ea, T  # state vectors
+
+    def keplerian_elements_to_state_vectors_debug(self):
+        """
+        Shortened version of keplerian_elements_to_state_vectors()
+        for the case where L, ϖ and Ω are known.
+        """
+        a, e, i, Ω, ω, ϖ, L = self.a, self.e, self.i, self.Ω, self.ω, self.ϖ, self.L  # for readability of formulas
+        ma, ea, nu, T, t, mu = self.ma, self.ea, self.nu, self.T, self.t, self.mu  # for readability of formulas
+
+        ω = ϖ - Ω
+        ma = L - ϖ
+        ea = CurveSimPhysics.kepler_equation_root(e, ma, ea_guess=ma)
+        nu = 2 * math.atan(math.sqrt((1 + e) / (1 - e)) * math.tan(ea / 2))  # 3b: true anomaly (from eccentric anomaly)
+        r = a * (1 - e * math.cos(ea))  # 4b: radius r
+        h = math.sqrt(mu * a * (1 - e ** 2))  # 5b: specific angular momentum h
+
+        x = r * (math.cos(Ω) * math.cos(ω + nu) - math.sin(Ω) * math.sin(ω + nu) * math.cos(i))  # 6b: position component x
+        y = r * (math.sin(Ω) * math.cos(ω + nu) + math.cos(Ω) * math.sin(ω + nu) * math.cos(i))  # 6b: position component y
+        z = r * (math.sin(i) * math.sin(ω + nu))  # 6b: position component z
+
+        p = a * (1 - e ** 2)  # 7b: Semi-latus rectum. Used in velocity calculation.
+        dx = (x * h * e / (r * p)) * math.sin(nu) - (h / r) * (math.cos(Ω) * math.sin(ω + nu) + math.sin(Ω) * math.cos(ω + nu) * math.cos(i))  # 7b: velocity component x
+        dy = (y * h * e / (r * p)) * math.sin(nu) - (h / r) * (math.sin(Ω) * math.sin(ω + nu) - math.cos(Ω) * math.cos(ω + nu) * math.cos(i))  # 7b: velocity component y
+        dz = (z * h * e / (r * p)) * math.sin(nu) + (h / r) * (math.cos(ω + nu) * math.sin(i))  # 7b: velocity component z
+        return np.array([x, y, z]), np.array([dx, dy, dz]), nu, ma, ea, T  # state vectors
+
+    def keplerian_elements_to_state_vectors_chatgpt(self):
+        """Calculates the state vectors (position and velocity) from Keplerian Orbit Elements.
+        Returns also true anomaly, eccentric anomaly, mean anomaly and the time of periapsis."""
+        a, e, i, Ω, ω, ϖ, L = self.a, self.e, self.i, self.Ω, self.ω, self.ϖ, self.L  # for readability of formulas
+        ma, ea, nu, T, t, mu = self.ma, self.ea, self.nu, self.T, self.t, self.mu  # for readability of formulas
+        print("hej, chatgpt")
+        # Calculate ω if necessary
+        if ω is None and ϖ is not None and Ω is not None:
+            ω = ϖ - Ω
+
+        # Calculate mean anomaly if necessary
+        if ma is None and L is not None and ϖ is not None:
+            ma = L - ϖ
+
+        # Eccentric anomaly and true anomaly
+        if ea is not None:
+            # Calculate true anomaly from eccentric anomaly
+            nu = 2 * math.atan2(math.sqrt(1 + e) * math.sin(ea / 2), math.sqrt(1 - e) * math.cos(ea / 2))
+            # Calculate mean anomaly from eccentric anomaly
+            ma = ea - e * math.sin(ea)
+        else:
+            if nu is not None:
+                # Calculate eccentric anomaly from true anomaly
+                ea = 2 * math.atan2(math.sqrt(1 - e) * math.sin(nu / 2), math.sqrt(1 + e) * math.cos(nu / 2))
+            elif ma is not None:
+                # Solve for eccentric anomaly using Kepler's equation
+                ea = CurveSimPhysics.kepler_equation_root_chatgpt(e, ma, ea_guess=ma)
+                # Calculate true anomaly from eccentric anomaly
+                nu = 2 * math.atan2(math.sqrt(1 + e) * math.sin(ea / 2), math.sqrt(1 - e) * math.cos(ea / 2))
+            elif T is not None:
+                # Calculate mean motion
+                n = math.sqrt(mu / (a ** 3))
+                # Calculate mean anomaly at time of periapsis
+                ma = n * (t - T)
+                # Solve for eccentric anomaly using Kepler's equation
+                ea = CurveSimPhysics.kepler_equation_root_chatgpt(e, ma, ea_guess=ma)
+                # Calculate true anomaly from eccentric anomaly
+                nu = 2 * math.atan2(math.sqrt(1 + e) * math.sin(ea / 2), math.sqrt(1 - e) * math.cos(ea / 2))
+            else:
+                raise Exception("nu or ma or ea or T has to be provided to keplerian_elements_to_state_vectors()")
+
+        # Calculate mean angular motion
+        n = math.sqrt(mu / (a ** 3))
+
+        # Calculate time of periapsis passage
+        T = t - (ma / n)
+
+        # Position in orbital plane
+        r = a * (1 - e * math.cos(ea))
+        x_orb = r * math.cos(nu)
+        y_orb = r * math.sin(nu)
+
+        # Velocity in orbital plane
+        vx_orb = -math.sqrt(mu / (a * (1 - e ** 2))) * math.sin(ea)
+        vy_orb = math.sqrt(mu / (a * (1 - e ** 2))) * (math.sqrt(1 - e ** 2) * math.cos(ea))
+
+        # Rotation matrices for inclination, ascending node, and argument of periapsis
+        cos_Omega, sin_Omega = math.cos(Ω), math.sin(Ω)
+        cos_omega, sin_omega = math.cos(ω), math.sin(ω)
+        cos_i, sin_i = math.cos(i), math.sin(i)
+
+        # Transformation to 3D space
+        x = (cos_Omega * cos_omega - sin_Omega * sin_omega * cos_i) * x_orb + (-cos_Omega * sin_omega - sin_Omega * cos_omega * cos_i) * y_orb
+        y = (sin_Omega * cos_omega + cos_Omega * sin_omega * cos_i) * x_orb + (-sin_Omega * sin_omega + cos_Omega * cos_omega * cos_i) * y_orb
+        z = (sin_i * sin_omega) * x_orb + (sin_i * cos_omega) * y_orb
+
+        dx = (cos_Omega * cos_omega - sin_Omega * sin_omega * cos_i) * vx_orb + (-cos_Omega * sin_omega - sin_Omega * cos_omega * cos_i) * vy_orb
+        dy = (sin_Omega * cos_omega + cos_Omega * sin_omega * cos_i) * vx_orb + (-sin_Omega * sin_omega + cos_Omega * cos_omega * cos_i) * vy_orb
+        dz = (sin_i * sin_omega) * vx_orb + (sin_i * cos_omega) * vy_orb
+
+        return np.array([x, y, z]), np.array([dx, dy, dz]), nu, ma, ea, T  # state vectors
+
+    def keplerian_elements_to_state_vectors(self):
+        """Calculates the state vectors (position and velocity) from Keplerian Orbit Elements.
+        Returns also true anomaly, eccentric anomaly, mean anomaly and the time of periapsis.
+        [a]: https://web.archive.org/web/20160418175843/https://ccar.colorado.edu/asen5070/handouts/cart2kep2002.pdf
+        [b]: https://web.archive.org/web/20170810015111/http://ccar.colorado.edu/asen5070/handouts/kep2cart_2002.doc
+        [c]: https://space.stackexchange.com/questions/19322/converting-orbital-elements-to-cartesian-state-vectors/19335#19335
+        [d]: https://space.stackexchange.com/questions/55356/how-to-find-eccentric-anomaly-by-mean-anomaly
+        [e]: https://github.com/alfonsogonzalez/AWP/blob/main/src/python_tools/numerical_tools.py
+        Numbers in comments refer to numbered formulas in [a] and [b].
+        Code based on [c]. Added calculation of eccentric anomaly based on the explanations
+        in [d] using a stripped down version of [e]."""
+        a, e, i, Ω, ω, ϖ, L = self.a, self.e, self.i, self.Ω, self.ω, self.ϖ, self.L  # for readability of formulas
+        ma, ea, nu, T, t, mu = self.ma, self.ea, self.nu, self.T, self.t, self.mu  # for readability of formulas
+
+        if ω is None and ϖ is not None and Ω is not None:
+            ω = ϖ - Ω
+        if ma is None and L is not None and ϖ is not None:
+            ma = L - ϖ
+        if ea is not None:  # ea provided
+            nu = 2 * math.atan(math.sqrt((1 + e) / (1 - e)) * math.tan(ea / 2))  # 3b: true anomaly (from eccentric anomaly)
+            ma = ea - e * math.sin(ea)  # 2b: Mean anomaly (from eccentric anomaly). Just for completeness.
+        else:  # ea not provided
+            if nu is not None:  # nu provided
+                ea = 2 * math.atan(math.sqrt((1 - e) / (1 + e)) * math.tan(nu / 2))  # 11a: eccentric anomaly (from true anomaly) [rad]
+                ma = ea - e * math.sin(ea)  # 2b: Mean anomaly (from eccentric anomaly). Just for completeness.
+            else:  # nu, ea not provided
+                if ma is not None:  # ma provided
+                    ea = CurveSimPhysics.kepler_equation_root(e, ma, ea_guess=ma)  # A good guess is important. With guess=0 the root finder very often does not converge.
+                    nu = 2 * math.atan(math.sqrt((1 + e) / (1 - e)) * math.tan(ea / 2))  # 3b: true anomaly (from eccentric anomaly)
+                else:  # nu, ea, ma not provided
+                    if T is not None:  # T provided
+                        n = math.sqrt(mu / a ** 3)  # 1b: Mean angular motion. Not needed in this function. (Except for ma, which is not needed.)
+                        ma = n * T  # 1b: Mean anomaly at time of periapsis (from angular motion).
+                        ea = CurveSimPhysics.kepler_equation_root(e, ma, ea_guess=ma)  # A good guess is important. With guess=0 the root finder very often does not converge.
+                        nu = 2 * math.atan(math.sqrt((1 + e) / (1 - e)) * math.tan(ea / 2))  # 3b: true anomaly (from eccentric anomaly)
+                    else:  # nu, ea, ma, T not provided
+                        raise Exception("nu or ma or ea or T has to be provided to keplerian_elements_to_state_vectors()")
+        n = math.sqrt(mu / a ** 3)  # 12a: mean angular motion
+        T = ma / n  # Time of periapsis (from mean anomaly and angular motion). Just for completeness.
+
+        # Now update ma, ea and nu for a delay
+        # print(f'@Transit: {math.degrees(nu) =   :4.0f}   {math.degrees(ma) =   :4.0f}   {math.degrees(ea) =   :4.0f}')
+        ma += t * n  # 1b
+        ea = CurveSimPhysics.kepler_equation_root(e, ma, ea_guess=ma)  # A good guess is important. With guess=0 the root finder very often does not converge.
+        nu = 2 * math.atan(math.sqrt((1 + e) / (1 - e)) * math.tan(ea / 2))  # 3b: true anomaly (from eccentric anomaly)
+        # print(f' delayed: {math.degrees(nu) =   :4.0f}   {math.degrees(ma) =   :4.0f}   {math.degrees(ea) =   :4.0f}')
+        # nu = nu % (2*math.pi)
+        # print(f'@Transit: {math.degrees(nu) =   :4.0f}   {math.degrees(ma) =   :4.0f}   {math.degrees(ea) =   :4.0f}')
+        r = a * (1 - e * math.cos(ea))  # 4b: radius r
+        h = math.sqrt(mu * a * (1 - e ** 2))  # 5b: specific angular momentum h
+        x = r * (math.cos(Ω) * math.cos(ω + nu) - math.sin(Ω) * math.sin(ω + nu) * math.cos(i))  # 6b: position component x
+        y = r * (math.sin(Ω) * math.cos(ω + nu) + math.cos(Ω) * math.sin(ω + nu) * math.cos(i))  # 6b: position component y
+        z = r * (math.sin(i) * math.sin(ω + nu))  # 6b: position component z
+        p = a * (1 - e ** 2)  # 7b: Semi-latus rectum. Used in velocity calculation.
+        dx = (x * h * e / (r * p)) * math.sin(nu) - (h / r) * (math.cos(Ω) * math.sin(ω + nu) + math.sin(Ω) * math.cos(ω + nu) * math.cos(i))  # 7b: velocity component x
+        dy = (y * h * e / (r * p)) * math.sin(nu) - (h / r) * (math.sin(Ω) * math.sin(ω + nu) - math.cos(Ω) * math.cos(ω + nu) * math.cos(i))  # 7b: velocity component y
+        dz = (z * h * e / (r * p)) * math.sin(nu) + (h / r) * (math.cos(ω + nu) * math.sin(i))  # 7b: velocity component z
+        return np.array([x, y, z]), np.array([dx, dy, dz]), nu, ma, ea, T  # state vectors
+
+    def calc_state_vectors(self, p, bodies):
+        """Get initial position and velocity of the physical body self."""
+        self.mu = CurveSimPhysics.gravitational_parameter(bodies, p.g)  # is the same for all bodies in the system, because they are orbiting a common barycenter
+        if self.velocity is None:  # State vectors are not in config file. So they will be calculated from Kepler orbit parameters instead.
+            pos, vel, *_ = self.keplerian_elements_to_state_vectors_debug_new()
+            self.positions[0] = np.array(pos, dtype=float)  # [m] initial position
+            self.velocity = np.array(vel, dtype=float)  # [m/s] initial velocity
+
+    def eclipsed_by(self, body, iteration):
+        """Returns area, relative_radius
+        area: Area of self which is eclipsed by body.
+        relative_radius: The distance of the approximated center of the eclipsed area from the center of self as a percentage of self.radius (used for limb darkening)."""
+        if body.positions[iteration][1] < self.positions[iteration][1]:  # Is body nearer to viewpoint than self? (i.e. its position has a smaller y-coordinate)
+            d = CurveSimPhysics.distance_2d_ecl(body, self, iteration)
+            if d < self.radius + body.radius:  # Does body eclipse self?
+                if d <= abs(self.radius - body.radius):  # Annular (i.e. ring) eclipse or total eclipse
+                    if self.radius < body.radius:  # Total eclipse
+                        area = self.area_2d
+                        relative_radius = 0
+                        # print(f'  total: {iteration:7d}  rel.area: {area/self.area_2d*100:6.0f}%  rel.r: {relative_radius*100:6.0f}%')
+                        return area, relative_radius
+                    else:  # Annular (i.e. ring) eclipse
+                        area = body.area_2d
+                        relative_radius = d / self.radius
+                        # print(f'   ring: {iteration:7d}  rel.area: {area / self.area_2d * 100:6.0f}%  rel.r: {relative_radius * 100:6.0f}%')
+                        return area, relative_radius
+                else:  # Partial eclipse
+                    # Eclipsed area is the sum of a circle segment of self plus a circle segment of body
+                    # https://de.wikipedia.org/wiki/Kreissegment  https://de.wikipedia.org/wiki/Schnittpunkt#Schnittpunkte_zweier_Kreise
+                    self.d = (self.radius ** 2 - body.radius ** 2 + d ** 2) / (2 * d)  # Distance of center from self to radical axis
+                    body.d = (body.radius ** 2 - self.radius ** 2 + d ** 2) / (2 * d)  # Distance of center from body to radical axis
+                    body.h = body.radius + self.d - d  # Height of circle segment
+                    self.h = self.radius + body.d - d  # Height of circle segment
+                    body.angle = 2 * math.acos(1 - body.h / body.radius)  # Angle of circle segment
+                    self.angle = 2 * math.acos(1 - self.h / self.radius)  # Angle of circle segment
+                    body.eclipsed_area = body.radius ** 2 * (body.angle - math.sin(body.angle)) / 2  # Area of circle segment
+                    self.eclipsed_area = self.radius ** 2 * (self.angle - math.sin(self.angle)) / 2  # Area of circle segment
+                    area = body.eclipsed_area + self.eclipsed_area  # Eclipsed area is sum of two circle segments.
+                    relative_radius = (self.radius + self.d - body.h) / (2 * self.radius)  # Relative distance between approximated center C of eclipsed area and center of self
+                    # print(f'partial: {iteration:7d}  rel.area: {area/self.area_2d*100:6.0f}%  rel.r: {relative_radius*100:6.0f}%')
+                    return area, relative_radius
+            else:  # No eclipse because, seen from viewer, the bodies are not close enough to each other
+                return 0.0, 0.0
+        else:  # body cannot eclipse self, because self is nearer to viewer than body
+            return 0.0, 0.0

curvesimulator-0.1.0/curvesimulator/cs_lightcurve.py

@@ -0,0 +1,12 @@
+import numpy as np
+
+
+class CurveSimLightcurve(np.ndarray):
+
+    def __new__(cls, shape, dtype=float):
+        obj = np.zeros(shape, dtype=dtype).view(cls)
+        return obj
+
+    def __str__(self):
+        return f'CurveSimLightcurve: max={self.max(initial=99.0):.5f}, min={self.min(initial=-99.0):.5f}, len={len(self)}'
+

curvesimulator-0.1.0/curvesimulator/cs_parameters.py

@@ -0,0 +1,102 @@
+import configparser
+import sys
+
+
+class CurveSimParameters:
+
+    def __init__(self):
+        """Read program parameters and properties of the physical bodies from config file."""
+        # Read config file
+        self.standard_sections = ["Astronomical Constants", "Video", "Plot", "Scale", "Debug"]
+        config = configparser.ConfigParser(inline_comment_prefixes='#')
+        self.configfilename = CurveSimParameters.find_and_check_config_file(default="curvesimulator.ini", standard_sections=self.standard_sections)
+        config.read(self.configfilename)
+
+        # [Astronomical Constants]
+        # For ease of use of these constants in the config file they are additionally defined here without the prefix "self.".
+        g = eval(config.get("Astronomical Constants", "g"))
+        au = eval(config.get("Astronomical Constants", "au"))
+        r_sun = eval(config.get("Astronomical Constants", "r_sun"))
+        m_sun = eval(config.get("Astronomical Constants", "m_sun"))
+        l_sun = eval(config.get("Astronomical Constants", "l_sun"))
+        r_jup = eval(config.get("Astronomical Constants", "r_jup"))
+        m_jup = eval(config.get("Astronomical Constants", "m_jup"))
+        r_earth = eval(config.get("Astronomical Constants", "r_earth"))
+        m_earth = eval(config.get("Astronomical Constants", "m_earth"))
+        v_earth = eval(config.get("Astronomical Constants", "v_earth"))
+        self.g, self.au, self.r_sun, self.m_sun, self.l_sun = g, au, r_sun, m_sun, l_sun,
+        self.r_jup, self.m_jup, self.r_earth, self.m_earth, self.v_earth = r_jup, m_jup, r_earth, m_earth, v_earth
+
+        # [Video]
+        self.video_file = config.get("Video", "video_file")
+        self.frames = eval(config.get("Video", "frames"))
+        self.fps = eval(config.get("Video", "fps"))
+        self.dt = eval(config.get("Video", "dt"))
+        self.sampling_rate = eval(config.get("Video", "sampling_rate"))
+        self.iterations = self.frames * self.sampling_rate
+
+        # [Scale]
+        self.scope_left = eval(config.get("Scale", "scope_left"))
+        self.star_scale_left = eval(config.get("Scale", "star_scale_left"))
+        self.planet_scale_left = eval(config.get("Scale", "planet_scale_left"))
+        self.scope_right = eval(config.get("Scale", "scope_right"))
+        self.star_scale_right = eval(config.get("Scale", "star_scale_right"))
+        self.planet_scale_right = eval(config.get("Scale", "planet_scale_right"))
+        self.autoscaling = config.get("Scale", "autoscaling") == "on"
+        self.min_radius = eval(config.get("Scale", "min_radius")) / 100.0
+        self.max_radius = eval(config.get("Scale", "max_radius")) / 100.0
+
+        # [Plot]
+        self.figure_width = eval(config.get("Plot", "figure_width"))
+        self.figure_height = eval(config.get("Plot", "figure_height"))
+        self.xlim = eval(config.get("Plot", "xlim"))
+        self.ylim = eval(config.get("Plot", "ylim"))
+        self.time_units = {"s": 1, "min": 60, "h": 3600, "d": 24 * 3600,
+                           "mon": 365.25 * 24 * 3600 / 12, "y": 365.25 * 24 * 3600}
+        self.x_unit_name = config.get("Plot", "x_unit")
+        self.x_unit_value = self.time_units[self.x_unit_name]
+        self.red_dot_height = eval(config.get("Plot", "red_dot_height"))
+        self.red_dot_width = eval(config.get("Plot", "red_dot_width"))
+
+        # Checking all parameters defined so far
+        for key in vars(self):
+            if type(getattr(self, key)) not in [str, dict, bool, list]:
+                if getattr(self, key) <= 0:
+                    print(f'{self=}   {key=}   {getattr(self, key)=}    {type(getattr(self, key))=}')
+                    raise Exception(f"No parameter in sections {self.standard_sections} may be zero or negative.")
+
+        # [Debug]
+        self.debug_L = list(eval(config.get("Debug", "debug_L")))
+        # print(f'{self.debug_L=}, {type(self.debug_L)=}')
+
+    def __repr__(self):
+        return f'CurveSimParameters from {self.configfilename}'
+
+    @staticmethod
+    def find_and_check_config_file(default, standard_sections):
+        """Check program parameters and extract config file name from them.
+        Check if config file can be opened and contains all standard sections."""
+        # Check program parameters and extract config file name from them.
+        if len(sys.argv) == 1:
+            configfilename = default
+            print(f'Using default config file {configfilename}. Specify config file name as program parameter if you '
+                  f'want to use another config file.')
+        elif len(sys.argv) == 2:
+            configfilename = sys.argv[1]
+            print(f'Using {configfilename} as config file.')
+        else:
+            configfilename = sys.argv[1]
+            print(f'Using {configfilename} as config file. Further program parameters are ignored.')
+        config = configparser.ConfigParser(inline_comment_prefixes='#')  # Read config file.
+        red = "\u001b[31m"
+        reset = "\u001b[0m"
+        if len(config.read(configfilename)) < 1:  # does opening the config file fail?
+            print(red + f'Config file {configfilename} not found. ' + reset)
+            print(red + f'Provide the config file name as the program parameter if you do not want to use the config file {configfilename}. ' + reset)
+            print(red + f'If you run this script in a jupyter notebook, add this line to the script: sys.argv[1]="yourconfigfilename.ini"' + reset)
+            exit(1)
+        for section in standard_sections:  # Does the config file contain all standard sections?
+            if section not in config.sections():
+                print(red + f'Section {section} missing in config file.' + reset)
+                exit(2)
+        return configfilename

curvesimulator-0.1.0/curvesimulator/cs_physics.py

@@ -0,0 +1,92 @@
+import math
+
+
+class CurveSimPhysics:
+
+    @staticmethod
+    def kepler_equation(ea, e, ma):
+        """ea: eccentric anomaly [rad], e: eccentricity, ma: mean anomaly [rad]"""
+        if not -2 * math.pi < ea < 2 * math.pi:
+            raise ValueError("eccentric anomaly ea must be in radians but is outside of the range ]-2π;2π[")
+        if not -2 * math.pi < ma < 2 * math.pi:
+            raise ValueError("mean anomaly ma must be in radians but is outside of the range ]-2π;2π[")
+        if not 0 <= e < 1:
+            raise ValueError("eccentricity e is outside of the range [0;1[")
+        return ea - e * math.sin(ea) - ma
+
+    @staticmethod
+    def kepler_equation_derivative(ea, e):
+        """ea: eccentric anomaly [rad], e: eccentricity"""
+        return 1.0 - e * math.cos(ea)
+
+    @staticmethod
+    def kepler_equation_root(e, ma, ea_guess=0.0, tolerance=1e-10, max_steps=50):
+        """Calculate the root of the Kepler Equation with the Newton–Raphson method.
+            e: eccentricity, ma: mean anomaly [rad], ea_guess: eccentric anomaly [rad]. ea_guess=ma is a good start."""
+        for n in range(max_steps):
+            delta = CurveSimPhysics.kepler_equation(ea_guess, e, ma) / CurveSimPhysics.kepler_equation_derivative(ea_guess, e)
+            if abs(delta) < tolerance:
+                return ea_guess - delta
+            ea_guess -= delta
+        raise RuntimeError('Newton\'s root solver did not converge.')
+
+    @staticmethod
+    def kepler_equation_root_chatgpt(e, ma, ea_guess=0.0, tolerance=1e-10, max_steps=50):
+        """Returns the root of the Kepler Equation with the Newton–Raphson method.
+            e: eccentricity, ma: mean anomaly [rad], ea_guess: eccentric anomaly [rad]. ea_guess=ma is a good start."""
+        ea = ea_guess
+        for _ in range(max_steps):
+            f_ea = ea - e * math.sin(ea) - ma
+            f_prime_ea = 1 - e * math.cos(ea)
+            delta = -f_ea / f_prime_ea
+            ea += delta
+            if abs(delta) < tolerance:
+                return ea
+        raise RuntimeError("Kepler's equation solver did not converge.")
+
+    @staticmethod
+    def kepler_equation_root_debug(e, ma, ea_guess=0.0, tolerance=1e-10, max_steps=50):
+        """
+        Alternative Method for calculating the root of the Kepler Equation from source
+        [f]: https://www.researchgate.net/publication/232203657_Orbital_Ephemerides_of_the_Sun_Moon_and_Planets, Section 8.10
+        e: eccentricity, ma: mean anomaly [rad], ea_guess: eccentric anomaly [rad]. ea_guess=ma is a good start.
+        """
+        e_deg = math.degrees(e)
+        ma_deg = math.degrees(ma)
+        ea_deg = ma_deg + e_deg * math.sin(ma)
+
+        for n in range(max_steps):
+            delta_ma = ma_deg - (ea_deg - e * math.sin(ea_deg))
+            delta_ea = delta_ma / (1 - e * math.cos(ea_deg))
+            ea_deg += delta_ea
+            if abs(delta_ea) < tolerance:
+                return math.radians(ea_deg)
+        raise RuntimeError('Solution for Kepler\'s Equation did not converge.')
+
+
+    @staticmethod
+    def gravitational_parameter(bodies, g):
+        """Calculate the gravitational parameter of masses orbiting a common barycenter
+        https://en.wikipedia.org/wiki/Standard_gravitational_parameter"""
+        mass = 0.0
+        for body in bodies:
+            mass += body.mass
+        return g * mass
+
+    @staticmethod
+    def distance_2d_ecl(body1, body2, i):
+        """Return distance of the centers of 2 physical bodies as seen by a viewer (projection y->0)."""
+        dx = body1.positions[i][0] - body2.positions[i][0]
+        dz = body1.positions[i][2] - body2.positions[i][2]
+        return math.sqrt((dx ** 2 + dz ** 2))
+
+    @staticmethod
+    def limbdarkening(relative_radius, beta):
+        """https://en.wikipedia.org/wiki/Limb_darkening
+        https://de.wikipedia.org/wiki/Photosph%C3%A4re#Mitte-Rand-Verdunkelung
+        Approximates the flux of a star at a point on the star seen from a very large distance.
+        The point's apparent distance from the star's center is relative_radius * radius.
+        Beta depends on the wavelength. Beta=2.3 is a good compromise for the spectrum of visible light."""
+        if relative_radius >= 1:
+            return 1 / (1 + beta)
+        return (1 + beta * math.sqrt(1 - relative_radius ** 2)) / (1 + beta)

curvesimulator-0.1.0/curvesimulator/curvesim.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+# Curvesim - A Star System Lightcurve Simulator
+# Curvesim calculates the movements and eclipses of celestial bodies and produces a video of this.
+# Specify mass, radius and other properties of some stars and planets in a configuration file.
+# Then run "curvesimulator.py <configfilename>" to produce the video.
+# The video shows simultanously a view of the star system from the top and from the side and
+# the lightcurve of the system's total luminosity over time.
+# Usually you do not need to look at or even modify the python code. Instead control the program's
+# outcome with the config file. The meaning of all program parameters is documented in the config file.
+# Curvesim uses ffmpeg to convert the data into a video. Download ffmpeg from https://www.ffmpeg.org/download.html.
+# Extract the zip file and add "<yourdriveandpath>\FFmpeg\bin" to Environment Variable PATH.
+#
+# Your questions and comments are welcome.
+# Just open an issue on https://github.com/lichtgestalter/curvesim/issues to get my attention :)
+import math
+
+from cs_animation import CurveSimAnimation
+from cs_bodies import CurveSimBodies
+from cs_parameters import CurveSimParameters
+
+# If you run this script in a jupyter notebook, uncomment the next 2 lines in order to provide the name of your config file.
+# import sys
+# sys.argv[1] = "provide_your_config_file_name_here.ini"
+
+
+def curvesim():
+    parameters = CurveSimParameters()  # Read program parameters from config file.
+    bodies = CurveSimBodies(parameters)  # Read physical bodies from config file and initialize them, calculate their state vectors and generate their patches for the animation
+    lightcurve = bodies.calc_physics(parameters)  # Calculate body positions and the resulting lightcurve.
+    CurveSimAnimation(parameters, bodies, lightcurve)  # Create the video
+    return parameters, bodies, lightcurve
+
+
+def debug_print_points():
+    # Just for debugging purposes, because something in the initial state vector is wrong.
+    parameters = CurveSimParameters()  # Read program parameters from config file.
+    for _L in parameters.debug_L:
+        bodies = CurveSimBodies(parameters, debug_L=_L)  # Initialize the physical bodies, calculate their state vectors and generate their patches for the animation
+        bodies[1].positions[0] /= 2273900000.0  # bodies[0] is the sun, bodies[1] is the test planet
+        bodies[1].a /= 2273900000.0  # normalize to a=100
+        myfile = "debug_file.txt"
+        with open(myfile, "a", encoding='utf-8') as file:  # encoding is important, otherwise symbols like Ω get destroyed
+            if bodies[1].L == 0:  # write headline with parameters, e.g. "a=100 e=0.90 i=90 Ω=0 ϖ=0"
+                file.write(f'a={bodies[1].a:.0f} e={bodies[1].e:.2f} i={bodies[1].i / math.pi * 180:.0f} Ω={bodies[1].Ω / math.pi * 180:.0f} ϖ={bodies[1].ϖ / math.pi * 180:.0f}\n')
+            file.write(f'L{bodies[1].L / math.pi * 180:.0f},{bodies[1].positions[0][0]:.2f},{bodies[1].positions[0][1]:.2f},{bodies[1].positions[0][2]:.2f}\n')  # write coordinates of starting position for this value of L
+    return parameters, bodies
+
+
+def main():
+    parameters, bodies, lightcurve = curvesim()
+    # parameters, bodies = debug_print_points()
+    print(parameters)
+    print(bodies)
+    # print(lightcurve)
+
+
+if __name__ == '__main__':
+    main()

curvesimulator-0.1.0/curvesimulator.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: curvesimulator
+Version: 0.1.0
+Summary: Curvesimulator calculates the movements and eclipses of celestial bodies and produces a video of this and of the resulting lightcurve.
+Home-page: https://github.com/lichtgestalter/curvesimulator
+Author: Uli Scheuss
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: configparser
+
+# curvesim
+A Star System and Lightcurve Simulator<br>
+<br>
+Curvesim produces a video of the movements and eclipses of celestial bodies and of the resulting lightcurve.<br>
+<br>
+Curvesim is fast and the videos use little disk space. A video takes about the same time to produce as its playing time and uses less than 0.5 MB disc space per minute.<br>
+<br>
+Specify mass, radius, orbital elements and other properties of some stars and planets in a configuration file.<br>
+Then run "curvesim.py <configfilename>" to produce the video.
+The video shows simultanously a view of the star system from the top and from the side and
+the lightcurve of the system's total luminosity over time.<br>
+<br>
+Usually you do not need to look at or even modify the python code. Instead control the program's
+outcome with the config file. The meaning of all program parameters is documented in the config file.<br>
+<br>
+Curvesim uses ffmpeg to convert the data into a video. <br> 
+Download ffmpeg from https://www.ffmpeg.org/download.html. <br>
+Extract the zip file and (on Windows) add "<yourdriveandpath>\FFmpeg\bin" to the environment variable PATH.<br>
+<br>
+For questions and comments just open an issue on https://github.com/lichtgestalter/curvesim/issues to get my attention :)<br>

curvesimulator-0.1.0/curvesimulator.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.py
+curvesimulator/__init__.py
+curvesimulator/cs_animation.py
+curvesimulator/cs_bodies.py
+curvesimulator/cs_body.py
+curvesimulator/cs_lightcurve.py
+curvesimulator/cs_parameters.py
+curvesimulator/cs_physics.py
+curvesimulator/curvesim.py
+curvesimulator.egg-info/PKG-INFO
+curvesimulator.egg-info/SOURCES.txt
+curvesimulator.egg-info/dependency_links.txt
+curvesimulator.egg-info/requires.txt
+curvesimulator.egg-info/top_level.txt

curvesimulator-0.1.0/curvesimulator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

curvesimulator-0.1.0/curvesimulator.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+matplotlib
+configparser

curvesimulator-0.1.0/curvesimulator.egg-info/top_level.txt

@@ -0,0 +1 @@
+curvesimulator

curvesimulator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

curvesimulator-0.1.0/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="curvesimulator",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        # List your dependencies here
+        "numpy",
+        "matplotlib",
+        "configparser",
+        # "math",
+        # "time",
+        # "sys",
+    ],
+    author="Uli Scheuss",
+    description="Curvesimulator calculates the movements and eclipses of celestial bodies and produces a video of this and of the resulting lightcurve.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/lichtgestalter/curvesimulator",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)