diff --git a/.gitignore b/.gitignore
index e4aac3a..bd9ed0b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,9 +7,11 @@ __pycache__/
 
 # Python
 response_tools_py.egg-info/
+build/
 
 # data directories
 response-information/attenuation-data/
 response-information/detector-response-data/
 response-information/effective-area-data/
-response-information/quantum-efficiency-data/
\ No newline at end of file
+response-information/quantum-efficiency-data/
+response-information/atmospheric-data/
\ No newline at end of file
diff --git a/assets/response-tools-py-figs/att-figs/atmospheric-transmissions.png b/assets/response-tools-py-figs/att-figs/atmospheric-transmissions.png
new file mode 100644
index 0000000..34bbeea
Binary files /dev/null and b/assets/response-tools-py-figs/att-figs/atmospheric-transmissions.png differ
diff --git a/assets/response-tools-py-figs/att-figs/model-transmissions.png b/assets/response-tools-py-figs/att-figs/model-transmissions.png
index bda1fce..094ca29 100644
Binary files a/assets/response-tools-py-figs/att-figs/model-transmissions.png and b/assets/response-tools-py-figs/att-figs/model-transmissions.png differ
diff --git a/assets/response-tools-py-figs/att-figs/transmissions.png b/assets/response-tools-py-figs/att-figs/transmissions.png
index 8970b3e..136abee 100644
Binary files a/assets/response-tools-py-figs/att-figs/transmissions.png and b/assets/response-tools-py-figs/att-figs/transmissions.png differ
diff --git a/assets/response-tools-py-figs/det-resp-figs/cdte-response-matrix.png b/assets/response-tools-py-figs/det-resp-figs/cdte-response-matrix.png
index a350328..20007c5 100644
Binary files a/assets/response-tools-py-figs/det-resp-figs/cdte-response-matrix.png and b/assets/response-tools-py-figs/det-resp-figs/cdte-response-matrix.png differ
diff --git a/assets/response-tools-py-figs/det-resp-figs/cmos-response-matrices.png b/assets/response-tools-py-figs/det-resp-figs/cmos-response-matrices.png
index a7a2cbf..871acc4 100644
Binary files a/assets/response-tools-py-figs/det-resp-figs/cmos-response-matrices.png and b/assets/response-tools-py-figs/det-resp-figs/cmos-response-matrices.png differ
diff --git a/assets/response-tools-py-figs/response-figs/response-chain.png b/assets/response-tools-py-figs/response-figs/response-chain.png
new file mode 100644
index 0000000..8650292
Binary files /dev/null and b/assets/response-tools-py-figs/response-figs/response-chain.png differ
diff --git a/assets/response-tools-py-figs/response-figs/response-hit-combinations.png b/assets/response-tools-py-figs/response-figs/response-hit-combinations.png
new file mode 100644
index 0000000..fa187a8
Binary files /dev/null and b/assets/response-tools-py-figs/response-figs/response-hit-combinations.png differ
diff --git a/response-information/atmospheric-data/README.md b/response-information/atmospheric-data/README.md
new file mode 100644
index 0000000..9775858
--- /dev/null
+++ b/response-information/atmospheric-data/README.md
@@ -0,0 +1,3 @@
+# Detector quantum efficiency data files
+
+Only really here so this folder is tracked by `git`.
diff --git a/response-tools-py/examples/README.md b/response-tools-py/examples/README.md
index 91fcd85..82e351f 100644
--- a/response-tools-py/examples/README.md
+++ b/response-tools-py/examples/README.md
@@ -1,3 +1,13 @@
 # `response-tools-py` Examples
 
 This module contains functions to handle the visualization of the various response data products.
+
+## 1. Data handling examples
+
+- [using_the_functions.py](./functions_and_outputs.py)
+  - Shows how to use the functions and their outputs in the package.
+
+## 2. Plotting examples
+
+- [plot_arf_rmf_drm.py](./plot_arf_rmf_drm.py)
+  - Shows how to obtain and plot the ARF, RMF, and DRM for Telescope 2.
diff --git a/response-tools-py/examples/functions_and_outputs.py b/response-tools-py/examples/functions_and_outputs.py
new file mode 100644
index 0000000..7e40302
--- /dev/null
+++ b/response-tools-py/examples/functions_and_outputs.py
@@ -0,0 +1,231 @@
+"""
+Function & Outputs
+------------------
+
+Script showing a quick example on how to use the functions.
+
+The chosen telescope for the example is Telescope 2 with photon path:
+- Thermal blanket -> Marshall 10-shell X-7 -> Al (0.015") -> CdTe4
+
+Mainly a quick example on unit aware objects and how to access the 
+returned dataclass objects.
+
+This example shows the use of nice high level functions that are tied to
+FOXSI-4 telescopes. 
+- responses
+- telescope_parts
+
+If you're looking for access to response data of the 
+individual components with more freedom then you'll likely be interested 
+in the longer named moduels in the package like:
+- attenuation
+- detector_response
+- effective_area
+- quantum_efficiency
+
+THIS SCRIPT IS AN EXAMPLE, DO NOT USE DIRECTLY. 
+-----------------------------------------------
+If you would like to run the contents of this script and play around 
+with it then either use this file and be aware of not adding/commiting 
+any changes you make and/or just make a copy of this file, put it 
+somewhere else on your computer, and play around with the copy.
+"""
+
+import numpy as np
+
+"""
+For higher level user engagement, the following two modules are the ones 
+likely to use. The `telescope_parts` are well-named functions tied to 
+FOXSI positions: E.g., `foxsi4_position2_optics` will return FOXSI-4's 
+optical information for Position/Telescope 2.
+
+The `responses` module will contains functions that combine the relevant 
+`telescope_parts` functions into one to return higher level products 
+such as the telescope's Ancillary Response Function (ARF), 
+Redistribution Matrix Function (RMF), and/or Detector Response Matrix 
+(DRM).
+"""
+
+import response_tools_py.responses as responses
+import response_tools_py.telescope_parts as telescope_parts
+
+"""
+Let's look at the `foxsi4_position2_optics` function since we mentioned
+it earlier. To see the documentation for this, and any function, we can 
+always run:
+
+```
+>>> help(telescope_parts.foxsi4_position2_optics)
+Help on function foxsi4_position2_optics in module 
+response_tools_py.telescope_parts:
+
+foxsi4_position2_optics(mid_energies, off_axis_angle)
+    Position 2 MSFC heritage X-7 optic effective areas.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+            The energies at which the position 2 optics is required. If 
+            `numpy.nan<<astropy.units.keV` is passed then an entry for 
+            all native file energies are returned.
+            Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+            The off-axis angle of the source.
+            Unit must be convertable to arc-minutes.
+            
+    Returns
+    -------     
+    : `effective_area.EffAreaOutput`
+            An object containing the effective area information of the 
+            MSFC heritage X-7 optic. See accessible information using 
+            `.contents` on the output.
+(END)
+```
+
+We can see that the help function tells us about the function, how to 
+use it, and what it returns. The above function is looking for some
+energies and an off-axis angle.
+
+It shows that one thing we're making use of here are unit aware inputs 
+to functions (believe me, when it comes to response units, this will 
+save time). 
+
+So let's import Astropy's unit module.
+"""
+
+import astropy.units as u
+
+"""
+Let's choose a sensible energy array and off-axis angle (remembering to 
+add the units to the array/value):
+"""
+
+mid_energies = np.arange(4,20,0.5) << u.keV 
+off_axis_angle = 0 << u.arcmin
+pos2_optics = telescope_parts.foxsi4_position2_optics(mid_energies, 
+                                                      off_axis_angle)
+
+"""
+One great thing about the unit-awareness of the inputs/outputs is that 
+you can pass any reasonable input units and they'll be converted for you
+so you don't need to worry about conversion factors throughout your code
+to use the functions.
+
+E.g., the following will result in the same function output
+"""
+
+mid_energies_eV = np.arange(4_000,20_000,500) << u.eV 
+off_axis_angle_arcsec = 0 << u.arcsec
+_pos2_ = telescope_parts.foxsi4_position2_optics(mid_energies_eV, 
+                                                 off_axis_angle_arcsec)
+
+"""
+I.e., `pos2_optics` and `_pos2_` are identical.
+
+You can also access just the value or just the unit from a unit-aware 
+object with `.value` or `.unit` as well. This can useful for axis labels
+when necessary.
+
+The output of `pos2_optics` (an `pos2_optics_new`) isn't just an array 
+now, it's a dataclass. The dataclass contains the effective areas of the 
+optics but also the energy, file, off-axis angle information used to 
+produce it. This is crucial to track when there are a lot of files 
+flying around.
+
+As suggested in the "Output" section of the helpful documentation 
+earlier, we can see the contents of the dataclass and how to access the 
+information within it:
+"""
+
+print(pos2_optics.contents)
+
+"""
+The above should produce something like:
+
+```
+{'filename': 'some-long-file-path-and-name',
+ 'function_path': 'eff_area_msfc_10shell\n->foxsi4_position2_optics',
+ 'mid_energies': <Quantity [ 4. ,  4.5,  5. ,  5.5,  6. ,  6.5,  7. ,  
+            7.5,  8. ,  8.5,   9. ,  9.5, 10. , 10.5, 11. , 11.5, 12. , 
+            12.5, 13. , 13.5, 14. , 14.5, 15. , 15.5, 16. , 16.5, 17. , 
+            17.5, 18. , 18.5, 19. , 19.5] keV>,
+ 'off_axis_angle': <Quantity 0. arcmin>,
+ 'effective_areas': <Quantity [        nan, 25.6       , 25.72057417, 
+            25.7       , 25.41348566, 25.2       , 25.43761831, 
+            25.8       , 25.81248981, 25.6       , 25.40025845, 
+            24.8       , 23.53212343, 21.72665134, 19.4       ,
+            16.63423381, 13.70639236, 10.92535473,  8.6       ,  
+            6.93807847,   5.82109618,  5.06856579,  4.5       ,  
+            3.96451406,  3.45878343,   3.02366109,  2.7       ,  
+            2.48516453,  2.32308489,  2.1744628 ,   2.        ,  
+            1.76986129] cm2>,
+ 'optic_id': 'X-7',
+ 'model': False}
+```
+
+Note: there is a method called `print_contents()` you can use on the 
+function output that might format the contents a little nicer than the
+above you may wish to use.
+
+Each field can be accessed with the displayed name. For excample, to get
+the effective areas of the optics, simply:
+"""
+
+print(pos2_optics.effective_areas)
+
+"""
+Notice that these are also unit-aware, help you see at a glance you're 
+working with a product that you might expect.
+
+The `telescope_parts.foxsi4_position2_optics` function is helpful but an
+even higher level exists that will allow a user to specify a FOXSI-4 
+telescope to obtain the Ancillary Response Function (ARF), 
+Redistribution Matrix Function (RMF), and/or Detector Response Matrix 
+(DRM).
+
+First, we can get the RMF for a telescope, say, Telescope 2:
+"""
+
+pos2_rmf = responses.foxsi4_telescope2_rmf(region=0)
+
+"""
+The `region` input refers to the different pitch regions across the CdTe
+detectors. IF you would rather specificy by passing the pitch (that is
+unit aware) then practice running `help` on the function and check the 
+documentation.
+
+The RMF defined the input and output energy axes for the detector so we
+might as well access the RMF input energies for those energies we want 
+the ARF values for:
+"""
+
+mid_energies = (pos2_rmf.input_energy_edges[:-1]\
+                +pos2_rmf.input_energy_edges[1:])/2
+pos2_arf = responses.foxsi4_telescope2_arf(mid_energies=mid_energies, 
+                                           off_axis_angle=0<<u.arcmin)
+
+"""
+Once we have the RMF and ARF for a given instrument, you might want to 
+just see what the total DRM is. This can be done by passing the ARF and 
+RMF to the general `responses.foxsi4_telescope_response` function:
+"""
+
+pos2_drm = responses.foxsi4_telescope_response(pos2_arf, pos2_rmf)
+
+"""
+Note that with the FOXSI-4 Telescope fucntions (`foxsi4_telescope*`), 
+there exists a field in the class called `elements`. This field contains
+all the dataclasses used to produce the objects `response` field.
+
+Checking the `elements` field for, say, the ARF object:
+"""
+
+print(pos2_arf.elements)
+
+"""
+We find that the `elements` field contains all the dataclasses that 
+produced the Telescope 2 ARF such as the thermal blanket transmission 
+(dimensionless), the Marshall 10-shell X-7 optics effective areas 
+(cm**2), and the Al (0.015") attenuator transmissions (dimensionless).
+"""
\ No newline at end of file
diff --git a/response-tools-py/examples/plot_arf_rmf_drm.py b/response-tools-py/examples/plot_arf_rmf_drm.py
new file mode 100644
index 0000000..3bee15f
--- /dev/null
+++ b/response-tools-py/examples/plot_arf_rmf_drm.py
@@ -0,0 +1,80 @@
+"""
+Plotting ARFs, RMFs, and DRMs
+-----------------------------
+
+Script showing a quick example how to plot the Ancillary Response 
+Function (ARF), Redistribution Matrix Function (RMF), and the Detector 
+Response Matrix (DRM) of a FOXSI-4 telescope.
+
+The chosen telescope is Telescope 2 with photon path:
+- Thermal blanket -> Marshall 10-shell X-7 -> Al (0.015") -> CdTe4
+
+THIS SCRIPT IS AN EXAMPLE, DO NOT USE DIRECTLY. 
+-----------------------------------------------
+If you would like to run the contents of this script and play around 
+with it then either use this file and be aware of not adding/commiting 
+any changes you make and/or just make a copy of this file, put it 
+somewhere else on your computer, and play around with the copy.
+"""
+
+import astropy.units as u
+from matplotlib.colors import LogNorm
+import matplotlib.gridspec as gridspec
+import matplotlib.pyplot as plt
+import numpy as np
+
+import response_tools_py.responses as responses
+
+fig = plt.figure(figsize=(18, 5))
+gs = gridspec.GridSpec(1, 3)
+
+# set up the ARF with the RMF information then make the DRM
+off_axis_angle = 0 << u.arcmin
+pos_rmf = responses.foxsi4_telescope2_rmf(region=0)
+mid_energies = (pos_rmf.input_energy_edges[:-1]\
+                +pos_rmf.input_energy_edges[1:])/2
+pos_arf = responses.foxsi4_telescope2_arf(mid_energies=mid_energies, 
+                                          off_axis_angle=off_axis_angle)
+pos_drm = responses.foxsi4_telescope_response(pos_arf, pos_rmf)
+
+# the ARF info
+gs_ax0 = fig.add_subplot(gs[0, 0])
+gs_ax0.plot(pos_arf.mid_energies, pos_arf.response)
+gs_ax0.set_xlabel(f"Photon Energy [{pos_arf.mid_energies.unit:latex}]")
+gs_ax0.set_ylabel(f"Response [{pos_arf.response.unit:latex}]")
+gs_ax0.set_title(f"Telescope 2: ARF")
+
+# the RMF info
+gs_ax1 = fig.add_subplot(gs[0, 1])
+r = gs_ax1.imshow(pos_rmf.response.value, 
+                origin="lower", 
+                norm=LogNorm(vmin=0.001), 
+                extent=[np.min(pos_rmf.output_energy_edges.value), 
+                        np.max(pos_rmf.output_energy_edges.value), 
+                        np.min(pos_rmf.input_energy_edges.value), 
+                        np.max(pos_rmf.input_energy_edges.value)]
+                )
+cbar = plt.colorbar(r)
+cbar.ax.set_ylabel(f"Response [{pos_rmf.response.unit:latex}]")
+gs_ax1.set_xlabel(f"Count Energy [{pos_rmf.output_energy_edges.unit:latex}]")
+gs_ax1.set_ylabel(f"Photon Energy [{pos_rmf.input_energy_edges.unit:latex}]")
+gs_ax1.set_title(f"Telescope 2: RMF")
+
+# the DRM info
+gs_ax2 = fig.add_subplot(gs[0, 2])
+r = gs_ax2.imshow(pos_drm.response.value, 
+                origin="lower", 
+                norm=LogNorm(vmin=0.001), 
+                extent=[np.min(pos_drm.output_energy_edges.value), 
+                        np.max(pos_drm.output_energy_edges.value), 
+                        np.min(pos_drm.input_energy_edges.value), 
+                        np.max(pos_drm.input_energy_edges.value)]
+                )
+cbar = plt.colorbar(r)
+cbar.ax.set_ylabel(f"Response [{pos_drm.response.unit:latex}]")
+gs_ax2.set_xlabel(f"Count Energy [{pos_drm.output_energy_edges.unit:latex}]")
+gs_ax2.set_ylabel(f"Photon Energy [{pos_drm.input_energy_edges.unit:latex}]")
+gs_ax2.set_title(f"Telescope 2: DRM")
+
+plt.tight_layout()
+plt.show()
\ No newline at end of file
diff --git a/response-tools-py/response_tools_py/attenuation.py b/response-tools-py/response_tools_py/attenuation.py
index 307c070..85b5c7c 100644
--- a/response-tools-py/response_tools_py/attenuation.py
+++ b/response-tools-py/response_tools_py/attenuation.py
@@ -1,8 +1,11 @@
 """Code to load different attenuators. """
 
+from dataclasses import dataclass
 import logging
 import os
 import pathlib
+import sys
+import warnings
 
 from astropy.io import fits
 import astropy.units as u
@@ -10,131 +13,537 @@
 import pandas
 import scipy
 
+from response_tools_py.util import BaseOutput, native_resolution
+
 ATT_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "response-information", "attenuation-data")
+ATM_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "response-information", "atmospheric-data")
+ASSETS_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "assets", "response-tools-py-figs", "att-figs")
+
+@dataclass
+class AttOutput(BaseOutput):
+    """Class for keeping track of attenuation response values."""
+    # numbers
+    transmissions: u.Quantity
+    # bookkeeping
+    attenuation_type: str
+    model: bool
+    # any other fields needed can be added here
+    # can even add with a default so the input is not required for every other instance
+    mid_energies: u.Quantity = np.nan<<u.keV
+    off_axis_angle: u.Quantity = np.nan<<u.arcmin
+    times: u.Quantity = np.nan<<u.second
 
 # thermal blanket attenuation
 @u.quantity_input(mid_energies=u.keV)
 def att_thermal_blanket(mid_energies, file=None):
-    """Return thermal blanket transmittance interpolated to the given energies."""
+    """Thermal blanket transmittance interpolated to the given energies.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
+    """
     _f = os.path.join(ATT_PATH, "F4_Blanket_transmission_v1.dat") if file is None else file
     att = scipy.io.readsav(_f)
     att_es, att_values = att["energy_kev"] << u.keV, att["f4_transmission"] << u.dimensionless_unscaled
-    return np.interp(mid_energies.value, att_es.value, att_values.value, left=0, right=1) << u.dimensionless_unscaled
-
-# thermal blanket attenuation
+    mid_energies = native_resolution(native_x=att_es, input_x=mid_energies)
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies,
+                     transmissions=np.interp(mid_energies.value, 
+                                             att_es.value, 
+                                             att_values.value, 
+                                             left=0, 
+                                             right=1) << u.dimensionless_unscaled,
+                     attenuation_type="Thermal-Blanket",
+                     model=True,
+                     )
+
+# uniform Al attenuation
 @u.quantity_input(mid_energies=u.keV)
-def att_uniform_al_cdte(mid_energies, file=None, position=None):
-    """Return thermal blanket transmittance interpolated to the given energies."""
-    if position is None:
-        logging.info("`position` must be 2 or 4.")
+def att_uniform_al_cdte(mid_energies, position=None, file=None):
+    """Uniform Al filter transmittance interpolated to given energies.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    position : `int`
+        The focal plane position of the desired attenuator. Must be in 
+        the list [2, 4]. 
+        Default: None
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
+    """
+    if (position is None) or (position not in [2,4]):
+        logging.warning(f"The {sys._getframe().f_code.co_name} `position` must be 2 or 4.")
     _f = os.path.join(ATT_PATH, f"unif_att_p{position}_theoretical_v1.csv") if file is None else file
     att = pandas.read_csv(_f)
     att_es, att_values = att["energy[keV]"] << u.keV, att["transmission"] << u.dimensionless_unscaled
