According to theworldmaterial.com the density of V4A stainless steel is approximately 8000 kg/m³
or 8.0 g/cm³
Physics
How to compute & plot sun path diagram using skyfield in Python
In this example, we’ll show how to generate a sun path diagram for any given day for a preselected location. By using the skyfield library, we can obtain extremely accurate predictions of the sun’s position in the sky, and in contrast to many other libraries, we can use the same method to predict the position of other celestial bodies.
#!/usr/bin/env python3 from skyfield import api from skyfield import almanac from datetime import datetime from datetime import timedelta from matplotlib import pyplot as plt import pytz import dateutil.parser from collections import namedtuple from UliEngineering.Utils.Date import * import matplotlib.ticker as mtick # Matplotlib formatter def format_degrees(value, pos=None): return f'{value:.0f} °' ts = api.load.timescale() ephem = api.load_file('de421.bsp') sun = ephem["Sun"] earth = ephem["Earth"] # Data types AltAz = namedtuple("AltAz", ["altitude", "azimuth", "distance"]) TimeAltAz = namedtuple("TimeAltAz", ["time", "altitude", "azimuth", "distance"]) def sun_altaz(planet_at_location, ts): # Compute the sun position as seen from the observer at <location> sun_pos = planet_at_location.at(ts).observe(sun).apparent() # Compute apparent altitude & azimuth for the sun's position altitude, azimuth, distance = sun_pos.altaz() return AltAz(altitude, azimuth, distance) def sun_altaz_for_day(location, year, month, day, tz): earth_at_location = (earth + location) minutes = list(yield_minutes_on_day(year=year, month=month, day=day, tz=tz)) skyfield_minutes = ts.from_datetimes(minutes) minutely_altaz = [sun_altaz(earth_at_location, ts) for ts in skyfield_minutes] # Extract components for plotting minutely_alt = [altaz.altitude.degrees for altaz in minutely_altaz] minutely_az = [altaz.azimuth.degrees for altaz in minutely_altaz] minutely_distance = [altaz.distance for altaz in minutely_altaz] return TimeAltAz(minutes, minutely_alt, minutely_az, minutely_distance) # Random location near Munich location = api.Topos('48.324777 N', '11.405610 E', elevation_m=519) # Compute Alt/Az for two different days jun = sun_altaz_for_day(location, 2022, 6, 15, pytz.timezone("Europe/Berlin")) dec = sun_altaz_for_day(location, 2022, 12, 15, pytz.timezone("Europe/Berlin")) # Plot! plt.gca().yaxis.set_major_formatter(mtick.FuncFormatter(format_degrees)) plt.gca().xaxis.set_major_formatter(mtick.FuncFormatter(format_degrees)) plt.plot(jun.azimuth, jun.altitude, label="15th of June") plt.plot(dec.azimuth, dec.altitude, label="15th of December") plt.ylim([0, None]) # Do not show sun angles below the horizon plt.ylabel("Sun altitude") plt.xlabel("Sun azimuth") plt.title("Apparent sun position at our office") plt.grid() plt.gca().legend() plt.gcf().set_size_inches(10,5) plt.savefig("Sun path.svg")
How to compute position of sun in the sky in Python using skyfield
The following code computes the position of the sun (in azimuth/altitude coordinates) in the sky using the skyfield
library. Note that you need to download de421.bsp
.
from skyfield import api from skyfield import almanac from datetime import datetime from datetime import timedelta import dateutil.parser from calendar import monthrange ts = api.load.timescale() ephem = api.load_file('de421.bsp') sun = ephem["Sun"] earth = ephem["Earth"] # Compute sunrise & sunset for random location near Munich location = api.Topos('48.324777 N', '11.405610 E', elevation_m=519) # Compute the sun position as seen from the observer at <location> sun_pos = (earth + location).at(ts.now()).observe(sun).apparent() # Compute apparent altitude & azimuth for the sun's position altitude, azimuth, distance = sun_pos.altaz() # Print results (example) print(f"Altitude: {altitude.degrees:.4f} °") print(f"Azimuth: {azimuth.degrees:.4f} °")
Example output
Altitude: -3.3121 ° Azimuth: 48.4141 °
Factors influencing the accuracy of the calculation
This way of calculating the position takes into account:
- The slight shift in position caused by light speed
- The very very slight shift in position caused by earth’s gravity
But it does not take into account:
- Atmospheric distortions shifting the sun’s position
- The extent of the sun’s disk causing the sun to emanate not from a point but apparently from an area
How to compute sunrise & sunset in Python using skyfield
The following code will compute the sunrise & sunset at a specific location & elevation using the skyfield
library. Note that you need to download de413.bsp
.
from skyfield import api from skyfield import almanac from datetime import datetime from datetime import timedelta import dateutil.parser from calendar import monthrange ts = api.load.timescale() ephem = api.load_file('de413.bsp') def compute_sunrise_sunset(location, year=2019, month=1, day=1): t0 = ts.utc(year, month, day, 0) # t1 = t0 plus one day t1 = ts.utc(t0.utc_datetime() + timedelta(days=1)) t, y = almanac.find_discrete(t0, t1, almanac.sunrise_sunset(ephem, location)) sunrise = None for time, is_sunrise in zip(t, y): if is_sunrise: sunrise = dateutil.parser.parse(time.utc_iso()) else: sunset = dateutil.parser.parse(time.utc_iso()) return sunrise, sunset # Compute sunrise & sunset for random location near Munich location = api.Topos('48.324777 N', '11.405610 E', elevation_m=519) now = datetime.now() sunrise, sunset = compute_sunrise_sunset(location, now.year, now.month, now.day) # Print result (example) print(f'Sunrise today: {sunrise}') print(f'Sunset today: {sunset}')
Definition of sunrise & sunset in this context
According to the skyfield
documentation:
Skyfield uses the same definition as the United States Naval Observatory: the Sun is up when its center is 0.8333 degrees below the horizon, which accounts for both its apparent radius of around 16 arcminutes and also for the 34 arcminutes by which atmospheric refraction on average lifts the image of the Sun.
Other caveats
- Note that obstructions like mountains are not taken into account for this model
- Note that the resulting timestamps are UTC, if you want local time, you’ll have to convert them appropriately
Example output:
Sunrise today: 2022-06-19 03:12:56+00:00 Sunset today: 2022-06-19 19:18:38+00:00
FR4 PCB thermal expansion online calculator
Calculate the thermal expansion in millimeters (mm) of a FR4 PCB in X/Y direction. A typical temperature difference default is 65°C
, the difference between 20°C
room temperature and the max temperature rating of 85°C
parts. The default 13ppm/°C
thermal expansion coefficient is from this website.
You can enter values with SI suffixes like 12.2m (equivalent to 0.012) or 14k (14000) or 32u (0.000032).
The results are calculated while you type and shown directly below the calculator, so there is no need to press return or click on a Calculate button. Just make sure that all inputs are green by entering valid values.
Lumen to Candela online calculator & Python code
You can enter values with SI suffixes like 12.2m (equivalent to 0.012) or 14k (14000) or 32u (0.000032).
The results are calculated while you type and shown directly below the calculator, so there is no need to press return or click on a Calculate button. Just make sure that all inputs are green by entering valid values.
Formula
\Omega_{sr} = 2\cdot\pi\cdot(1-\cos(\frac{\theta}{2}))
I_{v} = \frac{\Phi_v}{\Omega_{sr}}
where:
- \theta is the apex angle in radians
- \Omega_{sr} is the solid angle in Steradians
- \Phi_v is the luminous flux in lux (lx).
- I_{v} is the luminous intensity in candela (cd).
Python code
You can use the UliEngineering library like this:
from UliEngineering.Physics.Light import lumen_to_candela_by_apex_angle from UliEngineering.EngineerIO import auto_format, auto_print # These are equivalent: intensity = lumen_to_candela_by_apex_angle("25 lm", "120°") # intensity = 7.9577 (cd) intensity = lumen_to_candela_by_apex_angle(25.0, 120.0) # intensity = 7.9577 (cd) # ... or get out a human-readable value: intensity_str = auto_format(lumen_to_candela_by_apex_angle, "25 lm", "120°") # "7.96 cd" # ... or print directly auto_print(lumen_to_candela_by_apex_angle, "25 lm", "120°") # prints "7.96 cd"
In case you can’t use UliEngineering, use this Python function:
import math def lumen_to_candela_by_apex_angle(flux, angle): """ Compute the luminous intensity from the luminous flux, assuming that the flux of <flux> is distributed equally around a cone with apex angle <angle>. Keyword parameters ------------------ flux : value, engineer string or NumPy array The luminous flux in Lux. angle : value, engineer string or NumPy array The apex angle of the emission cone, in degrees For many LEDs, this is >>> lumen_to_candela_by_apex_angle(25., 120.) 7.957747154594769 """ solid_angle = 2*math.pi*(1.-math.cos((angle*math.pi/180.)/2.0)) return flux / solid_angle # Usage example print(lumen_to_candela_by_apex_angle(25., 120.)) # Prints 7.957747154594769 (cd)