EXOSIMS.Completeness package

Submodules

EXOSIMS.Completeness.BrownCompleteness module

class EXOSIMS.Completeness.BrownCompleteness.BrownCompleteness(Nplanets=100000000.0, **specs)[source]

Bases: Completeness

Completeness class template

This class contains all variables and methods necessary to perform Completeness Module calculations in exoplanet mission simulation.

Parameters:: specs – user specified values

Nplanets

Number of planets for initial completeness Monte Carlo simulation

Type:: integer

classpath

Path on disk to Brown Completeness

Type:: string

filename

Name of file where completeness interpolant is stored

Type:: string

updates

Completeness values of successive observations of each star in the target list (initialized in gen_update)

Type:: float nx5 ndarray

calc_fdmag(dMag, smin, smax)[source]

Calculates probability density of dMag by integrating over projected separation

Parameters:

dMag (float ndarray) – Planet delta magnitude(s)
smin (float ndarray) – Value of minimum projected separation (AU) from instrument
smax (float ndarray) – Value of maximum projected separation (AU) from instrument

Returns:

Value of probability density

Return type:

float

comp_calc(smin, smax, dMag)[source]

Calculates completeness for given minimum and maximum separations and dMag

Note: this method assumes scaling orbits when scaleOrbits == True has already occurred for smin, smax, dMag inputs

Parameters:

smin (float ndarray) – Minimum separation(s) in AU
smax (float ndarray) – Maximum separation(s) in AU
dMag (float ndarray) – Difference in brightness magnitude

Returns:

Completeness values

Return type:

float ndarray

comp_per_intTime(intTimes, TL, sInds, fZ, fEZ, WA, mode, C_b=None, C_sp=None, TK=None)[source]

Calculates completeness for integration time

Parameters:

intTimes (astropy Quantity array) – Integration times
TL (TargetList module) – TargetList class object
sInds (integer ndarray) – Integer indices of the stars of interest
fZ (astropy Quantity array) – Surface brightness of local zodiacal light in units of 1/arcsec2
fEZ (astropy Quantity array) – Surface brightness of exo-zodiacal light in units of 1/arcsec2
WA (astropy Quantity) – Working angle of the planet of interest in units of arcsec
mode (dict) – Selected observing mode
C_b (astropy Quantity array) – Background noise electron count rate in units of 1/s (optional)
C_sp (astropy Quantity array) – Residual speckle spatial structure (systematic error) in units of 1/s (optional)

Returns:

Completeness values

Return type:

flat ndarray

completeness_setup()[source]

Preform any preliminary calculations needed for this flavor of completeness

For BrownCompleteness this includes generating a 2D histogram of s vs. dMag for the planet population and creating interpolants over it.

completeness_update(TL, sInds, visits, dt)[source]

Updates completeness value for stars previously observed by selecting the appropriate value from the updates array

Parameters:

TL (TargetList module) – TargetList class object
sInds (integer array) – Indices of stars to update
visits (integer array) – Number of visits for each star
dt (astropy Quantity array) – Time since previous observation

Returns:

Completeness values for each star

Return type:

float ndarray

comps_input_reshape(intTimes, TL, sInds, fZ, fEZ, WA, mode, C_b=None, C_sp=None, TK=None)[source]

Reshapes inputs for comp_per_intTime and dcomp_dt as necessary

Parameters:

intTimes (astropy Quantity array) – Integration times
TL (TargetList module) – TargetList class object
sInds (integer ndarray) – Integer indices of the stars of interest
fZ (astropy Quantity array) – Surface bright ness of local zodiacal light in units of 1/arcsec2
fEZ (astropy Quantity array) – Surface brightness of exo-zodiacal light in units of 1/arcsec2
WA (astropy Quantity) – Working angle of the planet of interest in units of arcsec
mode (dict) – Selected observing mode
C_b (astropy Quantity array) – Background noise electron count rate in units of 1/s (optional)
C_sp (astropy Quantity array) – Residual speckle spatial structure (systematic error) in units of 1/s (optional)

Returns:

intTimes (astropy Quantity array):: Integration times
sInds (integer ndarray):: Integer indices of the stars of interest
fZ (astropy Quantity array):: Surface brightness of local zodiacal light in units of 1/arcsec2
fEZ (astropy Quantity array):: Surface brightness of exo-zodiacal light in units of 1/arcsec2
WA (astropy Quantity):: Working angle of the planet of interest in units of arcsec
smin (ndarray):: Minimum projected separations in AU
smax (ndarray):: Maximum projected separations in AU
dMag (ndarray):: Difference in brightness magnitude