-    return np.interp(mid_energies.value, att_es.value, att_values.value, left=0, right=1) << u.dimensionless_unscaled
+    mid_energies = native_resolution(native_x=att_es, input_x=mid_energies)
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies,
+                     transmissions=np.interp(mid_energies.value, 
+                                             att_es.value, 
+                                             att_values.value, 
+                                             left=0, 
+                                             right=1) << u.dimensionless_unscaled,
+                     attenuation_type="Uniform-Al-Filter",
+                     model=True,
+                     )
 
 # pixelated attenuator attenuation
 @u.quantity_input(mid_energies=u.keV)
-def att_pixelated(mid_energies, file=None, values=None):
-    """Return pixelated attenuator transmittance interpolated to the given energies."""
+def att_pixelated(mid_energies, use_model=False, file=None):
+    """Pixelated attenuator transmittance interpolated to energies.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    use_model : `bool`
+        Defines whether to use the measured values for the pixelated
+        attenuator (False) or the modelled values (True).
+        Default: False
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
+    """
     _f = os.path.join(ATT_PATH, "20240607_fosxi4_transmission_v1.csv") if file is None else file
     att = pandas.read_csv(_f)
     att_es, att_values_measured, att_values_modelled = att["energy"] << u.keV, att["measured_transmission"] << u.dimensionless_unscaled, att["modeled_transmission"] << u.dimensionless_unscaled
 
-    if values=="measured":
-        return np.interp(mid_energies.value, att_es.value, att_values_measured.value, left=0, right=1) << u.dimensionless_unscaled
-    elif values in ["modelled", "modeled"]:
-        return np.interp(mid_energies.value, att_es.value, att_values_modelled.value, left=0, right=1) << u.dimensionless_unscaled
+    mid_energies = native_resolution(native_x=att_es, input_x=mid_energies)
+    if use_model:
+        att_vals = att_values_modelled
     else:
-        logging.info("`values` must be \"measured\" or \"modelled\" (or \"modeled\" for you Americans).")
+        att_vals = att_values_measured
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies,
+                     transmissions=np.interp(mid_energies.value, 
+                                             att_es.value, 
+                                             att_vals.value, 
+                                             left=0, 
+                                             right=0) << u.dimensionless_unscaled,
+                     attenuation_type="Pixelated-Attenuator",
+                     model=use_model,
+                     )
 
 # aluminized mylar attenuation
 @u.quantity_input(mid_energies=u.keV)
 def att_al_mylar(mid_energies, file=None):
-    """Return aluminized mylar transmittance interpolated to the given energies."""
+    """Aluminized mylar transmittance interpolated to given energies.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
+    """
     _f = os.path.join(ATT_PATH, "thin_mylar_p3_p5_theoretical_v1.csv") if file is None else file
     att = pandas.read_csv(_f)
     att_es, att_values = att["energy[keV]"] << u.keV, att["transmission"] << u.dimensionless_unscaled
-    return np.interp(mid_energies.value, att_es.value, att_values.value, left=0, right=1) << u.dimensionless_unscaled
+    mid_energies = native_resolution(native_x=att_es, input_x=mid_energies)
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies,
+                     transmissions=np.interp(mid_energies.value, 
+                                             att_es.value, 
+                                             att_values.value, 
+                                             left=0, 
+                                             right=1) << u.dimensionless_unscaled,
+                     attenuation_type="Aluminized-Mylar",
+                     model=True,
+                     )
 
 # pre-filter attenuation
 @u.quantity_input(mid_energies=u.keV)
-def _att_old_prefilter0(mid_energies, file=None):
-    """Return pre-filter 0 transmittance interpolated to the given energies.
+def _att_old_prefilter(mid_energies, position=None, file=None):
+    """Pre-filter transmittance interpolated to the given energies.
     
     This function was used for simulations pre-launch.
     """
-    logging.warning("This might not be the function you are looking for, please see `att_cmos_obfilter`.")
+    if (position is None) or (position not in [0,1]):
+        logging.warning(f"The {sys._getframe().f_code.co_name} `position` must be 0 or 1.")
+    logging.warning(f"Caution: This might not be the function you are looking for ({sys._getframe().f_code.co_name}), please see `att_cmos_obfilter`.")
     _f = os.path.join(ATT_PATH, "CMOST_Prefilter_transmission.dat") if file is None else file
     att = scipy.io.readsav(_f)
-    att_es, att_values = att["cmos_prefilter_transmission"]["energy_kev"][0], att["cmos_prefilter_transmission"]["position0"][0]
-
-    # this attenuation acts weird because it stops noticably above 0 at 1 keV (the lower energy), so...
-    # assume same drop-off as pre-filter1
-    _obf1_numbers = _att_old_prefilter1(mid_energies, file=None).value
-    _ex_obf0_inds = np.nonzero(_obf1_numbers<att_values[0])
-    _energy_ext = mid_energies[_ex_obf0_inds].value
-    att_es = np.concatenate((_energy_ext-np.max(_energy_ext)+att_es[0], att_es)) << u.keV
-    att_values = np.concatenate((_obf1_numbers[_ex_obf0_inds], att_values)) << u.dimensionless_unscaled
+    att_es, att_values = att["cmos_prefilter_transmission"]["energy_kev"][0] << u.keV, att["cmos_prefilter_transmission"][f"position{position}"][0] << u.dimensionless_unscaled
+
+    mid_energies = native_resolution(native_x=att_es, input_x=mid_energies)
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies,
+                     transmissions=np.interp(mid_energies.value, 
+                                             att_es.value, 
+                                             att_values.value, 
+                                             left=0, 
+                                             right=1) << u.dimensionless_unscaled,
+                     attenuation_type=f"Old-Prelaunch-Prefiler{position}",
+                     model=True,
+                     )
 
-    return np.interp(mid_energies.value, att_es.value, att_values.value, left=0, right=1) << u.dimensionless_unscaled
-    
-# pre-filter attenuation
 @u.quantity_input(mid_energies=u.keV)
-def _att_old_prefilter1(mid_energies, file=None):
-    """Return pre-filter 1 transmittance interpolated to the given energies.
-    
-    This function was used for simulations pre-launch.
+def att_sigmoid(mid_energies, l ,x0, k, b):
+    """Sigmoid model for a general/fake attenuator.
+
+    The functional form of the sigmoid is:
+
+    .. math::
+        (l / (1 + np.exp(-k*(mid_energies.value-x0))) + b)
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
     """
-    logging.warning("Caution: This might not be the function you are looking for, please see `att_cmos_obfilter`.")
-    _f = os.path.join(ATT_PATH, "CMOST_Prefilter_transmission.dat") if file is None else file
-    att = scipy.io.readsav(_f)
-    att_es, att_values = att["cmos_prefilter_transmission"]["energy_kev"][0] << u.keV, att["cmos_prefilter_transmission"]["position1"][0] << u.dimensionless_unscaled
-    return np.interp(mid_energies.value, att_es.value, att_values.value, left=0, right=1) << u.dimensionless_unscaled
 
-@u.quantity_input(mid_energies=u.keV)
-def att_sigmoid(mid_energies, l ,x0, k, b):
-    """Sigmoid model for a general/fake attenuator."""
-    return (l / (1 + np.exp(-k*(mid_energies.value-x0))) + b) << u.dimensionless_unscaled
+    return AttOutput(filename="No-File",
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies,
+                     transmissions=(l / (1 + np.exp(-k*(mid_energies.value-x0))) + b) << u.dimensionless_unscaled,
+                     attenuation_type=f"Analytical-Sigmoid-Model",
+                     model=True,
+                     )
 
 @u.quantity_input(mid_energies=u.keV)
-def att_cmos_filter(mid_energies, file=None, telescope=None):
-    if telescope is None:
-        logging.warning("`telescope` input in `att_cmos_filter()` must be 0 or 1.")
+def att_cmos_filter(mid_energies, telescope=None, file=None):
+    """CMOS pre-filters for the SXR telescopes.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    telescope : `int`
+        The focal plane position of the desired attenuator. Must be in 
+        the list [0, 1]. 
+        Default: None
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
+    """
+    if (telescope is None) or (telescope not in [0,1]):
+        logging.warning(f"The `telescope` input in {sys._getframe().f_code.co_name} must be 0 or 1.")
         return
     _f = os.path.join(ATT_PATH, f"foxsi4_telescope-{telescope}_BASIC_attenuation_filter_transmittance_v1.fits") if file is None else file
     with fits.open(_f) as hdul:
         es, t = hdul[2].data << u.keV, hdul[1].data << u.dimensionless_unscaled
-    return np.interp(mid_energies.value, es.value, t.value, left=0, right=1) << u.dimensionless_unscaled
+    mid_energies = native_resolution(native_x=es, input_x=mid_energies)
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies,
+                     transmissions=np.interp(mid_energies.value, 
+                                             es.value, 
+                                             t.value, 
+                                             left=0, 
+                                             right=1) << u.dimensionless_unscaled,
+                     attenuation_type=f"CMOS-Prefilter{telescope}",
+                     model=True,
+                     )
 
 @u.quantity_input(mid_energies=u.keV)
-def att_cmos_obfilter(mid_energies, file=None, telescope=None):
-    if telescope is None:
-        logging.warning("`telescope` input in `att_cmos_obfilter()` must be 0 or 1.")
+def att_cmos_obfilter(mid_energies, telescope=None, file=None):
+    """CMOS OBF filters for the SXR telescopes.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    telescope : `int`
+        The focal plane position of the desired attenuator. Must be in 
+        the list [0, 1]. 
+        Default: None
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
+    """
+    if (telescope is None) or (telescope not in [0,1]):
+        logging.warning(f"The `telescope` input in {sys._getframe().f_code.co_name} must be 0 or 1.")
         return
     _f = os.path.join(ATT_PATH, f"foxsi4_telescope-{telescope}_BASIC_optical_blocking_filter_transmittance_v1.fits") if file is None else file
     with fits.open(_f) as hdul:
         es, t = hdul[2].data << u.keV, hdul[1].data << u.dimensionless_unscaled
-    return np.interp(mid_energies.value, es.value, t.value, left=0, right=1) << u.dimensionless_unscaled
-
-@u.quantity_input(off_axis_angle=u.arcsec)
-def att_cmos_collimator_ratio(off_axis_angle, file=None, telescope=None):
-    if telescope is None:
-        logging.warning("`telescope` input in `att_cmos_collimator_ratio()` must be 0 or 1.")
+    mid_energies = native_resolution(native_x=es, input_x=mid_energies)
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies,
+                     transmissions=np.interp(mid_energies.value, 
+                                             es.value, 
+                                             t.value, 
+                                             left=0, 
+                                             right=1) << u.dimensionless_unscaled,
+                     attenuation_type=f"CMOS-OBF-filter{telescope}",
+                     model=True,
+                     )
+
+@u.quantity_input(off_axis_angle=u.arcmin)
+def att_cmos_collimator_ratio(off_axis_angle, telescope=None, file=None):
+    """CMOS OBF filters for the SXR telescopes.
+
+    Parameters
+    ----------
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        Default: 0 arc-minutes (on axis)
+
+    telescope : `int`
+        The focal plane position of the desired attenuator. Must be in 
+        the list [0, 1]. 
+        Default: None
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
+    """
+    if (telescope is None) or (telescope not in [0,1]):
+        logging.warning(f"The `telescope` input in {sys._getframe().f_code.co_name} must be 0 or 1.")
         return
     _f = os.path.join(ATT_PATH, f"foxsi4_telescope-{telescope}_BASIC_collimator_aperture_ratio_v1.fits") if file is None else file
     with fits.open(_f) as hdul:
-        oa_angles, aperture_ratio = hdul[2].data << u.arcsec, hdul[1].data << u.dimensionless_unscaled
-    return np.interp(off_axis_angle.value, oa_angles.value, aperture_ratio.value, left=0, right=0) << u.dimensionless_unscaled
-
-if __name__=="__main__":
-    import matplotlib.pyplot as plt
-
-    from phot_spec import create_energy_midpoints, zeroes2nans
-
-    SAVE_ASSETS = False
-    assets_dir = os.path.join(pathlib.Path(__file__).parent, "..", "..", "assets", "response-tools-py-figs", "att-figs")
-    pathlib.Path(assets_dir).mkdir(parents=True, exist_ok=True)
+        oa_angles, aperture_ratio = hdul[2].data << u.arcmin, hdul[1].data << u.dimensionless_unscaled
+    off_axis_angle = native_resolution(native_x=oa_angles, input_x=off_axis_angle)
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     off_axis_angle=off_axis_angle,
+                     transmissions=np.interp(off_axis_angle.value, 
+                                             oa_angles.value, 
+                                             aperture_ratio.value, 
+                                             left=0, 
+                                             right=0) << u.dimensionless_unscaled,
+                     attenuation_type=f"CMOS-Collimator-Ratio{telescope}",
+                     model=True,
+                     )
+
+@u.quantity_input(mid_energies=u.keV, time=u.second)
+def att_foxsi4_atmosphere(mid_energies, time_range=None, file=None):
+    """ 
+    Atmsopheric attenuation from and for FOXSI-4 flight data.
+
+    energy = array containing energy in keV for energies 0.01 - 30 keV. Array has 506 elements
+		 
+    atmospheric_trans = array containing transmission for all energy values in energy array.
+                        Transmission is calculated for 10284 times covering the FOXSI-4 flight. 
+                        Array shape is: [10284,506] which corresponds to transmission for [time,energy]
+                        
+                        Launch time t = 0 corresponds to  index [0,*] 
+                        Observation starts at t = 100s corresponds to index [2000,*]
+                        Approximate middle of observation at t = 280s corresponds to index [5600,*]
+                        End of observation at t = 461s corresponds to index [9200,*] 
+
+
+    Units in the FITS header needs to change from keV->eV
+    Need an array of times included
+    -> 10,284 entries and t=0 is index `0` while t=100 is index `2000`
+    -> final time is 100/2000 * 10284 = 514.2
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    time_range : `astropy.units.quantity.Quantity` or `None`
+        The time range the atmsopheric transmissions should be averaged
+        over. If `None`, `numpy.nan<<astropy.units.second`, or
+        `[numpy.nan, numpy.nan]<<astropy.units.second` then the full 
+        time will be considered and the output will not be averaged but 
+        a grid of the transmissions at all times and at any provided
+        energies.
+    
+    file : `str` or `None`
+        Path/name of a custom file wanting to be loaded in as the 
+        atmospheric data file.
+
+    Returns
+    -------
+    : `AttOutput`
+        An object containing the energies for each transmission, the 
+        transmissions, and more. See accessible information using 
+        `.contents` on the output.
+    """
+    if (time_range is None) or np.all(np.isnan(time_range)):
+        time_range = [np.nan, np.nan] << u.second
+    
+    if (len(time_range)!=2):
+        warnings.warn(f"{sys._getframe().f_code.co_name} `time_range` (convertable to astropy.units.seconds) should be of length 2.")
+        return
 
+    _f = os.path.join(ATM_PATH, f"FOXSI4_atmospheric_transmission_v1.fits") if file is None else file
+    with fits.open(_f) as hdul:
+        native_times, native_energies, transmission = hdul[1].data["TIME"][0]<<u.second, (hdul[1].data["ENERGY"][0]<<u.eV)<<u.keV, hdul[1].data["ATMOSPHERIC_TRANS"][0]<<u.dimensionless_unscaled
+
+        # assume some sort of uniform uniform binning
+        en_res = np.mean(np.diff(native_energies))
+
+    # if the time range is nothing them just want all the times, deal with energies separately
+    if np.all(np.isnan(time_range)):
+        if np.all(np.isnan(mid_energies)):
+            # don't bother going further if we're just going to return the native data
+            return AttOutput(filename=_f,
+                             function_path=f"{sys._getframe().f_code.co_name}",
+                             mid_energies=native_energies<<u.keV,
+                             times=native_times,
+                             transmissions=transmission,
+                             attenuation_type="File-Atmospheric-Transmissions",
+                             model=True,
+                             )
+        
+        # the grid can be huge so let's help cut down on the interpolation amount
+        cut_native_energies_inds = np.nonzero(((mid_energies[0]-en_res)<=native_energies) & (native_energies<=(mid_energies[-1]+en_res)))
+        cut_native_energies = native_energies[cut_native_energies_inds]
+        cut_transmission = transmission[cut_native_energies_inds]
+
+        x, y = np.meshgrid(cut_native_energies, native_times)
+        # PROPER INTERPOLATION: i = scipy.interpolate.LinearNDInterpolator(list(zip(x.flatten().value, y.flatten().value)), cut_transmission.T.flatten().value)
+        # the grid is really fine so is it good enough to just use nearest neighbours?
+        i = scipy.interpolate.NearestNDInterpolator(list(zip(x.flatten().value, y.flatten().value)), cut_transmission.T.flatten().value)
+
+        mid_energies = native_resolution(native_x=native_energies, input_x=mid_energies)
+        all_times = native_resolution(native_x=native_times, input_x=time_range)
+        X, Y = np.meshgrid(mid_energies, all_times)
+
+        return AttOutput(filename=_f,
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         times=all_times,
+                         transmissions=i(X, Y)<<u.dimensionless_unscaled,
+                         attenuation_type="Energy-Interpolated-Atmospheric-Transmissions",
+                         model=True,
+                         )
+
+    # this is a big array so let's slice before interpolating
+    time_inds = np.nonzero((time_range[0]<=native_times) & (native_times<=time_range[1]))[0]
+
+    mid_energies = native_resolution(native_x=native_energies, input_x=mid_energies)
+
+    # # we'll interpolate so make sure to include a range one wider for the energy range
+    # energy_inds = np.nonzero((mid_energies[0]<=native_energies) & (native_energies<=mid_energies[-1]))[0]
+    # energy_inds = np.insert(energy_inds, 0, energy_inds[0]-1) if energy_inds[0]>0 else energy_inds
+    # energy_inds = np.insert(energy_inds, 1, energy_inds[-1]+1) if energy_inds[-1]<(len(energy_inds)-1) else energy_inds
+
+    times = native_times[time_inds]
+    transmissions = transmission[:,time_inds]
+
+    tave_transmissions = np.mean(transmissions, axis=1)
+
+    return AttOutput(filename=_f,
+                     function_path=f"{sys._getframe().f_code.co_name}",
+                     mid_energies=mid_energies<<u.keV,
+                     times=times,
+                     transmissions=np.interp(mid_energies.value, 
+                                             native_energies.value, 
+                                             tave_transmissions.value, 
+                                             left=0, 
+                                             right=0) << u.dimensionless_unscaled,
+                     attenuation_type="Time-Averaged-Atmospheric-Transmissions",
+                     model=True,
+                     )
+
+def asset_att(save_asset=False):
     mid_energies = create_energy_midpoints()
 
     tb_col, obf0_col, obf1_col, cdte_fixed2_col, cdte_fixed4_col = plt.cm.viridis([0, 0.2, 0.4, 0.6, 0.8])
@@ -143,90 +552,206 @@ def att_cmos_collimator_ratio(off_axis_angle, file=None, telescope=None):
 
     # all attenuators
     plt.figure(figsize=(10,8))
-    att_therm_bl = zeroes2nans(att_thermal_blanket(mid_energies))
+    att_therm_bl = zeroes2nans(att_thermal_blanket(mid_energies).transmissions)
     plt.ylabel(f"Transmission [{att_therm_bl.unit:latex}]")
     plt.xlabel(f"Energy [{mid_energies.unit:latex}]")
     p1 = plt.plot(mid_energies, att_therm_bl, color=tb_col, ls="-", label="Thermal blanket")
 
-    old_prefilter0 = zeroes2nans(_att_old_prefilter0(mid_energies))
+    old_prefilter0 = zeroes2nans(_att_old_prefilter(mid_energies, position=0).transmissions)
     p2 = plt.plot(mid_energies, old_prefilter0, color=obf0_col, ls="--", label="Old pre-filter 0", lw=3)
 
-    old_prefilter1 = zeroes2nans(_att_old_prefilter1(mid_energies))
+    old_prefilter1 = zeroes2nans(_att_old_prefilter(mid_energies, position=1).transmissions)
     p3 = plt.plot(mid_energies, old_prefilter1, color=obf1_col, ls="-.", label="Old pre-filter 1", lw=3)
 
