lalsuite 7.26.2.dev20251207__cp313-cp313-manylinux_2_28_x86_64.whl

lalsimulation/gwsignal/core/conditioning_subroutines.py

@@ -0,0 +1,196 @@
+# Import required stuff
+import numpy as np
+from astropy import units as u
+from gwpy.timeseries import TimeSeries
+import warnings
+from scipy.signal import butter, sosfiltfilt
+
+# Routine to high-pass time series
+
+def high_pass_time_series(time_series, dt, fmin, attenuation, N):
+    """
+    High-pass a time series
+
+    Parameters
+    ----------
+    time_series : `TimeSeries`
+        GwPy TimeSeries object
+    dt : `float`
+        Sampling value of time series
+    fmin : `float`
+        Minimum frequency for high-pass
+    attenuation : `float`
+        Attenuation value at low-freq cut-off
+    N : `float`
+        Order of butterworth filter
+    """
+
+    # Following butterworth filters as applied to LAL:
+    # See : https://lscsoft.docs.ligo.org/lalsuite/lal/group___butterworth_time_series__c.html
+
+    # Number of samples
+    Ns = len(time_series)
+    fs = 1./dt                # Sampling frequency
+    a1 = attenuation          # Attenuation at the low-freq cut-off
+
+
+    w1 = np.tan(np.pi * fmin * dt)                # Transformed frequency variable at f_min
+    wc = w1 * (1.0 / a1**0.5 - 1)**(1.0/(2.0*N))  # Cut-off freq. from attenuation
+    fc = fs * np.arctan(wc) / np.pi               # For use in butterworth filter
+
+    # Construct the filter and then forward - backward filter the time-series
+    sos = butter(N, fc, btype='highpass', output='sos', fs=fs)
+    output = sosfiltfilt(sos, time_series)
+
+    output = TimeSeries(output, t0=time_series.epoch, dt=time_series.dt)
+    return output
+
+
+
+def time_array_condition_stage1(hp, hc, dt, t_extra, fmin):
+    """
+    Stage 1 of time-series conditioning - add taper and high-pass the time-series
+
+    Parameters
+    ----------
+    hp : `TimeSeries`
+        GwPy TimeSeries object
+    hc : `TimeSeries`
+        GwPy TimeSeries object
+    dt : `float`
+        Sampling value of time series
+    t_extra : `float`
+        Initial extra time for conditioning
+    fmin : `float`
+        Minimum frequency for high-pass
+    """
+
+    # Following XLALSimInspiralTDConditionStage1
+
+    # Generate the cos taper
+    Ntaper = np.round(t_extra/dt)
+    taper_array = np.arange(Ntaper)
+    w = 0.5 - 0.5*np.cos(taper_array*np.pi/Ntaper)
+    w_ones = np.ones(len(hp))
+    w_ones[:int(Ntaper)] *= w
+    hp *= w_ones
+    hc *= w_ones
+
+    # High pass filter the waveform.
+    hp = high_pass_time_series(hp, dt, fmin, 0.99, 8.)
+    hc = high_pass_time_series(hc, dt, fmin, 0.99, 8.)
+
+    # Remove trailing zeroes from array
+    np.trim_zeros(hp, trim='b')
+    np.trim_zeros(hc, trim='b')
+
+    return hp, hc
+
+
+def time_array_condition_stage2(hp, hc, dt, fmin, fmax):
+    """
+    Stage 2 of time-series conditioning - taper end of waveform based off maximum frequency
+
+    Parameters
+    ----------
+    hp : `TimeSeries`
+        GwPy TimeSeries object
+    hc : `TimeSeries`
+        GwPy TimeSeries object
+    dt : `float`
+        Sampling value of time series
+    fmin : `float`
+        Minimum frequency for high-pass
+    fmax : `float`
+        Minimum frequency for high-pass
+
+    """
+
+
+    # Following XLALSimInspiralTDConditionStage2
+    min_taper_samples = 4.
+    if len(hp)<2*min_taper_samples:
+        warnings.warn("Current waveform has less than %i samples: No Final tapering will be applied"%(2*min_taper_samples))
+        return 0
+
+    # taper end of waveform: 1 cycle at f_max; at least min_taper_samples
+    # note: this tapering is done so the waveform goes to zero at the next
+    # point beyond the end of the data
+    ntaper = int(np.round(1./(fmax*dt)))
+    ntaper = np.max([ntaper, min_taper_samples])
+
+    # Taper end of waveform
+    taper_array = np.arange(1, ntaper)
+    w = 0.5 - 0.5*np.cos(taper_array*np.pi/ntaper)
+    Nsize = len(hp)
+    w_ones = np.ones(Nsize)
+    w_ones[int(Nsize-ntaper+1):] *= w[::-1]
+    hp *= w_ones
+    hc *= w_ones
+
+
+    # Taper off one cycle at low frequency
+    ntaper = np.round(1./(fmin*dt))
+    ntaper = np.max([ntaper, min_taper_samples])
+
+    # Taper end of waveform
+    taper_array = np.arange(ntaper)
+    w = 0.5 - 0.5*np.cos(taper_array*np.pi/ntaper)
+    w_ones = np.ones(Nsize)
+    w_ones[:int(ntaper)] *= w
+    hp *= w_ones
+    hc *= w_ones
+
+    return hp, hc
+
+def resize_gwpy_timeseries(hp, start_id, new_length):
+    """
+    Resize a given gwpy TimeSeries which has a given length and starts at a point specified by start_id. If start_id
+    is negative, the timeseries will be padded on the left with that amount.
+
+    Parameters
+    ----------
+    hp : gwpy.TimeSeries
+       TimeSeries that needs to be resized
+
+    start_id : int
+       If positive, index at which TimeSeries will now start from. If negative, TimeSeries will be zero padded with
+       that length on the left.
+
+    new_length : int
+        Final length of output array. This will be done by clippling the end of the TimeSeries, if new_length is
+        larger than len(hp[start_id:]); otherwise zero_pad on right
+
+    Returns
+    -------
+    hp : gwpy.TimeSeries
+        Resized gwpy.TimeSeries object.
+
+    """
+    # Resize gwpy time series by prpending the array with zeros
+    # and then adjust the epoch accordingly
+    dt = hp.dt.value
+
+    # Do the left padding / cutting
+    if start_id < 0:
+        zeros = np.zeros(int(abs(start_id)))
+        hp = np.concatenate([zeros, hp])
+    elif start_id>=0:
+        hp = hp[int(start_id):]
+
+
+    # Right padding / cutting
+    end_id = int(len(hp) - new_length)
+    if end_id < 0 :
+        zeros = np.zeros(int(abs(end_id)))
+        hp = np.concatenate([hp, zeros])
+    elif end_id>0:
+        hp = hp[:-end_id]
+
+    fin_length = len(hp)
+    times_new = np.arange(0, new_length)*dt*u.s
+    times_new = times_new - times_new[np.argmax(hp)]
+    hp_out = hp
+    hp_out.times = times_new
+
+    return hp_out

