+# Copyright (C) 2017 Christopher M. Biwer
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 3 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+# Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+"""
+This modules provides classes and functions for transforming parameters.
+"""
+
+import os
+import logging
+import numpy
+
+from pycbc import conversions
+from pycbc import coordinates
+from pycbc import cosmology
+from pycbc.io import record
+from pycbc.waveform import parameters
+from pycbc.boundaries import Bounds
+from pycbc import VARARGS_DELIM
+from pycbc.pnutils import jframe_to_l0frame
+
+logger = logging.getLogger('pycbc.transforms')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#
+# =============================================================================
+#
+# Forward Transforms
+#
+# =============================================================================
+#
+
+
+
+
[docs]
+
class MchirpQToMass1Mass2(BaseTransform):
+
"""Converts chirp mass and mass ratio to component masses."""
+
+
name = "mchirp_q_to_mass1_mass2"
+
+
def __init__(
+
self, mass1_param=None, mass2_param=None, mchirp_param=None, q_param=None
+
):
+
if mass1_param is None:
+
mass1_param = parameters.mass1
+
if mass2_param is None:
+
mass2_param = parameters.mass2
+
if mchirp_param is None:
+
mchirp_param = parameters.mchirp
+
if q_param is None:
+
q_param = parameters.q
+
self.mass1_param = mass1_param
+
self.mass2_param = mass2_param
+
self.mchirp_param = mchirp_param
+
self.q_param = q_param
+
self._inputs = [self.mchirp_param, self.q_param]
+
self._outputs = [self.mass1_param, self.mass2_param]
+
super(MchirpQToMass1Mass2, self).__init__()
+
+
+
+
+
+
+
+
+
[docs]
+
def jacobian(self, maps):
+
"""Returns the Jacobian for transforming mchirp and q to mass1 and
+
mass2.
+
"""
+
mchirp = maps[self.mchirp_param]
+
q = maps[self.q_param]
+
return mchirp * ((1.0 + q) / q ** 3.0) ** (2.0 / 5)
+
+
+
+
[docs]
+
def inverse_jacobian(self, maps):
+
"""Returns the Jacobian for transforming mass1 and mass2 to
+
mchirp and q.
+
"""
+
m1 = maps[self.mass1_param]
+
m2 = maps[self.mass2_param]
+
return conversions.mchirp_from_mass1_mass2(m1, m2) / m2 ** 2.0
+
+
[docs]
+
class MchirpEtaToMass1Mass2(BaseTransform):
+
"""Converts chirp mass and symmetric mass ratio to component masses."""
+
+
name = "mchirp_eta_to_mass1_mass2"
+
_inputs = [parameters.mchirp, parameters.eta]
+
_outputs = [parameters.mass1, parameters.mass2]
+
+
+
+
+
+
+
+
+
[docs]
+
def jacobian(self, maps):
+
"""Returns the Jacobian for transforming mchirp and eta to mass1 and
+
mass2.
+
"""
+
mchirp = maps[parameters.mchirp]
+
eta = maps[parameters.eta]
+
m1 = conversions.mass1_from_mchirp_eta(mchirp, eta)
+
m2 = conversions.mass2_from_mchirp_eta(mchirp, eta)
+
return mchirp * (m1 - m2) / (m1 + m2) ** 3
+
+
+
+
[docs]
+
def inverse_jacobian(self, maps):
+
"""Returns the Jacobian for transforming mass1 and mass2 to
+
mchirp and eta.
+
"""
+
m1 = maps[parameters.mass1]
+
m2 = maps[parameters.mass2]
+
mchirp = conversions.mchirp_from_mass1_mass2(m1, m2)
+
eta = conversions.eta_from_mass1_mass2(m1, m2)
+
return -1.0 * mchirp / eta ** (6.0 / 5)
+
+
[docs]
+
class ChirpDistanceToDistance(BaseTransform):
+
"""Converts chirp distance to luminosity distance, given the chirp mass."""
+
+
name = "chirp_distance_to_distance"
+
_inputs = [parameters.chirp_distance, parameters.mchirp]
+
_outputs = [parameters.distance]
+
+
def __init__(self, ref_mass=1.4):
+
self.inputs = set(self._inputs)
+
self.outputs = set(self._outputs)
+
self.ref_mass = ref_mass
+
+
+
+
+
+
+
+
+
[docs]
+
def jacobian(self, maps):
+
"""Returns the Jacobian for transforming chirp distance to
+
luminosity distance, given the chirp mass.
+
"""
+
ref_mass = 1.4
+
mchirp = maps["mchirp"]
+
return (2.0 ** (-1.0 / 5) * self.ref_mass / mchirp) ** (-5.0 / 6)
+
+
+
+
[docs]
+
def inverse_jacobian(self, maps):
+
"""Returns the Jacobian for transforming luminosity distance to
+
chirp distance, given the chirp mass.
+
"""
+
ref_mass = 1.4
+
mchirp = maps["mchirp"]
+
return (2.0 ** (-1.0 / 5) * self.ref_mass / mchirp) ** (5.0 / 6)
+
+
[docs]
+
class AlignTotalSpin(BaseTransform):
+
"""Converts angles from total angular momentum J frame to orbital angular
+
momentum L (waveform) frame"""
+
+
name = "align_total_spin"
+
_inputs = [parameters.thetajn, parameters.spin1x, parameters.spin1y,
+
parameters.spin1z, parameters.spin2x, parameters.spin2y,
+
parameters.spin2z, parameters.mass1, parameters.mass2,
+
parameters.f_ref, "phi_ref"]
+
_outputs = [parameters.inclination, parameters.spin1x, parameters.spin1y,
+
parameters.spin1z, parameters.spin2x, parameters.spin2y,
+
parameters.spin2z]
+
+
def __init__(self):
+
self.inputs = set(self._inputs)
+
self.outputs = set(self._outputs)
+
super(AlignTotalSpin, self).__init__()
+
+
+
+
[docs]
+
class SphericalToCartesian(BaseTransform):
+
"""Converts spherical coordinates to cartesian.
+
+
Parameters
+
----------
+
x : str
+
The name of the x parameter.
+
y : str
+
The name of the y parameter.
+
z : str
+
The name of the z parameter.
+
radial : str
+
The name of the radial parameter.
+
azimuthal : str
+
The name of the azimuthal angle parameter.
+
polar : str
+
The name of the polar angle parameter.
+
"""
+
+
name = "spherical_to_cartesian"
+
+
def __init__(self, x, y, z, radial, azimuthal, polar):
+
self.x = x
+
self.y = y
+
self.z = z
+
self.radial = radial
+
self.polar = polar
+
self.azimuthal = azimuthal
+
self._inputs = [self.radial, self.azimuthal, self.polar]
+
self._outputs = [self.x, self.y, self.z]
+
super(SphericalToCartesian, self).__init__()
+
+
+
+
+
+
+
[docs]
+
class SphericalSpin1ToCartesianSpin1(SphericalToCartesian):
+
"""Converts spherical spin parameters (radial and two angles) to
+
catesian spin parameters. This class only transforms spins for the first
+
component mass.
+
+
**Deprecation Warning:** This will be removed in a future update. Use
+
:py:class:`SphericalToCartesian` with spin-parameter names passed in
+
instead.
+
"""
+
+
name = "spherical_spin_1_to_cartesian_spin_1"
+
+
def __init__(self):
+
logger.warning(
+
"Deprecation warning: the %s transform will be "
+
"removed in a future update. Please use %s instead, "
+
"passing spin1x, spin1y, spin1z, spin1_a, "
+
"spin1_azimuthal, spin1_polar as arguments.",
+
self.name, SphericalToCartesian.name
+
)
+
super(SphericalSpin1ToCartesianSpin1, self).__init__(
+
"spin1x", "spin1y", "spin1z", "spin1_a",
+
"spin1_azimuthal", "spin1_polar"
+
)
+
[docs]
+
class SphericalSpin2ToCartesianSpin2(SphericalToCartesian):
+
"""Converts spherical spin parameters (radial and two angles) to
+
catesian spin parameters. This class only transforms spins for the first
+
component mass.
+
+
**Deprecation Warning:** This will be removed in a future update. Use
+
:py:class:`SphericalToCartesian` with spin-parameter names passed in
+
instead.
+
"""
+
+
name = "spherical_spin_2_to_cartesian_spin_2"
+
+
def __init__(self):
+
logger.warning(
+
"Deprecation warning: the %s transform will be "
+
"removed in a future update. Please use %s instead, "
+
"passing spin2x, spin2y, spin2z, spin2_a, "
+
"spin2_azimuthal, spin2_polar as arguments.",
+
self.name, SphericalToCartesian.name
+
)
+
super(SphericalSpin2ToCartesianSpin2, self).__init__(
+
"spin2x", "spin2y", "spin2z",
+
"spin2_a", "spin2_azimuthal", "spin2_polar"
+
)
+
[docs]
+
class DistanceToRedshift(BaseTransform):
+
"""Converts distance to redshift."""
+
+
name = "distance_to_redshift"
+
inverse = None
+
_inputs = [parameters.distance]
+
_outputs = [parameters.redshift]
+
+
+
+
[docs]
+
class AlignedMassSpinToCartesianSpin(BaseTransform):
+
"""Converts mass-weighted spins to cartesian z-axis spins."""
+
+
name = "aligned_mass_spin_to_cartesian_spin"
+
_inputs = [parameters.mass1, parameters.mass2, parameters.chi_eff, "chi_a"]
+
_outputs = [
+
parameters.mass1,
+
parameters.mass2,
+
parameters.spin1z,
+
parameters.spin2z,
+
]
+
+
+
+
+
+
+
[docs]
+
class PrecessionMassSpinToCartesianSpin(BaseTransform):
+
"""Converts mass-weighted spins to cartesian x-y plane spins."""
+
+
name = "precession_mass_spin_to_cartesian_spin"
+
_inputs = [parameters.mass1, parameters.mass2,
+
"xi1", "xi2", "phi_a", "phi_s"]
+
_outputs = [
+
parameters.mass1,
+
parameters.mass2,
+
parameters.spin1x,
+
parameters.spin1y,
+
parameters.spin2x,
+
parameters.spin2y,
+
]
+
+
+
+
+
+
+
[docs]
+
class CartesianSpinToChiP(BaseTransform):
+
"""Converts cartesian spins to `chi_p`."""
+
+
name = "cartesian_spin_to_chi_p"
+
_inputs = [
+
parameters.mass1,
+
parameters.mass2,
+
parameters.spin1x,
+
parameters.spin1y,
+
parameters.spin2x,
+
parameters.spin2y,
+
]
+
_outputs = ["chi_p"]
+
+
+
+
[docs]
+
class LambdaFromTOVFile(BaseTransform):
+
"""Transforms mass values corresponding to Lambda values for a given EOS
+
interpolating from the mass-Lambda data for that EOS read in from an
+
external ASCII file.
+
+
The interpolation of the mass-Lambda data is a one-dimensional piecewise
+
linear interpolation. If the ``redshift_mass`` keyword argument is ``True``
+
(the default), the mass values to be transformed are assumed to be detector
+
frame masses. In that case, a distance should be provided along with the
+
mass for transformation to the source frame mass before the Lambda values
+
are extracted from the interpolation. If the transform is read in from a
+
config file, an example code block would be:
+
+
.. code-block:: ini
+
+
[{section}-lambda1]
+
name = lambda_from_tov_file
+
mass_param = mass1
+
lambda_param = lambda1
+
distance = 40
+
mass_lambda_file = {filepath}
+
+
If this transform is used in a parameter estimation analysis where
+
distance is a variable parameter, the distance to be used will vary
+
with each draw. In that case, the example code block will be:
+
+
.. code-block:: ini
+
+
[{section}-lambda1]
+
name = lambda_from_tov_file
+
mass_param = mass1
+
lambda_param = lambda1
+
mass_lambda_file = filepath
+
+
If your prior is in terms of the source-frame masses (``srcmass``), then
+
you can shut off the redshifting by adding ``do-not-redshift-mass`` to the
+
config file. In this case you do not need to worry about a distance.
+
Example:
+
+
.. code-block:: ini
+
+
[{section}-lambda1]
+
name = lambda_from_tov_file
+
mass_param = srcmass1
+
lambda_param = lambda1
+
mass_lambda_file = filepath
+
do-not-redshift-mass =
+
+
Parameters
+
----------
+
mass_param : str
+
The name of the mass parameter to transform.
+
lambda_param : str
+
The name of the tidal deformability parameter that mass_param is to
+
be converted to interpolating from the data in the mass-Lambda file.
+
mass_lambda_file : str
+
Path of the mass-Lambda data file. The first column in the data file
+
should contain mass values, and the second column Lambda values.
+
distance : float, optional
+
The distance (in Mpc) of the source. Used to redshift the mass. Needed
+
if ``redshift_mass`` is True and no distance parameter exists If
+
None, then a distance must be provided to the transform.
+
redshift_mass : bool, optional
+
Redshift the mass parameters when computing the lambdas. Default is
+
False.
+
file_columns : list of str, optional
+
The names and order of columns in the ``mass_lambda_file``. Must
+
contain at least 'mass' and 'lambda'. If not provided, will assume the
+
order is ('mass', 'lambda').
+
"""
+
+
name = "lambda_from_tov_file"
+
+
def __init__(
+
self,
+
mass_param,
+
lambda_param,
+
mass_lambda_file,
+
distance=None,
+
redshift_mass=True,
+
file_columns=None,
+
):
+
self._mass_lambda_file = mass_lambda_file
+
self._mass_param = mass_param
+
self._lambda_param = lambda_param
+
self.redshift_mass = redshift_mass
+
self._distance = distance
+
self._inputs = [mass_param, "distance"]
+
self._outputs = [lambda_param]
+
if file_columns is None:
+
file_columns = ["mass", "lambda"]
+
dtype = [(fname, float) for fname in file_columns]
+
data = numpy.loadtxt(self._mass_lambda_file, dtype=dtype)
+
self._data = data
+
super(LambdaFromTOVFile, self).__init__()
+
+
@property
+
def mass_param(self):
+
"""Returns the input mass parameter."""
+
return self._mass_param
+
+
@property
+
def lambda_param(self):
+
"""Returns the output lambda parameter."""
+
return self._lambda_param
+
+
@property
+
def data(self):
+
return self._data
+
+
@property
+
def mass_data(self):
+
"""Returns the mass data read from the mass-Lambda data file for
+
an EOS.
+
"""
+
return self._data["mass"]
+
+
@property
+
def lambda_data(self):
+
"""Returns the Lambda data read from the mass-Lambda data file for
+
an EOS.
+
"""
+
return self._data["lambda"]
+
+
@property
+
def distance(self):
+
"""Returns the fixed distance to transform mass samples from detector
+
to source frame if one is specified.
+
"""
+
return self._distance
+
+
+
[docs]
+
@staticmethod
+
def lambda_from_tov_data(m_src, mass_data, lambda_data):
+
"""Returns Lambda corresponding to a given mass interpolating from the
+
TOV data.
+
+
Parameters
+
----------
+
m : float
+
Value of the mass.
+
mass_data : array
+
Mass array from the Lambda-M curve of an EOS.
+
lambda_data : array
+
Lambda array from the Lambda-M curve of an EOS.
+
+
Returns
+
-------
+
lambdav : float
+
The Lambda corresponding to the mass `m` for the EOS considered.
+
"""
+
if m_src > mass_data.max():
+
# assume black hole
+
lambdav = 0.0
+
else:
+
lambdav = numpy.interp(m_src, mass_data, lambda_data)
+
return lambdav
+
+
+
+
+
+
+
[docs]
+
@classmethod
+
def from_config(cls, cp, section, outputs):
+
# see if we're redshifting masses
+
if cp.has_option("-".join([section, outputs]), "do-not-redshift-mass"):
+
additional_opts = {"redshift_mass": False}
+
skip_opts = ["do-not-redshift-mass"]
+
else:
+
additional_opts = None
+
skip_opts = None
+
return super(LambdaFromTOVFile, cls).from_config(
+
cp, section, outputs, skip_opts=skip_opts, additional_opts=additional_opts
+
)
+
+
[docs]
+
class LambdaFromMultipleTOVFiles(BaseTransform):
+
"""Uses multiple equation of states.
+
+
Parameters
+
----------
+
mass_param : str
+
The name of the mass parameter to transform.
+
lambda_param : str
+
The name of the tidal deformability parameter that mass_param is to
+
be converted to interpolating from the data in the mass-Lambda file.
+
mass_lambda_file : str
+
Path of the mass-Lambda data file. The first column in the data file
+
should contain mass values, and the second column Lambda values.
+
distance : float, optional
+
The distance (in Mpc) of the source. Used to redshift the mass. If
+
None, then a distance must be provided to the transform.
+
file_columns : list of str, optional
+
The names and order of columns in the ``mass_lambda_file``. Must
+
contain at least 'mass' and 'lambda'. If not provided, will assume the
+
order is ('radius', 'mass', 'lambda').
+
"""
+
+
name = "lambda_from_multiple_tov_files"
+
+
def __init__(
+
self,
+
mass_param,
+
lambda_param,
+
map_file,
+
distance=None,
+
redshift_mass=True,
+
file_columns=None,
+
):
+
self._map_file = map_file
+
self._mass_param = mass_param
+
self._lambda_param = lambda_param
+
self._distance = distance
+
self.redshift_mass = redshift_mass
+
self._inputs = [mass_param, "eos", "distance"]
+
self._outputs = [lambda_param]
+
# create a dictionary of the EOS files from the map_file
+
self._eos_files = {}
+
with open(self._map_file, "r") as fp:
+
for line in fp:
+
fname = line.rstrip("\n")
+
eosidx = int(os.path.basename(fname).split(".")[0])
+
self._eos_files[eosidx] = os.path.abspath(fname)
+
# create an eos cache for fast load later
+
self._eos_cache = {}
+
if file_columns is None:
+
file_columns = ("radius", "mass", "lambda")
+
self._file_columns = file_columns
+
super(LambdaFromMultipleTOVFiles, self).__init__()
+
+
@property
+
def mass_param(self):
+
"""Returns the input mass parameter."""
+
return self._mass_param
+
+
@property
+
def lambda_param(self):
+
"""Returns the output lambda parameter."""
+
return self._lambda_param
+
+
@property
+
def map_file(self):
+
"""Returns the mass data read from the mass-Lambda data file for
+
an EOS.
+
"""
+
return self._map_file
+
+
@property
+
def distance(self):
+
"""Returns the fixed distance to transform mass samples from detector
+
to source frame if one is specified.
+
"""
+
return self._distance
+
+
+
[docs]
+
def get_eos(self, eos_index):
+
"""Gets the EOS for the given index.
+
+
If the index is not in range returns None.
+
"""
+
try:
+
eos = self._eos_cache[eos_index]
+
except KeyError:
+
try:
+
fname = self._eos_files[eos_index]
+
eos = LambdaFromTOVFile(
+
mass_param=self._mass_param,
+
lambda_param=self._lambda_param,
+
mass_lambda_file=fname,
+
distance=self._distance,
+
redshift_mass=self.redshift_mass,
+
file_columns=self._file_columns,
+
)
+
self._eos_cache[eos_index] = eos
+
except KeyError:
+
eos = None
+
return eos
+
+
+
+
+
+
+
[docs]
+
@classmethod
+
def from_config(cls, cp, section, outputs):
+
# see if we're redshifting masses
+
if cp.has_option("-".join([section, outputs]), "do-not-redshift-mass"):
+
additional_opts = {"redshift_mass": False}
+
skip_opts = ["do-not-redshift-mass"]
+
else:
+
additional_opts = None
+
skip_opts = None
+
return super(LambdaFromMultipleTOVFiles, cls).from_config(
+
cp, section, outputs, skip_opts=skip_opts, additional_opts=additional_opts
+
)
+
+
[docs]
+
class GEOToSSB(BaseTransform):
+
"""Converts arrival time, sky localization, and polarization angle in the
+
geocentric frame to the corresponding values in the SSB frame."""
+
+
name = "geo_to_ssb"
+
+
default_params_name = {
+
'default_tc_geo': parameters.tc,
+
'default_longitude_geo': parameters.ra,
+
'default_latitude_geo': parameters.dec,
+
'default_polarization_geo': parameters.polarization,
+
'default_tc_ssb': parameters.tc,
+
'default_longitude_ssb': parameters.eclipticlongitude,
+
'default_latitude_ssb': parameters.eclipticlatitude,
+
'default_polarization_ssb': parameters.polarization
+
}
+
+
def __init__(
+
self, tc_geo_param=None, longitude_geo_param=None,
+
latitude_geo_param=None, polarization_geo_param=None,
+
tc_ssb_param=None, longitude_ssb_param=None,
+
latitude_ssb_param=None, polarization_ssb_param=None
+
):
+
params = [tc_geo_param, longitude_geo_param,
+
latitude_geo_param, polarization_geo_param,
+
tc_ssb_param, longitude_ssb_param,
+
latitude_ssb_param, polarization_ssb_param]
+
+
for index in range(len(params)):
+
if params[index] is None:
+
key = list(self.default_params_name.keys())[index]
+
params[index] = self.default_params_name[key]
+
+
self.tc_geo_param = params[0]
+
self.longitude_geo_param = params[1]
+
self.latitude_geo_param = params[2]
+
self.polarization_geo_param = params[3]
+
self.tc_ssb_param = params[4]
+
self.longitude_ssb_param = params[5]
+
self.latitude_ssb_param = params[6]
+
self.polarization_ssb_param = params[7]
+
self._inputs = [self.tc_geo_param, self.longitude_geo_param,
+
self.latitude_geo_param, self.polarization_geo_param]
+
self._outputs = [self.tc_ssb_param, self.longitude_ssb_param,
+
self.latitude_ssb_param, self.polarization_ssb_param]
+
+
super(GEOToSSB, self).__init__()
+
+
+
+
+
+
+
+
+
[docs]
+
@classmethod
+
def from_config(cls, cp, section, outputs):
+
tag = outputs
+
skip_opts = []
+
additional_opts = {}
+
+
# get custom variable names
+
variables = {
+
'tc-geo': cls.default_params_name['default_tc_geo'],
+
'longitude-geo': cls.default_params_name['default_longitude_geo'],
+
'latitude-geo': cls.default_params_name['default_latitude_geo'],
+
'polarization-geo': cls.default_params_name[
+
'default_polarization_geo'],
+
'tc-ssb': cls.default_params_name['default_tc_ssb'],
+
'longitude-ssb': cls.default_params_name['default_longitude_ssb'],
+
'latitude-ssb': cls.default_params_name['default_latitude_ssb'],
+
'polarization-ssb': cls.default_params_name[
+
'default_polarization_ssb']
+
}
+
for param_name in variables.keys():
+
name_underline = param_name.replace('-', '_')
+
if cp.has_option("-".join([section, outputs]), param_name):
+
skip_opts.append(param_name)
+
additional_opts.update(
+
{name_underline+'_param': cp.get_opt_tag(
+
section, param_name, tag)})
+
else:
+
additional_opts.update(
+
{name_underline+'_param': variables[param_name]})
+
+
return super(GEOToSSB, cls).from_config(
+
cp, section, outputs, skip_opts=skip_opts,
+
additional_opts=additional_opts
+
)
+
+
[docs]
+
class LISAToSSB(BaseTransform):
+
"""Converts arrival time, sky localization, and polarization angle in the
+
LISA frame to the corresponding values in the SSB frame."""
+
+
name = "lisa_to_ssb"
+
+
default_params_name = {
+
'default_tc_lisa': parameters.tc,
+
'default_longitude_lisa': parameters.eclipticlongitude,
+
'default_latitude_lisa': parameters.eclipticlatitude,
+
'default_polarization_lisa': parameters.polarization,
+
'default_tc_ssb': parameters.tc,
+
'default_longitude_ssb': parameters.eclipticlongitude,
+
'default_latitude_ssb': parameters.eclipticlatitude,
+
'default_polarization_ssb': parameters.polarization
+
}
+
+
def __init__(
+
self, tc_lisa_param=None, longitude_lisa_param=None,
+
latitude_lisa_param=None, polarization_lisa_param=None,
+
tc_ssb_param=None, longitude_ssb_param=None,
+
latitude_ssb_param=None, polarization_ssb_param=None
+
):
+
params = [tc_lisa_param, longitude_lisa_param,
+
latitude_lisa_param, polarization_lisa_param,
+
tc_ssb_param, longitude_ssb_param,
+
latitude_ssb_param, polarization_ssb_param]
+
for index in range(len(params)):
+
if params[index] is None:
+
key = list(self.default_params_name.keys())[index]
+
params[index] = self.default_params_name[key]
+
+
self.tc_lisa_param = params[0]
+
self.longitude_lisa_param = params[1]
+
self.latitude_lisa_param = params[2]
+
self.polarization_lisa_param = params[3]
+
self.tc_ssb_param = params[4]
+
self.longitude_ssb_param = params[5]
+
self.latitude_ssb_param = params[6]
+
self.polarization_ssb_param = params[7]
+
self._inputs = [self.tc_lisa_param, self.longitude_lisa_param,
+
self.latitude_lisa_param, self.polarization_lisa_param]
+
self._outputs = [self.tc_ssb_param, self.longitude_ssb_param,
+
self.latitude_ssb_param, self.polarization_ssb_param]
+
super(LISAToSSB, self).__init__()
+
+
+
+
+
+
+
+
+
[docs]
+
@classmethod
+
def from_config(cls, cp, section, outputs):
+
tag = outputs
+
skip_opts = []
+
additional_opts = {}
+
+
# get custom variable names
+
variables = {
+
'tc-lisa': cls.default_params_name['default_tc_lisa'],
+
'longitude-lisa': cls.default_params_name[
+
'default_longitude_lisa'],
+
'latitude-lisa': cls.default_params_name['default_latitude_lisa'],
+
'polarization-lisa': cls.default_params_name[
+
'default_polarization_lisa'],
+
'tc-ssb': cls.default_params_name['default_tc_ssb'],
+
'longitude-ssb': cls.default_params_name['default_longitude_ssb'],
+
'latitude-ssb': cls.default_params_name['default_latitude_ssb'],
+
'polarization-ssb': cls.default_params_name[
+
'default_polarization_ssb']
+
}
+
for param_name in variables.keys():
+
name_underline = param_name.replace('-', '_')
+
if cp.has_option("-".join([section, outputs]), param_name):
+
skip_opts.append(param_name)
+
additional_opts.update(
+
{name_underline+'_param': cp.get_opt_tag(
+
section, param_name, tag)})
+
else:
+
additional_opts.update(
+
{name_underline+'_param': variables[param_name]})
+
+
return super(LISAToSSB, cls).from_config(
+
cp, section, outputs, skip_opts=skip_opts,
+
additional_opts=additional_opts
+
)
+
+
[docs]
+
class LISAToGEO(BaseTransform):
+
"""Converts arrival time, sky localization, and polarization angle in the
+
LISA frame to the corresponding values in the geocentric frame."""
+
+
name = "lisa_to_geo"
+
+
default_params_name = {
+
'default_tc_lisa': parameters.tc,
+
'default_longitude_lisa': parameters.eclipticlongitude,
+
'default_latitude_lisa': parameters.eclipticlatitude,
+
'default_polarization_lisa': parameters.polarization,
+
'default_tc_geo': parameters.tc,
+
'default_longitude_geo': parameters.ra,
+
'default_latitude_geo': parameters.dec,
+
'default_polarization_geo': parameters.polarization
+
}
+
+
def __init__(
+
self, tc_lisa_param=None, longitude_lisa_param=None,
+
latitude_lisa_param=None, polarization_lisa_param=None,
+
tc_geo_param=None, longitude_geo_param=None,
+
latitude_geo_param=None, polarization_geo_param=None
+
):
+
params = [tc_lisa_param, longitude_lisa_param,
+
latitude_lisa_param, polarization_lisa_param,
+
tc_geo_param, longitude_geo_param,
+
latitude_geo_param, polarization_geo_param]
+
for index in range(len(params)):
+
if params[index] is None:
+
key = list(self.default_params_name.keys())[index]
+
params[index] = self.default_params_name[key]
+
+
self.tc_lisa_param = params[0]
+
self.longitude_lisa_param = params[1]
+
self.latitude_lisa_param = params[2]
+
self.polarization_lisa_param = params[3]
+
self.tc_geo_param = params[4]
+
self.longitude_geo_param = params[5]
+
self.latitude_geo_param = params[6]
+
self.polarization_geo_param = params[7]
+
self._inputs = [self.tc_lisa_param, self.longitude_lisa_param,
+
self.latitude_lisa_param, self.polarization_lisa_param]
+
self._outputs = [self.tc_geo_param, self.longitude_geo_param,
+
self.latitude_geo_param, self.polarization_geo_param]
+
super(LISAToGEO, self).__init__()
+
+
+
+
+
+
+
+
+
[docs]
+
@classmethod
+
def from_config(cls, cp, section, outputs):
+
tag = outputs
+
skip_opts = []
+
additional_opts = {}
+
+
# get custom variable names
+
variables = {
+
'tc-lisa': cls.default_params_name['default_tc_lisa'],
+
'longitude-lisa': cls.default_params_name[
+
'default_longitude_lisa'],
+
'latitude-lisa': cls.default_params_name['default_latitude_lisa'],
+
'polarization-lisa': cls.default_params_name[
+
'default_polarization_lisa'],
+
'tc-geo': cls.default_params_name['default_tc_geo'],
+
'longitude-geo': cls.default_params_name['default_longitude_geo'],
+
'latitude-geo': cls.default_params_name['default_latitude_geo'],
+
'polarization-geo': cls.default_params_name[
+
'default_polarization_geo']
+
}
+
for param_name in variables.keys():
+
name_underline = param_name.replace('-', '_')
+
if cp.has_option("-".join([section, outputs]), param_name):
+
skip_opts.append(param_name)
+
additional_opts.update(
+
{name_underline+'_param': cp.get_opt_tag(
+
section, param_name, tag)})
+
else:
+
additional_opts.update(
+
{name_underline+'_param': variables[param_name]})
+
+
return super(LISAToGEO, cls).from_config(
+
cp, section, outputs, skip_opts=skip_opts,
+
additional_opts=additional_opts
+
)
+
+
[docs]
+
class Log(BaseTransform):
+
"""Applies a log transform from an `inputvar` parameter to an `outputvar`
+
parameter. This is the inverse of the exponent transform.
+
+
Parameters
+
----------
+
inputvar : str
+
The name of the parameter to transform.
+
outputvar : str
+
The name of the transformed parameter.
+
"""
+
+
name = "log"
+
+
def __init__(self, inputvar, outputvar):
+
self._inputvar = inputvar
+
self._outputvar = outputvar
+
self._inputs = [inputvar]
+
self._outputs = [outputvar]
+
super(Log, self).__init__()
+
+
@property
+
def inputvar(self):
+
"""Returns the input parameter."""
+
return self._inputvar
+
+
@property
+
def outputvar(self):
+
"""Returns the output parameter."""
+
return self._outputvar
+
+
+
+
+
+
+
+
+
[docs]
+
def jacobian(self, maps):
+
r"""Computes the Jacobian of :math:`y = \log(x)`.
+
+
This is:
+
+
.. math::
+
+
\frac{\mathrm{d}y}{\mathrm{d}x} = \frac{1}{x}.
+
+
Parameters
+
----------
+
maps : dict or FieldArray
+
A dictionary or FieldArray which provides a map between the
+
parameter name of the variable to transform and its value(s).
+
+
Returns
+
-------
+
float
+
The value of the jacobian at the given point(s).
+
"""
+
x = maps[self._inputvar]
+
return 1.0 / x
+
+
+
+
[docs]
+
def inverse_jacobian(self, maps):
+
r"""Computes the Jacobian of :math:`y = e^{x}`.
+
+
This is:
+
+
.. math::
+
+
\frac{\mathrm{d}y}{\mathrm{d}x} = e^{x}.
+
+
Parameters
+
----------
+
maps : dict or FieldArray
+
A dictionary or FieldArray which provides a map between the
+
parameter name of the variable to transform and its value(s).
+
+
Returns
+
-------
+
float
+
The value of the jacobian at the given point(s).
+
"""
+
x = maps[self._outputvar]
+
return numpy.exp(x)
+
+
[docs]
+
class Logit(BaseTransform):
+
"""Applies a logit transform from an `inputvar` parameter to an `outputvar`
+
parameter. This is the inverse of the logistic transform.
+
+
Typically, the input of the logit function is assumed to have domain
+
:math:`\in (0, 1)`. However, the `domain` argument can be used to expand
+
this to any finite real interval.
+
+
Parameters
+
----------
+
inputvar : str
+
The name of the parameter to transform.
+
outputvar : str
+
The name of the transformed parameter.
+
domain : tuple or distributions.bounds.Bounds, optional
+
The domain of the input parameter. Can be any finite
+
interval. Default is (0., 1.).
+
"""
+
+
name = "logit"
+
+
def __init__(self, inputvar, outputvar, domain=(0.0, 1.0)):
+
self._inputvar = inputvar
+
self._outputvar = outputvar
+
self._inputs = [inputvar]
+
self._outputs = [outputvar]
+
self._bounds = Bounds(domain[0], domain[1],
+
btype_min="open", btype_max="open")
+
# shortcuts for quick access later
+
self._a = domain[0]
+
self._b = domain[1]
+
super(Logit, self).__init__()
+
+
@property
+
def inputvar(self):
+
"""Returns the input parameter."""
+
return self._inputvar
+
+
@property
+
def outputvar(self):
+
"""Returns the output parameter."""
+
return self._outputvar
+
+
@property
+
def bounds(self):
+
"""Returns the domain of the input parameter."""
+
return self._bounds
+
+
+
[docs]
+
@staticmethod
+
def logit(x, a=0.0, b=1.0):
+
r"""Computes the logit function with domain :math:`x \in (a, b)`.
+
+
This is given by:
+
+
.. math::
+
+
\mathrm{logit}(x; a, b) = \log\left(\frac{x-a}{b-x}\right).
+
+
Note that this is also the inverse of the logistic function with range
+
:math:`(a, b)`.
+
+
Parameters
+
----------
+
x : float
+
The value to evaluate.
+
a : float, optional
+
The minimum bound of the domain of x. Default is 0.
+
b : float, optional
+
The maximum bound of the domain of x. Default is 1.
+
+
Returns
+
-------
+
float
+
The logit of x.
+
"""
+
return numpy.log(x - a) - numpy.log(b - x)
+
+
+
+
[docs]
+
@staticmethod
+
def logistic(x, a=0.0, b=1.0):
+
r"""Computes the logistic function with range :math:`\in (a, b)`.
+
+
This is given by:
+
+
.. math::
+
+
\mathrm{logistic}(x; a, b) = \frac{a + b e^x}{1 + e^x}.
+
+
Note that this is also the inverse of the logit function with domain
+
:math:`(a, b)`.
+
+
Parameters
+
----------
+
x : float
+
The value to evaluate.
+
a : float, optional
+
The minimum bound of the range of the logistic function. Default
+
is 0.
+
b : float, optional
+
The maximum bound of the range of the logistic function. Default
+
is 1.
+
+
Returns
+
-------
+
float
+
The logistic of x.
+
"""
+
expx = numpy.exp(x)
+
return (a + b * expx) / (1.0 + expx)
+
+
+
+
+
+
+
+
+
+
[docs]
+
def jacobian(self, maps):
+
r"""Computes the Jacobian of :math:`y = \mathrm{logit}(x; a,b)`.
+
+
This is:
+
+
.. math::
+
+
\frac{\mathrm{d}y}{\mathrm{d}x} = \frac{b -a}{(x-a)(b-x)},
+
+
where :math:`x \in (a, b)`.
+
+
Parameters
+
----------
+
maps : dict or FieldArray
+
A dictionary or FieldArray which provides a map between the
+
parameter name of the variable to transform and its value(s).
+
+
Returns
+
-------
+
float
+
The value of the jacobian at the given point(s).
+
"""
+
x = maps[self._inputvar]
+
# check that x is in bounds
+
isin = self._bounds.__contains__(x)
+
if isinstance(isin, numpy.ndarray) and not isin.all():
+
raise ValueError("one or more values are not in bounds")
+
elif not isin:
+
raise ValueError("{} is not in bounds".format(x))
+
return (self._b - self._a) / ((x - self._a) * (self._b - x))
+
+
+
+
[docs]
+
def inverse_jacobian(self, maps):
+
r"""Computes the Jacobian of :math:`y = \mathrm{logistic}(x; a,b)`.
+
+
This is:
+
+
.. math::
+
+
\frac{\mathrm{d}y}{\mathrm{d}x} = \frac{e^x (b-a)}{(1+e^y)^2},
+
+
where :math:`y \in (a, b)`.
+
+
Parameters
+
----------
+
maps : dict or FieldArray
+
A dictionary or FieldArray which provides a map between the
+
parameter name of the variable to transform and its value(s).
+
+
Returns
+
-------
+
float
+
The value of the jacobian at the given point(s).
+
"""
+
x = maps[self._outputvar]
+
expx = numpy.exp(x)
+
return expx * (self._b - self._a) / (1.0 + expx) ** 2.0
+
+
+
+
[docs]
+
@classmethod
+
def from_config(cls, cp, section, outputs,
+
skip_opts=None, additional_opts=None):
+
"""Initializes a Logit transform from the given section.
+
+
The section must specify an input and output variable name. The domain
+
of the input may be specified using `min-{input}`, `max-{input}`.
+
Example:
+
+
.. code-block:: ini
+
+
[{section}-logitq]
+
name = logit
+
inputvar = q
+
outputvar = logitq
+
min-q = 1
+
max-q = 8
+
+
Parameters
+
----------
+
cp : pycbc.workflow.WorkflowConfigParser
+
A parsed configuration file that contains the transform options.
+
section : str
+
Name of the section in the configuration file.
+
outputs : str
+
The names of the parameters that are output by this transformation,
+
separated by `VARARGS_DELIM`. These must appear in the "tag" part
+
of the section header.
+
skip_opts : list, optional
+
Do not read options in the given list.
+
additional_opts : dict, optional
+
Any additional arguments to pass to the class. If an option is
+
provided that also exists in the config file, the value provided
+
will be used instead of being read from the file.
+
+
Returns
+
-------
+
cls
+
An instance of the class.
+
"""
+
# pull out the minimum, maximum values of the input variable
+
inputvar = cp.get_opt_tag(section, "inputvar", outputs)
+
s = "-".join([section, outputs])
+
opt = "min-{}".format(inputvar)
+
if skip_opts is None:
+
skip_opts = []
+
if additional_opts is None:
+
additional_opts = {}
+
else:
+
additional_opts = additional_opts.copy()
+
if cp.has_option(s, opt):
+
a = cp.get_opt_tag(section, opt, outputs)
+
skip_opts.append(opt)
+
else:
+
a = None
+
opt = "max-{}".format(inputvar)
+
if cp.has_option(s, opt):
+
b = cp.get_opt_tag(section, opt, outputs)
+
skip_opts.append(opt)
+
else:
+
b = None
+
if a is None and b is not None or b is None and a is not None:
+
raise ValueError(
+
"if providing a min(max)-{}, must also provide "
+
"a max(min)-{}".format(inputvar, inputvar)
+
)
+
elif a is not None:
+
additional_opts.update({"domain": (float(a), float(b))})
+
return super(Logit, cls).from_config(
+
cp, section, outputs, skip_opts, additional_opts
+
)
+
+
[docs]
+
class Mass1Mass2ToMchirpQ(MchirpQToMass1Mass2):
+
"""The inverse of MchirpQToMass1Mass2."""
+
+
name = "mass1_mass2_to_mchirp_q"
+
inverse = MchirpQToMass1Mass2
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
+
def __init__(
+
self, mass1_param=None, mass2_param=None, mchirp_param=None, q_param=None
+
):
+
if mass1_param is None:
+
mass1_param = parameters.mass1
+
if mass2_param is None:
+
mass2_param = parameters.mass2
+
if mchirp_param is None:
+
mchirp_param = parameters.mchirp
+
if q_param is None:
+
q_param = parameters.q
+
self.mass1_param = mass1_param
+
self.mass2_param = mass2_param
+
self.mchirp_param = mchirp_param
+
self.q_param = q_param
+
self._inputs = [self.mass1_param, self.mass2_param]
+
self._outputs = [self.mchirp_param, self.q_param]
+
BaseTransform.__init__(self)
+
[docs]
+
class Mass1Mass2ToMchirpEta(MchirpEtaToMass1Mass2):
+
"""The inverse of MchirpEtaToMass1Mass2."""
+
+
name = "mass1_mass2_to_mchirp_eta"
+
inverse = MchirpEtaToMass1Mass2
+
_inputs = inverse._outputs
+
_outputs = inverse._inputs
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
[docs]
+
class DistanceToChirpDistance(ChirpDistanceToDistance):
+
"""The inverse of ChirpDistanceToDistance."""
+
+
name = "distance_to_chirp_distance"
+
inverse = ChirpDistanceToDistance
+
_inputs = [parameters.distance, parameters.mchirp]
+
_outputs = [parameters.chirp_distance]
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
[docs]
+
class CartesianToSpherical(SphericalToCartesian):
+
"""Converts spherical coordinates to cartesian.
+
+
Parameters
+
----------
+
x : str
+
The name of the x parameter.
+
y : str
+
The name of the y parameter.
+
z : str
+
The name of the z parameter.
+
radial : str
+
The name of the radial parameter.
+
azimuthal : str
+
The name of the azimuthal angle parameter.
+
polar : str
+
The name of the polar angle parameter.
+
"""
+
+
name = "cartesian_to_spherical"
+
inverse = SphericalToCartesian
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
+
def __init__(self, *args):
+
super(CartesianToSpherical, self).__init__(*args)
+
# swap inputs and outputs
+
outputs = self._inputs
+
inputs = self._outputs
+
self._inputs = inputs
+
self._outputs = outputs
+
self.inputs = set(self._inputs)
+
self.outputs = set(self._outputs)
+
[docs]
+
class CartesianSpin1ToSphericalSpin1(CartesianToSpherical):
+
"""The inverse of SphericalSpin1ToCartesianSpin1.
+
+
**Deprecation Warning:** This will be removed in a future update. Use
+
:py:class:`CartesianToSpherical` with spin-parameter names passed in
+
instead.
+
"""
+
+
name = "cartesian_spin_1_to_spherical_spin_1"
+
+
def __init__(self):
+
logger.warning(
+
"Deprecation warning: the %s transform will be "
+
"removed in a future update. Please use %s instead, "
+
"passing spin1x, spin1y, spin1z, spin1_a, "
+
"spin1_azimuthal, spin1_polar as arguments.",
+
self.name, CartesianToSpherical.name
+
)
+
super(CartesianSpin1ToSphericalSpin1, self).__init__(
+
"spin1x", "spin1y", "spin1z",
+
"spin1_a", "spin1_azimuthal", "spin1_polar"
+
)
+
[docs]
+
class CartesianSpin2ToSphericalSpin2(CartesianToSpherical):
+
"""The inverse of SphericalSpin2ToCartesianSpin2.
+
+
**Deprecation Warning:** This will be removed in a future update. Use
+
:py:class:`CartesianToSpherical` with spin-parameter names passed in
+
instead.
+
"""
+
+
name = "cartesian_spin_2_to_spherical_spin_2"
+
+
def __init__(self):
+
logger.warning(
+
"Deprecation warning: the %s transform will be "
+
"removed in a future update. Please use %s instead, "
+
"passing spin2x, spin2y, spin2z, spin2_a, "
+
"spin2_azimuthal, spin2_polar as arguments.",
+
self.name, CartesianToSpherical.name
+
)
+
super(CartesianSpin2ToSphericalSpin2, self).__init__(
+
"spin2x", "spin2y", "spin2z",
+
"spin2_a", "spin2_azimuthal", "spin2_polar"
+
)
+
[docs]
+
class CartesianSpinToAlignedMassSpin(AlignedMassSpinToCartesianSpin):
+
"""The inverse of AlignedMassSpinToCartesianSpin."""
+
+
name = "cartesian_spin_to_aligned_mass_spin"
+
inverse = AlignedMassSpinToCartesianSpin
+
_inputs = inverse._outputs
+
_outputs = inverse._inputs
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
[docs]
+
class CartesianSpinToPrecessionMassSpin(PrecessionMassSpinToCartesianSpin):
+
"""The inverse of PrecessionMassSpinToCartesianSpin."""
+
+
name = "cartesian_spin_to_precession_mass_spin"
+
inverse = PrecessionMassSpinToCartesianSpin
+
_inputs = inverse._outputs
+
_outputs = inverse._inputs
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
[docs]
+
class ChiPToCartesianSpin(CartesianSpinToChiP):
+
"""The inverse of `CartesianSpinToChiP`."""
+
+
name = "cartesian_spin_to_chi_p"
+
inverse = CartesianSpinToChiP
+
_inputs = inverse._outputs
+
_outputs = inverse._inputs
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
[docs]
+
class SSBToGEO(GEOToSSB):
+
"""The inverse of GEOToSSB."""
+
+
name = "ssb_to_geo"
+
inverse = GEOToSSB
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
+
def __init__(
+
self, tc_geo_param=None, longitude_geo_param=None,
+
latitude_geo_param=None, polarization_geo_param=None,
+
tc_ssb_param=None, longitude_ssb_param=None,
+
latitude_ssb_param=None, polarization_ssb_param=None
+
):
+
params = [tc_geo_param, longitude_geo_param,
+
latitude_geo_param, polarization_geo_param,
+
tc_ssb_param, longitude_ssb_param,
+
latitude_ssb_param, polarization_ssb_param]
+
for index in range(len(params)):
+
if params[index] is None:
+
key = list(self.default_params_name.keys())[index]
+
params[index] = self.default_params_name[key]
+
+
self.tc_geo_param = params[0]
+
self.longitude_geo_param = params[1]
+
self.latitude_geo_param = params[2]
+
self.polarization_geo_param = params[3]
+
self.tc_ssb_param = params[4]
+
self.longitude_ssb_param = params[5]
+
self.latitude_ssb_param = params[6]
+
self.polarization_ssb_param = params[7]
+
self._inputs = [self.tc_ssb_param, self.longitude_ssb_param,
+
self.latitude_ssb_param, self.polarization_ssb_param]
+
self._outputs = [self.tc_geo_param, self.longitude_geo_param,
+
self.latitude_geo_param, self.polarization_geo_param]
+
[docs]
+
class SSBToLISA(LISAToSSB):
+
"""The inverse of LISAToSSB."""
+
+
name = "ssb_to_lisa"
+
inverse = LISAToSSB
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
+
def __init__(
+
self, tc_lisa_param=None, longitude_lisa_param=None,
+
latitude_lisa_param=None, polarization_lisa_param=None,
+
tc_ssb_param=None, longitude_ssb_param=None,
+
latitude_ssb_param=None, polarization_ssb_param=None
+
):
+
params = [tc_lisa_param, longitude_lisa_param,
+
latitude_lisa_param, polarization_lisa_param,
+
tc_ssb_param, longitude_ssb_param,
+
latitude_ssb_param, polarization_ssb_param]
+
for index in range(len(params)):
+
if params[index] is None:
+
key = list(self.default_params_name.keys())[index]
+
params[index] = self.default_params_name[key]
+
+
self.tc_lisa_param = params[0]
+
self.longitude_lisa_param = params[1]
+
self.latitude_lisa_param = params[2]
+
self.polarization_lisa_param = params[3]
+
self.tc_ssb_param = params[4]
+
self.longitude_ssb_param = params[5]
+
self.latitude_ssb_param = params[6]
+
self.polarization_ssb_param = params[7]
+
self._inputs = [self.tc_ssb_param, self.longitude_ssb_param,
+
self.latitude_ssb_param, self.polarization_ssb_param]
+
self._outputs = [self.tc_lisa_param, self.longitude_lisa_param,
+
self.latitude_lisa_param, self.polarization_lisa_param]
+
[docs]
+
class GEOToLISA(LISAToGEO):
+
"""The inverse of LISAToGEO."""
+
+
name = "geo_to_lisa"
+
inverse = LISAToGEO
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
+
def __init__(
+
self, tc_lisa_param=None, longitude_lisa_param=None,
+
latitude_lisa_param=None, polarization_lisa_param=None,
+
tc_geo_param=None, longitude_geo_param=None,
+
latitude_geo_param=None, polarization_geo_param=None
+
):
+
params = [tc_lisa_param, longitude_lisa_param,
+
latitude_lisa_param, polarization_lisa_param,
+
tc_geo_param, longitude_geo_param,
+
latitude_geo_param, polarization_geo_param]
+
for index in range(len(params)):
+
if params[index] is None:
+
key = list(self.default_params_name.keys())[index]
+
params[index] = self.default_params_name[key]
+
+
self.tc_lisa_param = params[0]
+
self.longitude_lisa_param = params[1]
+
self.latitude_lisa_param = params[2]
+
self.polarization_lisa_param = params[3]
+
self.tc_geo_param = params[4]
+
self.longitude_geo_param = params[5]
+
self.latitude_geo_param = params[6]
+
self.polarization_geo_param = params[7]
+
self._inputs = [self.tc_geo_param, self.longitude_geo_param,
+
self.latitude_geo_param, self.polarization_geo_param]
+
self._outputs = [self.tc_lisa_param, self.longitude_lisa_param,
+
self.latitude_lisa_param, self.polarization_lisa_param]
+
[docs]
+
class Exponent(Log):
+
"""Applies an exponent transform to an `inputvar` parameter.
+
+
This is the inverse of the log transform.
+
+
Parameters
+
----------
+
inputvar : str
+
The name of the parameter to transform.
+
outputvar : str
+
The name of the transformed parameter.
+
"""
+
+
name = "exponent"
+
inverse = Log
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
+
def __init__(self, inputvar, outputvar):
+
super(Exponent, self).__init__(outputvar, inputvar)
+
[docs]
+
class Logistic(Logit):
+
"""Applies a logistic transform from an `input` parameter to an `output`
+
parameter. This is the inverse of the logit transform.
+
+
Typically, the output of the logistic function has range :math:`\in [0,1)`.
+
However, the `codomain` argument can be used to expand this to any
+
finite real interval.
+
+
Parameters
+
----------
+
inputvar : str
+
The name of the parameter to transform.
+
outputvar : str
+
The name of the transformed parameter.
+
frange : tuple or distributions.bounds.Bounds, optional
+
The range of the output parameter. Can be any finite
+
interval. Default is (0., 1.).
+
"""
+
+
name = "logistic"
+
inverse = Logit
+
transform = inverse.inverse_transform
+
inverse_transform = inverse.transform
+
jacobian = inverse.inverse_jacobian
+
inverse_jacobian = inverse.jacobian
+
+
def __init__(self, inputvar, outputvar, codomain=(0.0, 1.0)):
+
super(Logistic, self).__init__(outputvar, inputvar, domain=codomain)
+
+
@property
+
def bounds(self):
+
"""Returns the range of the output parameter."""
+
return self._bounds
+
+
+
[docs]
+
@classmethod
+
def from_config(cls, cp, section, outputs,
+
skip_opts=None, additional_opts=None):
+
"""Initializes a Logistic transform from the given section.
+
+
The section must specify an input and output variable name. The
+
codomain of the output may be specified using `min-{output}`,
+
`max-{output}`. Example:
+
+
.. code-block:: ini
+
+
[{section}-q]
+
name = logistic
+
inputvar = logitq
+
outputvar = q
+
min-q = 1
+
max-q = 8
+
+
Parameters
+
----------
+
cp : pycbc.workflow.WorkflowConfigParser
+
A parsed configuration file that contains the transform options.
+
section : str
+
Name of the section in the configuration file.
+
outputs : str
+
The names of the parameters that are output by this transformation,
+
separated by `VARARGS_DELIM`. These must appear in the "tag" part
+
of the section header.
+
skip_opts : list, optional
+
Do not read options in the given list.
+
additional_opts : dict, optional
+
Any additional arguments to pass to the class. If an option is
+
provided that also exists in the config file, the value provided
+
will be used instead of being read from the file.
+
+
Returns
+
-------
+
cls
+
An instance of the class.
+
"""
+
# pull out the minimum, maximum values of the output variable
+
outputvar = cp.get_opt_tag(section, "output", outputs)
+
if skip_opts is None:
+
skip_opts = []
+
if additional_opts is None:
+
additional_opts = {}
+
else:
+
additional_opts = additional_opts.copy()
+
s = "-".join([section, outputs])
+
opt = "min-{}".format(outputvar)
+
if cp.has_option(s, opt):
+
a = cp.get_opt_tag(section, opt, outputs)
+
skip_opts.append(opt)
+
else:
+
a = None
+
opt = "max-{}".format(outputvar)
+
if cp.has_option(s, opt):
+
b = cp.get_opt_tag(section, opt, outputs)
+
skip_opts.append(opt)
+
else:
+
b = None
+
if a is None and b is not None or b is None and a is not None:
+
raise ValueError(
+
"if providing a min(max)-{}, must also provide "
+
"a max(min)-{}".format(outputvar, outputvar)
+
)
+
elif a is not None:
+
additional_opts.update({"codomain": (float(a), float(b))})
+
return super(Logistic, cls).from_config(
+
cp, section, outputs, skip_opts, additional_opts
+
)
+
+
[docs]
+
def compute_jacobian(samples, transforms, inverse=False):
+
"""Computes the jacobian of the list of transforms at the given sample
+
points.
+
+
Parameters
+
----------
+
samples : {FieldArray, dict}
+
Mapping object specifying points at which to compute jacobians.
+
transforms : list
+
List of BaseTransform instances to apply. Nested transforms are assumed
+
to be in order for forward transforms.
+
inverse : bool, optional
+
Compute inverse jacobians. Default is False.
+
+
Returns
+
-------
+
float :
+
The product of the jacobians of all fo the transforms.
+
"""
+
j = 1.0
+
if inverse:
+
for t in transforms:
+
j *= t.inverse_jacobian(samples)
+
else:
+
for t in transforms:
+
j *= t.jacobian(samples)
+
return j
