Instrument¶

The Instrument class contains information about the instrument. This includes storing the fields-of-view and spectral point spread functions that define each pixel.

Users can choose to use the Instrument class as-is or they can use it as a base class and derive their own instrument class. Either option works and its a matter of personal preference.

A typical usage:

class Test_Instrument( Instrument ):

def __init__(self):

    super().__init__( )

    aperture_area_cm2 = 25.0

    # ---- setup the instantaneous field of views used by the pixels.
    # ---- define the different fields of view
    # ---- used by this instrument. Define in instrument control frame coordinates

    fovidx0 = self.add_field_of_view( FOV_Rectangle(Hrange=(13, math.radians(0.0), math.radians(0.5)),
                                                    Vrange=(15, math.radians(0.0), math.radians(20.0 / 3600.0))))

    fovidx1 = self.add_field_of_view( FOV_Rectangle(Hrange=(13, math.radians(0.2), math.radians(0.5)),
                                                    Vrange=(15, math.radians(0.2), math.radians(20.0 / 3600.0))))

    # ---- setup the spectral point spread functions used by the pixel.
                                                                                                # The code will spatially integrate radiance over each field of view
    wavidx0 = self.add_wavelength_range( Wavelength_GaussianPSF(gaussian=(30, 450.0, 0.3)))     # Define the different wavelength regions used by the pixels
    wavidx1 = self.add_wavelength_range( Wavelength_GaussianPSF(gaussian=(30, 452.0, 0.3)))     # The code will spectrally integrate over each wavelength region
    wavidx2 = self.add_wavelength_range( Wavelength_GaussianPSF(gaussian=(30, 454.0, 0.3)))

    # ---- define the pixels used in this instrument in terms of the field of view
    # ---- and the spectral point spread functions

    fer.add_pixel( SpectralWindow( fovidx0, wavidx0, aperture_area_cm2) )                    # define the pixels used in the simulation
    fer.add_pixel( SpectralWindow( fovidx0, wavidx1, aperture_area_cm2) )                    # Each pixel is a combination of a wavelength range and a field of view
    fer.add_pixel( SpectralWindow( fovidx0, wavidx2, aperture_area_cm2) )                    # The front-end radiance will be integrated over the eavelength range and the field of view
    fer.add_pixel( SpectralWindow( fovidx1, wavidx0, aperture_area_cm2) )
    fer.add_pixel( SpectralWindow( fovidx1, wavidx1, aperture_area_cm2) )
    fer.add_pixel( SpectralWindow( fovidx1, wavidx2, aperture_area_cm2) )

class skimpy.Instrument¶

Class Instrument defines the fields of view, spectral point spread functions and spectral_windows that will be used to simulate the signals measured by an instrument. All skimpy simulations require an instrument to be defined.

__init__()¶: Creates an empty instrument object.

add_field_of_view(fov: skimpy.instrument.fov.FOV) → int¶

Add the given field of view to this instrument. Return the index of the field view. This index can be used when creating spectral_windows for this instrument

Parameters:	fov (FOV) – This field of view is added to theinstrument. The user should assume this field of view has been given to the instrument and should ensure they do not modify the object after the call.
Returns:	The index of this field of view in the instrument. This index can be used when creating spectral_windows for this instrument which use this field of view
Return type:	int

add_spectral_window(window: skimpy.instrument.spectralwindow.SpectralWindow) → int¶

Add the given spectral_window to this instrument. Returns the index of the spectral_window in the instrument.

Parameters:	window (SpectralWindow) – This spectral_window is added to the instrument. The user should assume this spectral_window object has been given to the instrument and should ensure they do not modify the object after the call.
Returns:	The index of this spectral point spread function in the instrument. This index can be used when creating spectral_windows for this instrument which use this spectral point spread function
Return type:	int

add_wavelength_range(wavelen_range: skimpy.instrument.wavelength_bandpass.Wavelength_BandPass) → int¶

