def _sample_pressure(self, samples, N=100, percentiles=False):
"""
Draw random samples of the gas pressure in [Pa] from the sampled
posterior distributions.
Args:
samples (ndarray): Samples of the posterior distributions from
``fit_vphi`` including the ``mstar``, ``gamma`` and ``mdisk``
values. Should be of shape ``[nsamples, ndim]``.
N (Optional[int]): Number of random samples to draw.
percentiles (Optional[bool]): If ``True``, take the 16th, 50th and
84th percentiles of the ``n_mol`` samples to estimate the
uncertainty.
perturbations_only (Optional[bool]): If ``True``, only plot the
perturbations rather than the full radial profile.
Returns:
P (ndarray): Array of the ``P`` samples. If ``percentiles=True``
this will be a ``[3, rvals.size]`` shaped array with
``[y, -dy, +dy]`` values based on the 16th, 50th and 84th
percentiles of the ``N`` random samples. Otherwise will be a
``[N, rvals.size]`` array of ``P`` profiles.
"""
P = self._sample_n_mol(samples=samples, N=N) * sc.k * self.T_gas * 1e6
if percentiles:
P = np.percentiles(P, [16, 50, 84], axis=0)
P = np.array([P[1], P[1] - P[0], P[2] - P[1]])
return P
def weightsFromPrecentiles(intensities, percentiles=[25, 50, 75, 100]):
perc = numpy.percentiles(intensities, percentiles)
weights = numpy.zeros(intensities.shape)
for p in perc:
ii = intensities > p
weights[ii] = weights[ii] + 1
return weights
def weightsFromPrecentiles(intensities, percentiles = [25,50,75,100]):
perc = numpy.percentiles(intensities, percentiles);
weights = numpy.zeros(intensities.shape);
for p in perc:
ii = intensities > p;
weights[ii] = weights[ii] + 1;
return weights;
def run(self, ccdExposure, bias=None, dark=None, flat=None, defects=None, fringes=None, bfKernel=None,
linearizer=None):
"""!Perform instrument signature removal on an exposure
Steps include:
- Detect saturation, apply overscan correction, bias, dark and flat
- Perform CCD assembly
- Interpolate over defects, saturated pixels and all NaNs
\param[in] ccdExposure -- lsst.afw.image.exposure of detector data
\param[in] bias -- exposure of bias frame
\param[in] dark -- exposure of dark frame
\param[in] flat -- exposure of flatfield
\param[in] defects -- list of detects
\param[in] fringes -- a pipe_base.Struct with field fringes containing
exposure of fringe frame or list of fringe exposure
\param[in] bfKernel -- kernel for brighter-fatter correction
\param[in] linearizer -- object for applying linearization
\return a pipe_base.Struct with field:
- exposure
"""
# Validate Input
if self.config.doBias and bias is None:
raise RuntimeError("Must supply a bias exposure if config.doBias True")
if self.config.doDark and dark is None:
raise RuntimeError("Must supply a dark exposure if config.doDark True")
if self.config.doFlat and flat is None:
raise RuntimeError("Must supply a flat exposure if config.doFlat True")
if self.config.doBrighterFatter and bfKernel is None:
raise RuntimeError("Must supply a kernel if config.doBrighterFatter True")
if fringes is None:
fringes = pipe_base.Struct(fringes=None)
if self.config.doFringe and not isinstance(fringes, pipe_base.Struct):
raise RuntimeError("Must supply fringe exposure as a pipe_base.Struct")
defects = [] if defects is None else defects
ccd = ccdExposure.getDetector()
if self.config.doBias:
self.biasCorrection(ccdExposure, bias)
if self.config.doBrighterFatter:
self.brighterFatterCorrection(ccdExposure, bfKernel,
self.config.brighterFatterMaxIter,
self.config.brighterFatterThreshold,
self.config.brighterFatterApplyGain,
)
if self.config.doDark:
self.darkCorrection(ccdExposure, dark)
for amp in ccd:
# if ccdExposure is one amp, check for coverage to prevent performing ops multiple times
if ccdExposure.getBBox().contains(amp.getBBox()):
ampExposure = ccdExposure.Factory(ccdExposure, amp.getBBox())
self.updateVariance(ampExposure, amp)
# Don't trust the variance not to be negative (over-subtraction of dark?)
# Where it's negative, set it to a robust measure of the variance on the image.
variance = ccdExposure.getMaskedImage().getVariance().getArray()
quartiles = numpy.percentiles(ccdExposure.getMaskedImage().getImage().getArray(), [25.0, 75.0])
stdev = 0.74*(quartiles[1] - quartiles[0])
variance[:] = numpy.where(variance > 0, variance, stdev**2)
if self.config.doFringe and not self.config.fringeAfterFlat:
self.fringe.run(ccdExposure, **fringes.getDict())
if self.config.doFlat:
self.flatCorrection(ccdExposure, flat)
self.maskAndInterpDefect(ccdExposure, defects)
self.saturationInterpolation(ccdExposure)
self.maskAndInterpNan(ccdExposure)
if self.config.doFringe and self.config.fringeAfterFlat:
self.fringe.run(ccdExposure, **fringes.getDict())
ccdExposure.getCalib().setFluxMag0(self.config.fluxMag0T1 * ccdExposure.getCalib().getExptime())
return pipe_base.Struct(
exposure=ccdExposure,
)
# Variance pop vs sample variance # sample variance is different because you divide by sample -1 # probability distribution function = probability of data falling within a given value #pribabilty desnity function for discrete data # pdf can be normal, uniform (ie uniform even chance) of exponential #percentiles divide data according to % at what is x% of the values are less than that value. ie income # distribution the 99% import numpy as np vals = np.random.normal(0, 0.5, 10000) np.percentiles(vals, 50) # Covariance # see https://www.youtube.com/watch?v=0nZT9fqr2MU # see https://www.youtube.com/watch?v=9Y0Alg8huJk - this is the best video # covariance = sum ((x -mean) * (y - mean)) /n -1 # correlation is dividing the covariance by the standard deviation of both variables - should # be range -1 (negative correlation) 0 (no correlation) and 1 positive correlation # a simpler equation uses dot product def de_mean(x): #work out deviation from mean
def ppf(self, q):
return np.percentiles(self.dataset, np.asarray(q)/100., axis=0)