'savefig.dpi': 300
})
#####
f_low = 15.
f_high = 2048.
# True NR parameters
nrs1 = +0.84984534
nrs2 = +0.84976985
nrmc = 29.57934177
nret = 0.22223058
nrmt = nrmc / nret**0.6
nrm1, nrm2 = mchirp_eta_to_mass1_mass2(nrmc, nret)
nrq = nrm1 / eta_mass1_to_mass2(nret, nrm1)
nrwav = UseNRinDA.nr_waveform(
filename=
'/home/prayush/research/cita-papers/SEOBtesting/Paper1/plots/InvestigateSimulations/d11.5-q8.5-sA_0_0_0_sB_0_0_0/rhOverM_CcePITT_Asymptotic_GeometricUnits.h5',
time_length=8)
nrwav.rescale_to_totalmass(nrmt)
nrhp = TimeSeries(nrwav.rescaled_hp, epoch=0)
nrhc = TimeSeries(nrwav.rescaled_hc, epoch=0)
nrh_max_amp_t, _ = nrwav.get_amplitude_peak()
nrwav2 = UseNRinDA.nr_waveform(
filename=
'/home/prayush/research/cita-papers/SEOBtesting/Paper1/plots/InvestigateSimulations/d11.5-q8.5-sA_0_0_0_sB_0_0_0/rhOverM_Asymptotic_GeometricUnits.h5',
time_length=8)
nrwav2.rescale_to_totalmass(nrmt)
mtotal_min = mass1_min + mass2_min
if options.mtotal_max:
mtotal_max = options.mtotal_max
else:
mtotal_max = mass1_max + mass2_max
if options.eta_max:
eta_max = options.eta_max
else:
eta_max = 0.25
if options.eta_min:
eta_min = options.eta_min
else:
eta_min = (mass_max / mass_min) / (1. + (mass_max / mass_min))**2
#
q_min = 10. / eta_mass1_to_mass2(eta_max, 10.)
q_max = 10. / eta_mass1_to_mass2(eta_min, 10.)
print(mtotal_min, mtotal_max)
print(q_min, q_max)
print(mass_min, mass_max)
ecc_min = options.ecc_min
ecc_max = options.ecc_max
anom_min = options.anomaly_min
anom_max = options.anomaly_max
smag_min = 0.
smag_max = 1.0
sxyz_min = -1.0
write_raw_modes_to_HDF5(waves,
subsamp_n=subsamp_n,
modes=write_amp_phase)
else:
write_compressed_modes_to_HDF5(waves)
del waves
waves = {}
if options.verbose and idx % num_write_verbose == 0:
print("Generating wave %d" % (idx + 1))
##
# Generate SEOBNRv3 modes
#
# Sample masses
#q = (uniform() * (q_max - q_min)) + q_min
eta = (uniform() * (eta_max - eta_min)) + eta_min
q = m2 / eta_mass1_to_mass2(eta, m2)
m1 = q * m2
#
# Sample spin A
_t1, _t2, _t3 = uniform(-1, 1), uniform(-1, 1), uniform(-1, 1)
_abst = (_t1**2 + _t2**2 + _t3**2)**0.5
_s1m = uniform(spin_mag_min, spin_mag_max)
s1x = _s1m * (_t1 / _abst)
s1y = _s1m * (_t2 / _abst)
s1z = _s1m * (_t3 / _abst)
if options.aligned_spin:
s1z = uniform(spin1z_min, spin1z_max)
s1x = s1y = 0
# Sample spin B
_t1, _t2, _t3 = uniform(-1, 1), uniform(-1, 1), uniform(-1, 1)
_abst = (_t1**2 + _t2**2 + _t3**2)**0.5
def verify_mass_range_options(opts, parser, nonSpin=False):
"""
Parses the metric calculation options given and verifies that they are
correct.
Parameters
----------
opts : argparse.Values instance
Result of parsing the input options with OptionParser
parser : object
The OptionParser instance.
nonSpin : boolean, optional (default=False)
If this is provided the spin-related options will not be checked.
"""
if not opts.min_mass1:
parser.error("Must supply --min-mass1")
if not opts.min_mass2:
parser.error("Must supply --min-mass2")
if not opts.max_mass1:
parser.error("Must supply --max-mass1")
if not opts.max_mass2:
parser.error("Must supply --max-mass2")
# Mass1 must be the heavier!
if opts.min_mass1 < opts.min_mass2:
parser.error("min-mass1 cannot be less than min-mass2!")
if opts.max_mass1 < opts.max_mass2:
parser.error("max-mass1 cannot be less than max-mass2!")
# If given are min/max total mass/chirp mass possible?
if opts.min_total_mass:
if opts.min_total_mass > opts.max_mass1 + opts.max_mass2:
err_msg = "Supplied minimum total mass %f " %(opts.min_total_mass,)
err_msg += "greater than the sum of the two max component masses "
err_msg += " %f and %f." %(opts.max_mass1,opts.max_mass2)
if opts.max_total_mass:
if opts.max_total_mass < opts.min_mass1 + opts.min_mass2:
err_msg = "Supplied maximum total mass %f " %(opts.max_total_mass,)
err_msg += "smaller than the sum of the two min component masses "
err_msg += " %f and %f." %(opts.min_mass1,opts.min_mass2)
raise ValueError(err_msg)
if opts.max_total_mass and opts.min_total_mass:
if opts.max_total_mass < opts.min_total_mass:
err_msg = "Min total mass must be larger than max total mass."
raise ValueError(err_msg)
# Assign min/max total mass from mass1, mass2 if not specified
if (not opts.min_total_mass) or \
((opts.min_mass1 + opts.min_mass2) > opts.min_total_mass):
opts.min_total_mass = opts.min_mass1 + opts.min_mass2
if (not opts.max_total_mass) or \
((opts.max_mass1 + opts.max_mass2) < opts.max_total_mass):
opts.max_total_mass = opts.max_mass1 + opts.max_mass2
# It is vital that min and max total mass be set correctly.
# This is becasue the heavily-used function get_random_mass will place
# points first in total mass (to some power), and then in eta. If the total
# mass limits are not well known ahead of time it will place unphysical
# points and fail.
# This test is a bit convoluted as we identify the maximum and minimum
# possible total mass from chirp mass and/or eta restrictions.
if opts.min_chirp_mass is not None:
# Need to get the smallest possible min_tot_mass from this chirp mass
# There are 4 possibilities for where the min_tot_mass is found on the
# line of min_chirp_mass that interacts with the component mass limits.
# Either it is found at max_m2, or at min_m1, or it starts on the equal
# mass line within the parameter space, or it doesn't intersect
# at all.
# First let's get the masses at both of these possible points
m1_at_max_m2 = pnutils.mchirp_mass1_to_mass2(opts.min_chirp_mass,
opts.max_mass2)
if m1_at_max_m2 < opts.max_mass2:
# Unphysical, remove
m1_at_max_m2 = -1
m2_at_min_m1 = pnutils.mchirp_mass1_to_mass2(opts.min_chirp_mass,
opts.min_mass1)
if m2_at_min_m1 > opts.min_mass1:
# Unphysical, remove
m2_at_min_m1 = -1
# Get the values on the equal mass line
m1_at_equal_mass, m2_at_equal_mass = pnutils.mchirp_eta_to_mass1_mass2(
opts.min_chirp_mass, 0.25)
# Are any of these possible?
if m1_at_max_m2 <= opts.max_mass1 and m1_at_max_m2 >= opts.min_mass1:
min_tot_mass = opts.max_mass2 + m1_at_max_m2
elif m2_at_min_m1 <= opts.max_mass2 and m2_at_min_m1 >= opts.min_mass2:
min_tot_mass = opts.min_mass1 + m2_at_min_m1
elif m1_at_equal_mass <= opts.max_mass1 and \
m1_at_equal_mass >= opts.min_mass1 and \
m2_at_equal_mass <= opts.max_mass2 and \
m2_at_equal_mass >= opts.min_mass2:
min_tot_mass = m1_at_equal_mass + m2_at_equal_mass
# So either the restriction is low enough to be redundant, or is
# removing all the parameter space
elif m2_at_min_m1 < opts.min_mass2:
# This is the redundant case, ignore
min_tot_mass = opts.min_total_mass
else:
# And this is the bad case
err_msg = "The minimum chirp mass provided is not possible given "
err_msg += "restrictions on component masses."
raise ValueError(err_msg)
# Is there also an eta restriction?
if opts.max_eta:
# Get the value of m1,m2 at max_eta, min_chirp_mass
max_eta_m1, max_eta_m2 = pnutils.mchirp_eta_to_mass1_mass2(
opts.min_chirp_mass, opts.max_eta)
max_eta_min_tot_mass = max_eta_m1 + max_eta_m2
if max_eta_min_tot_mass > min_tot_mass:
# Okay, eta does restrict this further. Still physical?
min_tot_mass = max_eta_min_tot_mass
if max_eta_m1 > opts.max_mass1:
err_msg = "The combination of component mass, chirp "
err_msg += "mass, eta and (possibly) total mass limits "
err_msg += "have precluded all systems."
raise ValueError(err_msg)
# Update min_tot_mass if needed
if min_tot_mass > opts.min_total_mass:
opts.min_total_mass = float(min_tot_mass)
# Then need to do max_chirp_mass and min_eta
if opts.max_chirp_mass is not None:
# Need to get the largest possible maxn_tot_mass from this chirp mass
# There are 3 possibilities for where the max_tot_mass is found on the
# line of max_chirp_mass that interacts with the component mass limits.
# Either it is found at min_m2, or at max_m1, or it doesn't intersect
# at all.
# First let's get the masses at both of these possible points
m1_at_min_m2 = pnutils.mchirp_mass1_to_mass2(opts.max_chirp_mass,
opts.min_mass2)
m2_at_max_m1 = pnutils.mchirp_mass1_to_mass2(opts.max_chirp_mass,
opts.max_mass1)
# Are either of these possible?
if m1_at_min_m2 <= opts.max_mass1 and m1_at_min_m2 >= opts.min_mass1:
max_tot_mass = opts.min_mass2 + m1_at_min_m2
elif m2_at_max_m1 <= opts.max_mass2 and m2_at_max_m1 >= opts.min_mass2:
max_tot_mass = opts.max_mass1 + m2_at_max_m1
# So either the restriction is low enough to be redundant, or is
# removing all the paramter space
elif m2_at_max_m1 > opts.max_mass2:
# This is the redundant case, ignore
max_tot_mass = opts.max_total_mass
else:
# And this is the bad case
err_msg = "The maximum chirp mass provided is not possible given "
err_msg += "restrictions on component masses."
raise ValueError(err_msg)
# Is there also an eta restriction?
if opts.min_eta:
# Get the value of m1,m2 at max_eta, min_chirp_mass
min_eta_m1, min_eta_m2 = pnutils.mchirp_eta_to_mass1_mass2(
opts.max_chirp_mass, opts.min_eta)
min_eta_max_tot_mass = min_eta_m1 + min_eta_m2
if min_eta_max_tot_mass < max_tot_mass:
# Okay, eta does restrict this further. Still physical?
max_tot_mass = min_eta_max_tot_mass
if min_eta_m1 < opts.min_mass1:
err_msg = "The combination of component mass, chirp "
err_msg += "mass, eta and (possibly) total mass limits "
err_msg += "have precluded all systems."
raise ValueError(err_msg)
# Update min_tot_mass if needed
if max_tot_mass < opts.max_total_mass:
opts.max_total_mass = float(max_tot_mass)
# Need to check max_eta alone for minimum and maximum mass
if opts.max_eta:
# Similar to above except this can affect both the minimum and maximum
# total mass. Need to identify where the line of max_eta intersects
# the parameter space, and if it affects mass restrictions.
m1_at_min_m2 = pnutils.eta_mass1_to_mass2(opts.max_eta, opts.min_mass2,
return_mass_heavier=True)
m2_at_min_m1 = pnutils.eta_mass1_to_mass2(opts.max_eta, opts.min_mass1,
return_mass_heavier=False)
m1_at_max_m2 = pnutils.eta_mass1_to_mass2(opts.max_eta, opts.max_mass2,
return_mass_heavier=True)
m2_at_max_m1 = pnutils.eta_mass1_to_mass2(opts.max_eta, opts.max_mass1,
return_mass_heavier=False)
# Check for restrictions on the minimum total mass
# Are either of these possible?
if m1_at_min_m2 <= opts.max_mass1 and m1_at_min_m2 >= opts.min_mass1:
min_tot_mass = opts.min_mass2 + m1_at_min_m2
elif m2_at_min_m1 <= opts.max_mass2 and m2_at_min_m1 >= opts.min_mass2:
# This case doesn't change the minimal total mass
min_tot_mass = opts.min_total_mass
# So either the restriction is low enough to be redundant, or is
# removing all the paramter space
elif m2_at_min_m1 > opts.max_mass2:
# This is the redundant case, ignore
min_tot_mass = opts.min_total_mass
else:
# And this is the bad case
err_msg = "The maximum eta provided is not possible given "
err_msg += "restrictions on component masses."
raise ValueError(err_msg)
# Update min_tot_mass if needed
if min_tot_mass > opts.min_total_mass:
opts.min_total_mass = float(min_tot_mass)
# Check for restrictions on the maximum total mass
# Are either of these possible?
if m2_at_max_m1 <= opts.max_mass2 and m2_at_max_m1 >= opts.min_mass2:
max_tot_mass = opts.max_mass1 + m2_at_max_m1
elif m1_at_max_m2 <= opts.max_mass1 and m1_at_max_m2 >= opts.min_mass1:
# This case doesn't change the maximal total mass
max_tot_mass = opts.max_total_mass
# So either the restriction is low enough to be redundant, or is
# removing all the paramter space, the latter case is already tested
else:
# This is the redundant case, ignore
max_tot_mass = opts.max_total_mass
if max_tot_mass < opts.max_total_mass:
opts.max_total_mass = float(max_tot_mass)
# Need to check min_eta alone for maximum and minimum total mass
if opts.min_eta:
# Same as max_eta.
# Need to identify where the line of max_eta intersects
# the parameter space, and if it affects mass restrictions.
m1_at_min_m2 = pnutils.eta_mass1_to_mass2(opts.min_eta, opts.min_mass2,
return_mass_heavier=True)
m2_at_min_m1 = pnutils.eta_mass1_to_mass2(opts.min_eta, opts.min_mass1,
return_mass_heavier=False)
m1_at_max_m2 = pnutils.eta_mass1_to_mass2(opts.min_eta, opts.max_mass2,
return_mass_heavier=True)
m2_at_max_m1 = pnutils.eta_mass1_to_mass2(opts.min_eta, opts.max_mass1,
return_mass_heavier=False)
# Check for restrictions on the maximum total mass
# Are either of these possible?
if m1_at_max_m2 <= opts.max_mass1 and m1_at_max_m2 >= opts.min_mass1:
max_tot_mass = opts.max_mass2 + m1_at_max_m2
elif m2_at_max_m1 <= opts.max_mass2 and m2_at_max_m1 >= opts.min_mass2:
# This case doesn't affect the maximum total mass
max_tot_mass = opts.max_total_mass
# So either the restriction is low enough to be redundant, or is
# removing all the paramter space
elif m2_at_max_m1 < opts.min_mass2:
# This is the redundant case, ignore
max_tot_mass = opts.max_total_mass
else:
# And this is the bad case
err_msg = "The minimum eta provided is not possible given "
err_msg += "restrictions on component masses."
raise ValueError(err_msg)
# Update min_tot_mass if needed
if max_tot_mass < opts.max_total_mass:
opts.max_total_mass = float(max_tot_mass)
# Check for restrictions on the minimum total mass
# Are either of these possible?
if m2_at_min_m1 <= opts.max_mass2 and m2_at_min_m1 >= opts.min_mass2:
min_tot_mass = opts.min_mass1 + m2_at_min_m1
elif m1_at_min_m2 <= opts.max_mass1 and m1_at_min_m2 >= opts.min_mass1:
# This case doesn't change the maximal total mass
min_tot_mass = opts.min_total_mass
# So either the restriction is low enough to be redundant, or is
# removing all the paramter space, which is tested above
else:
# This is the redundant case, ignore
min_tot_mass = opts.min_total_mass
if min_tot_mass > opts.min_total_mass:
opts.min_total_mass = float(min_tot_mass)
if opts.max_total_mass < opts.min_total_mass:
err_msg = "After including restrictions on chirp mass, component mass, "
err_msg += "eta and total mass, no physical systems are possible."
raise ValueError(err_msg)
if opts.max_eta and opts.min_eta:
if opts.max_eta < opts.min_eta:
parser.error("--max-eta must be larger than --min-eta.")
if nonSpin:
return
if opts.max_ns_spin_mag is None:
if opts.nsbh_flag:
parser.error("Must supply --max_ns_spin_mag with --nsbh-flag")
# Can ignore this if no NSs will be generated
elif opts.min_mass2 < (opts.ns_bh_boundary_mass or
massRangeParameters.default_nsbh_boundary_mass):
parser.error("Must supply --max-ns-spin-mag for the chosen"
" value of --min_mass2")
else:
opts.max_ns_spin_mag = opts.max_bh_spin_mag
if opts.max_bh_spin_mag is None:
if opts.nsbh_flag:
parser.error("Must supply --max_bh_spin_mag with --nsbh-flag")
# Can ignore this if no BHs will be generated
if opts.max_mass1 >= (opts.ns_bh_boundary_mass or
massRangeParameters.default_nsbh_boundary_mass):
parser.error("Must supply --max-bh-spin-mag for the chosen"
" value of --max_mass1")
else:
opts.max_bh_spin_mag = opts.max_ns_spin_mag