Add the given spectral point spread function to this instrument. Return the index of the spectral point spread functions. This index can be used when creating spectral_windows for this instrument

Parameters:	wavelen_range (Wavelength_BandPass) – This spectral point spread function is added to the instrument. The user should assume this spectral point spread function has been given to the instrument and should ensure they do not modify the object after the call.
Returns:	The index of this spectral point spread function in the instrument. This index can be used when creating spectral_windows for this instrument which use this spectral point spread function
Return type:	int

back_end¶

Returns the list of spectral_windows in this Instrument.

Returns:	The list of spectral_windows in this Instrument. Its actually an internal container object that can be indexed with integers.
Return type:	Iterable[int]

fovs¶

The list of all field of views defined in this Instrument

Returns:	The list of field of views stored in this Instrument. Its an internal container object that can be indexed with integers
Return type:	Iterable[FOV]

front_end_radiance() → skimpy.instrument.frontendradiance.FrontEndRadiance¶

Internal method. Returns the FrontEndRadiance object representing the front end spectral_windows.

Returns:	The object representing the front end spectral_windows.
Return type:	FrontEndRadiance

num_spectral_windows¶: Returns the number of spectral_windows defined in this instrument

numsamples¶: Returns the number of samples defined in this instrument. Only valid after the radiative transfer calculations

spectral_windows¶

Returns the list of spectral_windows in this Instrument.

Returns:	The list of spectral_windows in this Instrument. Its actually an internal container object that can be indexed with integers.
Return type:	Iterable[int]

wavelength_ranges¶

The list of all spectral point spread functions stored in this instrument.

Returns:	The list of spectral point spread functions stored in this Instrument. Its an internal container object that can be indexed with integers
Return type:	Iterable[Wavelength_BandPass]

SpectralWindow¶

class skimpy.SpectralWindow(instrument: Instrument, fov_integrator_index: int, wavelen_integrator_index: int, aperture_area_cm2: float)¶

SpectralWindow are solid angle elements within the instrument model that combine an instantaneous field of view with a spectral point spread function

The spectral_window also stores both the high resolution and integrated radiances, \(I(\lambda, \Omega, N_t)\) and \(ar{I}(N_t)\) respectively, generated by a call to the ForwardModel.

The spectral_window supports the concept of a hybridized spectral point spread function which tries to optimize the speed of RT calculation for UVIS-NIR situations where the toa albedo slowly varies across the spectral point spread function. In this case a low order spectral point function is used to calculate toa albeo in the radiative transfer code and then quickly interpolated onto a high order spectral point function. The high order grid can then accurately capture the high spectral variation of the solar irradiance in the calculated back_end_radiance signals.

This hybrid functionality is implemented as a pre RTM spectral point spread function and a post RTM spectral point spread function.

__init__(instrument: Instrument, fov_integrator_index: int, wavelen_integrator_index: int, aperture_area_cm2: float)¶

Configures the spectral_window with a field of view and a wavelength range. The field of view and the wavelength range objects can be shared amongst many objects and are essentially treated as read-only. There is an option to optimize the integration (we we use numpy.einsum) but it is not clear whether the optimization is useful unless you intend to repeatedly perform the integral.

Parameters:	fov_integrator_index (int) – The index in the instrument of the field of view to be used for this spectral_window. wavelen_integrator_index (int) – The index in the instrument of the spectral point spread function to be used for this spectral_window aperture_area_cm2 (float) – The area of the front aperture associated with tis spectral_window.

central_los_icf() → numpy.ndarray¶

Returns the central line of sight of the spectral_window as a unit vector in the Instrument Control Frame. This value is provided by the spectral_window’s field-of-view object, see FOV

Returns:	A 3 element array representing the central line of sight unit vector specified in the Instrument Control Frame
Return type:	np.ndarray

central_wavelength() → float¶

Returns the central wavelength of the spectral_window. This value is provided by the spectral_window’s spectral point spread function.

