def thin(self, rel_err=1.e-4, preserve_range=False):
"""Thin out the internal wavelengths of a Bandpass that uses a LookupTable.
If the bandpass was initialized with a LookupTable or from a file (which internally
creates a LookupTable), this function removes tabulated values while keeping the integral
over the set of tabulated values still accurate to the given relative error.
That is, the integral of the bandpass function is preserved to a relative precision
of `rel_err`, while eliminating as many internal wavelength values as possible. This
process will usually help speed up integrations using this bandpass. You should weigh
the speed improvements against your fidelity requirements for your particular use
case.
@param rel_err The relative error allowed in the integral over the throughput
function. [default: 1.e-4]
@param preserve_range Should the original range (`blue_limit` and `red_limit`) of the
Bandpass be preserved? (True) Or should the ends be trimmed to
include only the region where the integral is significant? (False)
[default: False]
@returns the thinned Bandpass.
"""
if len(self.wave_list) > 0:
x = self.wave_list
f = self(x)
newx, newf = utilities.thin_tabulated_values(
x, f, rel_err=rel_err, preserve_range=preserve_range)
tp = galsim.LookupTable(newx, newf, interpolant='linear')
blue_limit = np.min(newx)
red_limit = np.max(newx)
wave_list = np.array(newx)
return Bandpass(tp, blue_limit, red_limit, _wave_list=wave_list)
else:
return self
def thin(self, rel_err=1.e-4, preserve_range=False):
""" If the SED was initialized with a LookupTable or from a file (which internally creates a
LookupTable), then remove tabulated values while keeping the integral over the set of
tabulated values still accurate to `rel_err`.
@param rel_err The relative error allowed in the integral over the SED
[default: 1.e-4]
@param preserve_range Should the original range (`blue_limit` and `red_limit`) of the
SED be preserved? (True) Or should the ends be trimmed to
include only the region where the integral is significant? (False)
[default: False]
@returns the thinned SED.
"""
if len(self.wave_list) > 0:
wave_factor = 1.0 + self.redshift
x = self.wave_list / wave_factor
f = self._rest_photons(x)
newx, newf = utilities.thin_tabulated_values(x, f, rel_err=rel_err,
preserve_range=preserve_range)
spec = galsim.LookupTable(newx, newf, interpolant='linear')
blue_limit = np.min(newx) * wave_factor
red_limit = np.max(newx) * wave_factor
wave_list = np.array(newx) * wave_factor
return SED(spec, flux_type='fphotons', redshift=self.redshift,
_wave_list=wave_list, _blue_limit=blue_limit, _red_limit=red_limit)
else:
return self
def thin(self, rel_err=1.e-4, preserve_range=False):
"""Thin out the internal wavelengths of a Bandpass that uses a LookupTable.
If the bandpass was initialized with a LookupTable or from a file (which internally
creates a LookupTable), this function removes tabulated values while keeping the integral
over the set of tabulated values still accurate to the given relative error.
That is, the integral of the bandpass function is preserved to a relative precision
of `rel_err`, while eliminating as many internal wavelength values as possible. This
process will usually help speed up integrations using this bandpass. You should weigh
the speed improvements against your fidelity requirements for your particular use
case.
@param rel_err The relative error allowed in the integral over the throughput
function. [default: 1.e-4]
@param preserve_range Should the original range (`blue_limit` and `red_limit`) of the
Bandpass be preserved? (True) Or should the ends be trimmed to
include only the region where the integral is significant? (False)
[default: False]
@returns the thinned Bandpass.
"""
if len(self.wave_list) > 0:
x = self.wave_list
f = self(x)
newx, newf = utilities.thin_tabulated_values(x, f, rel_err=rel_err,
preserve_range=preserve_range)
tp = galsim.LookupTable(newx, newf, interpolant='linear')
blue_limit = np.min(newx)
red_limit = np.max(newx)
wave_list = np.array(newx)
return Bandpass(tp, blue_limit, red_limit, _wave_list=wave_list)
else:
return self
def thin(self, rel_err=1.e-4, trim_zeros=True, preserve_range=True, fast_search=True):
"""Thin out the internal wavelengths of a Bandpass that uses a LookupTable.
If the bandpass was initialized with a LookupTable or from a file (which internally
creates a LookupTable), this function removes tabulated values while keeping the integral
over the set of tabulated values still accurate to the given relative error.
That is, the integral of the bandpass function is preserved to a relative precision
of `rel_err`, while eliminating as many internal wavelength values as possible. This
process will usually help speed up integrations using this bandpass. You should weigh
the speed improvements against your fidelity requirements for your particular use
case.
@param rel_err The relative error allowed in the integral over the throughput
function. [default: 1.e-4]
@param trim_zeros Remove redundant leading and trailing points where f=0? (The last
leading point with f=0 and the first trailing point with f=0 will
be retained). Note that if both trim_leading_zeros and
preserve_range are True, then the only the range of `x` *after*
zero trimming is preserved. [default: True]
@param preserve_range Should the original range (`blue_limit` and `red_limit`) of the
Bandpass be preserved? (True) Or should the ends be trimmed to
include only the region where the integral is significant? (False)
[default: True]
@param fast_search If set to True, then the underlying algorithm will use a
relatively fast O(N) algorithm to select points to include in the
thinned approximation. If set to False, then a slower O(N^2)
algorithm will be used. We have found that the slower algorithm
tends to yield a thinned representation that retains fewer samples
while still meeting the relative error requirement, and may also
be somewhat more robust when computing SED fluxes through
Bandpasses when a significant fraction of the integrated flux
passes through low throughput bandpass light leaks.
[default: True]
@returns the thinned Bandpass.
"""
if len(self.wave_list) > 0:
x = self.wave_list
f = self(x)
newx, newf = utilities.thin_tabulated_values(x, f, rel_err=rel_err,
trim_zeros=trim_zeros,
preserve_range=preserve_range,
fast_search=fast_search)
tp = galsim.LookupTable(newx, newf, interpolant='linear')
blue_limit = np.min(newx)
red_limit = np.max(newx)
wave_list = np.array(newx)
return Bandpass(tp, 'nm', blue_limit, red_limit, _wave_list=wave_list)
else:
return self
def thin(self, rel_err=1.e-4, trim_zeros=True, preserve_range=True, fast_search=True):
""" If the SED was initialized with a LookupTable or from a file (which internally creates a
LookupTable), then remove tabulated values while keeping the integral over the set of
tabulated values still accurate to `rel_err`.
@param rel_err The relative error allowed in the integral over the SED
[default: 1.e-4]
@param trim_zeros Remove redundant leading and trailing points where f=0? (The last
leading point with f=0 and the first trailing point with f=0 will
be retained). Note that if both trim_leading_zeros and
preserve_range are True, then the only the range of `x` *after*
zero trimming is preserved. [default: True]
@param preserve_range Should the original range (`blue_limit` and `red_limit`) of the
SED be preserved? (True) Or should the ends be trimmed to
include only the region where the integral is significant? (False)
[default: True]
@param fast_search If set to True, then the underlying algorithm will use a
relatively fast O(N) algorithm to select points to include in the
thinned approximation. If set to False, then a slower O(N^2)
algorithm will be used. We have found that the slower algorithm
tends to yield a thinned representation that retains fewer samples
while still meeting the relative error requirement.
[default: True]
@returns the thinned SED.
"""
if len(self.wave_list) > 0:
wave_factor = 1.0 + self.redshift
x = self.wave_list / wave_factor
f = self._rest_photons(x)
newx, newf = utilities.thin_tabulated_values(x, f, rel_err=rel_err,
trim_zeros=trim_zeros,
preserve_range=preserve_range,
fast_search=fast_search)
spec = galsim.LookupTable(newx, newf, interpolant='linear')
blue_limit = np.min(newx) * wave_factor
red_limit = np.max(newx) * wave_factor
wave_list = np.array(newx) * wave_factor
return SED(spec, wave_type='nm', flux_type='fphotons',
redshift=self.redshift, _wave_list=wave_list,
_blue_limit=blue_limit, _red_limit=red_limit)
else:
return self