Add individual intensities

benchmarks/run_stardis.py

@@ -98,7 +98,6 @@ def time_raytrace(self):
         raytrace(
             self.stellar_model,
             self.stellar_radiation_field,
-            no_of_thetas=self.config.no_of_thetas,
         )
 
     def time_calc_alpha_line_at_nu(self):
@@ -209,7 +208,6 @@ def time_raytrace(self):
         raytrace(
             self.stellar_model,
             self.stellar_radiation_field,
-            no_of_thetas=self.config.no_of_thetas,
         )
 
     def time_calc_alpha_line_at_nu(self):

stardis/conftest.py

@@ -190,7 +190,10 @@ def example_stellar_radiation_field(
     example_stellar_model, example_config, example_tracing_nus, example_stellar_plasma
 ):
     stellar_radiation_field = RadiationField(
-        example_tracing_nus, blackbody_flux_at_nu, example_stellar_model
+        example_tracing_nus,
+        blackbody_flux_at_nu,
+        example_stellar_model,
+        example_config.no_of_thetas,
     )
 
     calc_alphas(
@@ -203,7 +206,6 @@ def example_stellar_radiation_field(
     raytrace(
         example_stellar_model,
         stellar_radiation_field,
-        no_of_thetas=example_config.no_of_thetas,
     )
     return stellar_radiation_field
 
@@ -216,7 +218,10 @@ def example_stellar_radiation_field_broadening(
     example_stellar_plasma_broadening,
 ):
     stellar_radiation_field = RadiationField(
-        example_tracing_nus, blackbody_flux_at_nu, example_stellar_model
+        example_tracing_nus,
+        blackbody_flux_at_nu,
+        example_stellar_model,
+        example_config_broadening.no_of_thetas,
     )
 
     calc_alphas(
@@ -229,7 +234,6 @@ def example_stellar_radiation_field_broadening(
     raytrace(
         example_stellar_model,
         stellar_radiation_field,
-        no_of_thetas=example_config_broadening.no_of_thetas,
     )
     return stellar_radiation_field
 
@@ -242,7 +246,10 @@ def example_stellar_radiation_field_parallel(
     example_stellar_plasma_broadening,
 ):
     stellar_radiation_field = RadiationField(
-        example_tracing_nus, blackbody_flux_at_nu, example_stellar_model
+        example_tracing_nus,
+        blackbody_flux_at_nu,
+        example_stellar_model,
+        example_config_parallel.no_of_thetas,
     )
 
     calc_alphas(
@@ -255,7 +262,6 @@ def example_stellar_radiation_field_parallel(
     raytrace(
         example_stellar_model,
         stellar_radiation_field,
-        no_of_thetas=example_config_parallel.no_of_thetas,
         n_threads=example_config_parallel.n_threads,
     )
     return stellar_radiation_field

stardis/io/base.py

@@ -70,7 +70,8 @@ def parse_config_to_model(config_fname, add_config_dict):
     logger.info("Reading model")
     if config.model.type == "marcs":
         raw_marcs_model = read_marcs_model(
-            Path(config.model.fname), gzipped=config.model.gzipped
+            Path(config.model.fname),
+            gzipped=config.model.gzipped,
         )
         stellar_model = raw_marcs_model.to_stellar_model(
             adata, final_atomic_number=config.model.final_atomic_number

stardis/io/model/marcs.py

@@ -10,6 +10,12 @@
 from stardis.model.geometry.radial1d import Radial1DGeometry
 from stardis.model.base import StellarModel
 from tardis.model.matter.composition import Composition
+from stardis.io.model.marcs_regex_patterns import (
+    METADATA_PLANE_PARALLEL_RE_STR,
+    METADATA_SPHERICAL_RE_STR,
+)
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -22,6 +28,7 @@ class MARCSModel(object):
 
     metadata: dict
     data: pd.DataFrame
+    spherical: bool
 
     def to_geometry(self):
         """
@@ -31,10 +38,15 @@ def to_geometry(self):
         -------
         stardis.model.geometry.radial1d.Radial1DGeometry
         """
+
+        reference_r = None
         r = (
             -self.data.depth.values[::-1] * u.cm
         )  # Flip data to move from innermost stellar point to surface
-        return Radial1DGeometry(r)
+        if self.spherical:
+            r += self.metadata["radius"]
+            reference_r = self.metadata["radius"]
+        return Radial1DGeometry(r, reference_r)
 
     def to_composition(self, atom_data, final_atomic_number):
         """
@@ -147,6 +159,7 @@ def to_stellar_model(self, atom_data, final_atomic_number=118):
             temperatures,
             marcs_geometry,
             marcs_composition,
+            spherical=self.spherical,
             microturbulence=self.metadata["microturbulence"],
         )
 
@@ -163,64 +176,16 @@ def read_marcs_metadata(fpath, gzipped=True):
             Path to model file
     gzipped : Bool
             Whether or not the file is gzipped
+    spherical : Bool
+            Whether or not the model is spherical
 
     Returns
     -------
     dict : dictionary
             metadata parameters of file
     """
-
-    METADATA_RE_STR = [
-        (r"(.+)\n", "fname"),
-        (
-            r"  (\d+\.)\s+Teff \[(.+)\]\.\s+Last iteration; yyyymmdd=\d+",
-            "teff",
-            "teff_units",
-        ),
-        (r"  (\d+\.\d+E\+\d+) Flux \[(.+)\]", "flux", "flux_units"),
-        (
-            r"  (\d+.\d+E\+\d+) Surface gravity \[(.+)\]",
-            "surface_grav",
-            "surface_grav_units",
-        ),
-        (
-            r"  (\d+\.\d+)\W+Microturbulence parameter \[(.+)\]",
-            "microturbulence",
-            "microturbulence_units",
-        ),
-        (r"  (\d+\.\d+)\s+(No mass for plane-parallel models)", "plane_parallel_mass"),
-        (
-            r" (\+?\-?\d+.\d+) (\+?\-?\d+.\d+) Metallicity \[Fe\/H] and \[alpha\/Fe\]",
-            "feh",
-            "afe",
-        ),
-        (
-            r"  (\d+\.\d+E\+00) (1 cm radius for plane-parallel models)",
-            "radius for plane-parallel model",
-        ),
-        (r"  (\d.\d+E-\d+) Luminosity \[(.+)\]", "luminosity", "luminosity_units"),
-        (
-            r"  (\d+.\d+) (\d+.\d+) (\d+.\d+) (\d+.\d+) are the convection parameters: alpha, nu, y and beta",
-            "conv_alpha",
-            "conv_nu",
-            "conv_y",
-            "conv_beta",
-        ),
-        (
-            r"  (0.\d+) (0.\d+) (\d.\d+E-\d+) are X, Y and Z, 12C\/13C=(\d+.?\d+)",
-            "x",
-            "y",
-            "z",
-            "12C/13C",
-        ),
-    ]
     BYTES_THROUGH_METADATA = 550
 
-    # Compile each of the regex pattern strings then open the file and match each of the patterns by line.
-    # Then add each of the matched patterns as a key:value pair to the metadata dict.
-    metadata_re = [re.compile(re_str[0]) for re_str in METADATA_RE_STR]
-    metadata = {}
-
     if gzipped:
         with gzip.open(fpath, "rt") as file:
             contents = file.readlines(BYTES_THROUGH_METADATA)
@@ -231,10 +196,29 @@ def read_marcs_metadata(fpath, gzipped=True):
 
     lines = list(contents)
 
-    for i, line in enumerate(lines):
-        metadata_re_match = metadata_re[i].match(line)
+    # Compile each of the regex pattern strings then open the file and match each of the patterns by line.
+    # Then add each of the matched patterns as a key:value pair to the metadata dict.
+    # Files are formatted a little differently depending on if the MARCS model is spherical or plane-parallel
+    if "plane-parallel" in lines[5]:
+        logger.info("Plane-parallel model detected.")
+        spherical = False
+        metadata_re = [
+            re.compile(re_str[0]) for re_str in METADATA_PLANE_PARALLEL_RE_STR
+        ]
+        metadata_re_str = METADATA_PLANE_PARALLEL_RE_STR
+    else:
+        logger.info("Spherical model detected.")
+        spherical = True
+        metadata_re = [re.compile(re_str[0]) for re_str in METADATA_SPHERICAL_RE_STR]
+        metadata_re_str = METADATA_SPHERICAL_RE_STR
 
-        for j, metadata_name in enumerate(METADATA_RE_STR[i][1:]):
+    metadata = {}
+
+    # Check each line against the regex patterns and add the matched values to the metadata dictionary
+    for i in range(len(metadata_re_str)):
+        line = lines[i]
+        metadata_re_match = metadata_re[i].match(line)
+        for j, metadata_name in enumerate(metadata_re_str[i][1:]):
             metadata[metadata_name] = metadata_re_match.group(j + 1)
 
     # clean up metadata dictionary by changing strings of numbers to floats and attaching parsed units where appropriate
@@ -248,7 +232,7 @@ def read_marcs_metadata(fpath, gzipped=True):
             metadata[key] = float(metadata[key])
     metadata = {key: metadata[key] for key in metadata if key not in keys_to_remove}
 
-    return metadata
+    return metadata, spherical
 
 
 def read_marcs_data(fpath, gzipped=True):
@@ -328,13 +312,20 @@ def read_marcs_model(fpath, gzipped=True):
             Path to model file
     gzipped : Bool
             Whether or not the file is gzipped
+    spherical : Bool
+            Whether or not the model is spherical
 
     Returns
     -------
     model : MARCSModel
         Assembled metadata and data pair of a MARCS model
     """
-    metadata = read_marcs_metadata(fpath, gzipped=gzipped)
+    try:
+        metadata, spherical = read_marcs_metadata(fpath, gzipped=gzipped)
+    except:
+        raise ValueError(
+            "Failed to read metadata from MARCS model file. Make sure that you are specifying if the file is gzipped appropriately."
+        )
     data = read_marcs_data(fpath, gzipped=gzipped)
 
-    return MARCSModel(metadata, data)
+    return MARCSModel(metadata, data, spherical=spherical)

stardis/io/model/marcs_regex_patterns.py

@@ -0,0 +1,98 @@
+METADATA_PLANE_PARALLEL_RE_STR = [
+    (r"(.+)\n", "fname"),
+    (
+        r"  (\d+\.)\s+Teff \[(.+)\]\.\s+Last iteration; yyyymmdd=\d+",
+        "teff",
+        "teff_units",
+    ),
+    (r"  (\d+\.\d+E\+\d+) Flux \[(.+)\]", "flux", "flux_units"),
+    (
+        r"  (\d+.\d+E\+\d+) Surface gravity \[(.+)\]",
+        "surface_grav",
+        "surface_grav_units",
+    ),
+    (
+        r"  (\d+\.\d+)\W+Microturbulence parameter \[(.+)\]",
+        "microturbulence",
+        "microturbulence_units",
+    ),
+    (r"  (\d+\.\d+)\s+(No mass for plane-parallel models)", "plane_parallel_mass"),
+    (
+        r" (\+?\-?\d+.\d+) (\+?\-?\d+.\d+) Metallicity \[Fe\/H] and \[alpha\/Fe\]",
+        "feh",
+        "afe",
+    ),
+    (
+        r"  (\d+\.\d+E\+00) (1 cm radius for plane-parallel models)",
+        "radius for plane-parallel model",
+    ),
+    (r"  (\d.\d+E-\d+) Luminosity \[(.+)\]", "luminosity", "luminosity_units"),
+    (
+        r"  (\d+.\d+) (\d+.\d+) (\d+.\d+) (\d+.\d+) are the convection parameters: alpha, nu, y and beta",
+        "conv_alpha",
+        "conv_nu",
+        "conv_y",
+        "conv_beta",
+    ),
+    (
+        r"  (0.\d+) (0.\d+) (\d.\d+E-\d+) are X, Y and Z, 12C\/13C=(\d+.?\d+)",
+        "x",
+        "y",
+        "z",
+        "12C/13C",
+    ),
+]
+
+METADATA_SPHERICAL_RE_STR = [
+    (r"(.+)\n", "fname"),
+    (
+        r"  (\d+\.)\s+Teff \[(.+)\]\.\s+Last iteration; yyyymmdd=\d+",
+        "teff",
+        "teff_units",
+    ),
+    (r"  (\d+\.\d+E\+\d+) Flux \[(.+)\]", "flux", "flux_units"),
+    (
+        r"  (\d+.\d+E\+\d+) Surface gravity \[(.+)\]",
+        "surface_grav",
+        "surface_grav_units",
+    ),
+    (
+        r"  (\d+\.\d+)\W+Microturbulence parameter \[(.+)\]",
+        "microturbulence",
+        "microturbulence_units",
+    ),
+    (
+        r"\s+(\d+\.\d+)\s+Mass \[(.+)\]",
+        "mass",
+        "mass_units",
+    ),
+    (
+        r" (\+?\-?\d+.\d+) (\+?\-?\d+.\d+) Metallicity \[Fe\/H] and \[alpha\/Fe\]",
+        "feh",
+        "afe",
+    ),
+    (
+        r"  (\d+.\d+E\+\d\d) Radius \[(.+)\] at Tau",
+        "radius",
+        "radius_units",
+    ),
+    (
+        r"\s+(\d+\.\d+(?:E[+-]?\d+)?) Luminosity \[(.+)\]",
+        "luminosity",
+        "luminosity_units",
+    ),
+    (
+        r"  (\d+.\d+) (\d+.\d+) (\d+.\d+) (\d+.\d+) are the convection parameters: alpha, nu, y and beta",
+        "conv_alpha",
+        "conv_nu",
+        "conv_y",
+        "conv_beta",
+    ),
+    (
+        r"  (0.\d+) (0.\d+) (\d.\d+E-\d+) are X, Y and Z, 12C\/13C=(\d+.?\d+)",
+        "x",
+        "y",
+        "z",
+        "12C/13C",
+    ),
+]

stardis/model/base.py

@@ -21,16 +21,21 @@ class StellarModel(HDFWriterMixin):
         Composition of the model. Includes density and atomic mass fractions.
     no_of_depth_points : int
         Class attribute to be easily accessible for initializing arrays that need to match the shape of the model.
+    spherical : bool
+        Flag for spherical geometry.
     microturbulence : float
         Microturbulence in km/s.
     """
 
     hdf_properties = ["temperatures", "geometry", "composition"]
 
-    def __init__(self, temperatures, geometry, composition, microturbulence=0.0):
+    def __init__(
+        self, temperatures, geometry, composition, spherical=False, microturbulence=0.0
+    ):
         self.temperatures = temperatures
         self.geometry = geometry
         self.composition = composition
+        self.spherical = spherical
         self.microturbulence = microturbulence
 
     @property

stardis/model/geometry/radial1d.py

@@ -14,8 +14,9 @@ class Radial1DGeometry:
         distance to the next depth point
     """
 
-    def __init__(self, r):
+    def __init__(self, r, reference_r=None):
         self.r = r
+        self.reference_r = reference_r
 
     @property
     def dist_to_next_depth_point(self):