Returns:	The central wavelength of the spectral_window in nm
Return type:	float

fov() → skimpy.instrument.fov.FOV¶

Returns the field of view of this spectral_window. The field of view defines the high resolution lines of sight used for the radiative transfer calculations. The back_end_radiance values stored in the spectral_window will integrate/average back_end_radiance over this field of view. Note that is is an angular field of view and denotes the solid angle subtended by the spectral_window. Most field of views assume uniform response across the area and calculate integration weights that only account for the physical angular area of each subdivision element.

Returns:	The field of view used by this SpectralWindow
Return type:	FOV

high_resolution_radiance¶

Returns the high resolution back_end_radiance values generated by the last call to the forward model. The high resolution radiances have values for all the lines of sight that subdivide the field of view of a spectral_window and all the wavelengths that contribute to the spectral point spread function. They also have values fro all the samples in the current platform’s observation policy

Different radiative transfer models return different derived classes of RadianceValues and the actual objects returned by this method are context dependent. UVIS-NIR calculations return an instance of RadianceValues_UVIS_NIR while IR calculations return an instance of RadianceValues_IR.

In all cases this method returns arrays of high resolution back_end_radiance. The high resolution wavelengths can be found in the spectral_windows post-rtm point spread function and the high resolution lines of sight can be found in the spectral_window’s field of view For scalar back_end_radiance calculations the arrays will be of the form, \(I(\lambda, \Omega, N_t)\) where \(N_t\) is the number of samples generated by the platform. For polarized calculations the array is if the form \(I(\lambda, \Omega, N_t, P)\) where \(P\) is the polarization axis and depending upon context, typically refers to the 4 element index \([I,Q,U,V]\).

The first dimension is always used for the wavelengths across the spectral point spread function. This axis always is retained even when only one wavelength is used. The values of the wavelengths are given by post_rtm_point_spread_function(). This dimension is integrated over and removed in the spectral_window’s back_end_radiance() value.
The second dimension is always used for the instantaneous lines of sight that sub-divide the field of view. This axis is always retained even when there is only one point. The lines of sight are given by fov(). This dimension is integrated over and removed in the spectral_window’s back_end_radiance() value
The third dimension is for the samples from the current platform’s Observation Policy, see Platform. This dimension is retained and becomes the first dimension of the spectral_window’s back_end_radiance() value.
Higher dimensions are context dependent and are not yet precisely defined. For example weighting functions created with the UVIS-NIR method require an extra fourth dimnesion. Polarized back_end_radiance calculations are another option which need the fourth dimension while polarized weighting functions require an extra fourth and fifth dimension! Exercise care when using these scenarios.

Returns:	The high resolution front-end back_end_radiance, typically an array of \(I(\lambda, \Omega, N_t, extra fields)\). The wavelengths used in the high resolution back_end_radiance can be found in the `post_rtm_point_spread_function()` method. The lines of sight used in the high resolution back_end_radiance can be found in `fov()`.
Return type:	RadianceValues

post_rtm_point_spread_function() → skimpy.instrument.wavelength_bandpass.Wavelength_BandPass¶

Returns the spectral point spread function used by this spectral_window. This is the spectral point spread function internally created by the forward model after the call to the radiative transfer model. It is often identical to pre_rtm_point_spread_function().

It is provided for hybrid UVIS-NIR calculations where the top-of-atmosphere albedo is calculated with relatively few data points and then interpolated onto a the high resolution grid of the solar spectrum. This band pass is always used to integrate the back_end_radiance values returned from the forward model. Users do not need to set this value as it is internally set by the forward model code.

Returns:	The spectral point spread function used by this spectral_window. This defines the high resolution wavelengths used to store the high resolution back_end_radiance values in the spectral_window
Return type:	Wavelength_BandPass

pre_rtm_point_spread_function() → skimpy.instrument.wavelength_bandpass.Wavelength_BandPass¶