Return type:

tuple

dcomp_dt(intTimes, TL, sInds, fZ, fEZ, WA, mode, C_b=None, C_sp=None, TK=None)[source]

Calculates derivative of completeness with respect to integration time

Parameters:

intTimes (astropy Quantity array) – Integration times
TL (TargetList module) – TargetList class object
sInds (integer ndarray) – Integer indices of the stars of interest
fZ (astropy Quantity array) – Surface brightness of local zodiacal light in units of 1/arcsec2
fEZ (astropy Quantity array) – Surface brightness of exo-zodiacal light in units of 1/arcsec2
WA (astropy Quantity) – Working angle of the planet of interest in units of arcsec
mode (dict) – Selected observing mode
C_b (astropy Quantity array) – Background noise electron count rate in units of 1/s (optional)
C_sp (astropy Quantity array) – Residual speckle spatial structure (systematic error) in units of 1/s (optional)

Returns:

Derivative of completeness with respect to integration time (units 1/time)

Return type:

astropy Quantity array

genC(Cpath, nplan, xedges, yedges, steps, remainder=0)[source]

Gets completeness interpolant for initial completeness

This function either loads a completeness .comp file based on specified Planet Population module or performs Monte Carlo simulations to get the 2D completeness values needed for interpolation.

Parameters:

Cpath (string) – path to 2D completeness value array
nplan (float) – number of planets used in each simulation
xedges (float ndarray) – x edge of 2d histogram (separation)
yedges (float ndarray) – y edge of 2d histogram (dMag)
steps (integer) – number of nplan simulations to perform
remainder (integer) – residual number of planets to simulate

Returns:

2D numpy ndarray containing completeness probability density values

Return type:

float ndarray

gen_update(TL)[source]

Generates dynamic completeness values for multiple visits of each star in the target list

Parameters:: TL (TargetList) – TargetList class object

generate_cache_names(**specs)[source]: Generate unique filenames for cached products

genplans(nplan)[source]

Generates planet data needed for Monte Carlo simulation

Parameters:

nplan (integer) – Number of planets

Returns:

s (astropy Quantity array):: Planet apparent separations in units of AU
dMag (ndarray):: Difference in brightness

Return type:

tuple

hist(nplan, xedges, yedges)[source]

Returns completeness histogram for Monte Carlo simulation

This function uses the inherited Planet Population module.

Parameters:

nplan (float) – number of planets used
xedges (float ndarray) – x edge of 2d histogram (separation)
yedges (float ndarray) – y edge of 2d histogram (dMag)

Returns:

2D numpy ndarray containing completeness frequencies

Return type:

float ndarray

target_completeness(TL)[source]

Generates completeness values for target stars using average case values

This method is called from TargetList __init__ method.

Parameters:: TL (TargetList module) – TargetList class object
Returns:: Completeness values for each target star
Return type:: float ndarray

EXOSIMS.Completeness.GarrettCompleteness module

class EXOSIMS.Completeness.GarrettCompleteness.GarrettCompleteness(order_of_quadrature=15, **specs)[source]

Bases: BrownCompleteness

Analytical Completeness class

This class contains all variables and methods necessary to perform Completeness Module calculations based on Garrett and Savransky 2016 in exoplanet mission simulation.

The completeness calculations performed by this method assume that all planetary parameters are independently distributed. The probability density functions used here are either independent or marginalized from a joint probability density function.

Parameters:

order_of_quadrature (int) – The order of quadrature used in the comp_dmag function’s fixed quad integration. Higher values will give marginal improvements in the comp_calc completeness values, but are slower.
**specs – Input Specification

updates

Completeness values of successive observations of each star in the target list (initialized in gen_update)

Type:: nx5 ndarray

Jac(b)[source]

Calculates determinant of the Jacobian transformation matrix to get the joint probability density of dMag and s

Parameters:: b (ndarray) – Phase angles
Returns:: Determinant of Jacobian transformation matrix
Return type:: f (ndarray)

Rgrand(R, z)[source]

Calculates integrand for determining probability density of albedo times planetary radius squared

Parameters:

R (ndarray) – Values of planetary radius
z (float) – Value of albedo times planetary radius squared

Returns:

Values of integrand

Return type:

f (ndarray)

calc_fdmag(dMag, smin, smax)[source]

Calculates probability density of dMag by integrating over projected separation

Parameters:

dMag (float ndarray) – Planet delta magnitude(s)
smin (float ndarray) – Value of minimum projected separation (AU) from instrument
smax (float ndarray) – Value of maximum projected separation (AU) from instrument

Returns:

Value of probability density

Return type:

f (float)

comp_calc(smin, smax, dMag)[source]

Calculates completeness for given minimum and maximum separations and dMag

Note: this method assumes scaling orbits when scaleOrbits == True has already occurred for smin, smax, dMag inputs

Parameters:

smin (float ndarray) – Minimum separation(s) in AU
smax (float ndarray) – Maximum separation(s) in AU
dMag (float ndarray) – Difference in brightness magnitude

Returns:

Completeness value(s)

Return type:

comp (float ndarray)

comp_dmag(smin, smax, max_dMag)[source]

Calculates completeness by first integrating over projected separation and then dMag.

Parameters:

smin (ndarray) – Values of minimum projected separation (AU) from instrument
smax (ndarray) – Value of maximum projected separation (AU) from instrument
max_dMag (float ndarray) – Maximum planet delta magnitude

Returns:

Completeness values

Return type:

comp (ndarray)

comp_s(smin, smax, dMag)[source]

Calculates completeness by first integrating over dMag and then projected separation.

Parameters:

smin (ndarray) – Values of minimum projected separation (AU) from instrument
smax (ndarray) – Value of maximum projected separation (AU) from instrument
dMag (ndarray) – Planet delta magnitude

Returns:

Completeness values

Return type:

comp (ndarray)

completeness_setup()[source]

Preform any preliminary calculations needed for this flavor of completeness

For GarrettCompleteness this involves setting up various interpolants. See [Garrett2016] for details.

f_dmag()

f_dmags()

f_dmagsRp(Rp, dmag, s)[source]

Calculates the joint probability density of planetary radius, dMag, and projected separation

Parameters:

Rp (ndarray) – Values of planetary radius
dmag (float) – Planet delta magnitude
s (float) – Value of projected separation

Returns:

Values of joint probability density

Return type:

f (ndarray)

f_dmagsz(z, dmag, s)[source]

Calculates the joint probability density of albedo times planetary radius squared, dMag, and projected separation

Parameters:

z (ndarray) – Values of albedo times planetary radius squared
dmag (float) – Planet delta magnitude
s (float) – Value of projected separation

Returns:

Values of joint probability density

Return type:

f (ndarray)

f_r(r)[source]

Calculates the probability density of orbital radius

Parameters:: r (float) – Value of semi-major axis in AU
Returns:: Value of probability density
Return type:: f (float)

f_s()

f_sdmag(s, dmag)[source]

Calculates the joint probability density of projected separation and dMag by flipping the order of f_dmags

Parameters:

s (float) – Value of projected separation (AU)
dmag (float) – Planet delta magnitude

Returns:

Value of joint probability density

Return type:

f (float)

f_z(z)[source]

Calculates probability density of albedo times planetary radius squared

Parameters:: z (float) – Value of albedo times planetary radius squared
Returns:: Probability density
Return type:: f (float)

genComp(Cpath, TL)[source]

Generates function to get completeness values

Parameters:

Cpath (str) – Path to pickled dictionary containing interpolant function
TL (TargetList module) – TargetList class object

Returns:

Marginalized to self.mode_dMag probability density function for projected separation

Return type:

dist_s (callable(s))

maxdmag(s)[source]

Calculates the maximum value of dMag for projected separation

Parameters:: s (float) – Projected separation (AU)
Returns:: Maximum planet delta magnitude
Return type:: maxdmag (float)

mindmag(s)[source]

Calculates the minimum value of dMag for projected separation

Parameters:: s (float) – Projected separations (AU)
Returns:: Minimum planet delta magnitude
Return type:: mindmag (float)

rgrand1(e, a, r)[source]

Calculates first integrand for determinining probability density of orbital radius

Parameters:

e (ndarray) – Values of eccentricity
a (float) – Values of semi-major axis in AU
r (float) – Values of orbital radius in AU

Returns:

Values of first integrand

Return type:

f (ndarray)

rgrand2(a, r)[source]

Calculates second integrand for determining probability density of orbital radius

Parameters:

a (float) – Value of semi-major axis in AU
r (float) – Value of orbital radius in AU

Returns:

Value of second integrand

Return type:

f (float)

rgrandac(e, a, r)[source]

Calculates integrand for determining probability density of orbital radius when semi-major axis is constant

Parameters:

e (ndarray) – Values of eccentricity
a (float) – Value of semi-major axis in AU
r (float) – Value of orbital radius in AU

Returns:

Value of integrand

Return type:

f (ndarray)

rgrandec(a, e, r)[source]

Calculates integrand for determining probability density of orbital radius when eccentricity is constant

Parameters:

a (ndarray) – Values of semi-major axis in AU
e (float) – Value of eccentricity
r (float) – Value of orbital radius in AU

Returns:

Value of integrand

Return type:

f (float)

s_bound(dmag, smax)[source]

Calculates the bounding value of projected separation for dMag

Parameters:

dmag (float) – Planet delta magnitude
smax (float) – maximum projected separation (AU)

Returns:

boundary value of projected separation (AU)

Return type:

sb (float)

target_completeness(TL)[source]

Generates completeness values for target stars

This method is called from TargetList __init__ method.

Parameters:: TL (TargetList module) – TargetList class object
Returns:: int_comp: 1D numpy array of completeness values for each target star
Return type:: ndarray(float))

EXOSIMS.Completeness.IntegrationTimeAdjustedCompleteness module

class EXOSIMS.Completeness.IntegrationTimeAdjustedCompleteness.IntegrationTimeAdjustedCompleteness(Nplanets=100000.0, **specs)[source]

Bases: SubtypeCompleteness

Integration time-adjusted Completeness. See [Keithly2021b]

Parameters:

Nplanets (int) – number of planets to simulate in IAC
specs – user specified values

Nplanets

Number of planets for initial completeness Monte Carlo simulation

Type:: int

classpath

Path on disk to Brown Completeness

Type:: str

filename

Name of file where completeness interpolant is stored

Type:: str

updates

Completeness values of successive observations of each star in the target list (initialized in gen_update)

Type:: float nx5 numpy.ndarray

comp_calc(smin, smax, dMag, subpop=-2, tmax=0.0, starMass=<<class 'astropy.constants.iau2015.IAU2015'> name='Solar mass' value=1.988409870698051e+30 uncertainty=4.468805426856864e+25 unit='kg' reference='IAU 2015 Resolution B 3 + CODATA 2018'>, IACbool=False)[source]

Calculates completeness for given minimum and maximum separations and dMag

Parameters:

smin (float numpy.ndarray) – Minimum separation(s) in AU
smax (float numpy.ndarray) – Maximum separation(s) in AU
dMag (float numpy.ndarray) – Difference in brightness magnitude
subpop (int) – planet subtype to use for calculation of int_comp -2 - planet population -1 - earthLike population (i,j) - kopparapu planet subtypes
tmax (float) – the integration time of the observation in days
starMass (float) – star mass in units of M_sun
IACbool (bool) – Use integration time-adjusted completeness or normal Brown completeness If False, tmax does nothing. Defaults False.

Returns:

comp, SubtypeCompleteness Completeness values (Brown’s method mixed with classification) or integration time adjusted completeness totalCompleteness_maxIntTimeCorrected

Return type:

numpy.ndarray

..note:

This method assumes scaling orbits when scaleOrbits == True has already
occurred for smin, smax, dMag inputs

EXOSIMS.Completeness.SubtypeCompleteness module

class EXOSIMS.Completeness.SubtypeCompleteness.SubtypeCompleteness(binTypes='kopparapuBins_extended', **specs)[source]

Bases: BrownCompleteness

Completeness by planet subtype

Parameters:

binTypes (str) – string specifying the kopparapuBin Types to use
**specs – Input Specification

Nplanets

Number of planets for initial completeness Monte Carlo simulation

Type:: int

classpath

Path on disk to Brown Completeness

Type:: string

filename

Name of file where completeness interpolant is stored

Type:: str

updates

Completeness values of successive observations of each star in the target list (initialized in gen_update)

Type:: float nx5 numpy.ndarray

binTypes

string specifying the kopparapuBin Types to use

Type:: str

SubtypeHist(nplan, xedges, yedges, TL)[source]

Returns completeness histogram for Monte Carlo simulation

This function uses the inherited Planet Population module.

Parameters:

nplan (float) – number of planets used
xedges (float ndarray) – x edge of 2d histogram (separation)
yedges (float ndarray) – y edge of 2d histogram (dMag)
TL (target list object) –

Returns:

float (numpy.ndarray):: 2D numpy ndarray containing completeness frequencies
hs (dict):: dict with index [bini,binj] containing arrays of counts per Array bin
bini (float):: planet size type index
binj (float):: planet incident stellar flux index
h_earthLike (float):: number of earth like exoplanets
h (numpy.ndarray):: 2D numpy array of bin counts over all dmag vs s
xedges (numpy.ndarray):: array of bin edges originally input and used in histograms
yedges (numpy.ndarray):: array of bin edges originally input and used in histograms
counts (dict):: dict with index [bini,binj] containing total number of planets in bini,binj
count (float):: total number of planets in the whole populatiom
count_earthLike (float):: total number of earth-like planets in the whole population

Return type:

tuple

calc_fdmag(dMag, smin, smax, subpop=-2)[source]

Calculates probability density of dMag by integrating over projected separation

Parameters:

dMag (float ndarray) – Planet delta magnitude(s)
smin (float ndarray) – Value of minimum projected separation (AU) from instrument
smax (float ndarray) – Value of maximum projected separation (AU) from instrument
subpop (int) – planet subtype to use for calculation of int_comp -2 - planet population -1 - earthLike population (i,j) - kopparapu planet subtypes

Returns:

Value of probability density

Return type:

float

classifyEarthlikePlanets(Rp, TL, starind, sma, ej)[source]

Determine Kopparapu bin of an individual planet.

Verified with Kopparapu Extended

Parameters:

Rp (float) – planet radius in Earth Radii
TL (object) – EXOSIMS target list object
sma (float) – planet semi-major axis in AU
ej (float) – planet eccentricity

Returns:

bini (int):: planet size-type: 0-Smaller than Earthlike, 1- Earthlike, 2- Larger than Earth-like
binj (int):: planet incident stellar-flux: 0- lower than Earthlike, 1- flux of Earthlike, 2- higher flux than Earth-like

Return type:

tuple

classifyPlanet(Rp, TL, starind, sma, ej)[source]

Determine Kopparapu bin of an individual planet

Parameters:

Rp (float) – planet radius in Earth Radii
TL (object) – EXOSIMS target list object
sma (float) – planet semi-major axis in AU
ej (float) – planet eccentricity

Returns:

bini (int):: planet size-type: 0-rocky, 1- Super-Earths, 2- sub-Neptunes, 3- sub-Jovians, 4- Jovians
binj (int):: planet incident stellar-flux: 0- hot, 1- warm, 2- cold
earthLike (bool):: boolean indicating whether the planet is earthLike or not earthLike

Return type:

tuple

classifyPlanets(Rp, TL, starind, sma, ej)[source]

Determine Kopparapu bin of an individual planet.

Verified with Kopparapu Extended

Parameters:

Rp (float) – planet radius in Earth Radii
TL (object) – EXOSIMS target list object
sma (float) – planet semi-major axis in AU
ej (float) – planet eccentricity

Returns:

bini (int):: planet size-type: 0-rocky, 1- Super-Earths, 2- sub-Neptunes, 3- sub-Jovians, 4- Jovians
binj (int):: planet incident stellar-flux: 0- hot, 1- warm, 2- cold
earthLike (bool):: boolean indicating whether the planet is earthLike or not earthLike

Return type:

tuple

comp_calc(smin, smax, dMag, subpop=-2)[source]

Calculates completeness for given minimum and maximum separations and dMag

Note: this method assumes scaling orbits when scaleOrbits == True has already occurred for smin, smax, dMag inputs

Parameters:

smin (float ndarray) – Minimum separation(s) in AU
smax (float ndarray) – Maximum separation(s) in AU
dMag (float ndarray) – Difference in brightness magnitude
subpop (int) – planet subtype to use for calculation of int_comp -2 - planet population -1 - earthLike population (i,j) - kopparapu planet subtypes

Returns:

Completeness values

Return type:

float ndarray

comp_calc2(smin, smax, dMag_min, dMag_max, subpop=-2)[source]

Calculates completeness for given minimum and maximum separations and dMag

Note: this method assumes scaling orbits when scaleOrbits == True has already occurred for smin, smax, dMag inputs

Parameters:

smin (float ndarray) – Minimum separation(s) in AU
smax (float ndarray) – Maximum separation(s) in AU
dMag_min (float ndarray) – Minimum difference in brightness magnitude
dMag_max (float ndarray) – Maximum difference in brightness magnitude
subpop (int) – planet subtype to use for calculation of int_comp -2 - planet population -1 - earthLike population (i,j) - kopparapu planet subtypes

Returns:

Completeness values

Return type:

float ndarray

comp_per_intTime(intTimes, TL, sInds, fZ, fEZ, WA, mode, C_b=None, C_sp=None, TK=None)[source]

Calculates completeness for integration time

Parameters:

intTimes (astropy Quantity array) – Integration times
TL (TargetList module) – TargetList class object
sInds (integer ndarray) – Integer indices of the stars of interest
fZ (astropy Quantity array) – Surface brightness of local zodiacal light in units of 1/arcsec2
fEZ (astropy Quantity array) – Surface brightness of exo-zodiacal light in units of 1/arcsec2
WA (astropy Quantity) – Working angle of the planet of interest in units of arcsec
mode (dict) – Selected observing mode
C_b (astropy Quantity array) – Background noise electron count rate in units of 1/s (optional)
C_sp (astropy Quantity array) – Residual speckle spatial structure (systematic error) in units of 1/s (optional)
TK (Timekeeping object) – timekeeping object for compatability with SLSQPScheduler

Returns:

Completeness values

Return type:

flat ndarray

completeness_setup()[source]

Preform any preliminary calculations needed for this flavor of completeness

For SubtypeCompleteness this generates comleteness by planet bin

comps_input_reshape(intTimes, TL, sInds, fZ, fEZ, WA, mode, C_b=None, C_sp=None, TK=None)[source]

Reshapes inputs for comp_per_intTime and dcomp_dt as necessary

Parameters:

intTimes (astropy Quantity array) – Integration times
TL (TargetList module) – TargetList class object
sInds (integer ndarray) – Integer indices of the stars of interest
fZ (astropy Quantity array) – Surface bright ness of local zodiacal light in units of 1/arcsec2
fEZ (astropy Quantity array) – Surface brightness of exo-zodiacal light in units of 1/arcsec2
WA (astropy Quantity) – Working angle of the planet of interest in units of arcsec
mode (dict) – Selected observing mode
C_b (astropy Quantity array) – Background noise electron count rate in units of 1/s (optional)
C_sp (astropy Quantity array) – Residual speckle spatial structure (systematic error) in units of 1/s (optional)

Returns:

intTimes (astropy Quantity array):: Integration times
sInds (integer ndarray):: Integer indices of the stars of interest
fZ (astropy Quantity array):: Surface brightness of local zodiacal light in units of 1/arcsec2
fEZ (astropy Quantity array):: Surface brightness of exo-zodiacal light in units of 1/arcsec2
WA (astropy Quantity):: Working angle of the planet of interest in units of arcsec
smin (ndarray):: Minimum projected separations in AU
smax (ndarray):: Maximum projected separations in AU
dMag (ndarray):: Difference in brightness magnitude

Return type:

tuple

dcomp_dt(intTimes, TL, sInds, fZ, fEZ, WA, mode, C_b=None, C_sp=None, TK=None)[source]

Calculates derivative of completeness with respect to integration time

Parameters:

intTimes (astropy Quantity array) – Integration times
TL (TargetList module) – TargetList class object
sInds (integer ndarray) – Integer indices of the stars of interest
fZ (astropy Quantity array) – Surface brightness of local zodiacal light in units of 1/arcsec2
fEZ (astropy Quantity array) – Surface brightness of exo-zodiacal light in units of 1/arcsec2
WA (astropy Quantity) – Working angle of the planet of interest in units of arcsec
mode (dict) – Selected observing mode
C_b (astropy Quantity array) – Background noise electron count rate in units of 1/s (optional)
C_sp (astropy Quantity array) – Residual speckle spatial structure (systematic error) in units of 1/s (optional)
TK (Timekeeping object) – timekeeping object for compatability with SLSQPScheduler

Returns:

Derivative of completeness with respect to integration time (units 1/time)

Return type:

astropy Quantity array

dmag_limits(rmin, rmax, pmax, pmin, Rmax, Rmin, phaseFunc)[source]

Limits of delta magnitude as a function of separation