lalsimulation/gwsignal/core/errors.py

@@ -0,0 +1,136 @@
+import lal
+from functools import wraps
+from astropy import units as u
+
+
+##############################################################################################################
+# Mapping between LAL Errors and Python
+##############################################################################################################
+
+def mapexception(func):
+    """
+    Wrapper to map LAL erros to Python errors
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        exception = None
+        try:
+            return func(*args, **kwargs)
+        except RuntimeError as e:
+            lalerr = lal.GetBaseErrno()
+            exception = exceptionmap[lalerr] if lalerr in exceptionmap else e
+            raise exception from None
+    return wrapper
+
+# Map of errors raised by LAL to Python errors
+exceptionmap = {
+    lal.ENOENT:     FileNotFoundError("No such file or directory"),
+    lal.EIO:        OSError("I/O Error"),
+    lal.ENOMEM:     MemoryError("Memory Allocation Error"),
+    lal.EFAULT:     ValueError("Invalid pointer"),
+    lal.EINVAL:     ValueError("Invalid Argument"),
+    lal.EDOM:       ValueError("Input domain error"),
+    lal.ERANGE:     ArithmeticError("Output range error"),
+    lal.ENOSYS:     NotImplementedError("Function not implemented"),
+    lal.EFAILED:    RuntimeError("Generic Failure"),
+    lal.EBADLEN:    ValueError("Inconsistent or invalid length"),
+    lal.ESIZE:      ValueError("Wrong Size"),
+    lal.EDIMS:      ValueError("Wrong dimensions"),
+    lal.ETYPE:      TypeError("Wrong or unknown type"),
+    lal.ETIME:      ValueError("Invalid time"),
+    lal.EFREQ:      ValueError("Invalid frequency"),
+    lal.EUNIT:      u.UnitsError("Invalid units"),
+    lal.ENAME:      ValueError("Wrong name"),
+    lal.EDATA:      ValueError("Invalid data"),
+    lal.ESYS:       SystemError("System Error"),
+    lal.EERR:        RuntimeError("Internal Error"),
+    lal.EFPINVAL:   FloatingPointError("IEEE Invalid floating point operation, eg sqrt(-1), 0/0"),
+    lal.EFPDIV0:    ZeroDivisionError("IEEE Division by zero floating point error"),
+    lal.EFPOVRFLW:  OverflowError("IEEE Floating point overflow error"),
+    lal.EFPUNDFLW:  FloatingPointError("IEEE Floating point underflow error"),
+    lal.EFPINEXCT:  FloatingPointError("IEEE Floating point inexact error"),
+    lal.EMAXITER:   ArithmeticError("Exceeded maximum number of iterations"),
+    lal.EDIVERGE:   ArithmeticError("Series is diverging"),
+    lal.ESING:      ArithmeticError("Apparent singularity detected"),
+    lal.ETOL:       ArithmeticError("Failed to reach specified tolerance"),
+    lal.ELOSS:      ArithmeticError("Loss of accuracy"),
+    lal.EUSR0:      RuntimeError("User defined Error"),
+    lal.EUSR1:      RuntimeError("User defined Error"),
+    lal.EUSR2:      RuntimeError("User defined Error"),
+    lal.EUSR3:      RuntimeError("User defined Error"),
+    lal.EUSR4:      RuntimeError("User defined Error"),
+    lal.EUSR5:      RuntimeError("User defined Error"),
+    lal.EUSR6:      RuntimeError("User defined Error"),
+    lal.EUSR7:      RuntimeError("User defined Error"),
+    lal.EUSR8:      RuntimeError("User defined Error"),
+    lal.EUSR9:      RuntimeError("User defined Error")
+    }
+
+##############################################################################################################
+# Errors callable by GWSignal.
+# Each error should be subclasses from existing python errors, for eg., ValueError, Exception etc.
+##############################################################################################################
+
+class WaveformGenerationError(Exception):
+    """
+    Raise Error when there is an issue with waveform generation.
+
+    Parameters
+    ----------
+        message   : Output message for the error.
+    Returns
+    -------
+        Raises waveform generation error exception
+
+    """
+    def __init__(self, message="Error during waveform generation"):
+        self.message = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f'{self.message}'
+
+
+class DomainError(ValueError):
+    """
+    Raise Error when parameter passes is out of waveform domain
+
+    Parameters
+    ----------
+        parameter : Parameter in question
+        message   : Output message for the error.
+
+    Returns
+    -------
+        Raises domain error exception
+    """
+    def __init__(self, parameter, message="Input parameter out of waveform domain"):
+        self.parameter = parameter
+        self.message = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f'{self.parameter} -> {self.message}'
+
+
+class PathError(FileNotFoundError):
+    """
+    Raise Exception when the needed file is not at the given path
+
+    Parameters
+    ----------
+        file_name : Path to the file in question.
+        message   : Output message for the error.
+
+    Returns
+    -------
+        Raises File not found at given path error excetion.
+
+    """
+    def __init__(self, file_path, message="File not found at "):
+        self.file_path = file_path
+        self.message = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f'{self.message} -> {self.file_path}'

lalsimulation/gwsignal/core/gw.py

@@ -0,0 +1,206 @@
+from astropy.coordinates import Angle, SkyCoord
+from astropy.time import Time
+from astropy import units as u
+from typing import Dict, NamedTuple, Union
+from gwpy.timeseries import TimeSeries
+from gwpy.frequencyseries import FrequencySeries
+import lal
+import lalsimulation as lalsim
+import numpy as np
+import warnings
+
+class GravitationalWavePolarizations(NamedTuple):
+    hp: Union[TimeSeries, FrequencySeries]
+    hc: Union[TimeSeries, FrequencySeries]
+    """
+    GravitationalWavePolarizations class that takes hp,hc GwPy Time/FrequencySeries objects as inputs. Provides method to compute
+    zero noise strain given a detector, sky-position, polarization and time of arrival values.
+    Parameters
+    ----------
+    hp, hc : GwPy `TimeSeries` or `FrequencySeries` objects
+    """
+    def domain(self):
+        if isinstance(self.hp, TimeSeries) and isinstance(self.hc, TimeSeries):
+            return 'time'
+        elif isinstance(self.hp, FrequencySeries) and isinstance(self.hc, FrequencySeries):
+            return 'frequency'
+        else:
+            return 'mixed'
+
+    def strain(self, det, ra, dec, psi, tgps):
+        """
+        Compute the detector strain in zero-noise
+
+        Parameters
+        ----------
+        det : `str`
+            Name of the detector, for eg: 'H1' or 'L1'
+        ra : `~astropy.units.Quantity`
+            Right-ascension of the binary in units of rad
+        dec : `~astropy.units.Quantity`
+            Declination of the binary in units of rad
+        psi : `~astropy.units.Quantity`
+            Polarization in units of rad
+        tgps : `float`, `~astropy.units.Quantity`
+            GPS Time of time-of-arrival of signal. Either as float or in units of s
+
+        Returns
+        -------
+        h : `TimeSeries` or `FrequencySeries` object
+            Waveform recomposed with detector response (Fp*hp + Fc*hc)
+        """
+
+        # Might change it later; for now keeping it as used by ligo.
+        warnings.warn("This code is currently UNREVIEWED, use with caution!!")
+        pos = SkyCoord(ra = ra, dec = dec)
+        psi = Angle(psi)
+        t = Time(tgps, format='gps', scale='utc')
+
+        if isinstance(det, str):
+            det = lalsim.DetectorPrefixToLALDetector(det)
+
+        if self.domain() == 'time':
+            hp = self.hp.to_lal()
+            hc = self.hc.to_lal()
+            hp.epoch += t.gps
+            hc.epoch += t.gps
+            h = lalsim.SimDetectorStrainREAL8TimeSeries(hp, hc, pos.ra.rad, pos.dec.rad, psi.rad, det)
+            h = TimeSeries.from_lal(h)
+            return h
+
+        elif self.domain() == 'frequency':
+            # WARNING: does not account for Earth rotation or non-LWL effects
+
+            epoch = lal.LIGOTimeGPS(t.gps)
+            dt = lal.TimeDelayFromEarthCenter(det.location, pos.ra.rad, pos.dec.rad, epoch)
+            fp, fc = lal.ComputeDetAMResponse(det.response, pos.ra.rad, pos.dec.rad, psi.rad, lal.GreenwichMeanSiderealTime(epoch))
+
+            # Shouldn't this have a overall time shift due to time-delay from earth center? or does epoch take care of it?
+            # TODO: adress during phase 2 of review
+
+            h = (fp * self.hp + fc * self.hc)
+            h.epoch = Time(t.gps + dt, format='gps', scale='utc')
+            return h
+        else:
+            return ValueError('hp and hc must both be either TimeSeries or FrequencySeries')
+
+    def add_strain(self, data, det, ra, dec, psi, tgps, response=None):
+         """
+         Add strain to some LAL strain as required
+
+         Parameters:
+         data : LAL TimeSeries data
+            Data in which to add detector response strain
+        det : `str`
+            Name of the detector, for eg: 'H1' or 'L1'
+        ra : `~astropy.units.Quantity`
+            Right-ascension of the binary in units of rad
+        dec : `~astropy.units.Quantity`
+            Declination of the binary in units of rad
+        psi : `~astropy.units.Quantity`
+            Polarization in units of rad
+        tgps : `float`, `~astropy.units.Quantity`
+            GPS Time of time-of-arrival of signal. Either as float or in units of s
+        response : `COMPLEX16FrequencySeries`
+            Response function passed to lalsimulation.SimAddInjectionREAL8TimeSeries,
+            transforming strain to detector output units. Use None for unit response.
+
+        Returns
+        -------
+        data : `TimeSeries` object
+            Detector response injected in strain data
+         """
+         warnings.warn("This code is currently UNREVIEWED, use with caution!")
+         h = self.strain(det, ra, dec, psi, tgps)
+         # Adding condition to convert FrequencySeries to TimeSeries if strain is in freq domain
+         if isinstance(h, FrequencySeries):
+             h = h.ifft()
+         h = h.to_lal()
+         data = data.to_lal()
+         lalsim.SimAddInjectionREAL8TimeSeries(data, h, response)
+         data = TimeSeries.from_lal(data)
+         return data
+
+
+class ModePair(NamedTuple):
+    """
+    Returns a named tuple given the l,m values
+    """
+    l: int
+    m: int
+
+
+class SpinWeightedSphericalHarmonicMode(ModePair):
+    """
+    Class to return spin `s` weighted spherical harmonic given ModePair
+    """
+
+    def __new__(cls, s, l, m):
+        new = super().__new__(cls, l, m)
+        if new.l < abs(s):
+            raise ValueError('Require l >= |s|')
+        if abs(new.m) > new.l:
+            raise ValueError('Require |m| <= l')
+        new.s = s
+        return new
+
+    def __call__(self, theta, phi):
+        theta = Angle(theta, u.rad)
+        phi = Angle(phi, u.rad)
+        return lal.SpinWeightedSphericalHarmonic(theta.rad, phi.rad, self.s, self.l, self.m)
+
+
+class TensorSphericalHarmonicMode(SpinWeightedSphericalHarmonicMode):
+    """
+    Class to return spin `-2` weighted spherical harmonic given ModePair
+    """
+    def __new__(cls, l, m):
+        return super().__new__(cls, -2, l, m)
+
+
+class GravitationalWaveModes(Dict[SpinWeightedSphericalHarmonicMode, Union[TimeSeries, FrequencySeries]]):
+    """
+    Class for gravitational wave modes which returns the  waveform recomposed with -2 spin weighted spherical harmonics
+    given a (theta, phi) value
+    """
+    def __call__(self, theta, phi):
+        """
+        Return plus and cross polarizations from the gravitational wave modes.
+
+        Parameters
+        ----------
+        theta : `~astropy.units.Quantity`
+            Theta angle (inclination, theta_jn) in units of rad.
+        phi : `~astropy.units.Quantity`
+            Phi angle (inclination, theta_jn) in units of rad.
+        """
+        if isinstance(theta, float) and isinstance(phi, float):
+            raise TypeError("Theta and phi should be in units of astropy.units.rad, not float")
+        elif theta.unit.is_equivalent(u.rad) and phi.unit.is_equivalent(u.rad):
+            pass
+        else:
+            raise TypeError("Theta and phi should be in units of astropy.units.rad")
+
+
+        hpc = 0.
+        hp = 0.
+        hc = 0.
+        for key, hlm in self.items():
+            if isinstance(key, str):
+                pass
+            elif isinstance(hlm, TimeSeries):
+                mode = TensorSphericalHarmonicMode(int(key[0]), int(key[1]))
+                hpc += mode(theta, phi) * hlm
+                hp = hpc.real
+                hc = -hpc.imag
+
+            elif isinstance(hlm, FrequencySeries):
+                # Recombination of freq domain hp/hc from here :
+                # https://git.ligo.org/lscsoft/lalsuite/-/blob/master/lalsimulation/lib/LALSimInspiral.c#L3477
+                l, m = int(key[0]), int(key[1])
+                mode = TensorSphericalHarmonicMode(l, m)
+                ylm = mode(theta, phi)
+                hp  += 0.5*( ylm * hlm + np.conj(ylm) * np.conj(hlm)[::-1])
+                hc  += 1j*0.5*( ylm * hlm - np.conj(ylm)* np.conj(hlm)[::-1])
+
+        return GravitationalWavePolarizations(hp, hc)

lalsimulation/gwsignal/core/parameter_conventions.py

@@ -0,0 +1,122 @@
+import numpy as np
+from astropy import units as u
+
+# Define lists of allowed mass / spin parameter names
+mass_params_old_ = ["mass1_det", "mass2_det",
+                "total_mass_det", "chirp_mass_det",
+                "mass_difference_det", "reduced_mass_det"]
+
+
+mass_params_ = ["mass1", "mass2","total_mass", "chirp_mass",
+                "mass_difference", "reduced_mass"]
+
+mass_params = mass_params_+["mass_ratio", "sym_mass_ratio"]
+
+spin_params = ["spin1x", "spin1y", "spin1z", "spin2x", "spin2y", "spin2z",
+            "spin1_norm","spin1_tilt","spin1_phi","spin2_norm","spin2_tilt","spin2_phi"]
+
+# Waveform generation parameters
+gen_params = ["deltaT", "deltaF", "f22_start", "f_max", "phi_ref", "f22_ref","lmax"]
+
+#Extrinsic parameters
+extrinsic_params = ["distance", "inclination",  "longAscNodes", "meanPerAno"]
+
+# Condition Parameters
+condition_params = ["condition"]
+
+#Tidal parameters
+tidal_params = ["lambda1","lambda2","TidalOctupolarLambda1","TidalOctupolarLambda2",
+                "TidalHexadecapolarLambda1","TidalHexadecapolarLambda2",
+                "TidalQuadrupolarFMode1","TidalQuadrupolarFMode2",
+                "TidalOctupolarFMode1","TidalOctupolarFMode2"]
+
+#Non GR parameters
+nongr_params = ["phi1","phi2","phi3","phi4","dchi0","dchi1","dchi2","dchi3","dchi4",
+                "dchi5","dchi5l","dchi6","dchi6l","dchi7","dxi1","dxi2","dxi3","dxi4",
+                "dxi5","dxi6","dsigma1","dsigma2","dsigma3","dsigma4","dalpha1",
+                "dalpha2","dalpha3","dalpha4","dalpha5","dbeta1","dbeta2","dbeta3",
+                "alphaPPE","betaPPE","alphaPPE0","betaPPE0","alphaPPE1","betaPPE1",
+                "alphaPPE2","betaPPE2","alphaPPE3","betaPPE3","alphaPPE4","betaPPE4",
+                "alphaPPE5","betaPPE5","alphaPPE6","betaPPE6","alphaPPE7","betaPPE7",
+                "liv","log10lambda_eff","LIV_A_sign","nonGR_alpha","dchikappaS",
+                "dchikappaA","domega220","dtau220","domega210","dtau210","domega330",
+                "dtau330","domega440","dtau440","domega550","dtau550",]
+
+#Other parameters
+
+other_params = ["eccentricity"]
+
+_other_params = ["modes","axis","NumRelData", "approximant"]
+
+#Array-like parameters
+
+arr_params = ["ModeArray", "ModeArrayJframe"]
+
+
+full_parameter_list = np.concatenate([mass_params, spin_params, gen_params,extrinsic_params,
+                                      other_params,_other_params,arr_params,tidal_params,nongr_params, condition_params])
+
+#Units shared between dictionaries
+common_units_dictionary = {
+                        "spin1x" : u.dimensionless_unscaled,
+                        "spin1y" : u.dimensionless_unscaled,
+                        "spin1z" : u.dimensionless_unscaled,
+                        "spin2x" : u.dimensionless_unscaled,
+                        "spin2y" : u.dimensionless_unscaled,
+                        "spin2z" : u.dimensionless_unscaled,
+                        "spin1_norm":u.dimensionless_unscaled,
+                        "spin2_norm":u.dimensionless_unscaled,
+                        "spin1_tilt":u.rad,
+                        "spin2_tilt":u.rad,
+                        "spin1_phi":u.rad,
+                        "spin2_phi":u.rad,
+                        "deltaT":u.s,
+                        "deltaF":u.Hz,
+                        "f_min":u.Hz,
+                        "f22_start":u.Hz,
+                        "f22_ref":u.Hz,
+                        "f_max":u.Hz,
+                        "f_ref":u.Hz,
+                        "phi_ref":u.rad,
+                        "inclination":u.rad,
+                        "eccentricity":u.dimensionless_unscaled,
+                        "longAscNodes":u.rad,
+                        "meanPerAno":u.rad
+                        }
+
+common_units_dictionary = {**common_units_dictionary,**{param:u.dimensionless_unscaled for param in other_params}}
+common_units_dictionary = {**common_units_dictionary,**{param:u.dimensionless_unscaled for param in nongr_params}}
+common_units_dictionary = {**common_units_dictionary,**{param:u.dimensionless_unscaled for param in tidal_params}}
+
+#SI Units Dictionary
+SI_units_dictionary = {**{mass:u.kg for mass in mass_params_},**{mass_dimensionless:u.dimensionless_unscaled for mass_dimensionless in mass_params if mass_dimensionless not in mass_params_}}
+SI_units_dictionary = {**SI_units_dictionary,**{"distance":u.m},**common_units_dictionary}
+
+#Cosmo Units Dictionary
+Cosmo_units_dictionary = {**{mass:u.solMass for mass in mass_params_},**{mass_dimensionless:u.dimensionless_unscaled for mass_dimensionless in mass_params if mass_dimensionless not in mass_params_}}
+Cosmo_units_dictionary = {**Cosmo_units_dictionary,**{"distance":u.pc},**common_units_dictionary}
+
+units_dict  = {"S.I.":SI_units_dictionary,"Cosmo":Cosmo_units_dictionary}
+
+#Non-Dimensional quantities
+
+Non_d_list = np.concatenate([_other_params,arr_params])
+
+default_dict = {"mass1" : 1.*u.solMass,
+              "mass2" : 1.*u.solMass,
+              "spin1x" : 0.*u.dimensionless_unscaled,
+              "spin1y" : 0.*u.dimensionless_unscaled,
+              "spin1z" : 0.*u.dimensionless_unscaled,
+              "spin2x" : 0.*u.dimensionless_unscaled,
+              "spin2y" : 0.*u.dimensionless_unscaled,
+              "spin2z" : 0.*u.dimensionless_unscaled,
+              "deltaT" : 1./64.*u.s,
+              "f22_start" : 20.*u.Hz,
+              "f22_ref" : 20.*u.Hz,
+              "phi_ref": 0.*u.rad,
+              "distance" : 1.*u.Mpc,
+              "inclination" : 0.*u.rad,
+              "eccentricity" : 0.*u.dimensionless_unscaled,
+              "longAscNodes" : 0.*u.rad,
+              "meanPerAno" : 0.*u.rad
+              }