Returns the spectral point spread function used by this spectral_window. This is the spectral point spread function passed to the radiative transfer code. If hybrid processing is not requested then the stored high resolution back_end_radiance signals will be at the wavelengths specified in this object. If hybrid processing is requested then the stored high resolution back_end_radiance signals will use the wavelengths given in post_rtm_point_spread_function().

Returns:	The spectral point spread function used by this spectral_window. This defines the high resolution wavelengths used for the high resolution back_end_radiance calculation.
Return type:	Wavelength_BandPass

… _fov_class:

FOV¶

Each instrument has an array of list of Field-of-views stored in its self.fov member

class skimpy.FOV¶

A base class used to define the solid angle of a field of view in the front end optics. This class provides the quadrature infrastructure to allow integration of signals over the field of view. There are relatively few constraints on the system, for example the field of view could be rectangular for a slit or detector spectral_window or it may be circular for round detectors. see FOV_Rectangle for an implementation of a rectangular field of view.

__init__()¶: Initialize self. See help(type(self)) for accurate signature.

central_los_icf() → numpy.ndarray¶

Returns the unit vector of the central line of sight associated with this field of view. This is considered to be the nominal pointing direction of this entire field of view.

Returns:	The unit vector of the central line of sight. This is a 3 element array specified in the Instrument Control Frame
Return type:	np.ndarray (3)

lines_of_sight_in_icf() → numpy.ndarray¶

Returns the lines of sight that span this field of view.

Returns:	Returns the N unit vectors of the lines of sight that span this field of view. Each unit vector is specified in the Instrument Control Frame.
Return type:	np.ndarray (3,N)

quadrature_weights() → numpy.ndarray¶

Returns the N quadrature weights associated with the N lines of sight that span this field of view.

Returns:	The quadrature weights of the N lines of sight that span this field of view. The quadrature weights should be normalized so they sum to unity.
Return type:	np.ndarray (N)

solid_angle()¶

” Returns ths solid angle of this field of view.

Returns:	The solid angle of this field of view. This can be used to convert averaged back_end_radiance to photons
Return type:	float

FOV_Rectangle¶

class skimpy.instrument.fov.FOV_Rectangle(Hrange: Tuple[int, float, float] = None, Hvalues: numpy.ndarray = None, Vrange: Tuple[int, float, float] = None, Vvalues: numpy.ndarray = None)¶

A class used to represent a rectangular field of view. The class provides lines of sight that span the field of view that are used to numerically integrate back_end_radiance across the field of view. The rectangular field of view is specified with angular sizes in the front entrance aperture. The horizontal dimension of the slit is parallel to \(\hat{y}_{ICF}\) in the Instrument Control Frame (ICF) and the vertical dimension is parallel to \(\hat{z}_{ICF}\). All sizes and spacings of the rectangular field of view are specified in radians. The quadrature normalization is setup up so the sum of the quadrature weights will give the solid angle area of the rectangular region.

__init__(Hrange: Tuple[int, float, float] = None, Hvalues: numpy.ndarray = None, Vrange: Tuple[int, float, float] = None, Vvalues: numpy.ndarray = None)¶

Parameters:

Hrange (Tuple[int, float, float]) – A three element tuple that provides (N, H_centre and H_width) for the horizontal dimension of the field of view. These three numbers configure the field of view with N evenly spaced trapezoidal integration points in the horizontal direction. A line of sight is generated at each quadrature point. N is the number of steps used in evenly spaced trapezoidal integration across the horizontal direction and must be greater than 0. Note that an odd number of points will place a line of sight at the center of the field-of-view in the horizontal direction. H_centre is the horizontal center of this rectangular field of view in the Instrument Control Frame (ICF) expressed in radians. The angles are applied as a right-handed yaw around the \(\hat{z}_{ICF}\). H_width is the full angular width of the field of view in the horizontal direction in the Instrument Control Frame (ICF) expressed in radians. Half of the width is to the left of the centre and half of the width is to the right of the centre. The Hvalues optional argument must not be set.
Hvalues (np.ndarray) – An array (Nh) of “H” horizontal angular values that specify the location of quadrature points across the horizontal dimension of the rectangular field of view. The elements in the array do not need to be evenly spaced. There should be at least 2 elements. If you need only 1 element then use the Hrange option. The first and last element are assumed to specify the full width of the slit and there is no contribution to the integrated signal from outside these ranges: i.e. the numerical integration is from Hvalues[0] to Hvalues[-1]. All values in the array are expressed as radians and are applied as a right-handed yaw around the \(\hat{z}_{ICF}\). Lines of sight will be generated for each point in the horizontal array. The Hrange optional arguments must not be set.
Vrange (Tuple[int, float,float]) – A three element tuple (N, V_centre and V_width) that describes the vertical dimension of the field of view. These three numbers configure the field of view with N evenly spaced trapezoidal integration points in the vertical direction. A line of sight is generated at each quadrature point. N must be greater than 0 and is the number of steps used in evenly spaced trapezoidal integration across the vertical direction. Note that an odd number of points will place a line of sight at the center of the field-of-view in the vertical direction. V_centre is the vertical center of the rectangular field of view in Instrument Control Frame (ICF). It is expressed in radians and is applied as a left-handed pitch rotation around the \(\hat{y}_{ICF}\), this is intentional so positive values will orient \(\hat{x}_{ICF}\) upwards. V_width is the full angular height of the field of view in the vertical direction in the Instrument Control Frame (ICF) expressed in radians. The Vvalues optional argument must not be set.
Vvalues (np.ndarray) – An array (Nv) of vertical angular values that specify the location of quadrature points across the vertical dimension of the rectangular field of view. The elements in the array do not need to be evenly spaced but there should be at least 2 elements. If you need only 1 elements then use the Vrange option. The first and last element are assumed to specify the full height of the slit and there is no contribution to the integrated signal from outside these ranges: i.e. the numerical integration is from Vvalues[0] to Vvalues[-1]. All values in the array are expressed as radians and are applied as a left-handed pitch around the \(\hat{y}_{ICF}\). Lines of sight will be generated for each point in the horizontal array. The other optional arguments controlling the vertical field of view, Vrange, must not be set.

solid_angle()¶

” Returns the solid angle of the field of view. Factor that will convert solid angle averaged back_end_radiance (photons/nm/sec/ster) to photons/sec/nm by applying the total solid angle area.

Returns:	The factor that converts area averaged back_end_radiance to photons
Return type:	float

Wavelength_BandPass¶

class skimpy.Wavelength_BandPass(lambda0: float, rtm_processing_scheme='preconvolved', rtm_processing_scheme_options={}, **kwargs)¶

The base of a family of classes that provide the wavelengths used to calculate the back_end_radiance signals in a SpectralWindow class. The and spectral point spread function used by the instrument simulator. The object band-pass region is used to convolve the instrument’s spectral point spread function with the calculated back_end_radiance. The wavelength bandpass is involved with the integrals of the point spread function, \(R(\lambda-\lambda_{0}(\Omega))\), and the back_end_radiance such as,

\[\int_{\lambda}\:R_\lambda(\lambda-\lambda_{0}(\Omega))\,I(\lambda,\Omega)d\lambda\]

We often assume that the central wavelength, \(lambda_{0}\), is constant within a given spectral_window and is not a function of input angle, \(\Omega\). The integration demands the point spread function is properly normalized. .. math:

\int_\lambda\:R_\lambda(\lambda-\lambda_{0})\,d\lambda = 1

A primary responsibility of the wavelength bandpass object is to try and ensure that the above integrals are performed with accuracy. This can be difficult to achieve with just a handful of quadrature points as the input back_end_radiance signal \(I(\lambda,\Omega)\), will often have significant high frequency structure attributable to solar Fraunhofer lines etc.

There are a few strategies that can be used to handle this situation:

High Resolution Algorithm, a brute force technique that performs all radiative transfer calculations at the high wavelength resolution available for solar spectra databases (typically ~0.04 nm). This will always work but places huge demands on the Sasktran radiative transfer model and results in long run times.

Pre-convolve Algorithm, a common traditional technique where the solar spectrum is pre-convolved to the instrument resolution and all radiative transfer calculations are performed at a lower resolution appropriate for the point spread function. This is relatively quick but can introduce stray spectral artifacts.

Hybrid High Resolution Algorithm a hybridized approach suitable for many UVIS-NIR calculations is to perform the radiative transfer calculations at lower spectral resolution and then use the high resolution solar spectrum to interpolate on to a high resolution wavelength grid. This relies on the fact that the top-of-atmosphere albedo calculated by the radiative transfer model is often varying much more slowly in wavelength than the high resolution solar spectra and can be accurately interpolated with a low order polynomial.

In practice, the spectral point spread function is often represented by a Gaussian distribution. See also, class Wavelength_GaussianPSF

PSF(wavelen: numpy.ndarray) → numpy.ndarray¶

Calculates the point spread function at the array of wavelengths. This is typically called when evaluating the band-pass integrals with the Hybrid Algorithm*.

Parameters:	wavelen (np.ndarray) – An array of wavelengths in nanometers
Returns:	An array of point spread functions evaluated at each wavelength.
Return type:	np.ndarray

__init__(lambda0: float, rtm_processing_scheme='preconvolved', rtm_processing_scheme_options={}, **kwargs)¶

Initializes the Wavelength_BandPass base class.

The parameter solar_spectrum_preconvolved_FWHM is an important parameter that controls and optionally configures the algorithm used for point spread function integrals across the wavelength bandpass

If provided then set the full width half maximum in nanometers. It will be used to pre-convolve the solar spectrum before integration. Class RadianceSimulator will use the Pre-convolve Algorithm described above when performing spectral integrals. It will use the pre-convolved solar spectrum to integrate the back_end_radiance and spectral point spread function at low to modest spectral resolution.

If not provided (None) then class RadianceSimulator will use the Hybrid Algorithm described above when performing spectral point spread integrals: it will linearly interpolate the back_end_toa_albedo on to the native resolution of the solar spectrum and multiply by the full resolution solar spectrum. Integration is performed with class RadianceSimulator using a different quadrature class, typically trapezoidal based.

the option to use High resolution Algorithm is implemented as a special case of the Hybrid Algorithm

Parameters:	lambda0 (float) – Specifies the central wavelength in nanometers of the wavelength bandpass.

central_wavelength() → float¶

Returns the central wavelength in nm of the bandpass region

Returns:	The central bandpass central/primary wavelength in nanometers.
Return type:	float

clone_with_user_defined_wavelengths(new_wavlens: numpy.ndarray) → skimpy.instrument.wavelength_bandpass.Wavelength_BandPass¶

Clones this spectral point spread function and maps it to use a new set of wavelengths for the quadrature points. This is used when we are in hybrid mode and internally switch the wavelength resolutions.

Returns:	If successful returns a new instance of this object but now has its quadrature points set to the new wavelengths passed in. Not all members of the family of Wavelength_BandPass classes will be able to support this method.
Return type:	Wavelength_BandPass

fwhm() → float¶: Returns the FWHM max o fthis wavelength bandpass. This is used when generating pre-convolved solar spectra to ensure they are the same resolution as the bandpass

get_rtm_processing_scheme()¶: Returns the name of the current RTM processing scheme and the options associated :return: RTM

is_hybrid_scheme() → bool¶

Returns true if we are using the hybrid processing rtm_scheme

Returns:	True if using Hybrid procesisng rtm_scheme else False
Return type:	bool

quadrature_weights() → numpy.ndarray¶

Returns the weights of the quadrature points covering the bandpass range which are used used when applying the spectral point spread function integral. T

