def append_lambda_to_xml(file_name, eos_name, file_name_out=None): param_list = lalsimutils.xml_to_ChooseWaveformParams_array(file_name) from gwemlightcurves.KNModels import table eos, eos_fam = table.get_lalsim_eos(eos_name) print("Writing to xml:") print("Event m1 m2 lambda1 lambda2") for i in np.arange(len(param_list)): m1 = param_list[i].m1 m2 = param_list[i].m2 param_list[i].lambda1 = calc_lambda_from_m(m1, eos_fam) param_list[i].lambda2 = calc_lambda_from_m(m2, eos_fam) print(i, "[", param_list[i].m1 / lal.MSUN_SI, param_list[i].m2 / lal.MSUN_SI, param_list[i].lambda1, param_list[i].lambda2, "]") if file_name_out is None: file_name_out = file_name.replace(".xml.gz", "") + "_" + eos_name lalsimutils.ChooseWaveformParams_array_to_xml(param_list, fname=file_name_out)
# # USAGE # python util_TestXMLParameterStorage.py ; ligolw_print -t sim_inspiral -c alpha5 output.xml.gz import RIFT.lalsimutils as lalsimutils import numpy as np import lal import argparse parser = argparse.ArgumentParser() parser.add_argument("--output-file", default="output") opts = parser.parse_args() P_list_in = [] for i in np.arange(5): P_list_in.append(lalsimutils.ChooseWaveformParams(m1=lal.MSUN_SI * (i + 1))) P_list_in[-1].lambda1 = 3 * i + 1 P_list_in[-1].lambda2 = 3 * i + 2 P_list_in[-1].approx = 3 * i + 2 P_list_in[-1].print_params() lalsimutils.ChooseWaveformParams_array_to_xml(P_list_in, fname=opts.output_file) print(" ------ ") P_list_out = lalsimutils.xml_to_ChooseWaveformParams_array(opts.output_file + ".xml.gz") for P in P_list_out: P.print_params()
# Loop over everything, and find best point best_fits_here = [] closest_so_far_d = 1e10 closest_so_far = () for group in glist: # if opts.verbose: # print " Checking ", group res = nr_closest_to(P, dist_here, group) # pair of values returned if res[1] < closest_so_far_d: closest_so_far = (group, res[0]) closest_so_far_d = res[1] if opts.verbose: print(" NEW CLOSEST SIMULATION FOR THIS POSTERIOR POINT", closest_so_far, closest_so_far_d) if closest_so_far_d > opts.cut: P_list_retain.append(P) dist_list_retain.append(closest_so_far_d) else: print( " Skipping point shown below as too close to simulations because the closest has distance", closest_so_far_d, " which is less than ", opts.cut) P.print_params() lalsimutils.ChooseWaveformParams_array_to_xml(P_list_retain, fname=opts.fname_output, fref=P.fref) np.savetxt(opts.fname_output + "_distances.dat", np.array([dist_list_retain]).T)
val = val/ lal.MSUN_SI if val < downselect_dict[param][0] or val > downselect_dict[param][1]: include_item =False if include_item: P_out.append(P) # Randomize parameters that have been requested to be randomized # - note there is NO SANITY CHECKING if you do this # - target: tidal parameters, more efficiently hammer on low-tide corner if necessary if len(opts.random_parameter) >0: random_ranges = {} for indx in np.arange(len(opts.random_parameter)): param = opts.random_parameter[indx] random_ranges[param] = np.array(eval(opts.random_parameter_range[indx])) for P in P_out: for param in opts.random_parameter: val = np.random.uniform( random_ranges[param][0], random_ranges[param][1]) if param in ['mc','m1','m2','mtot']: val = val* lal.MSUN_SI P.assign_param(param,val) # Export lalsimutils.ChooseWaveformParams_array_to_xml(P_out,fname=opts.inj_file_out,fref=P.fref)
P.m1 = event_dict["m1"]*lal.MSUN_SI; P.m2=event_dict["m2"]*lal.MSUN_SI; P.s1z = event_dict["s1z"]; P.s2z = event_dict["s2z"] # Load in ini file to select relevant fmin, fref [latter usually unused] config = ConfigParser.ConfigParser() config.read(opts.use_ini) fmin_vals ={} fmin_fiducial = -1 ifo_list = eval(config.get('analysis','ifos')) for ifo in ifo_list: fmin_vals[ifo] = unsafe_config_get(config,['lalinference','flow'])[ifo] fmin_fiducial = fmin_vals[ifo] event_dict["IFOs"] = ifo_list print( "IFO list from ini ", ifo_list) P.fmin = fmin_fiducial P.fref = unsafe_config_get(config,['engine','fref']) # Write 'target_params.xml.gz' file lalsimutils.ChooseWaveformParams_array_to_xml([P], "target_params") helper_psd_args = '' srate=4096 # default, built into helper, unwise to go lower, LI will almost never do higher if opts.make_bw_psds: helper_psd_args += " --assume-fiducial-psd-files --fmax " + str(srate/2-1) # Create provenance info : we want run to be reproducible if True: os.mkdir("reproducibility") # Write this script and its arguments import shutil, json # thisfile = os.path.realpath(__file__)
if otps.verbose: print(downselect_dict) # downselection procedure: fix units so I can downselect on mass parameters for p in ['mc', 'm1', 'm2', 'mtot']: if p in downselect_dict.keys(): downselect_dict[p] = np.array(downselect_dict[p], dtype=np.float64) downselect_dict[p] *= lal.MSUN_SI # add back units P_list_in = lalsimutils.xml_to_ChooseWaveformParams_array(opts.fname) P_inj = lalsimutils.xml_to_ChooseWaveformParams_array(opts.fname)[opts.event] param_ref_vals = {} for param in downselect_dict.keys(): param_ref_vals[param] = P_inj.extract_param(param) P_list = [] for P in P_list_in: include_item = True for param in downselect_dict.keys(): param_here = P.extract_param(param) if not (param_here > downselect_dict[param][0] and param_here < downselect_dict[param][1]): include_item = False continue if include_item: P_list.append(P) lalsimutils.ChooseWaveformParams_array_to_xml( P_list, opts.fname_out.replace(".xml.gz", "")) # don't write the postfix twice
if fstart_NR < P.fmin or not opts.require_fmin_above_NR_start: # only add mass point if a valid mass choice, given NR starting frequency. grid = grid + [newline] print(" ---- DONE WITH GRID SETUP --- ") print(" grid points # = ", len(grid)) grid_out, P_list = evaluate_overlap_on_grid(hfBase, param_names, grid) if len(grid_out) == 0: print(" No points survive....") ### ### Optional: Write grid to XML file (ONLY if using cutoff option) ### lalsimutils.ChooseWaveformParams_array_to_xml(P_list, fname=opts.fname, fref=P.fref) ### ### Write output to text file: p1 p2 p3 ... overlap, only including named params ### headline = ' '.join(param_names + ['ip']) if int( np.version.short_version.split('.')[1] ) >= 7: # http://docs.scipy.org/doc/numpy/reference/generated/numpy.savetxt.html np.savetxt(opts.fname + ".dat", grid_out, header=headline) else: np.savetxt(opts.fname + ".dat", grid_out) # ### ### Optional: Scatterplot
else: full_spoke[key] = [[mtot, lnLhere, sigma_here]] ### ### Create ILE job to follow it up ### # Create xml file with correct mass and NR parameters m1, m2 = best_matches_masses[(opts.nr_group, opts.nr_param)] wfP = nrwf.WaveformModeCatalog(opts.nr_group, opts.nr_param, metadata_only=True) wfP.P.assign_param('mtot', (m1 + m2) * lal.MSUN_SI) wfP.P.print_params() P_list = [wfP.P] lalsimutils.ChooseWaveformParams_array_to_xml( P_list, fname="single-pt") # choice of fref irrelevant with open(str(opts.run_dir) + "/command-single.sh", 'r') as runfile: rf = str(runfile.readlines()[1]) rf = rf.replace('create_event_dag_via_grid', 'integrate_likelihood_extrinsic') rf += " --maximize-only" rf = rf.split() rf[rf.index("--sim-xml") + 1] = "single-pt.xml.gz" rf[rf.index("--output-file") + 1] = "ILE-single.xml.gz" if "--n-copies" in rf: rf[rf.index("--n-copies") + 1] = "" if "--n-max" in rf: rf[rf.index("--n-max") + 1] = " 10000 " rf_submit = ' '.join(rf) if "--n-copies" in rf:
# Loop, removing duplicates sequentially P_list_out = [] n = len(P_list) indxList = np.arange(n - 1) print(indxList) param_names = opts.compare_parameter for indx in indxList: print(" Testing ", indx, "out of ", n) do_we_add_it = True for indx2 in np.arange(indx + 1, n): are_all_parameters_the_same = True for param in param_names: param_val = P_list[indx].extract_param(param) param_val2 = P_list[indx2].extract_param(param) if rosDebug: print(param, param_val, param_val2) if not (param_val == param_val2): are_all_parameters_the_same = False # conclude test for this index if are_all_parameters_the_same: do_we_add_it = False if rosDebug: print(" Match between ", indx, " and ", indx2) if do_we_add_it: P_list_out = P_list_out + [P_list[indx]] # Write output print(" Saving ", len(P_list_out)) lalsimutils.ChooseWaveformParams_array_to_xml( P_list_out, fname=opts.output_file) # note xml.gz is appended
nCount +=1 # Cross-look-up try: P_sample = sd_P[spoke_id][0] # if this fails P_sample.waveFlags =None P_sample.nonGRparams = None P_sample.print_params() except: nFailures +=1 print(" Failed cross lookup for ", spoke_id, nCount, " failure count = ", nFailures) continue # Clean sd_here =spokes.CleanSpokeEntries(sd_dat[spoke_id]) # Refine: find mass values code, mvals_new = spokes.Refine(sd_here[:,0], sd_here[:,1]) if mvals_new is None: continue # Failed mvals_new = np.array(mvals_new) mvals_new = mvals_new[ mvals_new > 0] # eliminate negtive masses! print(key, len(sd_here), code, mvals_new) if code == 'refined' or code =='extended': for m in mvals_new: print(m) P = P_sample.manual_copy() P.tref = P_sample.tref # BE VERY CAREFUL: The structure swig-bound to store time is NOT a float, and requires careful memory management P.assign_param('mtot',m*lal.MSUN_SI) P_list.append(P) if P_list: lalsimutils.ChooseWaveformParams_array_to_xml(P_list, opts.save_refinement_fname)
param = parameters_to_center[pIndex] val = P_ref_list[indx].extract_param(param) dat_ref[indx, pIndex] = val P_out = [] dx = np.mean(dat, axis=0) - np.mean(dat_ref, axis=0) dat_out = [] for indx in np.arange(len(P_list)): bInclude = True vec = np.zeros(len(parameters_to_center)) for pIndex in np.arange(len(parameters_to_center)): param = parameters_to_center[pIndex] vec[pIndex] = valNew = dat[indx, pIndex] - dx[pIndex] if param == 'eta': if valNew > 0.25 or valNew < 0.001: bInclude = False continue if param == 's1z' or param == 's2z': if valNew > 1 or valNew < -1: bInclude = False continue P_list[indx].assign_param(param, valNew) P_list[indx].tref = float(P_list[indx].tref) P_out.append(P_list[indx]) dat_out.append(vec) print(" Recentering report: last two should be equal : ", np.mean(dat, axis=0), np.mean(dat_ref, axis=0), np.mean(dat_out, axis=0)) lalsimutils.ChooseWaveformParams_array_to_xml(P_out, "shifted.xml.gz")