-    cdte_fixed4 = zeroes2nans(att_uniform_al_cdte(mid_energies, position=4))
+    cdte_fixed4 = zeroes2nans(att_uniform_al_cdte(mid_energies, position=4).transmissions)
     p4 = plt.plot(mid_energies, cdte_fixed4, color=cdte_fixed4_col, ls="-.", label="CdTe fixed p4")
 
-    cdte_fixed2 = zeroes2nans(att_uniform_al_cdte(mid_energies, position=2))
+    cdte_fixed2 = zeroes2nans(att_uniform_al_cdte(mid_energies, position=2).transmissions)
     p5 = plt.plot(mid_energies, cdte_fixed2, color=cdte_fixed2_col, ls="-.", label="CdTe fixed p2")
 
-    pix_att_meas = zeroes2nans(att_pixelated(mid_energies, values="measured"))
+    pix_att_meas = zeroes2nans(att_pixelated(mid_energies, use_model=False).transmissions)
     p6 = plt.plot(mid_energies, pix_att_meas, color=pix_att_meas_col, ls="--", label="Pix. Att. Measured")
 
-    pix_att_mod = zeroes2nans(att_pixelated(mid_energies, values="modelled"))
+    pix_att_mod = zeroes2nans(att_pixelated(mid_energies, use_model=True).transmissions)
     p7 = plt.plot(mid_energies, pix_att_mod, color=pix_att_mod_col, ls="--", label="Pix. Att. Modelled")
 
-    al_mylar_mod = zeroes2nans(att_al_mylar(mid_energies))
+    al_mylar_mod = zeroes2nans(att_al_mylar(mid_energies).transmissions)
     p8 = plt.plot(mid_energies, al_mylar_mod, color=al_mylar_mod_col, ls="-", label="Al-Mylar")
 
-    cmos_t0 = att_cmos_filter(mid_energies, telescope=0)
+    cmos_t0 = att_cmos_filter(mid_energies, telescope=0).transmissions
     p9 = plt.plot(mid_energies, cmos_t0, color=cmost0_col, ls="-", label="CMOS0-filter", lw=2)
 
-    cmos_t1 = att_cmos_filter(mid_energies, telescope=1)
+    cmos_t1 = att_cmos_filter(mid_energies, telescope=1).transmissions
     p10 = plt.plot(mid_energies, cmos_t1, color=cmost1_col, ls="-.", label="CMOS1-filter", lw=2)
 
-    cmos_t2 = att_cmos_obfilter(mid_energies, telescope=0)
+    cmos_t2 = att_cmos_obfilter(mid_energies, telescope=0).transmissions
     p11 = plt.plot(mid_energies, cmos_t2, color=cmost2_col, ls="--", label="CMOS0-OBF", lw=1)
 
-    cmos_t3 = att_cmos_obfilter(mid_energies, telescope=1)
+    cmos_t3 = att_cmos_obfilter(mid_energies, telescope=1).transmissions
     p12 = plt.plot(mid_energies, cmos_t3, color=cmost3_col, ls=":", label="CMOS1-OBF", lw=1)
 
     plt.ylim([0,1.05])
-    plt.xlim([0.5, 100])
+    plt.xlim([0.5, 30])
     plt.xscale("log")
 
     plt.title("Attenuators")
     
     plt.legend(handles=p1+p2+p3+p4+p5+p6+p7+p8+p9+p10+p11+p12)
     plt.tight_layout()
-    if SAVE_ASSETS:
-        plt.savefig(os.path.join(assets_dir,"transmissions.png"), dpi=200, bbox_inches="tight")
+    if save_asset:
+        pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
+        plt.savefig(os.path.join(ASSETS_PATH,"transmissions.png"), dpi=200, bbox_inches="tight")
     plt.show()
 
-    ## other
-    # collimator (so far, only have value for on-axis)
-    print(att_cmos_collimator_ratio(0<<u.arcsec, file=None, telescope=0))
-    print(att_cmos_collimator_ratio(0<<u.arcsec, file=None, telescope=1))
+def asset_sigmoid(save_asset=False):
+    mid_energies = create_energy_midpoints()
+
+    plt.figure(figsize=(10,8))
 
     # any fake/functionaly model attenuators
     # sigmoid
     l ,x0, k, b = 1, 0, 1, 0
     example = att_sigmoid(mid_energies, l ,x0, k, b)
-    p1 = plt.plot(mid_energies, example, ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
+    p1 = plt.plot(mid_energies, example.transmissions, ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
     l ,x0, k, b = 1.04, 0, 1, 0
-    p2 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b), ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
+    p2 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b).transmissions, ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
     l ,x0, k, b = 1, 3, 1, 0
-    p3 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b), ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
+    p3 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b).transmissions, ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
     l ,x0, k, b = 1, 3, 1, 0.04
-    p4 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b), ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
+    p4 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b).transmissions, ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
     l ,x0, k, b = 1, 10, 0.5, 0
-    p5 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b), ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
+    p5 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b).transmissions, ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
     l ,x0, k, b = 1, 10, 1, 0
-    p6 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b), ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
+    p6 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b).transmissions, ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
     l ,x0, k, b = 1, 10, 2, 0
-    p7 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b), ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
+    p7 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b).transmissions, ls="-", label=f"l:{l} ,x0:{x0}, k:{k}, b:{b}")
     l ,x0, k, b = 1, 25, 1, 0
-    p8 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b), ls="-", label=f"spectrometer-like:\nl:{l} ,x0:{x0}, k:{k}, b:{b}")
+    p8 = plt.plot(mid_energies, att_sigmoid(mid_energies, l, x0, k, b).transmissions, ls="-", label=f"spectrometer-like:\nl:{l} ,x0:{x0}, k:{k}, b:{b}")
 
-    plt.ylabel(f"Transmission [{example.unit:latex}]")
+    plt.ylabel(f"Transmission [{example.transmissions.unit:latex}]")
     plt.xlabel(f"Energy [{mid_energies.unit:latex}]")
     plt.title("Fake Attenuator, Sigmoid$=l/(1+exp^{-k*(x-x0)})+b")
     plt.ylim([0,1.05])
-    plt.xlim([0.5, 100])
+    plt.xlim([0.5, 30])
     plt.xscale("log")
 
     plt.legend(handles=p1+p2+p3+p4+p5+p6+p7+p8)
     plt.tight_layout()
-    if SAVE_ASSETS:
-        plt.savefig(os.path.join(assets_dir,"model-transmissions.png"), dpi=200, bbox_inches="tight")
-    plt.show()
\ No newline at end of file
+    if save_asset:
+        pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
+        plt.savefig(os.path.join(ASSETS_PATH,"model-transmissions.png"), dpi=200, bbox_inches="tight")
+    plt.show()
+
+def asset_atm(save_asset=False):
+    fig = plt.figure(figsize=(16,6))
+
+    obs_start = 100
+    obs_mid = 280
+    obs_end = 461
+
+    gs = gridspec.GridSpec(1, 3)
+
+    gs_ax0 = fig.add_subplot(gs[0, 0])
+
+    energy0, time0 = [1]<<u.keV, np.nan<<u.second
+    atm0 = att_foxsi4_atmosphere(mid_energies=energy0, time_range=time0)
+    p0 = gs_ax0.plot(atm0.times, atm0.transmissions, ls=":", label=f"energy:{energy0:latex}\ntime:{time0:latex}", lw=3)
+
+    energy1, time1 = [1, 3, 5, 10, 15]<<u.keV, np.nan<<u.second
+    atm1 = att_foxsi4_atmosphere(mid_energies=energy1, time_range=time1)
+    p1 = []
+    for i in range(len(energy1)):
+        p1 += gs_ax0.plot(atm1.times, atm1.transmissions[:,i], ls="-", label=f"energy:{energy1[i]:latex}")
+
+    gs_ax0.set_ylabel(f"Transmission [{atm0.transmissions.unit:latex}]")
+    gs_ax0.set_xlabel(f"Time (Obs. start=100 s) [{atm0.times.unit:latex}]")
+    gs_ax0.set_ylim([0,1.05])
+    v0 = gs_ax0.axvline(obs_start, ls="-.", c="k", label="obs. start")
+    v1 = gs_ax0.axvline(obs_mid, ls="-.", c="k", label="obs. middle")
+    v2 = gs_ax0.axvline(obs_end, ls="-.", c="k", label="obs. end")
+    gs_ax0.set_xlim([0, 600])
+    gs_ax0.set_title("Sampled energy band transmission vs. time")
+    plt.legend(handles=p0+p1+[v0,v1,v2])
+    
+
+    gs_ax1 = fig.add_subplot(gs[0, 1])
+
+    energy2, time2 = np.nan<<u.keV, [obs_start, obs_end]<<u.second
+    atm2 = att_foxsi4_atmosphere(mid_energies=energy2, time_range=time2)
+    p2 = gs_ax1.plot(atm2.mid_energies, atm2.transmissions, ls="-", label=f"time range:{time2:latex}")
+
+    energy3, time3 = np.nan<<u.keV, np.nan<<u.second
+    atm3 = att_foxsi4_atmosphere(mid_energies=energy3, time_range=time3)
+
+    # will come back here: st, mid, en = np.nonzero(t3==obs_start), np.nonzero(t3==obs_mid), np.nonzero(t3==obs_end)
+    p3 = gs_ax1.plot(atm3.mid_energies, atm3.transmissions[:, 2000], ls="-", label=f"time:{atm3.times[2000]:latex}")
+    p4 = gs_ax1.plot(atm3.mid_energies, atm3.transmissions[:, 5600], ls="-", label=f"time:{atm3.times[5600]:latex}")
+    p5 = gs_ax1.plot(atm3.mid_energies, atm3.transmissions[:, 9200], ls="-", label=f"time:{atm3.times[9200]:latex}")
+
+    gs_ax1.set_ylabel(f"Transmission [{atm3.transmissions.unit:latex}]")
+    gs_ax1.set_xlabel(f"Energy [{atm3.mid_energies.unit:latex}]")
+    gs_ax1.set_ylim([0,1.05])
+    gs_ax1.set_xlim([0.01, 30])
+    gs_ax1.set_xscale("log")
+    gs_ax1.set_title("Time averaged and time sampled transmission vs. energy")
+    plt.legend(handles=p2+p3+p4+p5)
+
+    
+    gs_ax2 = fig.add_subplot(gs[0, 2])
+
+    energy4, time4 = [0.01, 0.02, 0.05, 0.1, 0.3, 0.5, 1, 3, 5, 10, 15, 30]<<u.keV, [obs_start, obs_end]<<u.second
+    atm4 = att_foxsi4_atmosphere(mid_energies=energy4, time_range=time4)
+    colour4 = "blue"
+    p6 = gs_ax2.plot(atm4.mid_energies, atm4.transmissions, label=f"time range:{atm4.times[0]:.2f}$-${atm4.times[-1]:.2f}\nrandom-ish energy sampling", marker="x", ms=4, c=colour4)
+
+    energy5, time5 = np.arange(3,30.1, 0.1)<<u.keV, [obs_start, obs_end]<<u.second
+    atm5 = att_foxsi4_atmosphere(mid_energies=energy5, time_range=time5)
+    colour5 = "orange"
+    gs_ax2.plot(atm5.mid_energies, atm5.transmissions, label=f"time range:{atm5.times[0]:.2f}$-${atm5.times[-1]:.2f}\nCdTe range+response resolution", marker="x", ms=2, c=colour5)
+    # inset Axes for the CdTe plot
+    x1, x2, y1, y2 = 2.5, 30, 0.95, 1.04  # subregion of the original image
+    axins = gs_ax2.inset_axes([0.4, 0.35, 0.5, 0.4],
+                              xlim=(x1, x2), 
+                              ylim=(y1, y2)) #, xticklabels=[], yticklabels=[])
+    axins.plot(atm4.mid_energies, atm4.transmissions, label=f"time range:{atm4.times[0]:.2f}$-${atm4.times[-1]:.2f}\nrandom-ish energy sampling", marker="x", ms=6, c=colour4)
+    p7 = axins.plot(atm5.mid_energies, atm5.transmissions, label=f"time range:{atm5.times[0]:.2f}$-${atm5.times[-1]:.2f}\nCdTe range+response resolution", marker="x", ms=4, c=colour5)
+    axins.set_xscale("log")
+    _rectangle, _connectors = gs_ax2.indicate_inset_zoom(axins, edgecolor="black")
+    # edit the connecting lines so they make sense
+    _connectors[0].__dict__["_visible"] = False 
+    _connectors[1].__dict__["_visible"] = True
+
+    gs_ax2.set_ylabel(f"Transmission [{atm3.transmissions.unit:latex}]")
+    gs_ax2.set_xlabel(f"Energy [{atm3.mid_energies.unit:latex}]")
+    gs_ax2.set_ylim([0,1.05])
+    gs_ax2.set_xlim([0.01, 30])
+    gs_ax2.set_xscale("log")
+    gs_ax2.set_title("Time averaged transmission vs. sampled energy")
+    plt.legend(handles=p6+p7)
+
+    plt.suptitle("FOXSI-4 Flight Atmospheric Transmission")
+
+    plt.tight_layout()
+    if save_asset:
+        pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
+        plt.savefig(os.path.join(ASSETS_PATH,"atmospheric-transmissions.png"), dpi=200, bbox_inches="tight")
+    plt.show()
+
+if __name__=="__main__":
+    import matplotlib.pyplot as plt
+    import matplotlib.gridspec as gridspec
+
+    from phot_spec import create_energy_midpoints, zeroes2nans
+
+    SAVE_ASSETS = False
+    
+    asset_att(save_asset=SAVE_ASSETS)
+    
+    ## other
+    # collimator (so far, only have value for on-axis)
+    print(att_cmos_collimator_ratio(0<<u.arcsec, file=None, telescope=0).transmissions)
+    print(att_cmos_collimator_ratio(0<<u.arcsec, file=None, telescope=1).transmissions)
+
+    asset_sigmoid(save_asset=SAVE_ASSETS)
+
+    asset_atm(save_asset=SAVE_ASSETS)
\ No newline at end of file
diff --git a/response-tools-py/response_tools_py/detector_response.py b/response-tools-py/response_tools_py/detector_response.py
index cd7a41e..a76398d 100644
--- a/response-tools-py/response_tools_py/detector_response.py
+++ b/response-tools-py/response_tools_py/detector_response.py
@@ -1,43 +1,196 @@
 """Code to load different detectro responses. """
 
+from dataclasses import dataclass
+
 import logging
 import os
 import pathlib
+import sys
 
 from astropy.io import fits
 import astropy.units as u
-from matplotlib.colors import LogNorm, Normalize
-import matplotlib.gridspec as gridspec
-import matplotlib.pyplot as plt
 import numpy as np
 
+from response_tools_py.util import BaseOutput
+
 DET_RESP_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "response-information", "detector-response-data")
+ASSETS_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "assets", "response-tools-py-figs", "det-resp-figs")
+
+@dataclass
+class DetectorResponseOutput(BaseOutput):
+    """Class for keeping track of effective area response values."""
+    # numbers
+    input_energy_edges: u.Quantity # photon axis
+    output_energy_edges: u.Quantity # count axis
+    detector_response: u.Quantity # rmf
+    # bookkeeping
+    detector: str
+    # any other fields needed can be added here
+    # can even add with a default so the input is not required for every other instance
 
 def cdte_det_resp_rmf(file):
-    """Return the redistribution matrix from a given file."""
+    """Return the redistribution matrix for CdTe from a given file.
+
+    Parameters
+    ----------
+    file : `str`
+        The file for the RMF.
+
+    Returns
+    -------
+    : `DetectorResponseOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
     e_lo, e_hi, ngrp, fchan, nchan, matrix = _read_rmf(file)
 
     fchan_array = col2arr_py(fchan)
     nchan_array = col2arr_py(nchan)
 
-    return e_lo<<u.keV, e_hi<<u.keV, vrmf2arr_py(data=matrix,
-                                                 n_grp_list=ngrp,
-                                                 f_chan_array=fchan_array,
-                                                 n_chan_array=nchan_array)<<(u.ct/u.ph)
+    energies = np.append(e_lo, e_hi[-1])<<u.keV
+
+    return DetectorResponseOutput(filename=file,
+                                  function_path=f"{sys._getframe().f_code.co_name}",
+                                  input_energy_edges=energies,
+                                  output_energy_edges=energies,
+                                  detector_response=vrmf2arr_py(data=matrix,
+                                                                n_grp_list=ngrp,
+                                                                f_chan_array=fchan_array,
+                                                                n_chan_array=nchan_array)<<(u.ct/u.ph),
+                                  detector="CdTe-General-Detector-Response"
+                                  )
+
+@u.quantity_input(pitch=u.um)
+def cdte_det_resp(cdte:int=None, region:int=None, pitch=None, side:str="merged", event_type:str="all", file=None):
+    """Return the redistribution matrix for CdTe from a given file.
+
+    Requires the `cdte` input and _either_ `region` _xor_ `pitch`.
+
+    Wrapper for `cdte_det_resp_rmf` with bookkeeping.
+
+    Parameters
+    ----------
+    cdte : `int`
+        The CdTe detector number. Must be in [1,2,3,4].
+
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    file : `str`
+        The file for the RMF.
+
+    Returns
+    -------
+    : `DetectorResponseOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+
+    have_region, have_pitch = (region is not None), (pitch is not None)
+    pitch2region = {60<<u.um:0, 80<<u.um:1, 100<<u.um:2}
+    valid_region, valid_pitch = (region in list(pitch2region.values())), (pitch in list(pitch2region.keys()))
+
+    if (cdte is None) or (cdte not in [1,2,3,4]):
+        logging.warning(f"In {sys._getframe().f_code.co_name}, `cdte` must be given and in [1,2,3,4].")
+        return 
+    
+    if ((not have_region) and (not have_pitch)) \
+        or (have_region and have_pitch):
+        logging.warning(f"In {sys._getframe().f_code.co_name}, either `region` [0,1,2] _xor_ `pitch` [60<<u.um,80<<u.um,100<<u.um] must be given.")
+        return 
+    
+    if have_region and (not valid_region):
+        logging.warning(f"In {sys._getframe().f_code.co_name}, the `region` must be in [0,1,2].")
+        return 
+
+    if have_pitch and (not valid_pitch):
+        logging.warning(f"In {sys._getframe().f_code.co_name}, the `pitch` must be in [60<<u.um,80<<u.um,100<<u.um].")
+        return 
+    
+    if side not in ["pt", "merged"]:
+        logging.warning(f"In {sys._getframe().f_code.co_name}, the `side` must be in [\"pt\", \"merged\"].")
+        return 
+    
+    if event_type not in ["1hit", "2hit", "all", "mix"]:
+        logging.warning(f"In {sys._getframe().f_code.co_name}, the `event_type` must be in [\"1hit\", \"2hit\", (\"all\", \"mix\")].")
+        return 
+    
+    if side=="merged" and event_type=="mix":
+        event_type="all"
+    elif side in ["pt"] and event_type=="all":
+        event_type="mix"
+    
+    region = pitch2region[pitch] if have_pitch else region
+    
+    _f = os.path.join(DET_RESP_PATH, "cdte", side, f"Resp_3keVto30keV_CdTe{cdte}_reg{region}_{event_type}.rmf") if file is None else file
+    r = cdte_det_resp_rmf(_f)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    r.detector = f"CdTe{cdte}-Detector-Response"
+    return r
 
 def cmos_det_resp(file=None, telescope=None):
+    """Return the redistribution matrix for CMOS from a given file.
+
+    Parameters
+    ----------
+    file : `str`
+        The file for the RMF.
+
+    telescope : `int`
+        Either 0 or 1.
+
+    Returns
+    -------
+    : `DetectorResponseOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
 
-    if telescope is None:
-        logging.warning("`telescope` input in cmos_det_resp()` must be 0 or 1.")
+    if (telescope is None) or (telescope not in [0,1]):
+        logging.warning(f"The `telescope` input in {sys._getframe().f_code.co_name} must be 0 or 1.")
         return
         
     _f = os.path.join(DET_RESP_PATH, 
                       "cmos", 
-                      f"foxsi4_telescope-{telescope}_BASIC_RESPONSE_MATRIX_V25APR13.fits") if file is None else file
+                      f"foxsi4_telescope-{telescope}_BASIC_RESPONSE_MATRIX_v1.fits") if file is None else file
     
     with fits.open(_f) as hdul:
-        matrix, counts, energy = hdul[1].data<<(u.ct/u.ph), hdul[2].data<<u.dimensionless_unscaled, hdul[3].data<<u.keV # units?
-    return counts, energy, matrix 
+        matrix, counts, energy = hdul[1].data<<(u.DN/u.ph), hdul[2].data<<u.DN, hdul[3].data<<u.keV # units?
+
+    return DetectorResponseOutput(filename=file,
+                                  function_path=f"{sys._getframe().f_code.co_name}",
+                                  input_energy_edges=energy,
+                                  output_energy_edges=counts,
+                                  detector_response=matrix,
+                                  detector=f"CMOS{telescope}-Detector-Response"
+                                  )
 
 def _read_rmf(file):
     """
@@ -232,79 +385,108 @@ def vrmf2arr_py(data=None, n_grp_list=None, f_chan_array=None, n_chan_array=None
 
     return mat_array_py
 
-
-if __name__=="__main__":
-
-    SAVE_ASSETS = False
-    assets_dir = os.path.join(pathlib.Path(__file__).parent, "..", "..", "assets", "response-tools-py-figs", "det-resp-figs")
-    pathlib.Path(assets_dir).mkdir(parents=True, exist_ok=True)
-
+def asset_cmos_resp(save_asset=False):
     # CMOS
     fig = plt.figure(figsize=(12,7))
 
     gs = gridspec.GridSpec(1, 2)
     gs_ax0 = fig.add_subplot(gs[0, 0])
     telescope = 0
-    c, e, m = cmos_det_resp(file=None, telescope=telescope)
-    extent = [np.min(c.value), np.max(c.value), np.min(e.value), np.max(e.value)]
-    i = gs_ax0.imshow(m.value, origin="lower", aspect=(extent[1]-extent[0])/(extent[3]-extent[2]), extent=extent, norm=LogNorm())
+    cmos0_resp = cmos_det_resp(file=None, telescope=telescope)
+    extent = [np.min(cmos0_resp.output_energy_edges.value), 
+              np.max(cmos0_resp.output_energy_edges.value), 
+              np.min(cmos0_resp.input_energy_edges.value), 
+              np.max(cmos0_resp.input_energy_edges.value)]
+    i = gs_ax0.imshow(cmos0_resp.detector_response.value, origin="lower", aspect=(extent[1]-extent[0])/(extent[3]-extent[2]), extent=extent, norm=LogNorm())
     gs_ax0.set_ylim([0,10])
-    gs_ax0.set_xlabel("Counts?")
-    gs_ax0.set_ylabel(f"Energy? [{e.unit:latex}]")
+    gs_ax0.set_xlabel(f"Counts [{cmos0_resp.output_energy_edges.unit:latex}]")
+    gs_ax0.set_ylabel(f"Energy [{cmos0_resp.input_energy_edges.unit:latex}]")
     gs_ax0.set_title(f"CMOS{telescope}")
     cax = gs_ax0.inset_axes([0.1, 0.08, 0.8, 0.05],)
     cbar = fig.colorbar(i, cax=cax, orientation='horizontal')
-    cbar.set_label(f"{m.unit:latex}?", size=8, labelpad=0)
+    cbar.set_label(f"{cmos0_resp.detector_response.unit:latex}", size=8, labelpad=0)
     cax.tick_params(axis='both', which='major', labelsize=6)
 
 
     gs_ax1 = fig.add_subplot(gs[0, 1])
     telescope = 1
-    c, e, m = cmos_det_resp(file=None, telescope=telescope)
-    extent = [np.min(c.value), np.max(c.value), np.min(e.value), np.max(e.value)]
-    i = gs_ax1.imshow(m.value, origin="lower", aspect=(extent[1]-extent[0])/(extent[3]-extent[2]), extent=extent, norm=LogNorm())
+    cmos1_resp = cmos_det_resp(file=None, telescope=telescope)
+    extent = [np.min(cmos1_resp.output_energy_edges.value), 
+              np.max(cmos1_resp.output_energy_edges.value), 
+              np.min(cmos1_resp.input_energy_edges.value), 
+              np.max(cmos1_resp.input_energy_edges.value)]
+    i = gs_ax1.imshow(cmos1_resp.detector_response.value, origin="lower", aspect=(extent[1]-extent[0])/(extent[3]-extent[2]), extent=extent, norm=LogNorm())
     gs_ax1.set_ylim([0,10])
-    gs_ax1.set_xlabel("Counts?")
-    gs_ax1.set_ylabel(f"Energy? [{e.unit:latex}]")
+    gs_ax1.set_xlabel(f"Counts [{cmos1_resp.output_energy_edges.unit:latex}]")
+    gs_ax1.set_ylabel(f"Energy [{cmos1_resp.input_energy_edges.unit:latex}]")
     gs_ax1.set_title(f"CMOS{telescope}")
     cax = gs_ax1.inset_axes([0.1, 0.08, 0.8, 0.05],)
     cbar = fig.colorbar(i, cax=cax, orientation='horizontal')
-    cbar.set_label(f"{m.unit:latex}?", size=8, labelpad=0)
+    cbar.set_label(f"{cmos1_resp.detector_response.unit:latex}", size=8, labelpad=0)
     cax.tick_params(axis='both', which='major', labelsize=6)
 
     plt.tight_layout()
-    if SAVE_ASSETS:
-        plt.savefig(os.path.join(assets_dir,"cmos-response-matrices.png"), dpi=200, bbox_inches="tight")
+    if save_asset:
+        pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
+        plt.savefig(os.path.join(ASSETS_PATH,"cmos-response-matrices.png"), dpi=200, bbox_inches="tight")
     plt.show()
 
+def asset_cdte_resp(save_asset=False):
     # CdTe
     d_rmf = os.path.join(DET_RESP_PATH, "cdte", "pt") 
     f_rmf = "Resp_3keVto30keV_CdTe1_reg0_1hit.rmf"
 
-
-    e_lo, e_hi, rmf = cdte_det_resp_rmf(os.path.join(pathlib.Path(__file__).parent, d_rmf, f_rmf))
+    cdte_resp = cdte_det_resp_rmf(os.path.join(pathlib.Path(__file__).parent, d_rmf, f_rmf))
 
     fig = plt.figure(figsize=(12, 5))
     gs = gridspec.GridSpec(1, 2)
 
     gs_ax0 = fig.add_subplot(gs[0, 0])
-    r = gs_ax0.imshow(rmf.value, origin="lower", norm=Normalize(vmin=0.001, vmax=0.12), extent=[np.min(e_lo.value), np.max(e_lo.value), np.min(e_lo.value), np.max(e_lo.value)])
+    r = gs_ax0.imshow(cdte_resp.detector_response.value, 
+                      origin="lower", 
+                      norm=Normalize(vmin=0.001, 
+                                     vmax=np.max(cdte_resp.detector_response.value)*0.9), 
+                      extent=[np.min(cdte_resp.output_energy_edges.value), 
+                              np.max(cdte_resp.output_energy_edges.value), 
+                              np.min(cdte_resp.input_energy_edges.value), 
+                              np.max(cdte_resp.input_energy_edges.value)]
+                      )
     cbar = plt.colorbar(r)
-    cbar.ax.set_ylabel('Counts photon$^{-1}$')
-    fig.suptitle(d_rmf+f_rmf)
-    gs_ax0.set_xlabel("Count Energy [keV]")
-    gs_ax0.set_ylabel("Photon Energy [keV]")
+    cbar.ax.set_ylabel(f"Response [{cdte_resp.detector_response.unit:latex}]")
+    gs_ax0.set_xlabel(f"Count Energy [{cdte_resp.output_energy_edges.unit:latex}]")
+    gs_ax0.set_ylabel(f"Photon Energy [{cdte_resp.input_energy_edges.unit:latex}]")
     gs_ax0.set_title("Linear Scale")
 
-    gs_ax0 = fig.add_subplot(gs[0, 1])
-    r = gs_ax0.imshow(rmf.value, origin="lower", norm=LogNorm(vmin=0.001, vmax=0.12), extent=[np.min(e_lo.value), np.max(e_lo.value), np.min(e_lo.value), np.max(e_lo.value)])
+    gs_ax1 = fig.add_subplot(gs[0, 1])
+    r = gs_ax1.imshow(cdte_resp.detector_response.value, 
+                      origin="lower", 
+                      norm=LogNorm(vmin=0.001, 
+                                   vmax=np.max(cdte_resp.detector_response.value)*0.9), 
+                      extent=[np.min(cdte_resp.output_energy_edges.value), 
+                              np.max(cdte_resp.output_energy_edges.value), 
+                              np.min(cdte_resp.input_energy_edges.value), 
+                              np.max(cdte_resp.input_energy_edges.value)]
+                      )
     cbar = plt.colorbar(r)
-    cbar.ax.set_ylabel('Counts photon$^{-1}$')
-    fig.suptitle(d_rmf+f_rmf)
-    gs_ax0.set_xlabel("Count Energy [keV]")
-    gs_ax0.set_ylabel("Photon Energy [keV]")
-    gs_ax0.set_title("Log Scale")
-
-    if SAVE_ASSETS:
-        plt.savefig(os.path.join(assets_dir,"cdte-response-matrix.png"), dpi=200, bbox_inches="tight")
-    plt.show()
\ No newline at end of file
+    cbar.ax.set_ylabel(f"Response [{cdte_resp.detector_response.unit:latex}]")
+    gs_ax1.set_xlabel(f"Count Energy [{cdte_resp.output_energy_edges.unit:latex}]")
+    gs_ax1.set_ylabel(f"Photon Energy [{cdte_resp.input_energy_edges.unit:latex}]")
+    gs_ax1.set_title("Log Scale")
+
+    fig.suptitle(f_rmf)
+
+    if save_asset:
+        pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
+        plt.savefig(os.path.join(ASSETS_PATH,"cdte-response-matrix.png"), dpi=200, bbox_inches="tight")
+    plt.show()
+
+if __name__=="__main__":
+    from matplotlib.colors import LogNorm, Normalize
+    import matplotlib.gridspec as gridspec
+    import matplotlib.pyplot as plt
+
+    SAVE_ASSETS = False
+
+    asset_cdte_resp(save_asset=SAVE_ASSETS)
+    
+    asset_cmos_resp(save_asset=SAVE_ASSETS)
\ No newline at end of file
diff --git a/response-tools-py/response_tools_py/effective_area.py b/response-tools-py/response_tools_py/effective_area.py
index 1a4f979..c33c48f 100644
--- a/response-tools-py/response_tools_py/effective_area.py
+++ b/response-tools-py/response_tools_py/effective_area.py
@@ -1,35 +1,85 @@
 """Code to load different effective areas. """
 
+from dataclasses import dataclass
 import logging
 import os
 import pathlib
+import sys
 
 from astropy.io import fits
 import astropy.units as u
 import matplotlib.gridspec as gridspec
 import matplotlib.pyplot as plt
 import numpy as np
-from scipy.interpolate import CloughTocher2DInterpolator, LinearNDInterpolator 
+from scipy.interpolate import CloughTocher2DInterpolator
 import pandas
 
-from util import native_resolution
+from response_tools_py.util import BaseOutput, native_resolution
 
 EFF_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "response-information", "effective-area-data")
 ASSETS_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "assets", "response-tools-py-figs", "eff-area-figs")
 
-@u.quantity_input(mid_energies=u.keV, off_axis=u.arcmin)
-def eff_area_msfc_10shell(mid_energies, off_axis=0, file_tilt=None, file_pan=None, optic_id=None):
-    """ 
-    Tilt is the off-axis angle when the optics up coincides with Solar North (“vertical”). Pan is the other angle (“horizontal”).
+@dataclass
+class EffAreaOutput(BaseOutput):
+    """Class for keeping track of effective area response values."""
+    # numbers
+    mid_energies: u.Quantity
+    off_axis_angle: u.Quantity
+    effective_areas: u.Quantity
+    # bookkeeping
+    optic_id: str
+    model: bool
+    # any other fields needed can be added here
+    # can even add with a default so the input is not required for every other instance
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def eff_area_msfc_10shell(mid_energies, off_axis_angle=0<<u.arcmin, optic_id=None, file_tilt=None, file_pan=None):
+    """Function for the heritage 10-shell FOXSI-4 optic effective areas.
+
+    The effective areas from the heritage optics do not use a 
+    theoretical or model fit, instead they use the measured data-points 
+    and interpolate where necessary.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        Default: 0 arc-minutes (on axis)
+
+    optic_id : `str`
+        Heritage optic to be returned. Choices are \"X-7\" or \"X-8\".
+        Default: None
+
+    file_tilt, file_pan : `str` or `None`
+        Gives the ability to provide custom files for the tilt and pan
+        information. Tilt is the off-axis angle when the optics 
+        up coincides with Solar North (“vertical”). Pan is the other 
+        angle (“horizontal”).
+        Default: None
+
+    Returns
+    -------
+    : `EffAreaOutput`
+        An object containing the energies for each effective area, the 
+        off-axis angle used, the effective areas, and more. See 
+        accessible information using `.contents` on the output.
     """
     _id = optic_id if optic_id in ["X-7", "X-8"] else None
     if _id is None:
         logging.warning("Please provide a MSFC heritage optic ID from [\'X-7\', \'X-8\'].")
+        return
         
-    vals_tilt = _get_ea_file_info(_id, "tilt", file=file_tilt)
-    vals_pan = _get_ea_file_info(_id, "pan", file=file_pan)
+    _ft, vals_tilt = _get_ea_file_info(_id, "tilt", file=file_tilt)
+    _fp, vals_pan = _get_ea_file_info(_id, "pan", file=file_pan)
 
-    # from Milo on 17/3/2025 @ 13:47 (Slack)
+    # from Milo to Kris on 17/3/2025 @ 13:47 (Slack)
     ea_energies = [4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 11. , 13. , 15. , 17. , 19. , 22.5, 27.5] << u.keV
 
     off_axis_angles_tilt, eff_areas_tilt = _get_oa_and_ea_msfc_10shell(vals_tilt)
