Interesting question. Assuming the figure of 10 million stars per cubic parsec is correct, there's still one missing piece of information to try getting a estimate: The size of this region with a very high concentration of stars. But at least we know it can't go very far, because at such densities (d), it would take a sphere with radius r = (3 *10^11 / 4 * pi * d)^(1/3) ~= 6.2 parsecs to hold about 100 billion stars, on the order of the actual number of stars in the entire galaxy. So I will guess this region of high star density (r) holds only about 1% of that, corresponding to a radius of (3 *10^9 / 4 * pi * d)^(1/3) ~= 1.34 parsecs.
To get a estimate of the brightness of the sky near the galactic center, I coded a simulation using Pharo 10 (a Smalltalk dialect):
This simulation just populates a spherical region of space randomly with points representing stars, assigning each of then a power output following the distribution of known stars near the solar system. Then it sums the luminance component of each star above a plane that passes through the center, and perpendicular to it. This is done 10 times and the average is taken, to average out the effect of a particular run where by chance we get a star very close to the center point, where we assume the planet of the observer is located. This estimate makes some assumptions:
- Stars near the core are randomly distributed in every direction;
- Stars don't obstruct each other. Probably mostly true, as the size of the stars is very small, when compared to the distances that separates them;
- The radiation has a path mostly free of dust, doubtful when talking about the Milkyway core;
- Luminance (total W/m^2) is a good proxy for what you would actually see with your eyes. Probably not that realistic, as stars different of the sun radiate a lot of the energy outside the visible spectrum, as ultraviolet or infrared;
- We can take the known stars near the solar system as a representative sample of those near the galactic core. That's doubtful, as there's probably lots of still undiscovered brown and red dwarfs near us, and the near earth sample doesn't contain some kinds of stars that are surely present at the galact center, like red giants, outside the main sequence.
Given those disclaimer, here is the code for the simulation, as executed in Pharo's playground:
| sunPowerOutput au moonAverageDistance moonRadius moonAlbedo sun radii t0 |
sunPowerOutput := 3.828e26. "In W/m^2"
au := 1.5e11. "In meters"
moonAverageDistance := 3.844e8. "In meters"
moonRadius := 1.7374e6. "In meters"
moonAlbedo := 0.1. "Dimensionless"
radii := #( 0.1675 0.335 0.67 1.34 ). "In parsecs"
sun := CelestialBody
withX: 0
withY: 0
withZ: 0
withPower: sunPowerOutput.
Transcript
clear;
show: 'Solar constant estimate (W/m^2): ';
show: (sun fluxDensity: au);
cr.
moon := CelestialBody
withX: 0
withY: 0
withZ: 0
withPower:
moonAlbedo * (sun fluxDensity: au) * Float pi
* moonRadius squared.
Transcript
show: 'Lunar constant estimate (W/m^2): ';
show: (moon fluxDensity: moonAverageDistance);
cr.
Transcript
show: 'Stellar constant estimate (W/m^2): ';
show:
(GalaxyCore withRadius: 150 withDensity: 0.14) centerPowerDensity;
cr.
Transcript
show: 'Radius';
show: ';';
show: 'W/m^2';
cr.
t0 := DateAndTime now.
radii do: [ :radius |
Transcript
show: radius;
show: ';';
show: (((1 to: 10) collect: [ :each |
(GalaxyCore withRadius: radius withDensity: 1e7)
centerPowerDensity ]) average round: 4);
cr ].
Transcript
show: 'Done in '
,
(((DateAndTime now - t0) asMilliSeconds / 1000) round: 2) asFloat asString
, ' seconds';
cr
The results, as printed to Pharo's transcript, are as follows:
Solar constant estimate (W/m^2): 1353.8780492350566
Lunar constant estimate (W/m^2): 0.0006914367075657645
Stellar constant estimate (W/m^2): 6.816259502147244e-7
Radius;W/m^2
0.1675;0.0649
0.335;0.1195
0.67;0.2405
1.34;0.4689
Done in 577.24 seconds
For comparison, initially I tried to get estimates for the solar constant at Earth orbit starting from the power output of the Sun, getting the estimate of about 1353.88 W/m²; for the full moon constant on the surface of Earth, assuming the Moon reflects 10% of the received solar radiation, getting the estimate of about 0.0007 W/m² (a little short of a milliwatt/m²); and for the stellar constant at the solar system position in the galaxy, assuming that the estimated stellar density of 0.14 stars/parsec³ in the neighborhood of the solar system extends uniformly into a spherical region with diameter about the thickness of the galactic disk, 300 parsecs, getting the estimate of about 6.8e-7 W/m² (a little short of a microwatt/m²).
With those values for context, I ran the simulation for the density informed by the question asker (10⁷ stars/ parsec³), the guessed radius for the high density core region (1.34 parsecs), and also for submultiples of this radius (r/2, r/8 and r/16), so we can have a idea of how the luminance values scale with radius.
The result, for r = 1.34 parsecs is close to half a watt/m², and the scaling with the radius of the region is nearly linear, with a rate of 0.35 W/m² for every parsec. The linear scaling makes sense, when we think about it, as when the size of the region increases, the average power received from each star decreases by r², but their number increases with volume, and so with r³, so the total amount increases proportinonal to r³/r² = r.
The value close to half a watt/m² we got for for a core region with radius of 1.34 parsecs is close to a thousand times the estimate we got for the full moon, spread across the entire sky. So I think the night sky of our putative planet in the core region of the galaxy would resemble our sky at late dusk, but with a much larger number of bright stars spread across the sky, surrounded by the diffuse light of more distant / less luminous stars.
About your question if we would be unable to resolve individual stars, we can try to get a upper bound estimate similar to the one in the answer I gave in this question: How many stars can we resolve?, but instead of using the resolution of the James Webb Space Telescope, we must plug the angular resolution of the naked eye, about 1 arcminute, or 60 arcseconds:
| resolution starsAtEquator starsInHemisphere |
Transcript clear.
resolution := 60. "Resolution in arc-seconds"
starsAtEquator := 360 * 60 * 60 / resolution.
starsInHemisphere := ((0 to: starsAtEquator // 4) collect: [ :each |
(each * Float pi / (starsAtEquator // 2)) cos
* starsAtEquator round: 0 ]) sum.
Transcript
show: 'Stars in whole celestial sphere: ';
show: 2 * starsInHemisphere
The upper-bound estimate we get is:
Stars in whole celestial sphere: 1.48532234e8
So, with the resolution of the naked eye, we can't resolve more than about 150 million individual stars in the whole sky, even if their combined luminous output it's not enough to awash the fainter ones.
I think you can get better estimates than mine, if you tweak the simulation to use a more realistic mass distribution function, probably some kind of continuous power law. I just picked randomly mass values from the stars near the solar system. But that doesn't account for stars with masses lower than the minimum in our solar neighborhood, and specially higher than the maximum. As the power output of stars scales with mass^3.5, by ignoring massive stars I may have incurred in large errors, in my estimate, as massive stars have a disproportional share of the radiation produced. Also it would be good to tweak the simulation to take into account luminous intensity instead of irradiance, to take into account only radiation actually visible to the human eye, not total radiation.
In the main code section shown above, the heavy lifting of the simulation is done by objects from two classes, CelestialBody and GalaxyCore. To ensure replicability, I did a File Out of the package containing the two classes, and copied the contents of the file below. So, if people want to verify the logic, or implementation details, or run it themselves, the contents can be copied to a .st textfile and then the package loaded into a Pharo image:
Object subclass: #CelestialBody
instanceVariableNames: 'x y z powerOutput'
classVariableNames: ''
package: 'MyAstroSimulation'!
!CelestialBody commentStamp: 'KS 6/24/2022 20:19' prior: 0!
I represent a point-like celestial body.
I hold the coordinates for the 3D position of a celestial body, and a luminance value. I can calculate the distance to another CelestialBody object, the flux density at a given distance, for bodies with nonzero power output values.
I collaborate with objects in the CelestialBody class, comprising their star-populations.
Public API and Key Messages
- distanceTo: anotherCelestialBody
- fluxDensity: givenDistance
- New instances can be created by specifying coordinates and power output values: CelestialBody withX: aFloat withY: aFloat2 withZ: aFloat3 withPower: aNumber
Internal Representation and Key Implementation Points.
Instance Variables
powerOutput: Float
x: Float
y: Float
z: Float
!
!CelestialBody methodsFor: 'initialization' stamp: 'KS 6/6/2022 19:57'!
initialize
"Initializes attributes of a newly created instance, without arguments. Defaults to 0"
"scope: x, y, z, powerOutput"
x := 0.
y := 0.
z := 0.
powerOutput := 0
! !
!CelestialBody methodsFor: 'distance functions' stamp: 'KS 6/11/2022 23:27'!
distanceTo: anotherBody
"Calculates distance between two point-like celestial objects"
"scope: x, y, z"
^ ((x - anotherBody x) squared + (y - anotherBody y) squared
+ (z - anotherBody z) squared) sqrt! !
!CelestialBody methodsFor: 'properties' stamp: 'KS 6/11/2022 23:27'!
fluxDensity: aRadius
"Calculates flux density (W/m^2) at distance aRadius from point-like source, using
inverse-square law."
"scope: powerOutput"
^ powerOutput / (4 * Float pi * aRadius squared)! !
!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:02'!
z
"Gets the Z cordinate"
"scope: z"
^ z! !
!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 19:59'!
x
"Gets the X cordinate"
"scope: x"
^ x! !
!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:00'!
y
"Gets the Y cordinate"
"scope: y"
^ y! !
!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:00'!
x: aFloat
"Sets the X cordinate"
"scope: x"
x := aFloat! !
!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:02'!
y: aFloat
"Sets the Y cordinate"
"scope: y"
y := aFloat! !
!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:07'!
powerOutput: aFloat
"Sets the total power output of the celestial body"
"scope: powerOutput"
powerOutput := aFloat! !
!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:07'!
z: aFloat
"Sets the Z cordinate"
"scope: z"
z := aFloat! !
"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!
CelestialBody class
instanceVariableNames: ''!
!CelestialBody class methodsFor: 'instance creation' stamp: 'KS 6/24/2022 18:47'!
withX: aFloat withY: aFloat2 withZ: aFloat3 withPower: aNumber
"Creates new instance of CelestialBody, with given coordinates and power output value."
"scope: x, y, z, powerOutput"
^ self new
x: aFloat;
y: aFloat2;
z: aFloat3;
powerOutput: aNumber! !
Object subclass: #GalaxyCore
instanceVariableNames: 'radius density volume massDistributionSample population randomCoordinate centerPlanet'
classVariableNames: ''
package: 'MyAstroSimulation'!
!GalaxyCore commentStamp: 'KS 6/24/2022 20:23' prior: 0!
I represent a spherical region in a galaxy.
I create and represent a simulated population of stars, distributed randomly within a spherical region of space. Over this region I can sum the contributions of individual stars to get the cross-sectional power density at a putative planet in the center of the spherical region. I have a random number generator to help populate the sphere, and I know the radius of this region, its star-density and a list of values that represents the mass distribution of stars.
I colaborate with the CelestialBody class, to create stars, to calculate the flux density at a given distance from them, and to calculate distances between them.
Public API and Key Messages
- centerPowerDensity
- Instances are created by specyfying radius and star density: GalaxyCore withRadius: aFloat1 withDensity: aFloat2
Internal Representation and Key Implementation Points.
Instance Variables
centerPlanet: CelestialBody
density: Float
massDistributionSample: Array
population: OrderedCollection
radius: Float
randomCoordinate: Random
volume: Float
Note that the way the class is structured, the objects are meant to have properties fixed at creation, and kept unchanged afterwards. The class doesn't ensure mutual consistency between attributes. For example, if volume is changed after creation, it will become inconsistent with radius.!
!GalaxyCore methodsFor: 'initialization' stamp: 'KS 6/24/2022 18:10'!
initialize
"Initializes the values of a newly created GalaxyCore with default values, when no arguments
are given. massDistributionSample values are taken from the list of all known stars, brown dwarfs, and sub-brown dwarfs within 5.0 parsecs (16.3 light-years) of the Solar System, as contained in
https://en.wikipedia.org/wiki/List_of_nearest_stars_and_brown_dwarfs (when a interval was given,
instead of point estimates, the average between upper and lower bound was used)."
"scope: centerPlanet, radius, density, volume, massDistributionSample, randomCoordinate,
population"
centerPlanet := CelestialBody new.
radius := 0.
density := 0.
volume := 0.
massDistributionSample := #( 2.063 1.499 1.079 1.018 1 0.909 0.82
0.81 0.783 0.754 0.75 0.7 0.67 0.67 0.63
0.602 0.6 0.486 0.48 0.465 0.45 0.401
0.39 0.38 0.37 0.35 0.334 0.294 0.281
0.271 0.26 0.248 0.223 0.176 0.17 0.168
0.15 0.144 0.143 0.14 0.136 0.131 0.13
0.122 0.113 0.111 0.11 0.11 0.11 0.11
0.11 0.102 0.1 0.1 0.1 0.1 0.09 0.09
0.08 0.08 0.08 0.07 0.07 0.065 0.05 0.045
0.032 0.03 0.027 0.0175 0.0065 ).
randomCoordinate := Random new.
population := OrderedCollection new.! !
!GalaxyCore methodsFor: 'instance initialization' stamp: 'KS 6/24/2022 12:52'!
populateOctant
"Creates a population of stars, to represent the core. To speed up the calculations, the population holds a single octant-worth of stars. As the sphere is a highly symmetrical solid,
the contribution calculated for this single octant can be multiplied by 8 to get corresponding
values to the whole sphere, or by 4 in case of a hemisphere. The stars are randomly placed in
a cube, and those farther than the core radius are rejected, to get a octant from the star-cube."
"scope: population, density, volume, radius, centerPlanet, randomCoordinate"
| parsec2meters |
parsec2meters := 3.0857e16.
[ population size < (density * volume / 8) rounded ] whileTrue: [
| star |
star := CelestialBody
withX: radius * parsec2meters * randomCoordinate next
withY: radius * parsec2meters * randomCoordinate next
withZ: radius * parsec2meters * randomCoordinate next
withPower: self powerDistribution.
(star distanceTo: centerPlanet) <= (radius * parsec2meters) ifTrue: [
population add: star ] ]! !
!GalaxyCore methodsFor: 'accessing' stamp: 'KS 6/11/2022 23:45'!
density: aFloat
"sets the star density in the galaxy core region (stars/parsec^3)"
"scope: density"
density := aFloat! !
!GalaxyCore methodsFor: 'accessing' stamp: 'KS 6/12/2022 00:37'!
radius: aFloat
"Sets the value for the core radius, in parsecs"
"scope: radius"
radius := aFloat! !
!GalaxyCore methodsFor: 'accessing' stamp: 'KS 6/12/2022 00:38'!
volume: aFloat
"Sets the volume of the core"
"scope: volume"
volume := aFloat! !
!GalaxyCore methodsFor: 'auxiliar' stamp: 'KS 6/24/2022 12:52'!
powerDistribution
"Picks a random value from massDistributionSample, calculates the corresponding power output
(luminosity, see https://en.wikipedia.org/wiki/Luminosity) from this mass and the reference
value for the sun, and returns the result."
"scope: massDistributionSample"
| mass |
mass := massDistributionSample atRandom.
^ 3.828e26 * (mass raisedTo: 3.5)! !
!GalaxyCore methodsFor: 'auxiliar' stamp: 'KS 6/24/2022 16:15'!
centerPowerDensity
"Takes every star from the galaxy core population, calculates its flux density at the center point of the core, takes its vertical component ( star z / (star distanceTo: centerPlanet)
equals the sine of the angle equator-center-star) and then sums the results for every star.
As population corresponds to a single octant of the core, multiplies the result by 4, to
represent the flux from the celestial hemisphere visible at a point in the surface of a
putative planet (represented by centerPlanet)."
"scope: population, centerPlanet"
^ 4 * (population collect: [ :star |
(star fluxDensity: (star distanceTo: centerPlanet)) * star z
/ (star distanceTo: centerPlanet) ]) sum! !
"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!
GalaxyCore class
instanceVariableNames: ''!
!GalaxyCore class methodsFor: 'instance creation' stamp: 'KS 6/24/2022 20:00'!
withRadius: aFloat1 withDensity: aFloat2
"Creates new GalaxyCore object with given radius and density."
"scope: radius, density, volume"
^ self new
radius: aFloat1;
density: aFloat2;
volume: (4 / 3) * Float pi * (aFloat1 raisedTo: 3);
populateOctant! !