Returns:	The array of weights in nanometers, one entry for each quadrature point.
Return type:	np.ndarray

set_rtm_processing_scheme(rtm_scheme: str, rtm_scheme_options: Dict[str, Any] = {})¶

Sets the processing rtm_scheme used for this wavelength range. The user option must be one of

highres. For UVIS-NIR, the RTM will calculate toa-albedo signals at the specified wavelengths and will apply a linearly interpolated high resolution solar spectrum. For IR the RTM will calculate back_end_radiance signals at the specified wavelengths. Default.

preconvolved. For UVIS-NIR, the RTM will calculate toa-albedo signals at the specified wavelengths, it will pre-convolve the solar spectrum to the specified resolution at those wavelengths and directly apply to the toa-albedo. For IR, not supported

hybrid. For UVIS-NIR, the RTM will calculate toa-albedo at the specified wavelengths. The TOA-albedo signal is then interpolated (linear, spline etc) onto the high resolution solar spectrum wavelength and the high resolution solar spectrum directly applied. For IR, not supported

Parameters:	rtm_scheme (str) – The processing rtm_scheme to be used for this wavelength range. It must be one of the three options shown above. rtm_scheme_options (Dict[str,Any]) – A list of options used to configure the processing required for the requested rtm_scheme. The options are specific to the rtm_scheme chosen. Default is None

wavelengths() → numpy.ndarray¶

Returns the wavelengths of the quadrature points covering the bandpass range which are used used when applying the spectral point spread function integral. This is called by the radiative transfer code to determine which wavelengths should be used in calculations.

Returns:	The array of wavelengths in nanometers, one entry for each quadrature point.
Return type:	np.ndarray

Wavelength_GaussianPSF¶

class skimpy.instrument.wavelength_bandpass_gaussian.Wavelength_GaussianPSF(N: int, lambda0: float, FWHM: float, make_clone=False, max_bound_in_sigmas=5, **kwargs)¶

Define a Gaussian spectral point spread function. This class uses user defined wavelengths across the Gaussian distribution and uses a custom quadrature to accurately perform weighted integration across the distribution.

PSF(wavelen: numpy.ndarray) → numpy.ndarray¶

Calculates the point spread function at the array of wavelengths. This is typically called when evaluating the band-pass integrals with the Hybrid Algorithm*.

Parameters:	wavelen (np.ndarray) – An array of wavelengths in nanometers
Returns:	An array of point spread functions evaluated at each wavelength.
Return type:	np.ndarray

__init__(N: int, lambda0: float, FWHM: float, make_clone=False, max_bound_in_sigmas=5, **kwargs)¶

Initializes the spectral point spread fucntion to follow a gaussian distribution with a peak at \(\lambda_0\) and a Full Width Half Maximum of FWHM. High resolution, front-end radiances will be integrated across the Gaussian bandpass using N point Gaussian quadrature. Set N to 1 if you do not need high resolution spectra.

Parameters:

N (int) – The order of the Gaussian quadrature across the wavelength bandpass. These points are typically evenly distributed across 5 standard deviations. Use a value of 1 if you do not need high resolution spectra.
lambda0 (float) – The central wavelength of the Gaussian distribution expressed in nanometers.
FWHM (float) – The full width half maximum width of the Gaussian distribution expressed in nanometers.
max_bound_in_sigmas (int) – Specifies how many standard deviations the Gaussian Point spread function extends above and below the central wavelength. Note that the standard deviation is approx FWHM/2.35. The defulat is 5.

clone_with_user_defined_wavelengths(new_wavlens: numpy.ndarray) → skimpy.instrument.wavelength_bandpass.Wavelength_BandPass¶: Clones this object with user defined wavelengths. This is internally used when supporting hybrid mode in UVIS-NIR applications

fwhm() → float¶: Returns the FWHM max of this wavelength bandpass. This is used when generating pre-convolved solar spectra to ensure they are the same resolution as the bandpass

standard_deviation() → float¶