@@ -39,32 +89,83 @@ def eff_area_msfc_10shell(mid_energies, off_axis=0, file_tilt=None, file_pan=Non
 
     x, y = np.meshgrid(ea_energies, off_axis_angles_tilt)
     i = CloughTocher2DInterpolator(list(zip(x.flatten().value, y.flatten().value)), mean_eff_areas_areas.T.flatten().value)
-
+    
     mid_energies = native_resolution(native_x=ea_energies, input_x=mid_energies)
-    off_axis = native_resolution(native_x=off_axis_angles_tilt, input_x=off_axis)
+    off_axis_angle = native_resolution(native_x=off_axis_angles_tilt, input_x=off_axis_angle)
 
-    return mid_energies, off_axis, i(mid_energies, off_axis) << u.cm**2
+    effective_areas = i(mid_energies, off_axis_angle) << u.cm**2
+    effective_areas[effective_areas<0<<u.cm**2] = 0<<u.cm**2
+
+    return EffAreaOutput(filename=f"tilt:{_ft}, pan:{_fp}",
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         off_axis_angle=off_axis_angle,
+                         effective_areas=effective_areas,
+                         optic_id=_id,
+                         model=False,
+                         )
 
 def _get_ea_file_info(optics_id, axis, file=None):
+    """Loads in the desired heritage .txt optic file."""
     _f = os.path.join(EFF_PATH, f"FOXSI3_Module_{optics_id}_EA_{axis}_v1.txt") if file is None else file
-    return np.loadtxt(_f, delimiter=",")
+    return _f, np.loadtxt(_f, delimiter=",")
 
 def _get_oa_and_ea_msfc_10shell(grid):
+    """Extract the angles and eff. areas + units for heritage optics."""
     off_axis_angles = grid[0]
     eff_areas = grid[1:]
     return off_axis_angles << u.arcmin, eff_areas << u.cm**2
 
-@u.quantity_input(mid_energies=u.keV)
-def eff_area_msfc_hi_res(mid_energies, file=None, position=None, use_model=False):
-    """Return MSCF hi-res effective areas interpolated to the given energies.
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def eff_area_msfc_hi_res(mid_energies, off_axis_angle=None, position=None, use_model=False, file=None):
+    """MSCF hi-res effective areas interpolated to the given energies.
     
-    Latest from Wayne.
+    This is the latest from Wayne.
     - older function is `eff_area_msfc`
     
     Position 0: X10/FM2
     Position 3: X09/FM1
     Position 6: X11/FM3
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        *** Not implemented yet. ***
+
+    position : `int`
+        The focal plane position of the desired optic. Must be in the
+        list [0, 3, 6]. 
+            Position 0 -> X10/FM2
+            Position 3 -> X09/FM1
+            Position 6 -> X11/FM3
+        Default: None
+
+    use_model : `bool`
+        Defines whether to use the measured values for the optic (False)
+        or the modelled values (True).
+        Default: False
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `EffAreaOutput`
+        An object containing the energies for each effective area, the 
+        effective areas, and more. See accessible information using 
+        `.contents` on the output.
     """
+    if off_axis_angle is not None:
+        logging.warning(f"The `off_axis_angle` input for MSFC high-resolution optics ({sys._getframe().f_code.co_name}) is not yet implemented.")
     # msfc_hi_res effective areas
     _f = os.path.join(EFF_PATH, "FOXSI4_Module_MSFC_HiRes_EA_with_models_v1.txt") if file is None else file
     e, f1, f2, f3, f1_m, f2_m, f3_m = np.loadtxt(_f).T
@@ -78,19 +179,33 @@ def eff_area_msfc_hi_res(mid_energies, file=None, position=None, use_model=False
     fm2 <<= u.cm**2
     fm3 <<= u.cm**2
     if position==0:
-        return mid_energies, np.interp(mid_energies.value, e.value, fm2.value, left=fm2.value[0], right=0) << u.cm**2
+        ea_vals, opt_id = fm2.value, "X10/FM2"
     elif position==3:
-        return mid_energies, np.interp(mid_energies.value, e.value, fm1.value, left=fm1.value[0], right=0) << u.cm**2
+        ea_vals, opt_id = fm1.value, "X09/FM1"
     elif position==6:
-        return mid_energies, np.interp(mid_energies.value, e.value, fm3.value, left=fm3.value[0], right=0) << u.cm**2
+        ea_vals, opt_id = fm3.value, "X11/FM3"
     else:
-        logging.warning("`position` must be 0 (X10/FM2), 3 (X09/FM1), or 6 (X11/FM3).")
+        logging.warning(f"The `position` in {sys._getframe().f_code.co_name} must be 0 (X10/FM2), 3 (X09/FM1), or 6 (X11/FM3).")
+        return
+
+    return EffAreaOutput(filename=_f,
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         off_axis_angle="N/A",
+                         effective_areas=np.interp(mid_energies.value, 
+                                                   e.value, 
+                                                   ea_vals, 
+                                                   left=ea_vals[0], 
+                                                   right=0) << u.cm**2,
+                         optic_id=opt_id,
+                         model=use_model,
+                         )
 
 @u.quantity_input(mid_energies=u.keV)
-def eff_area_msfc(mid_energies, file=None):
-    """Return early MSCF hi-res effective areas interpolated to the given energies."""
+def _eff_area_msfc(mid_energies, file=None):
+    """Early MSCF hi-res eff. areas interpolated to given energies."""
     # msfc_hi_res effective areas
-    logging.warning("Caution: This might not be the function you are looking for, please see `eff_area_msfc_hi_res`.")
+    logging.warning(f"Caution: This might not be the function ({sys._getframe().f_code.co_name}) you are looking for, please see `eff_area_msfc_hi_res`.")
     logging.warning("This current function loads in some very early numbers for the new FOXSI-4 MSFC optics.")
     _f = os.path.join(EFF_PATH, "3Inner_EA_EPDL97_14AA.csv") if file is None else file
     msfc_hi_res = pandas.read_csv(_f).to_numpy()[:,1:] # remove the first column that only indexes
@@ -99,65 +214,224 @@ def eff_area_msfc(mid_energies, file=None):
     msfc_hi_res_effa = msfc_hi_res_effas08 + msfc_hi_res_effas10
 
     mid_energies = native_resolution(native_x=msfc_hi_res_es, input_x=mid_energies)
-    return mid_energies, np.interp(mid_energies.value, msfc_hi_res_es.value, msfc_hi_res_effa.value, left=msfc_hi_res_effa.value[0], right=0) << u.cm**2
+
+    return EffAreaOutput(filename=_f,
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         off_axis_angle="N/A",
+                         effective_areas=np.interp(mid_energies.value, 
+                                                   msfc_hi_res_es.value, 
+                                                   msfc_hi_res_effa.value, 
+                                                   left=msfc_hi_res_effa.value[0], 
+                                                   right=0) << u.cm**2,
+                         optic_id="Early-MSFC-EAs",
+                         model=True,
+                         )
 
 @u.quantity_input(mid_energies=u.keV)
-def eff_area_nagoya(mid_energies, file=None):
-    """Return early Nagoya SXR hi-res effective areas interpolated to the given energies."""
+def _eff_area_nagoya(mid_energies, file=None):
+    """Early Nagoya SXR hi-res eff. areas interpolated to energies."""
     # nagoya sxr effective areas
-    logging.warning("Caution: This might not be the function you are looking for and has other effects included than just optics.")
+    logging.warning(f"Caution: This might not be the function ({sys._getframe().f_code.co_name}) you are looking for and has other effects included than just optics.")
     logging.warning("This current function loads in some very early numbers for the new FOXSI-4 Nagoya SXR optics.")
     _f = os.path.join(EFF_PATH, "effective-area_raytracing_soft-xray-optic_on-axis.txt") if file is None else file
     nagoya_sxr = np.loadtxt(_f)
     nagoya_sxr_es, nagoya_sxr_effa = nagoya_sxr[:,0] << u.keV, nagoya_sxr[:,1]/100 << u.cm**2
 
     mid_energies = native_resolution(native_x=nagoya_sxr_es, input_x=mid_energies)
-    return mid_energies, np.interp(mid_energies.value, nagoya_sxr_es.value, nagoya_sxr_effa.value, left=0, right=0) << u.cm**2
 
-@u.quantity_input(mid_energies=u.keV)
-def eff_area_nagoya_hxt(mid_energies, file=None):
-    """Return Nagoya HXR hi-res effective areas (measured) interpolated to the given energies."""
-    # nagoya sxr effective areas
-    _f = os.path.join(EFF_PATH, "nagoya_hxt_onaxis_measurement_v1.txt") if file is None else file
-    nagoya_sxr = np.loadtxt(_f)
-    # energy, energy_err, area, area_err
-    nagoya_sxr_es, _, nagoya_sxr_effa, _ = nagoya_sxr[:,0] << u.keV, nagoya_sxr[:,1] << u.keV, nagoya_sxr[:,2] << u.cm**2, nagoya_sxr[:,3] << u.cm**2
+    return EffAreaOutput(filename=_f,
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         off_axis_angle="N/A",
+                         effective_areas=np.interp(mid_energies.value, 
+                                                   nagoya_sxr_es.value, 
+                                                   nagoya_sxr_effa.value, 
+                                                   left=0, 
+                                                   right=0) << u.cm**2,
+                         optic_id="Early-Nagoya-SXR-EAs",
+                         model=True,
+                         )
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def eff_area_nagoya_hxt(mid_energies, off_axis_angle=None, use_model=False, file=None):
+    """Nagoya HXR hi-res effective areas interpolated to given energies.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        *** Not implemented yet. ***
+
+    use_model : `bool`
+        Defines whether to use the measured values for the optic (False)
+        or the modelled values (True).
+        Default: False
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `EffAreaOutput`
+        An object containing the energies for each effective area, the 
+        effective areas, and more. See accessible information using 
+        `.contents` on the output.
+    """
+    if off_axis_angle is not None:
+        logging.warning(f"The `off_axis_angle` input for Nagoya high-resolution optics ({sys._getframe().f_code.co_name}) is not yet implemented.")
+    # nagoya hxr effective areas
+    if not use_model:
+        _f = os.path.join(EFF_PATH, "nagoya_hxt_onaxis_measurement_v1.txt") if file is None else file
+        nagoya_hxr = np.loadtxt(_f)
+        nagoya_hxr_es, _, nagoya_hxr_effa, _ = nagoya_hxr[:,0] << u.keV, nagoya_hxr[:,1] << u.keV, nagoya_hxr[:,2] << u.mm**2, nagoya_hxr[:,3] << u.mm**2
+        nagoya_hxr_effa = nagoya_hxr_effa << u.cm**2
+    else:
+        _f = os.path.join(EFF_PATH, "HXR_Nagoya_FOXSI4.arf") if file is None else file
+        with fits.open(_f) as hdul:
+            nagoya_hxr_es = (hdul[1].data["ENERG_LO"]+hdul[1].data["ENERG_HI"])/2 << u.keV
+            nagoya_hxr_effa = hdul[1].data["SPECRESP"] << u.cm**2
     
-    mid_energies = native_resolution(native_x=nagoya_sxr_es, input_x=mid_energies)
-    return mid_energies, np.interp(mid_energies.value, nagoya_sxr_es.value, nagoya_sxr_effa.value, left=0, right=0) << u.cm**2
+    mid_energies = native_resolution(native_x=nagoya_hxr_es, input_x=mid_energies)
+
+    return EffAreaOutput(filename=_f,
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         off_axis_angle="N/A",
+                         effective_areas=np.interp(mid_energies.value, 
+                                                   nagoya_hxr_es.value, 
+                                                   nagoya_hxr_effa.value, 
+                                                   left=0, 
+                                                   right=0) << u.cm**2,
+                         optic_id="Nagoya-HXT",
+                         model=use_model,
+                         )
 
 @u.quantity_input(mid_energies=u.keV)
-def eff_area_nagoya_sxt(mid_energies, file=None):
-    """Return Nagoya SXR hi-res effective areas (measured) interpolated to the given energies."""
+def eff_area_nagoya_sxt(mid_energies, use_model=False, file=None):
+    """Nagoya SXR hi-res effective areas interpolated to given energies.
+    
+    Includes the collimator and OBF too.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    use_model : `bool`
+        Defines whether to use the measured values for the optic (False)
+        or the modelled values (True).
+        Default: False
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `EffAreaOutput`
+        An object containing the energies for each effective area, the 
+        effective areas, and more. See accessible information using 
+        `.contents` on the output.
+    """
     # nagoya sxr effective areas
-    _f = os.path.join(EFF_PATH, "nagoya_sxt_onaxis_measurement_v1.txt") if file is None else file
-    nagoya_sxr = np.loadtxt(_f)
-    # energy, energy_err, area, area_err
-    nagoya_sxr_es, _, nagoya_sxr_effa, _ = nagoya_sxr[:,0] << u.keV, nagoya_sxr[:,1] << u.keV, nagoya_sxr[:,2] << u.cm**2, nagoya_sxr[:,3] << u.cm**2
+    if not use_model:
+        _f = os.path.join(EFF_PATH, "nagoya_sxt_onaxis_measurement_v1.txt") if file is None else file
+        nagoya_sxr = np.loadtxt(_f)
+        nagoya_sxr_es, _, nagoya_sxr_effa, _ = nagoya_sxr[:,0] << u.keV, nagoya_sxr[:,1] << u.keV, nagoya_sxr[:,2] << u.mm**2, nagoya_sxr[:,3] << u.mm**2
+        nagoya_sxr_effa = nagoya_sxr_effa << u.cm**2
+    else:
+        _f = os.path.join(EFF_PATH, "SXR_nocollimator_noobf.arf") if file is None else file
+        with fits.open(_f) as hdul:
+            nagoya_sxr_es = (hdul[1].data["ENERG_LO"]+hdul[1].data["ENERG_HI"])/2 << u.keV
+            nagoya_sxr_effa = hdul[1].data["SPECRESP"] << u.cm**2
     
     mid_energies = native_resolution(native_x=nagoya_sxr_es, input_x=mid_energies)
-    return mid_energies, np.interp(mid_energies.value, nagoya_sxr_es.value, nagoya_sxr_effa.value, left=0, right=0) << u.cm**2
+
+    return EffAreaOutput(filename=_f,
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         off_axis_angle="N/A",
+                         effective_areas=np.interp(mid_energies.value, 
+                                                   nagoya_sxr_es.value, 
+                                                   nagoya_sxr_effa.value, 
+                                                   left=0, 
+                                                   right=0) << u.cm**2,
+                         optic_id="Nagoya-SXT",
+                         model=use_model,
+                         )
 
 @u.quantity_input(mid_energies=u.keV)
-def eff_area_cmos(mid_energies, file=None, telescope=None):
+def eff_area_cmos(mid_energies, telescope=None, file=None):
     """Return optics paired with CMOS effective areas interpolated to 
     the given energies.
     
     Telescope 0: position 0, X10/FM2(?)
     Telescope 1: position 1, Nagoya(?)
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    telescope : `int`
+        The focal plane position of the desired optic. Must be in the
+        list [0, 1]. 
+            Telescope 0 -> Position 0 -> X10/FM2 
+            Telescope 1 -> Position 1 -> Nagoya-SXR
+        Default: None
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `EffAreaOutput`
+        An object containing the energies for each effective area, the 
+        effective areas, and more. See accessible information using 
+        `.contents` on the output.
     """
-    if telescope is None:
-        logging.warning("`telescope` input in `eff_area_cmos()` must be 0 or 1.")
+    if (telescope is None) or (telescope not in [0,1]):
+        logging.warning(f"The `telescope` input in {sys._getframe().f_code.co_name} must be 0 or 1.")
         return
         
     _f = os.path.join(EFF_PATH, f"foxsi4_telescope-{telescope}_BASIC_mirror_effective_area_v1.fits") if file is None else file
     with fits.open(_f) as hdul:
         es, effas = hdul[2].data << u.keV, hdul[1].data << u.cm**2
     mid_energies = native_resolution(native_x=es, input_x=mid_energies)
-    return mid_energies, np.interp(mid_energies.value, es.value, effas.value, left=0, right=0) << u.cm**2
+
+    position_alias = {0:"CMOS-X10/FM2", 1:"CMOS-Nagoya-SXT"}
+
+    return EffAreaOutput(filename=_f,
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         off_axis_angle="N/A",
+                         effective_areas=np.interp(mid_energies.value, 
+                                                   es.value, 
+                                                   effas.value, 
+                                                   left=0, 
+                                                   right=0) << u.cm**2,
+                         optic_id=position_alias[telescope],
+                         model=True,
+                         )
 
 @u.quantity_input(mid_energies=u.keV)
-def eff_area_cmos_telescope(mid_energies, file=None, telescope=None):
+def eff_area_cmos_telescope(mid_energies, telescope=None, file=None):
     """Return full telescope(?) with CMOS effective areas interpolated to 
     the given energies.
     
@@ -167,13 +441,39 @@ def eff_area_cmos_telescope(mid_energies, file=None, telescope=None):
     **Note**
     Will come back to this when there are off-axis angles and do 2D 
     interp. Currently only on-axis angle so just interp across energies.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    telescope : `int`
+        The focal plane position of the desired optic. Must be in the
+        list [0, 1]. 
+            Telescope 0 -> Position 0 -> X10/FM2 
+            Telescope 1 -> Position 1 -> Nagoya-SXR
+        Default: None
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `EffAreaOutput`
+        An object containing the energies for each effective area, the 
+        effective areas, and more. See accessible information using 
+        `.contents` on the output.
     """
-    if telescope is None:
-        logging.warning("`telescope` input in `eff_area_cmos_telescope()` must be 0 or 1.")
+    if (telescope is None) or (telescope not in [0,1]):
+        logging.warning(f"The `telescope` input in {sys._getframe().f_code.co_name} must be 0 or 1.")
         return
     
     # not tracking this combined response product
-    logging.warning("Caution: This output will include a combined response from various elements.")
+    logging.warning(f"Caution: The {sys._getframe().f_code.co_name} output will include a combined response from various elements.")
     logging.warning("If you care about what elements are included then proceed carefully.")
     logging.warning("For current file, see PR#11 in the `cmos-tools` repository.")
 
@@ -182,7 +482,21 @@ def eff_area_cmos_telescope(mid_energies, file=None, telescope=None):
         # _ is the off-axis angle but it's just [0] at the minute
         ea_energies, _, effas = hdul[2].data << u.keV, hdul[3].data << u.arcsec, hdul[1].data << u.cm**2
     mid_energies = native_resolution(native_x=ea_energies, input_x=mid_energies)
-    return mid_energies, np.interp(mid_energies.value, ea_energies.value, effas.value, left=0, right=0) << u.cm**2
+
+    position_alias = {0:"Telescope-CMOS-X10/FM2", 1:"Telescope-CMOS-Nagoya-SXT"}
+
+    return EffAreaOutput(filename=_f,
+                         function_path=f"{sys._getframe().f_code.co_name}",
+                         mid_energies=mid_energies,
+                         off_axis_angle="N/A",
+                         effective_areas=np.interp(mid_energies.value, 
+                                                   ea_energies.value, 
+                                                   effas.value, 
+                                                   left=0, 
+                                                   right=0) << u.cm**2,
+                         optic_id=position_alias[telescope],
+                         model=True,
+                         )
 
 def asset_cmos_plot(save_asset=False):
     """Plot the CMOS data to visually check."""
@@ -193,29 +507,29 @@ def asset_cmos_plot(save_asset=False):
     gs = gridspec.GridSpec(1, 2)
 
     gs_ax0 = fig.add_subplot(gs[0, 0])
-    _, a0 = eff_area_cmos(mid_energies, file=None, telescope=0)
-    _, a1 = eff_area_cmos(mid_energies, file=None, telescope=1)
-    _, msfcp0 = eff_area_msfc_hi_res(mid_energies, file=None, position=0)
-    _, msfcp0m = eff_area_msfc_hi_res(mid_energies, file=None, position=0, use_model=True)
-    _, nag = eff_area_nagoya_sxt(mid_energies)
-    gs_ax0.plot(mid_energies, a0, label="CMOS telescope 0, position 0")
-    gs_ax0.plot(mid_energies, a1, label="CMOS telescope 1, position 1")
-    gs_ax0.plot(mid_energies, msfcp0, label="MSFC (meas.) position 0")
-    gs_ax0.plot(mid_energies, msfcp0m, label="MSFC (mod.) position 0")
-    gs_ax0.plot(mid_energies, nag, label="Nagoya (meas.) position 1")
+    a0 = eff_area_cmos(mid_energies, file=None, telescope=0)
+    a1 = eff_area_cmos(mid_energies, file=None, telescope=1)
+    msfcp0 = eff_area_msfc_hi_res(mid_energies, file=None, position=0)
+    msfcp0m = eff_area_msfc_hi_res(mid_energies, file=None, position=0, use_model=True)
+    nag_sxt = eff_area_nagoya_sxt(mid_energies)
+    gs_ax0.plot(mid_energies, a0.effective_areas, label="CMOS telescope 0, position 0")
+    gs_ax0.plot(mid_energies, a1.effective_areas, label="CMOS telescope 1, position 1")
+    gs_ax0.plot(mid_energies, msfcp0.effective_areas, label="MSFC (meas.) position 0")
+    gs_ax0.plot(mid_energies, msfcp0m.effective_areas, label="MSFC (mod.) position 0")
+    gs_ax0.plot(mid_energies, nag_sxt.effective_areas, label="Nagoya (meas.) position 1")
     gs_ax0.set_title("CMOS Optics")
-    gs_ax0.set_ylabel(f"Effective Area [{a0.unit:latex}]")
+    gs_ax0.set_ylabel(f"Effective Area [{a0.effective_areas.unit:latex}]")
     gs_ax0.set_xlabel(f"Energy [{mid_energies.unit:latex}]")
     plt.legend()
 
     # CMOS full telescope ones
     gs_ax1 = fig.add_subplot(gs[0, 1])
-    _, a0ft = eff_area_cmos_telescope(mid_energies, file=None, telescope=0)
-    _, a1ft = eff_area_cmos_telescope(mid_energies, file=None, telescope=1)
-    gs_ax1.plot(mid_energies, a0ft, label="CMOS telescope 0, position 0")
-    gs_ax1.plot(mid_energies, a1ft, label="CMOS telescope 1, position 1")
+    a0ft = eff_area_cmos_telescope(mid_energies, file=None, telescope=0)
+    a1ft = eff_area_cmos_telescope(mid_energies, file=None, telescope=1)
+    gs_ax1.plot(mid_energies, a0ft.effective_areas, label="CMOS telescope 0, position 0")
+    gs_ax1.plot(mid_energies, a1ft.effective_areas, label="CMOS telescope 1, position 1")
     gs_ax1.set_title("CMOS Telescope?")
-    gs_ax1.set_ylabel(f"Effective Area [{a0ft.unit:latex}]")
+    gs_ax1.set_ylabel(f"Effective Area [{a0ft.effective_areas.unit:latex}]")
     gs_ax1.set_xlabel(f"Energy [{mid_energies.unit:latex}]")
     plt.legend()
 
@@ -225,7 +539,7 @@ def asset_cmos_plot(save_asset=False):
         plt.savefig(os.path.join(ASSETS_PATH,"cmos-sxr-optics-resp.png"), dpi=200, bbox_inches="tight")
     plt.show()
 
-def asset_cmos_sxr(save_asset=False):
+def asset_cmos_files(save_asset=False):
     """Plot the CMOS data to visually check."""
     mid_energies = np.linspace(0, 20, 1000)<<u.keV
     
@@ -234,16 +548,37 @@ def asset_cmos_sxr(save_asset=False):
     gs = gridspec.GridSpec(1, 2)
 
     gs_ax0 = fig.add_subplot(gs[0, 0])
-    _, a1 = eff_area_cmos(mid_energies, file=None, telescope=1)
-    _, nag = eff_area_nagoya_sxt(mid_energies)
-    gs_ax0.plot(mid_energies, a1, label="CMOS telescope 1, position 1")
-    gs_ax0.plot(mid_energies, nag, label="Nagoya (meas.) position 1")
-    gs_ax0.set_title("CMOS SXR Optics")
-    gs_ax0.set_ylabel(f"Effective Area [{a1.unit:latex}]")
+    a0 = eff_area_cmos(mid_energies, telescope=0)
+    msfc_hi_res_p0 = eff_area_msfc_hi_res(mid_energies, position=0)
+    msfc_hi_res_p0m = eff_area_msfc_hi_res(mid_energies, position=0, use_model=True)
+    gs_ax0.plot(mid_energies, a0.effective_areas, label="CMOS telescope 0, position 0")
+    gs_ax0.plot(mid_energies, msfc_hi_res_p0.effective_areas, label="MSFC (meas.), position 0")
+    gs_ax0.plot(mid_energies, msfc_hi_res_p0m.effective_areas, label="MSFC (mod.), position 0")
+    gs_ax0.set_title("CMOS SXR Optics: Position 0")
+    gs_ax0.set_ylabel(f"Effective Area [{a0.effective_areas.unit:latex}]")
     gs_ax0.set_xlabel(f"Energy [{mid_energies.unit:latex}]")
     plt.legend()
     plt.yscale("log")
 
+    from attenuation import att_cmos_obfilter, att_cmos_collimator_ratio
+
+    gs_ax1 = fig.add_subplot(gs[0, 1])
+    a1 = eff_area_cmos(mid_energies, telescope=1)
+    nag_sxt = eff_area_nagoya_sxt(mid_energies)
+    gs_ax1.plot(mid_energies, a1.effective_areas*att_cmos_obfilter(mid_energies, telescope=1).transmissions*att_cmos_collimator_ratio(0<<u.arcmin, telescope=1).transmissions, label="CMOS telescope 1*collimator*obf, position 1")
+    gs_ax1.plot(mid_energies, nag_sxt.effective_areas, label="Nagoya SXT (meas.) position 1")
+    gs_ax1.set_title("CMOS SXR Optics: Position 1")
+    gs_ax1.set_ylabel(f"Effective Area [{a1.effective_areas.unit:latex}]")
+    gs_ax1.set_xlabel(f"Energy [{mid_energies.unit:latex}]")
+    plt.legend()
+    # plt.yscale("log")
+    plt.ylim([0,0.35])
+
+    plt.xlim([0,20])
+
+    # print(a1)
+    print(att_cmos_collimator_ratio(0<<u.arcmin, telescope=0), 1/att_cmos_collimator_ratio(0<<u.arcmin, telescope=0).transmissions)
+
     plt.tight_layout()
     if save_asset:
         pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
@@ -259,8 +594,8 @@ def asset_all_optics(save_asset=False):
     ## OPTIC: X-7
     optic = "X-7" 
 
-    vals_tilt = _get_ea_file_info(optic, "tilt")
-    vals_pan = _get_ea_file_info(optic, "pan")
+    _, vals_tilt = _get_ea_file_info(optic, "tilt")
+    _, vals_pan = _get_ea_file_info(optic, "pan")
     off_axis_angles_tilt, eff_areas_tilt = _get_oa_and_ea_msfc_10shell(vals_tilt)
     off_axis_angles_pan, eff_areas_pan = _get_oa_and_ea_msfc_10shell(vals_pan)
     ea_energies = [4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 11. , 13. , 15. , 17. , 19. , 22.5, 27.5] << u.keV
@@ -294,8 +629,8 @@ def asset_all_optics(save_asset=False):
     _ps = []
     for oaa in off_axis_angles_tilt:
         _lw = 1 if oaa >=0 else 2
-        _, _, efs = eff_area_msfc_10shell(ea_energies, off_axis=oaa<<u.arcmin, optic_id=optic)
-        _p = gs_ax2.plot(ea_energies, efs, label=f"{oaa:latex}", lw=_lw)
+        x7 = eff_area_msfc_10shell(ea_energies, off_axis_angle=oaa<<u.arcmin, optic_id=optic)
+        _p = gs_ax2.plot(ea_energies, x7.effective_areas, label=f"{oaa:latex}", lw=_lw)
         _ps += _p
     gs_ax2.set_ylabel(f"{optic} [{eff_areas_pan.unit:latex}]")
     gs_ax2.set_xlabel(f"Energy [{ea_energies.unit:latex}]")
@@ -303,14 +638,14 @@ def asset_all_optics(save_asset=False):
     gs_ax2.set_xlim([ea_energies[0].value, ea_energies[-1].value])
 
     for gsax in [gs_ax0, gs_ax1, gs_ax2]:
-        _, _, efs = eff_area_msfc_10shell(ea_energies, off_axis=0<<u.arcmin, optic_id=optic)
-        gsax.set_ylim([0, np.nanmax(efs).value*1.01])
+        x7 = eff_area_msfc_10shell(ea_energies, off_axis_angle=0<<u.arcmin, optic_id=optic)
+        gsax.set_ylim([0, np.nanmax(x7.effective_areas).value*1.01])
 
     ## OPTIC: X-8
     optic = "X-8"
 
-    vals_tilt = _get_ea_file_info(optic, "tilt")
-    vals_pan = _get_ea_file_info(optic, "pan")
+    _, vals_tilt = _get_ea_file_info(optic, "tilt")
+    _, vals_pan = _get_ea_file_info(optic, "pan")
     off_axis_angles_tilt, eff_areas_tilt = _get_oa_and_ea_msfc_10shell(vals_tilt)
     off_axis_angles_pan, eff_areas_pan = _get_oa_and_ea_msfc_10shell(vals_pan)
     ea_energies = [4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 11. , 13. , 15. , 17. , 19. , 22.5, 27.5] << u.keV
@@ -340,8 +675,8 @@ def asset_all_optics(save_asset=False):
     _ps = []
     for oaa in off_axis_angles_tilt:
         _lw = 1 if oaa >=0 else 2
-        _, _, efs = eff_area_msfc_10shell(ea_energies, off_axis=oaa<<u.arcmin, optic_id=optic)
-        _p = gs_ax5.plot(ea_energies, efs, label=f"{oaa:latex}", lw=_lw)
+        x8 = eff_area_msfc_10shell(ea_energies, off_axis_angle=oaa<<u.arcmin, optic_id=optic)
+        _p = gs_ax5.plot(ea_energies, x8.effective_areas, label=f"{oaa:latex}", lw=_lw)
         _ps += _p
     gs_ax5.set_ylabel(f"{optic} [{eff_areas_pan.unit:latex}]")
     gs_ax5.set_xlabel(f"Energy [{ea_energies.unit:latex}]")
@@ -349,57 +684,53 @@ def asset_all_optics(save_asset=False):
     gs_ax5.set_xlim([ea_energies[0].value, ea_energies[-1].value])
 
     for gsax in [gs_ax3, gs_ax4, gs_ax5]:
-        _, _, efs = eff_area_msfc_10shell(ea_energies, off_axis=0<<u.arcmin, optic_id=optic)
-        gsax.set_ylim([0, np.nanmax(efs).value*1.01])
+        x8 = eff_area_msfc_10shell(ea_energies, off_axis_angle=0<<u.arcmin, optic_id=optic)
+        gsax.set_ylim([0, np.nanmax(x8.effective_areas).value*1.01])
 
     gs_ax5 = fig.add_subplot(gs[2, 0])
     _f = os.path.join(EFF_PATH, "FOXSI4_Module_MSFC_HiRes_EA_with_models_v1.txt")
     e, *_ = np.loadtxt(_f).T
     e <<= u.keV
-    _, msfc_hi_res_p0 = eff_area_msfc_hi_res(e, position=0)
-    _, msfc_hi_res_p3 = eff_area_msfc_hi_res(e, position=3)
-    _, msfc_hi_res_p6 = eff_area_msfc_hi_res(e, position=6)
-    _, msfc_hi_res_p0m = eff_area_msfc_hi_res(e, position=0, use_model=True)
-    _, msfc_hi_res_p3m = eff_area_msfc_hi_res(e, position=3, use_model=True)
-    _, msfc_hi_res_p6m = eff_area_msfc_hi_res(e, position=6, use_model=True)
-    p10 = gs_ax5.plot(e, msfc_hi_res_p0, label="Pos. 0 (X10/FM2)")
-    p20 = gs_ax5.plot(e, msfc_hi_res_p3, label="Pos. 3 (X09/FM1)")
-    p30 = gs_ax5.plot(e, msfc_hi_res_p6, label="Pos. 6 (X11/FM3)")
-    p11 = gs_ax5.plot(e, msfc_hi_res_p0m, label="Pos. 0 (X10/FM2, model)")
-    p21 = gs_ax5.plot(e, msfc_hi_res_p3m, label="Pos. 3 (X09/FM1, model)")
-    p31 = gs_ax5.plot(e, msfc_hi_res_p6m, label="Pos. 6 (X11/FM3, model)")
+    msfc_hi_res_p0 = eff_area_msfc_hi_res(e, position=0)
+    msfc_hi_res_p3 = eff_area_msfc_hi_res(e, position=3)
+    msfc_hi_res_p6 = eff_area_msfc_hi_res(e, position=6)
+    msfc_hi_res_p0m = eff_area_msfc_hi_res(e, position=0, use_model=True)
+    msfc_hi_res_p3m = eff_area_msfc_hi_res(e, position=3, use_model=True)
+    msfc_hi_res_p6m = eff_area_msfc_hi_res(e, position=6, use_model=True)
+    p10 = gs_ax5.plot(e, msfc_hi_res_p0.effective_areas, label="Pos. 0 (X10/FM2)")
+    p20 = gs_ax5.plot(e, msfc_hi_res_p3.effective_areas, label="Pos. 3 (X09/FM1)")
+    p30 = gs_ax5.plot(e, msfc_hi_res_p6.effective_areas, label="Pos. 6 (X11/FM3)")
+    p11 = gs_ax5.plot(e, msfc_hi_res_p0m.effective_areas, label="Pos. 0 (X10/FM2, model)")
+    p21 = gs_ax5.plot(e, msfc_hi_res_p3m.effective_areas, label="Pos. 3 (X09/FM1, model)")
+    p31 = gs_ax5.plot(e, msfc_hi_res_p6m.effective_areas, label="Pos. 6 (X11/FM3, model)")
     gs_ax5.set_title("MSFC High-res.")
     gs_ax5.set_xlabel(f"Energy {e.unit:latex}")
-    gs_ax5.set_ylabel(f"Eff. Area {msfc_hi_res_p0.unit:latex}")
+    gs_ax5.set_ylabel(f"Eff. Area {msfc_hi_res_p0.effective_areas.unit:latex}")
     plt.legend(handles=p10+p11+p20+p21+p30+p31, fontsize=6)
 
     gs_ax5.set_xlim([e[0].value, e[-1].value])
 
     gs_ax6 = fig.add_subplot(gs[2, 1])
     for_native_res = np.nan << u.keV
-    native_es_on, old_vals = eff_area_nagoya(for_native_res, file=None)
-    native_es_cmos, cmos_vals = eff_area_cmos(for_native_res, file=None, telescope=1)
-    native_es_nag, nag_vals = eff_area_nagoya_sxt(for_native_res, file=None)
-    p1 = gs_ax6.plot(native_es_on, old_vals, label="Old SXR Nagoya")
-    p2 = gs_ax6.plot(native_es_cmos, cmos_vals, label="CMOS SXR Nagoya")
-    p3 = gs_ax6.plot(native_es_nag, nag_vals, label="SXR Nagoya")
+    early_nag = _eff_area_nagoya(for_native_res, file=None)
+    cmos_sxt = eff_area_cmos(for_native_res, telescope=1)
+    nag_sxt = eff_area_nagoya_sxt(for_native_res, file=None)
+    p1 = gs_ax6.plot(early_nag.mid_energies, early_nag.effective_areas, label="Old SXR Nagoya (might inc. coll. &| OBF)")
+    p2 = gs_ax6.plot(cmos_sxt.mid_energies, cmos_sxt.effective_areas, label="CMOS SXR Nagoya")
+    p3 = gs_ax6.plot(nag_sxt.mid_energies, nag_sxt.effective_areas, label="SXR Nagoya (inc. coll. & OBF)")
     gs_ax6.set_title("Nagoya SXR")
     gs_ax6.set_xlabel(f"Energy {e.unit:latex}")
-    gs_ax6.set_ylabel(f"Eff. Area {msfc_hi_res_p0.unit:latex}")
+    gs_ax6.set_ylabel(f"Eff. Area {msfc_hi_res_p0.effective_areas.unit:latex}")
     plt.legend(handles=p1+p2+p3, fontsize=6)
 
     gs_ax6 = fig.add_subplot(gs[2, 2])
     for_native_res = np.nan << u.keV
-    native_es_on, old_vals = eff_area_nagoya(for_native_res, file=None)
-    native_es_cmos, cmos_vals = eff_area_cmos(for_native_res, file=None, telescope=0)
-    native_es_nag, nag_vals = eff_area_nagoya_hxt(for_native_res, file=None)
-    p1 = gs_ax6.plot(native_es_on, old_vals, label="Old SXR Nagoya")
-    p2 = gs_ax6.plot(native_es_cmos, cmos_vals, label="CMOS HXR Nagoya")
-    p3 = gs_ax6.plot(native_es_nag, nag_vals, label="HXR Nagoya")
-    gs_ax6.set_title("Nagoya SXR")
+    nag_hxt = eff_area_nagoya_hxt(for_native_res, file=None)
+    p1 = gs_ax6.plot(nag_hxt.mid_energies, nag_hxt.effective_areas, label="HXR Nagoya")
+    gs_ax6.set_title("Nagoya HXR")
     gs_ax6.set_xlabel(f"Energy {e.unit:latex}")
-    gs_ax6.set_ylabel(f"Eff. Area {msfc_hi_res_p0.unit:latex}")
-    plt.legend(handles=p1+p2+p3, fontsize=6)
+    gs_ax6.set_ylabel(f"Eff. Area {msfc_hi_res_p0.effective_areas.unit:latex}")
+    plt.legend(handles=p1, fontsize=6)
 
     plt.tight_layout()
     if save_asset:
@@ -408,12 +739,7 @@ def asset_all_optics(save_asset=False):
     plt.show()
 
 if __name__=="__main__":
-    s = np.array([np.nan, np.nan])<<u.keV
-    s = np.nan<<u.keV
-    print(s, np.all(np.isnan(s)))
-    eff_area_nagoya_hxt(s, file=None)
     save_asset = False
-    # asset_cmos_plot(save_asset=save_asset)
-    asset_cmos_sxr(save_asset=save_asset)
-    # asset_all_optics(save_asset=save_asset)
-    
\ No newline at end of file
+    asset_cmos_plot(save_asset=save_asset)
+    asset_cmos_files(save_asset=save_asset)
+    asset_all_optics(save_asset=save_asset)
\ No newline at end of file
diff --git a/response-tools-py/response_tools_py/io/load_yaml.py b/response-tools-py/response_tools_py/io/load_yaml.py
index 12c9175..eda0c4c 100644
--- a/response-tools-py/response_tools_py/io/load_yaml.py
+++ b/response-tools-py/response_tools_py/io/load_yaml.py
@@ -14,6 +14,6 @@ def load_yaml(filename):
 
     return file_info
 
-def load_cdte_context():
+def load_response_context():
     """Function to load in the context information from file. """
     return load_yaml(os.path.join(pathlib.Path(__file__).parent, "..", "..", "..", "response-information", "info.yaml"))
\ No newline at end of file
diff --git a/response-tools-py/response_tools_py/quantum_efficiency.py b/response-tools-py/response_tools_py/quantum_efficiency.py
index 1c58fb7..819cbc6 100644
--- a/response-tools-py/response_tools_py/quantum_efficiency.py
+++ b/response-tools-py/response_tools_py/quantum_efficiency.py
@@ -1,50 +1,107 @@
 """Code to load different quantum efficiencies. """
 
+from dataclasses import dataclass
 import logging
 import os
 import pathlib
+import sys
 
 from astropy.io import fits
 import astropy.units as u
 import numpy as np
 
+from response_tools_py.util import BaseOutput, native_resolution
+
 Q_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "response-information", "quantum-efficiency-data")
+ASSETS_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "assets", "response-tools-py-figs", "quantum-eff-figs")
+
+@dataclass
+class QuantumEffOutput(BaseOutput):
+    """Class for keeping track of quantum efficiency response values."""
+    # numbers
+    mid_energies: u.Quantity
+    quantum_efficiency: u.Quantity
+    # bookkeeping
+    detector: str
+    # any other fields needed can be added here
+    # can even add with a default so the input is not required for every other instance = np.nan<<u.keV
 
 @u.quantity_input(mid_energies=u.keV)
-def qe_cmos(mid_energies, file=None, telescope=None):
+def qe_cmos(mid_energies, telescope=None, file=None):
     """Return quantum efficency of CMOS detectors.
     
     Telescope 0: position 0, X10/FM2(?)
     Telescope 1: position 1, Nagoya(?)
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the transmission is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    telescope : `int`
+        The focal plane position of the detector of the desired quantum 
+        efficiency. Must be in the list [0, 1]. 
+            Telescope 0 -> Position 0
+            Telescope 1 -> Position 1
+        Default: None
+
+    file : `str` or `None`
+        Gives the ability to provide custom files for the information. 
+        Default: None
+
+    Returns
+    -------
+    : `QuantumEffOutput`
+        An object containing the energies for each quantum efficency, 
+        the quantum efficencies, and more. See accessible information 
+        using `.contents` on the output.
     """
-    if telescope is None:
-        logging.warning("`telescope` input in `qe_cmos()` must be 0 or 1.")
+    if (telescope is None) or (telescope not in [0,1]):
+        logging.warning(f"The `telescope` input in {sys._getframe().f_code.co_name} must be 0 or 1.")
         return
         
     _f = os.path.join(Q_PATH, f"foxsi4_telescope-{telescope}_BASIC_sensor_quantum_efficiency_v1.fits") if file is None else file
     with fits.open(_f) as hdul:
         es, qe = hdul[2].data << u.keV, hdul[1].data << u.dimensionless_unscaled
-    return np.interp(mid_energies.value, es.value, qe.value, left=0, right=0) << u.dimensionless_unscaled
-
-if __name__=="__main__":
-    import matplotlib.pyplot as plt
+    mid_energies = native_resolution(native_x=es, input_x=mid_energies)
 
-    SAVE_ASSETS = False
-    assets_dir = os.path.join(pathlib.Path(__file__).parent, "..", "..", "assets", "response-tools-py-figs", "quantum-eff-figs")
-    pathlib.Path(assets_dir).mkdir(parents=True, exist_ok=True)
+    return QuantumEffOutput(filename=_f,
+                            function_path=f"{sys._getframe().f_code.co_name}",
+                            mid_energies=mid_energies,
+                            quantum_efficiency=np.interp(mid_energies.value, 
+                                                         es.value, 
+                                                         qe.value, 
+                                                         left=0, 
+                                                         right=0) << u.dimensionless_unscaled,
+                            detector="CMOS{telescope}-Quantum-Efficiency"
+                            )
 
+def asset_qe(save_asset=False):
     mid_energies = np.linspace(0, 20, 1000)<<u.keV
     plt.figure()
     qe0 = qe_cmos(mid_energies, telescope=0)
     qe1 = qe_cmos(mid_energies, telescope=1)
-    plt.plot(mid_energies, qe0, lw=2, label="CMOS telescope 0, position 0")
-    plt.plot(mid_energies, qe1, lw=1, ls=":", label="CMOS telescope 1, position 1")
+    plt.plot(mid_energies, qe0.quantum_efficiency, lw=2, label="CMOS telescope 0, position 0")
+    plt.plot(mid_energies, qe1.quantum_efficiency, lw=1, ls=":", label="CMOS telescope 1, position 1")
     plt.title("CMOS Detectors")
-    plt.ylabel(f"Quantum efficiency [{qe0.unit:latex}]")
+    plt.ylabel(f"Quantum efficiency [{qe0.quantum_efficiency.unit:latex}]")
     plt.xlabel(f"Energy [{mid_energies.unit:latex}]")
     plt.xlim([np.min(mid_energies.value), np.max(mid_energies.value)])
     plt.ylim([0, 1.01])
     plt.legend()
-    if SAVE_ASSETS:
-        plt.savefig(os.path.join(assets_dir,"cmos-qunatum-eff.png"), dpi=200, bbox_inches="tight")
+    if save_asset:
+        pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
+        plt.savefig(os.path.join(ASSETS_PATH,"cmos-qunatum-eff.png"), dpi=200, bbox_inches="tight")
     plt.show()
+
+if __name__=="__main__":
+    import matplotlib.pyplot as plt
+
+    SAVE_ASSETS = False
+    asset_qe(save_asset=SAVE_ASSETS)
+    
+
+    
diff --git a/response-tools-py/response_tools_py/responses.py b/response-tools-py/response_tools_py/responses.py
new file mode 100644
index 0000000..e785f4c
--- /dev/null
+++ b/response-tools-py/response_tools_py/responses.py
@@ -0,0 +1,898 @@
+"""Functions to make the RMFs and ARFs. """
+
+from dataclasses import dataclass
+import logging
+import os
+import pathlib
+import sys
+
+import astropy.units as u
+import numpy as np
+
+from response_tools_py.attenuation import att_foxsi4_atmosphere
+import response_tools_py.telescope_parts as tp
+from response_tools_py.util import BaseOutput
+
+ASSETS_PATH = os.path.join(pathlib.Path(__file__).parent, "..", "..", "assets", "response-tools-py-figs", "response-figs")
+
+@dataclass
+class Response1DOutput(BaseOutput):
+    """Class for keeping track of 1D response response values."""
+    # numbers
+    mid_energies: u.Quantity
+    response: u.Quantity
+    # bookkeeping
+    response_type: str
+    telescope: str
+    elements: tuple
+    # any other fields needed can be added here
+    # can even add with a default so the input is not required for every other instance
+
+@dataclass
+class Response2DOutput(BaseOutput):
+    """Class for keeping track of 2D response response values."""
+    # numbers
+    input_energy_edges: u.Quantity # photon axis
+    output_energy_edges: u.Quantity # count axis
+    response: u.Quantity
+    # bookkeeping
+    response_type: str
+    telescope: str
+    elements: tuple
+    # any other fields needed can be added here
+    # can even add with a default so the input is not required for every other instance
+
+def foxsi4_telescope_response(arf_response, rmf_response):
+    """Full Detector Response Matrix (DRM) for a given telescope.
+
+    This function will check the Ancillary Response Function (ARF) 
+    `mid_energies` field and the Redistribution Matrix Function (RMF) 
+    `input_energy_edges` field mid-points to check they match before 
+    combining both the ARF and RMF into the Detector Response Matrix 
+    (DRM).
+
+    Parameters
+    ----------
+    arf_response : `responses.Response1DOutput`
+        The Ancillary Response Function (ARF) object for a telescope.
+
+    rmf_response : `responses.Response2DOutput`
+        The Redistribution Matrix Function (RMF) object for a telescope.
+
+    Returns
+    -------
+    : `responses.Response2DOutput`
+        An object containing the 2D detector response information for a 
+        given ARF and RMF. See accessible information using `.contents` 
+        on the output.
+    """
+
+    # check compatibility
+    rmf_mids = (rmf_response.input_energy_edges[:-1]+rmf_response.input_energy_edges[1:])/2
+    if not np.all(arf_response.mid_energies==rmf_mids):
+        raise ValueError("The `arf_response.mid_energies` do not match the bin centers of `rmf_response.input_energy_edges`.\nDRM product cannot be calculated")
+
+    total_response = arf_response.response[:,None] * rmf_response.response
+
+    func_name = sys._getframe().f_code.co_name
+    arf_response.update_function_path(func_name)
+    rmf_response.update_function_path(func_name)
+
+    return Response2DOutput(filename="No-File",
+                            function_path=func_name,
+                            input_energy_edges=rmf_response.input_energy_edges,
+                            output_energy_edges=rmf_response.output_energy_edges,
+                            response=total_response,
+                            response_type="DRM",
+                            telescope="foxsi4-2",
+                            elements=(arf_response,
+                                      rmf_response,
+                                      ),
+                            )
+
+# telescope 2
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def foxsi4_telescope2_arf(mid_energies, off_axis_angle):
+    """The Ancillary Response Function (ARF) for Telescope 2.
+    
+    **DOES NOT** include atmospheric attenuation from flight.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the Telescope 2 componented are calculated. 
+        If `numpy.nan<<astropy.units.keV` is passed then an entry for 
+        all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+
+    Returns
+    -------
+    : `responses.Response1DOutput`
+        An object containing the 1D response information of Telescope 2. 
+        See accessible information using `.contents` on the output.
+    """
+    tb = tp.foxsi4_position2_thermal_blanket(mid_energies) 
+    opt = tp.foxsi4_position2_optics(mid_energies, 
+                                     off_axis_angle=off_axis_angle) 
+    uni_al = tp.foxsi4_position2_uniform_al(mid_energies)
+
+    arf = tb.transmissions * opt.effective_areas * uni_al.transmissions
+
+    func_name = sys._getframe().f_code.co_name
+    tb.update_function_path(func_name)
+    opt.update_function_path(func_name)
+    uni_al.update_function_path(func_name)
+
+    return Response1DOutput(filename="No-File",
+                            function_path=func_name,
+                            mid_energies=mid_energies,
+                            response=arf,
+                            response_type="ARF",
+                            telescope="foxsi4-2",
+                            elements=(tb, 
+                                      opt, 
+                                      uni_al,
+                                      ),
+                            )
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin, time_range=u.second)
+def foxsi4_telescope2_flight_arf(mid_energies, off_axis_angle, time_range):
+    """The flight Ancillary Response Function (ARF) for telescope 2.
+    
+    Includes atmospheric attenuation from flight.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the Telescope 2 componented are calculated. 
+        If `numpy.nan<<astropy.units.keV` is passed then an entry for 
+        all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+
+    time_range : `astropy.units.quantity.Quantity` or `None`
+        The time range the atmsopheric transmissions should be averaged
+        over. If `None`, `numpy.nan<<astropy.units.second`, or
+        `[numpy.nan, numpy.nan]<<astropy.units.second` then the full 
+        time will be considered and the output will not be averaged but 
+        a grid of the transmissions at all times and at any provided
+        energies.
+
+    Returns
+    -------
+    : `responses.Response1DOutput`
+        An object containing the 1D response information of Telescope 2. 
+        See accessible information using `.contents` on the output.
+    """
+    atm = att_foxsi4_atmosphere(mid_energies=mid_energies, 
+                                time_range=time_range)
+    arf = foxsi4_telescope2_arf(mid_energies, off_axis_angle)
+
+    flight_arf = atm.transmissions*arf.response
+
+    func_name = sys._getframe().f_code.co_name
+    atm.update_function_path(func_name)
+    arf.update_function_path(func_name)
+
+    return Response1DOutput(filename="No-File",
+                            function_path=func_name,
+                            mid_energies=mid_energies,
+                            response=flight_arf,
+                            response_type="ARF-flight",
+                            telescope=f"foxsi4-2",
+                            elements=(atm, 
+                                      arf,
+                                      ),
+                            )
+
+@u.quantity_input(pitch=u.um)
+def foxsi4_telescope2_rmf(region:int=None, pitch=None, _side:str="merged", _event_type:str="all"):
+    """The Redistribution Matrix Function (RMF) for Telescope 2. 
+
+    Parameters
+    ----------
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    _side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    _event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    Returns
+    -------
+    : `responses.Response2DOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+    
+    rmf = tp.foxsi4_position2_detector_response(region=region, 
+                                                pitch=pitch, 
+                                                _side=_side, 
+                                                _event_type=_event_type)
+    func_name = sys._getframe().f_code.co_name
+    rmf.update_function_path(func_name)
+
+    return Response2DOutput(filename="No-File",
+                            function_path=func_name,
+                            input_energy_edges=rmf.input_energy_edges,
+                            output_energy_edges=rmf.output_energy_edges,
+                            response=rmf.detector_response,
+                            response_type="RMF",
+                            telescope="foxsi4-2",
+                            elements=(rmf,
+                                      ),
+                            )
+
+# telescope 3
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def foxsi4_telescope3_arf(mid_energies, off_axis_angle=None):
+    """The Ancillary Response Function (ARF) for Telescope 3.
+    
+    **DOES NOT** include atmospheric attenuation from flight.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the Telescope 3 componented are calculated. 
+        If `numpy.nan<<astropy.units.keV` is passed then an entry for 
+        all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        *** Not implemented yet. ***
+
+    Returns
+    -------
+    : `responses.Response1DOutput`
+        An object containing the 1D response information of Telescope 3. 
+        See accessible information using `.contents` on the output.
+    """
+    if off_axis_angle is not None:
+        logging.warning(f"The `off_axis_angle` input for Telescope 3's optics ({sys._getframe().f_code.co_name}) is not yet implemented.")
+    tb = tp.foxsi4_position3_thermal_blanket(mid_energies) 
+    opt = tp.foxsi4_position3_optics(mid_energies) 
+    mylar = tp.foxsi4_position3_al_mylar(mid_energies)
+    pix_att = tp.foxsi4_position3_pixelated_attenuator(mid_energies)
+
+    arf = tb.transmissions * opt.effective_areas * mylar.transmissions * pix_att.transmissions
+
+    func_name = sys._getframe().f_code.co_name
+    tb.update_function_path(func_name)
+    opt.update_function_path(func_name)
+    mylar.update_function_path(func_name)
+    pix_att.update_function_path(func_name)
+
+    return Response1DOutput(filename="No-File",
+                            function_path=func_name,
+                            mid_energies=mid_energies,
+                            response=arf,
+                            response_type="ARF",
+                            telescope="foxsi4-2",
+                            elements=(tb, 
+                                      opt,
+                                      mylar, 
+                                      pix_att,
+                                      ),
+                            )
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin, time_range=u.second)
+def foxsi4_telescope3_flight_arf(mid_energies, time_range, off_axis_angle=None):
+    """The flight Ancillary Response Function (ARF) for Telescope 3.
+    
+    Includes atmospheric attenuation from flight.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the Telescope 3 componented are calculated. 
+        If `numpy.nan<<astropy.units.keV` is passed then an entry for 
+        all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        *** Not implemented yet. ***
+
+    time_range : `astropy.units.quantity.Quantity` or `None`
+        The time range the atmsopheric transmissions should be averaged
+        over. If `None`, `numpy.nan<<astropy.units.second`, or
+        `[numpy.nan, numpy.nan]<<astropy.units.second` then the full 
+        time will be considered and the output will not be averaged but 
+        a grid of the transmissions at all times and at any provided
+        energies.
+
+    Returns
+    -------
+    : `responses.Response1DOutput`
+        An object containing the 1D response information of Telescope 3. 
+        See accessible information using `.contents` on the output.
+    """
+    if off_axis_angle is not None:
+        logging.warning(f"The `off_axis_angle` input for Telescope 3's optics ({sys._getframe().f_code.co_name}) is not yet implemented.")
+    atm = att_foxsi4_atmosphere(mid_energies=mid_energies, 
+                                time_range=time_range)
+    arf = foxsi4_telescope3_arf(mid_energies)
+
+    flight_arf = atm.transmissions*arf.response
+
+    func_name = sys._getframe().f_code.co_name
+    atm.update_function_path(func_name)
+    arf.update_function_path(func_name)
+
+    return Response1DOutput(filename="No-File",
+                            function_path=func_name,
+                            mid_energies=mid_energies,
+                            response=flight_arf,
+                            response_type="ARF-flight",
+                            telescope=f"foxsi4-3",
+                            elements=(atm, 
+                                      arf,
+                                      ),
+                            )
+
+@u.quantity_input(pitch=u.um)
+def foxsi4_telescope3_rmf(region:int=None, pitch=None, _side:str="merged", _event_type:str="all"):
+    """The Redistribution Matrix Function (RMF) for Telescope 3. 
+
+    Parameters
+    ----------
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    _side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    _event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    Returns
+    -------
+    : `responses.Response2DOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+    
+    rmf = tp.foxsi4_position3_detector_response(region=region, 
+                                                pitch=pitch, 
+                                                _side=_side, 
+                                                _event_type=_event_type)
+    func_name = sys._getframe().f_code.co_name
+    rmf.update_function_path(func_name)
+
+    return Response2DOutput(filename="No-File",
+                            function_path=func_name,
+                            input_energy_edges=rmf.input_energy_edges,
+                            output_energy_edges=rmf.output_energy_edges,
+                            response=rmf.detector_response,
+                            response_type="RMF",
+                            telescope="foxsi4-3",
+                            elements=(rmf,
+                                      ),
+                            )
+
+# telescope 4
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def foxsi4_telescope4_arf(mid_energies, off_axis_angle=None):
+    """The Ancillary Response Function (ARF) for Telescope 4.
+    
+    **DOES NOT** include atmospheric attenuation from flight.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the Telescope 4 componented are calculated. 
+        If `numpy.nan<<astropy.units.keV` is passed then an entry for 
+        all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        *** Not implemented yet. ***
+
+    Returns
+    -------
+    : `responses.Response1DOutput`
+        An object containing the 1D response information of Telescope 4. 
+        See accessible information using `.contents` on the output.
+    """
+    if off_axis_angle is not None:
+        logging.warning(f"The `off_axis_angle` input for Telescope 4's optics ({sys._getframe().f_code.co_name}) is not yet implemented.")
+    tb = tp.foxsi4_position4_thermal_blanket(mid_energies) 
+    opt = tp.foxsi4_position4_optics(mid_energies) 
+    uni_al = tp.foxsi4_position4_uniform_al(mid_energies)
+
+    arf = tb.transmissions * opt.effective_areas * uni_al.transmissions
+
+    func_name = sys._getframe().f_code.co_name
+    tb.update_function_path(func_name)
+    opt.update_function_path(func_name)
+    uni_al.update_function_path(func_name)
+
+    return Response1DOutput(filename="No-File",
+                            function_path=func_name,
+                            mid_energies=mid_energies,
+                            response=arf,
+                            response_type="ARF",
+                            telescope="foxsi4-4",
+                            elements=(tb, 
+                                      opt, 
+                                      uni_al,
+                                      ),
+                            )
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin, time_range=u.second)
+def foxsi4_telescope4_flight_arf(mid_energies, time_range, off_axis_angle=None):
+    """The flight Ancillary Response Function (ARF) for Telescope 4.
+    
+    Includes atmospheric attenuation from flight.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the Telescope 4 componented are calculated. 
+        If `numpy.nan<<astropy.units.keV` is passed then an entry for 
+        all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        *** Not implemented yet. ***
+
+    time_range : `astropy.units.quantity.Quantity` or `None`
+        The time range the atmsopheric transmissions should be averaged
+        over. If `None`, `numpy.nan<<astropy.units.second`, or
+        `[numpy.nan, numpy.nan]<<astropy.units.second` then the full 
+        time will be considered and the output will not be averaged but 
+        a grid of the transmissions at all times and at any provided
+        energies.
+
+    Returns
+    -------
+    : `responses.Response1DOutput`
+        An object containing the 1D response information of Telescope 4. 
+        See accessible information using `.contents` on the output.
+    """
+    if off_axis_angle is not None:
+        logging.warning(f"The `off_axis_angle` input for Telescope 4's optics ({sys._getframe().f_code.co_name}) is not yet implemented.")
+    atm = att_foxsi4_atmosphere(mid_energies=mid_energies, 
+                                time_range=time_range)
+    arf = foxsi4_telescope4_arf(mid_energies)
+
+    flight_arf = atm.transmissions*arf.response
+
+    func_name = sys._getframe().f_code.co_name
+    atm.update_function_path(func_name)
+    arf.update_function_path(func_name)
+
+    return Response1DOutput(filename="No-File",
+                            function_path=func_name,
+                            mid_energies=mid_energies,
+                            response=flight_arf,
+                            response_type="ARF-flight",
+                            telescope=f"foxsi4-4",
+                            elements=(atm, 
+                                      arf,
+                                      ),
+                            )
+
+@u.quantity_input(pitch=u.um)
+def foxsi4_telescope4_rmf(region:int=None, pitch=None, _side:str="merged", _event_type:str="all"):
+    """The Redistribution Matrix Function (RMF) for Telescope 4. 
+
+    Parameters
+    ----------
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    _side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    _event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    Returns
+    -------
+    : `responses.Response2DOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+    
+    rmf = tp.foxsi4_position4_detector_response(region=region, 
+                                                pitch=pitch, 
+                                                _side=_side, 
+                                                _event_type=_event_type)
+    func_name = sys._getframe().f_code.co_name
+    rmf.update_function_path(func_name)
+
+    return Response2DOutput(filename="No-File",
+                            function_path=func_name,
+                            input_energy_edges=rmf.input_energy_edges,
+                            output_energy_edges=rmf.output_energy_edges,
+                            response=rmf.detector_response,
+                            response_type="RMF",
+                            telescope="foxsi4-4",
+                            elements=(rmf,
+                                      ),
+                            )
+
+# telescope 5
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def foxsi4_telescope5_arf(mid_energies, off_axis_angle):
+    """The Ancillary Response Function (ARF) for Telescope 5.
+    
+    **DOES NOT** include atmospheric attenuation from flight.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the Telescope 5 componented are calculated. 
+        If `numpy.nan<<astropy.units.keV` is passed then an entry for 
+        all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+
+    Returns
+    -------
+    : `responses.Response1DOutput`
+        An object containing the 1D response information of Telescope 5. 
+        See accessible information using `.contents` on the output.
+    """
+    tb = tp.foxsi4_position5_thermal_blanket(mid_energies) 
+    opt = tp.foxsi4_position5_optics(mid_energies, 
+                                     off_axis_angle=off_axis_angle) 
+    mylar = tp.foxsi4_position5_al_mylar(mid_energies)
+    pix_att = tp.foxsi4_position5_pixelated_attenuator(mid_energies)
+
+    arf = tb.transmissions * opt.effective_areas * mylar.transmissions * pix_att.transmissions
+
+    func_name = sys._getframe().f_code.co_name
+    tb.update_function_path(func_name)
+    opt.update_function_path(func_name)
+    mylar.update_function_path(func_name)
+    pix_att.update_function_path(func_name)
+
+    return Response1DOutput(filename="No-File",
+                            function_path=func_name,
+                            mid_energies=mid_energies,
+                            response=arf,
+                            response_type="ARF",
+                            telescope="foxsi4-5",
+                            elements=(tb, 
+                                      opt, 
+                                      mylar,
+                                      pix_att,
+                                      ),
+                            )
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin, time_range=u.second)
+def foxsi4_telescope5_flight_arf(mid_energies, off_axis_angle, time_range):
+    """The flight Ancillary Response Function (ARF) for Telescope 5.
+    
+    Includes atmospheric attenuation from flight.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the Telescope 5 componented are calculated. 
+        If `numpy.nan<<astropy.units.keV` is passed then an entry for 
+        all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+
+    time_range : `astropy.units.quantity.Quantity` or `None`
+        The time range the atmsopheric transmissions should be averaged
+        over. If `None`, `numpy.nan<<astropy.units.second`, or
+        `[numpy.nan, numpy.nan]<<astropy.units.second` then the full 
+        time will be considered and the output will not be averaged but 
+        a grid of the transmissions at all times and at any provided
+        energies.
+
+    Returns
+    -------
+    : `responses.Response1DOutput`
+        An object containing the 1D response information of Telescope 5. 
+        See accessible information using `.contents` on the output.
+    """
+    atm = att_foxsi4_atmosphere(mid_energies=mid_energies, 
+                                time_range=time_range)
+    arf = foxsi4_telescope5_arf(mid_energies, off_axis_angle)
+
+    flight_arf = atm.transmissions*arf.response
+
+    func_name = sys._getframe().f_code.co_name
+    atm.update_function_path(func_name)
+    arf.update_function_path(func_name)
+
+    return Response1DOutput(filename="No-File",
+                            function_path=func_name,
+                            mid_energies=mid_energies,
+                            response=flight_arf,
+                            response_type="ARF-flight",
+                            telescope=f"foxsi4-5",
+                            elements=(atm, 
+                                      arf,
+                                      ),
+                            )
+
+@u.quantity_input(pitch=u.um)
+def foxsi4_telescope5_rmf(region:int=None, pitch=None, _side:str="merged", _event_type:str="all"):
+    """The Redistribution Matrix Function (RMF) for Telescope 5. 
+
+    Parameters
+    ----------
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    _side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    _event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    Returns
+    -------
+    : `responses.Response2DOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+    
+    rmf = tp.foxsi4_position5_detector_response(region=region, 
+                                                pitch=pitch, 
+                                                _side=_side, 
+                                                _event_type=_event_type)
+    func_name = sys._getframe().f_code.co_name
+    rmf.update_function_path(func_name)
+
+    return Response2DOutput(filename="No-File",
+                            function_path=func_name,
+                            input_energy_edges=rmf.input_energy_edges,
+                            output_energy_edges=rmf.output_energy_edges,
+                            response=rmf.detector_response,
+                            response_type="RMF",
+                            telescope="foxsi4-5",
+                            elements=(rmf,
+                                      ),
+                            )
+
+def asset_response_chain_plot(save_asset=False):
+    """Plot the response chain data to visually check."""
+    pos2arffunc = {2:foxsi4_telescope2_arf, 
+                   3:foxsi4_telescope3_arf, 
+                   4:foxsi4_telescope4_arf, 
+                   5:foxsi4_telescope5_arf,
+                   }
+    pos2rmffunc = {2:foxsi4_telescope2_rmf, 
+                   3:foxsi4_telescope3_rmf, 
+                   4:foxsi4_telescope4_rmf, 
+                   5:foxsi4_telescope5_rmf,
+                   }
+    
+    fig = plt.figure(figsize=(11, 10))
+    positions = list(pos2rmffunc.keys())
+    gs = gridspec.GridSpec(len(positions), 3)
+
+    for c, key in enumerate(positions):
+        off_axis_angle = 0 << u.arcmin
+        pos_rmf = pos2rmffunc[key](region=0)
+        mid_energies = (pos_rmf.input_energy_edges[:-1]+pos_rmf.input_energy_edges[1:])/2
+        pos_arf = pos2arffunc[key](mid_energies=mid_energies, off_axis_angle=off_axis_angle)
+        pos_drm = foxsi4_telescope_response(pos_arf, pos_rmf)
+
+        gs_ax0 = fig.add_subplot(gs[c, 0])
+        gs_ax0.plot(pos_arf.mid_energies, pos_arf.response)
+        gs_ax0.set_xlabel(f"Photon Energy [{pos_arf.mid_energies.unit:latex}]")
+        gs_ax0.set_ylabel(f"Response [{pos_arf.response.unit:latex}]")
+        gs_ax0.set_title(f"Pos. {key}: ARF")
+
+        gs_ax1 = fig.add_subplot(gs[c, 1])
+        r = gs_ax1.imshow(pos_rmf.response.value, 
+                        origin="lower", 
+                        norm=LogNorm(vmin=0.001), 
+                        extent=[np.min(pos_rmf.output_energy_edges.value), 
+                                np.max(pos_rmf.output_energy_edges.value), 
+                                np.min(pos_rmf.input_energy_edges.value), 
+                                np.max(pos_rmf.input_energy_edges.value)]
+                        )
+        cbar = plt.colorbar(r)
+        cbar.ax.set_ylabel(f"Response [{pos_rmf.response.unit:latex}]")
+        gs_ax1.set_xlabel(f"Count Energy [{pos_rmf.output_energy_edges.unit:latex}]")
+        gs_ax1.set_ylabel(f"Photon Energy [{pos_rmf.input_energy_edges.unit:latex}]")
+        gs_ax1.set_title(f"Pos. {key}: RMF")
+
+        gs_ax2 = fig.add_subplot(gs[c, 2])
+        r = gs_ax2.imshow(pos_drm.response.value, 
+                        origin="lower", 
+                        norm=LogNorm(vmin=0.001), 
+                        extent=[np.min(pos_drm.output_energy_edges.value), 
+                                np.max(pos_drm.output_energy_edges.value), 
+                                np.min(pos_drm.input_energy_edges.value), 
+                                np.max(pos_drm.input_energy_edges.value)]
+                        )
+        cbar = plt.colorbar(r)
+        cbar.ax.set_ylabel(f"Response [{pos_drm.response.unit:latex}]")
+        gs_ax2.set_xlabel(f"Count Energy [{pos_drm.output_energy_edges.unit:latex}]")
+        gs_ax2.set_ylabel(f"Photon Energy [{pos_drm.input_energy_edges.unit:latex}]")
+        gs_ax2.set_title(f"Pos. {key}: DRM")
+    plt.tight_layout()
+    if save_asset:
+        pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
+        plt.savefig(os.path.join(ASSETS_PATH,"response-chain.png"), dpi=200, bbox_inches="tight")
+    plt.show()
+
+def asset_response_hit_combination_plot(save_asset=False):
+    """Look at different combinations of the 1hit and 2hit responses."""
+    p5_rmf1 = foxsi4_telescope5_rmf(region=0, _event_type="1hit")
+    p5_rmf2 = foxsi4_telescope5_rmf(region=0, _event_type="2hit")
+
+    fig = plt.figure(figsize=(18, 4.9))
+    gs = gridspec.GridSpec(1, 3)
+
+    gs_ax0 = fig.add_subplot(gs[0, 0])
+    h1f, h2f = 0.6, 0.4
+    m = h1f*p5_rmf1.response + h2f*p5_rmf2.response
+    r = gs_ax0.imshow(m.value, 
+                      origin="lower", 
+                      norm=LogNorm(vmin=0.001), 
+                      extent=[np.min(p5_rmf1.output_energy_edges.value), 
+                              np.max(p5_rmf1.output_energy_edges.value), 
+                              np.min(p5_rmf1.input_energy_edges.value), 
+                              np.max(p5_rmf1.input_energy_edges.value)]
+                      )
+    cbar = plt.colorbar(r)
+    cbar.ax.set_ylabel(f"Response [{m.unit:latex}]")
+    gs_ax0.set_xlabel(f"Count Energy [{p5_rmf1.output_energy_edges.unit:latex}]")
+    gs_ax0.set_ylabel(f"Photon Energy [{p5_rmf1.input_energy_edges.unit:latex}]")
+    gs_ax0.set_title(f"Pos. 5: RMF-({h1f}*1hit+{h2f}*2hit)")
+
+    gs_ax1 = fig.add_subplot(gs[0, 1])
+    h1f, h2f = 0.1, 0.9
+    m = h1f*p5_rmf1.response + h2f*p5_rmf2.response
+    r = gs_ax1.imshow(m.value, 
+                      origin="lower", 
+                      norm=LogNorm(vmin=0.001), 
+                      extent=[np.min(p5_rmf1.output_energy_edges.value), 
+                              np.max(p5_rmf1.output_energy_edges.value), 
+                              np.min(p5_rmf1.input_energy_edges.value), 
+                              np.max(p5_rmf1.input_energy_edges.value)]
+                      )
+    cbar = plt.colorbar(r)
+    cbar.ax.set_ylabel(f"Response [{m.unit:latex}]")
+    gs_ax1.set_xlabel(f"Count Energy [{p5_rmf1.output_energy_edges.unit:latex}]")
+    gs_ax1.set_ylabel(f"Photon Energy [{p5_rmf1.input_energy_edges.unit:latex}]")
+    gs_ax1.set_title(f"Pos. 5: RMF-({h1f}*1hit+{h2f}*2hit)")
+
+    gs_ax2 = fig.add_subplot(gs[0, 2])
+    h1f, h2f = 0.9, 0.1
+    m = h1f*p5_rmf1.response + h2f*p5_rmf2.response
+    r = gs_ax2.imshow(m.value, 
+                      origin="lower", 
+                      norm=LogNorm(vmin=0.001), 
+                      extent=[np.min(p5_rmf1.output_energy_edges.value), 
+                              np.max(p5_rmf1.output_energy_edges.value), 
+                              np.min(p5_rmf1.input_energy_edges.value), 
+                              np.max(p5_rmf1.input_energy_edges.value)]
+                      )
+    cbar = plt.colorbar(r)
+    cbar.ax.set_ylabel(f"Response [{m.unit:latex}]")
+    gs_ax2.set_xlabel(f"Count Energy [{p5_rmf1.output_energy_edges.unit:latex}]")
+    gs_ax2.set_ylabel(f"Photon Energy [{p5_rmf1.input_energy_edges.unit:latex}]")
+    gs_ax2.set_title(f"Pos. 5: RMF-({h1f}*1hit+{h2f}*2hit)")
+    plt.tight_layout()
+    if save_asset:
+        pathlib.Path(ASSETS_PATH).mkdir(parents=True, exist_ok=True)
+        plt.savefig(os.path.join(ASSETS_PATH,"response-hit-combinations.png"), dpi=200, bbox_inches="tight")
+    plt.show()
+
+if __name__=="__main__":
+    from matplotlib.colors import LogNorm
+    import matplotlib.gridspec as gridspec
+    import matplotlib.pyplot as plt
+
+    save_asset = False
+
+    asset_response_chain_plot(save_asset=save_asset)
+    asset_response_hit_combination_plot(save_asset=save_asset)
\ No newline at end of file
diff --git a/response-tools-py/response_tools_py/telescope_parts.py b/response-tools-py/response_tools_py/telescope_parts.py
new file mode 100644
index 0000000..fb17526
--- /dev/null
+++ b/response-tools-py/response_tools_py/telescope_parts.py
@@ -0,0 +1,604 @@
+"""Wrappers for position aliases for more specific functions."""
+
+import logging
+import sys
+
+import astropy.units as u
+
+from response_tools_py.attenuation import (att_thermal_blanket,
+                                           att_pixelated, 
+                                           att_al_mylar,
+                                           att_uniform_al_cdte
+                                           )
+from response_tools_py.detector_response import (cdte_det_resp, 
+                                                 cmos_det_resp,
+                                                 )
+from response_tools_py.effective_area import (eff_area_msfc_10shell,
+                                              eff_area_msfc_hi_res,
+                                              eff_area_nagoya_hxt,
+                                              )
+
+# position 2
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position2_thermal_blanket(mid_energies):
+    """Position 2 thermal blanket transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the thermal blanketing transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the thermal blanket. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_thermal_blanket(mid_energies)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def foxsi4_position2_optics(mid_energies, off_axis_angle):
+    """Position 2 MSFC heritage X-7 optic effective areas.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the position 2 optics is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+
+    Returns
+    -------
+    : `effective_area.EffAreaOutput`
+        An object containing the effective area information of the MSFC 
+        heritage X-7 optic. See accessible information using `.contents` 
+        on the output.
+    """
+    r = eff_area_msfc_10shell(mid_energies, 
+                              off_axis_angle=off_axis_angle, 
+                              optic_id="X-7")
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position2_uniform_al(mid_energies):
+    """Position 2 uniform Al attenuator transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the uniform Al attenuator transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the uniform Al attenuator. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_uniform_al_cdte(mid_energies, 
+                            position=2)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(pitch=u.um)
+def foxsi4_position2_detector_response(region:int=None, pitch=None, _side:str="merged", _event_type:str="all"):
+    """Position 2 CdTe4 detector response.
+
+    Parameters
+    ----------
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    _side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    _event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    Returns
+    -------
+    : `detector_response.DetectorResponseOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+    pos2_det = 4
+    r = cdte_det_resp(cdte=pos2_det, 
+                      region=region, 
+                      pitch=pitch, 
+                      side=_side, 
+                      event_type=_event_type)
+    if r is None:
+        return
+    r.update_function_path(sys._getframe().f_code.co_name)
+    r.detector = f"CdTe{pos2_det}-Detector-Response"
+    return r
+
+# position 3
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position3_thermal_blanket(mid_energies):
+    """Position 3 thermal blanket transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the thermal blanketing transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the thermal blanket. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_thermal_blanket(mid_energies)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def foxsi4_position3_optics(mid_energies, off_axis_angle=None):
+    """Position 3 MSFC high resolution optic effective areas.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the position 3 optics is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        *** Not implemented yet. ***
+
+    Returns
+    -------
+    : `effective_area.EffAreaOutput`
+        An object containing the effective area information of the MSFC 
+        high resolution optic. See accessible information using 
+        `.contents` on the output.
+    """
+    if off_axis_angle is not None:
+        logging.warning(f"The `off_axis_angle` input for Position 3's optics ({sys._getframe().f_code.co_name}) is not yet implemented.")
+    r = eff_area_msfc_hi_res(mid_energies, 
+                             off_axis_angle=off_axis_angle,
+                             position=3, 
+                             use_model=True)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position3_al_mylar(mid_energies):
+    """Position 3 thin Mylar window transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the thin Mylar window transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the thin Mylar window. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_al_mylar(mid_energies)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position3_pixelated_attenuator(mid_energies):
+    """Position 3 pixelated attenuator transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the pixelated attenuator transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the pixelated attenuator. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_pixelated(mid_energies, 
+                      use_model=True)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(pitch=u.um)
+def foxsi4_position3_detector_response(region:int=None, pitch=None, _side:str="merged", _event_type:str="all"):
+    """Position 3 CdTe2 detector response.
+
+    Parameters
+    ----------
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    _side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    _event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    Returns
+    -------
+    : `detector_response.DetectorResponseOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+    pos3_det = 2
+    r = cdte_det_resp(cdte=pos3_det, 
+                      region=region, 
+                      pitch=pitch, 
+                      side=_side, 
+                      event_type=_event_type)
+    if r is None:
+        return
+    r.update_function_path(sys._getframe().f_code.co_name)
+    r.detector = f"CdTe{pos3_det}-Detector-Response"
+    return r
+
+# position 4
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position4_thermal_blanket(mid_energies):
+    """Position 4 thermal blanket transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the thermal blanketing transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the thermal blanket. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_thermal_blanket(mid_energies)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def foxsi4_position4_optics(mid_energies, off_axis_angle=None):
+    """Position 4 Nagoya high resolution optic effective areas.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the position 4 optics is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+        *** Not implemented yet. ***
+
+    Returns
+    -------
+    : `effective_area.EffAreaOutput`
+        An object containing the effective area information of the 
+        Nagoya high resolution optic. See accessible information using 
+        `.contents` on the output.
+    """
+    if off_axis_angle is not None:
+        logging.warning(f"The `off_axis_angle` input for Position 4's optics ({sys._getframe().f_code.co_name}) is not yet implemented.")
+    r = eff_area_nagoya_hxt(mid_energies, 
+                            off_axis_angle=off_axis_angle,
+                            use_model=True)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position4_uniform_al(mid_energies):
+    """Position 4 uniform Al attenuator transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the uniform Al attenuator transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the uniform Al attenuator. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_uniform_al_cdte(mid_energies, 
+                            position=4)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(pitch=u.um)
+def foxsi4_position4_detector_response(region:int=None, pitch=None, _side:str="merged", _event_type:str="all"):
+    """Position 4 CdTe3 detector response.
+
+    Parameters
+    ----------
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    _side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    _event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    Returns
+    -------
+    : `detector_response.DetectorResponseOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+    pos4_det = 3
+    r = cdte_det_resp(cdte=pos4_det, 
+                      region=region, 
+                      pitch=pitch, 
+                      side=_side, 
+                      event_type=_event_type)
+    if r is None:
+        return
+    r.update_function_path(sys._getframe().f_code.co_name)
+    r.detector = f"CdTe{pos4_det}-Detector-Response"
+    return r
+
+# position 5
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position5_thermal_blanket(mid_energies):
+    """Position 5 thermal blanket transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the thermal blanketing transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the thermal blanket. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_thermal_blanket(mid_energies)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV, off_axis_angle=u.arcmin)
+def foxsi4_position5_optics(mid_energies, off_axis_angle):
+    """Position 5 MSFC heritage X-8 optic effective areas.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the position 5 optics is required. If 
+        `numpy.nan<<astropy.units.keV` is passed then an entry for all 
+        native file energies are returned. 
+        Unit must be convertable to keV.
+
+    off_axis_angle : `astropy.units.quantity.Quantity`
+        The off-axis angle of the source.
+        Unit must be convertable to arc-minutes.
+
+    Returns
+    -------
+    : `effective_area.EffAreaOutput`
+        An object containing the effective area information of the MSFC 
+        heritage X-8 optic. See accessible information using `.contents` 
+        on the output.
+    """
+    r = eff_area_msfc_10shell(mid_energies, 
+                              off_axis_angle=off_axis_angle<<u.arcmin, 
+                              optic_id="X-8")
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position5_al_mylar(mid_energies):
+    """Position 5 thin Mylar window transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the thin Mylar window transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the thin Mylar window. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_al_mylar(mid_energies)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(mid_energies=u.keV)
+def foxsi4_position5_pixelated_attenuator(mid_energies):
+    """Position 5 pixelated attenuator transmissions.
+
+    Parameters
+    ----------
+    mid_energies : `astropy.units.quantity.Quantity`
+        The energies at which the pixelated attenuator transmission is 
+        required. If `numpy.nan<<astropy.units.keV` is passed then an 
+        entry for all native file energies are returned. 
+        Unit must be convertable to keV.
+
+    Returns
+    -------
+    : `attenuation.AttOutput`
+        An object containing the attenuation/transmission information of
+        the pixelated attenuator. See accessible information using 
+        `.contents` on the output.
+    """
+    r = att_pixelated(mid_energies, 
+                      use_model=True)
+    r.update_function_path(sys._getframe().f_code.co_name)
+    return r
+
+@u.quantity_input(pitch=u.um)
+def foxsi4_position5_detector_response(region:int=None, pitch=None, _side:str="merged", _event_type:str="all"):
+    """Position 5 CdTe1 detector response.
+
+    Parameters
+    ----------
+    region : `int`
+        The region of the CdTe detector required. Either provide 
+        `region` _xor_ `pitch`. The `region` maps onto the pitches used 
+        across the detector. 
+            Region 0 -> 60<<astropy.units.um 
+            Region 1 -> 80<<astropy.units.um
+            Region 2 -> 100<<astropy.units.um
+
+    pitch : `astropy.units.quantity.Quantity`
+        Instead of `region`, it might be more usefule to specify the 
+        pitch in physical units (must b convertable to 
+        `astropy.units.um`). Either provide `region` _xor_ `pitch`.
+        The pitches map onto the `region` input.
+            60<<astropy.units.um -> Region 0
+            80<<astropy.units.um -> Region 1
+            100<<astropy.units.um -> Region 2
+
+    _side : `str`
+        Define the side on the detector the user requires the response 
+        from. Must be in ["pt", "merged"].
+        Default: "merged"
+
+    _event_type : `str`
+        Define the type of event trigger being considered in the 
+        response. Must be in ["1hit", "2hit", ("all", "mix")]. 
+        Note: \"all\" and \"mix\" are the same but some from different 
+        naming conventions on the merged and individual detector sides. 
+        This will be fixed at some point in the future.
+        Default: "all"
+
+    Returns
+    -------
+    : `detector_response.DetectorResponseOutput`
+        An object containing all the redistribution matrix information. 
+        See accessible information using `.contents` on the output.
+    """
+    pos5_det = 1
+    r = cdte_det_resp(cdte=pos5_det, 
+                      region=region, 
+                      pitch=pitch, 
+                      side=_side, 
+                      event_type=_event_type)
+    if r is None:
+        return
+    r.update_function_path(sys._getframe().f_code.co_name)
+    r.detector = f"CdTe{pos5_det}-Detector-Response"
+    return r
+
+if __name__=="__main__":
+    # mid_energies = [4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 11. , 13. , 15. , 17. , 19. , 22.5, 27.5] << u.keV
+    # p2_tb = position2_thermal_blanket(mid_energies)
+    p2_dr_reg = position2_detector_response(region=0)
+    p2_dr_pitch = position2_detector_response(pitch=60<<u.um)
+    position2_detector_response(region=0, pitch=60<<u.um)
+    position2_detector_response(pitch=80<<u.um, _side="merged", _event_type="1hit")
\ No newline at end of file
diff --git a/response-tools-py/response_tools_py/util.py b/response-tools-py/response_tools_py/util.py
index 2e369e2..7e1288c 100644
--- a/response-tools-py/response_tools_py/util.py
+++ b/response-tools-py/response_tools_py/util.py
@@ -1,5 +1,8 @@
 """Generally useful functions."""
 