Limits on dmag vs s JPDF from [Garrett2016] See https://github.com/dgarrett622/FuncComp/blob/master/FuncComp/util.py

Parameters:

rmin (float) – minimum planet-star distance possible in AU
rmax (float) – maximum planet-star distance possible in AU
pmax (float) – maximum planet albedo
Rmax (float) – maximum planet radius in earthRad
phaseFunc (callable) – with input in units of rad

Returns:

dmag_limit_functions (list):: list of lambda functions taking in ‘s’ with units of AU
lower_limits (list):: list of floats representing lower bounds on ‘s’
upper_limits (list):: list of floats representing upper bounds on ‘s’

Return type:

tuple

genSubtypeC(Cpath, nplan, xedges, yedges, steps, TL)[source]

Gets completeness interpolant for initial completeness

This function either loads a completeness .comp file based on specified Planet Population module or performs Monte Carlo simulations to get the 2D completeness values needed for interpolation.

Parameters:

Cpath (string) – path to 2D completeness value array
nplan (float) – number of planets used in each simulation
xedges (float ndarray) – x edge of 2d histogram (separation)
yedges (float ndarray) – y edge of 2d histogram (dMag)
steps (integer) – number of simulations to perform TL (target list object):

Returns:

2D numpy ndarray containing completeness probability density values

Return type:

float ndarray

gen_update(TL)[source]

Generates dynamic completeness values for multiple visits of each star in the target list

Parameters:: TL (TargetList) – TargetList class object

genplans(nplan, TL)[source]

Generates planet data needed for Monte Carlo simulation

Parameters:

nplan (integer) –
TL (target list object) –

Returns:

s (astropy Quantity array):: Planet apparent separations in units of AU
dMag (ndarray):: Difference in brightness
bini (int):: planet size-type: 0-rocky, 1- Super-Earths, 2- sub-Neptunes, 3- sub-Jovians, 4- Jovians
binj (int):: planet incident stellar-flux: 0- hot, 1- warm, 2- cold
earthLike (bool):: boolean indicating whether the planet is earthLike or not earthLike

Return type:

tuple

kopparapuBins()[source]: A function containing the Center 15 Kopparapu bins Updates the Rp_bins, Rp_lo, Rp_hi, L_bins, L_lo, and L_hi attributes

kopparapuBins_extended()[source]: A function containing the Full 35 Kopparapu bins Updates the Rp_bins, Rp_lo, Rp_hi, L_bins, L_lo, L_hi, and type_names attribute

kopparapuBins_old()[source]: A function containing the Inner 12 Kopparapu bins Updates the Rp_bins, Rp_lo, Rp_hi, L_bins, L_lo, and L_hi attributes

probDetectionIsOfType(dmag, uncertainty_dmag, separation, uncertainty_s, sub=-2)[source]

Calculates the probability a planet is of the given type

Parameters:

comp (completeness object) – a completeness object with the EVPOC_hs, count_hs, count_pop, EVPOCpdf_pop attributes (generated by the subtype completeness module)
dmag (float) – the mean dmag to evaluate at
() (uncertainty_s) – the uncertainty in dmag to evaluate over
() – the mean separation to evaluate at
() – the uncertainty in separation to evaluate over
subpop (int) – planet subtype to use for calculation of int_comp -2 - planet population -1 - earthLike population [i,j] - kopparapu planet subtypes

Returns:

prob (float):: a float indicating the probability a planet is both from the given sub-population and the instrument probability density function.
normProbProp (float):: Probability normalized by the population density joint probability density function

Return type:

tuple

putPlanetsInBoxes(out, TL)[source]

Classifies planets in a gen_summary out file by their hot/warm/cold and rocky/superearth/subneptune/subjovian/jovian bins

Parameters:

out (dict) – a gen_summary output dict
TL (TargetList object) – a target list object

Returns:

aggbins (list):: dims [# simulations, 5x3 numpy array]
earthLikeBins (list):: dims [# simulations]

Return type:

tuple

target_completeness(TL, calc_char_int_comp=False, subpop=-2)[source]

Generates completeness values for target stars

This method is called from TargetList __init__ method.

Parameters:

TL (TargetList module) – TargetList class object
calc_char_int_comp (boolean) –
subpop (int) – planet subtype to use for calculation of int_comp -2 - planet population -1 - earthLike population 0-N - kopparapu planet subtypes

Returns:

Completeness values for each target star

Return type:

float ndarray