+from dataclasses import dataclass
+from pprint import pprint
+
 import numpy as np
 
 def native_resolution(native_x, input_x):
@@ -10,4 +13,45 @@ def native_resolution(native_x, input_x):
     The idea here is that if we want to improve/change the logic here 
     then we only have to do it here and not literally everywhere.
     """
-    return native_x if np.all(np.isnan(input_x)) else input_x
\ No newline at end of file
+    return native_x if np.all(np.isnan(input_x)) else input_x<<native_x.unit
+
+@dataclass
+class BaseOutput:
+    """Class for keeping track of general response values."""
+    filename: str
+    # put the highest level function that returns the object
+    # designed to be overwritten if a wrapper is around a function, etc.
+    function_path: str 
+
+    @property
+    def contents(self):
+        """Contents of the data class. """
+        return self.__dict__
+
+    @property
+    def fields(self):
+        """Just the names of the fields in the data class. """
+        return list(self.contents.keys())
+
+    @property
+    def print_contents(self):
+        """Print the contents of the data class in a nice way. """
+        pprint(self.contents)
+
+    def update_function_path(self, new_function_name:str):
+        """Should help tracking nested function if needed."""
+        self.function_path += f"\n->{new_function_name}"
+
+    def __getitem__(self, index:str):
+        """Allow the field names to be passed like indices too.
+        
+        Example
+        -----------
+        >>> ex = BaseOutput(filename="foo", function="bar")
+        >>> ex.filename
+        "foo"
+        >>> ex["filename"]
+        "foo"
+        """
+        return (self.contents | {"fields":self.fields})[index]
+    
diff --git a/response-tools-py/setup.py b/response-tools-py/setup.py
index 143ed6c..eaabd7f 100644
--- a/response-tools-py/setup.py
+++ b/response-tools-py/setup.py
@@ -16,5 +16,5 @@
             "pandas",
         ],
     packages=setuptools.find_packages(),
-    zip_safe=False
-)
+    zip_safe=False,
+)
\ No newline at end of file