lalsuite 7.26.2.dev20260106__cp314-cp314-macosx_13_0_x86_64.whl

lalsuite-7.26.2.dev20260106.data/scripts/cbcBayesCombinePTMCMCh5s

@@ -0,0 +1,100 @@
+#!python
+# -*- coding: utf-8 -*-
+#
+#       cbcBayesCombinePTMCMCh5s.py
+#
+#       Copyright 2016
+#       Ben Farr <benjamin.farr@ligo.org>
+#
+#       Combine multiple HDF5s from the same parallel-tempered run into a common hdf5
+#
+#       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 2 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.
+
+from optparse import OptionParser
+
+import h5py
+
+from lalinference import git_version
+__author__="Ben Farr <benjamin.farr@ligo.org>"
+__version__= "git id %s"%git_version.id
+__date__= git_version.date
+
+USAGE='''%prog [options] PTMCMC_datafile.hdf5 [PTMCMC_datafile2.hdf5 ...]
+Combine chains from a parallel-tempered MCMC run spread across several HDF5 files.
+'''
+
+if __name__ == '__main__':
+    parser = OptionParser(USAGE)
+    parser.add_option(
+        '-o', '--outfile', type='string', default=None,
+        help='Output file for posterior samples. If None, file containing T=1 chain will be used', metavar='combined_chains.hdf5')
+    opts, args = parser.parse_args()
+
+    datafiles = args
+
+    group_id = '/lalinference/lalinference_mcmc'
+
+    outfile = opts.outfile
+
+    # find the file containing the coldest chain (i.e. a posterior_samples group)
+    for datafile in datafiles:
+        rootfile = datafile
+        possible_root = h5py.File(datafile, 'a')
+        if group_id + '/posterior_samples' in possible_root:
+            possible_root.close()
+            break
+        else:
+            possible_root.close()
+
+    if outfile:
+        if outfile != rootfile:
+            try:
+                outp = h5py.File(outfile, 'w-')
+
+                # Copy contents of the root hdf5 to preserve metadata
+                with h5py.File(rootfile, 'r') as inp:
+                    for group in inp.keys():
+                       inp.copy(group, outp['/'])
+
+            except IOError:
+                assert outfile in datafiles, \
+                    "Trying to write to an existing file that isn't being explicitly combined"
+
+                outp = h5py.File(outfile, 'a')
+
+                # Copy root over now for consistent behavior
+                with h5py.File(rootfile, 'r') as inp:
+                    for chain in inp[group_id].keys():
+                        chain_id = group_id + '/' + chain
+                        inp.copy(chain_id, outp[group_id])
+
+            # make sure the target group exists
+            try:
+                outp.create_group(group_id)
+            except ValueError:
+                pass
+    else:
+        outfile = rootfile
+
+    for datafile in datafiles:
+        if datafile == outfile:
+            continue
+        with h5py.File(datafile, 'r') as inp:
+            for chain in inp[group_id].keys():
+                chain_id = group_id + '/' + chain
+                if chain_id not in outp:
+                   inp.copy(chain_id, outp[group_id])
+    outp.close()

lalsuite-7.26.2.dev20260106.data/scripts/cbcBayesCombinePosteriors

@@ -0,0 +1,235 @@
+#!python
+# -*- coding: utf-8 -*-
+#       cbcBayesCombinePosteriors.py
+#
+#       Copyright 2016
+#       Christopher Berry <christopher.berry@ligo.org>
+#       Sebastian Gaebel <sebastian.gaebel@ligo.org>
+#
+#       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 2 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 is used for combining posterior samples together.
+"""
+
+#Import standard things
+import argparse
+try:
+    from lalinference import LALInferenceHDF5PosteriorSamplesDatasetName as posterior_grp_name
+except:
+    posterior_grp_name = "posterior_samples"
+from collections import defaultdict
+import h5py
+import numpy as np
+
+#Set-up commands
+parser = argparse.ArgumentParser(description="Combine some posterior samples.")
+parser.add_argument("-o", "--output", dest="outfilename", default="combined_posterior",
+                  help="Write combined posterior to OUTFILE", metavar="OUTFILE")
+parser.add_argument("-p", "--pos", action="append", dest="infilename",
+                  help="Combine posteriors from INFILE", metavar="INFILE", required=True)
+parser.add_argument("-a", "--all", dest="all",
+                  action="store_true", default=False,
+                  help="Use all posterior samples (do not weight)")
+parser.add_argument("-w", "--weight", action="append", default=[], dest="weightings",
+                  help="Weighting for posteriors", type=float)
+shuffleGroup = parser.add_mutually_exclusive_group()
+shuffleGroup.add_argument("-s", "--shuffle",
+                  action="store_true", dest="shuffle", default=True,
+                  help="Randomise posterior samples before combination [Default]")
+shuffleGroup.add_argument("-ns", "--no-shuffle",
+                  action="store_false", dest="shuffle",
+                  help="Do not randomise posterior samples before combination")
+parser.add_argument("-m", "--mix", dest="mix",
+                  action="store_true", default=False,
+                  help="Randomise combined samples")
+fileGroup = parser.add_mutually_exclusive_group()
+fileGroup.add_argument("-t", "--text",
+                  action="store_false", dest="hdf", default=False,
+                  help="Use ASCII posterior (.dat) files [Default]")
+fileGroup.add_argument("-f", "--hdf",
+                  action="store_true", dest="hdf",
+                  help="Use HDF5 posterior files")
+
+
+args = parser.parse_args()
+
+#Count arguments
+nPos = np.size(args.infilename)
+nWeight = np.size(args.weightings)
+
+print(args.weightings)
+
+#Check sensible combination of arguments
+if (nWeight != 0):
+    if args.all:
+        print("You cannot use all posterior samples and weight them!")
+        exit(1)
+
+    if (nWeight != nPos):
+        print("Please either specify a weight for each posterior file or none")
+        exit(1)
+else:
+    args.weightings = [1.0] * nPos
+
+#Specify combination ID
+combineID = "combined"
+if args.all:
+    combineID = combineID+"_all"
+else:
+    combineID = combineID+"_weight_"+'_'.join(map(str, args.weightings))
+
+if args.shuffle:
+    combineID = combineID+"_shuffle"
+else:
+    combineID = combineID+"_noshuffle"
+
+if args.mix:
+    combineID = combineID+"_mixed"
+
+print("Combined ID:", combineID)
+
+#Initiate lists to hold data
+samples = []
+paramsList = []
+sizeList = []
+metadata = {"lalinference": defaultdict(lambda: [None]*nPos),
+            "lalinference/"+combineID: defaultdict(lambda: [None]*nPos),
+            "lalinference/"+combineID+"/"+posterior_grp_name: defaultdict(lambda: [None]*nPos)}
+
+#Read in data
+for posIndex in range(nPos):
+    if args.hdf:
+        #HDF5 files with metadata
+        with h5py.File(args.infilename[posIndex], "r") as inFile:
+
+            group = inFile["lalinference"]
+            for key in group.attrs:
+                metadata["lalinference"][key][posIndex] = group.attrs[key]
+
+            run_id = list(group.keys())[0]
+
+            group = group[run_id]
+
+            for key in group.attrs:
+                metadata["lalinference/"+combineID][key][posIndex] = group.attrs[key]
+
+            if "combined_run_ids" not in group.attrs:
+                metadata["lalinference/"+combineID]["combined_run_ids"][posIndex] = run_id
+            elif "recombined_run_ids" not in group.attrs:
+                metadata["lalinference/"+combineID]["recombined_run_ids"][posIndex] = run_id
+            elif "rerecombined_run_ids" not in group.attrs:
+                metadata["lalinference/"+combineID]["rerecombined_run_ids"][posIndex] = run_id
+            elif "rererecombined_run_ids" not in group.attrs:
+                metadata["lalinference/"+combineID]["rererecombined_run_ids"][posIndex] = True
+            else:
+                print("Too many combinations to count!")
+
+
+            group = group[posterior_grp_name]
+            for key in group.attrs:
+                metadata["lalinference/"+combineID+posterior_grp_name][key][posIndex] = group.attrs[key]
+
+            posDtype = []
+            for key in group:
+                posDtype.append((key, group[key].dtype))
+                shape = group[key].shape
+
+            posData = np.empty(shape, dtype=posDtype)
+
+            for key in group:
+                posData[key] = group[key][:]
+
+    else:
+        #Standard text file
+        posData = np.genfromtxt(args.infilename[posIndex], names=True)
+
+    if (args.shuffle):
+        np.random.shuffle(posData)
+
+    samples.append(posData)
+    paramsList.append(set(posData.dtype.names))
+    sizeList.append(np.size(posData))
+
+
+#Create intersection
+paramsOut = list(set.intersection(*paramsList))
+
+datatypes = samples[0][paramsOut].dtype
+
+#Combine posteriors
+if (args.all):
+    #Use all samples
+    sizeOut = sum(sizeList)
+    samplesOut = np.empty(sizeOut, dtype=datatypes)
+
+    indexSize = sizeList
+
+else:
+    #Weight different posteriors
+    fracWeight = np.asarray(args.weightings) / float(sum(args.weightings))
+
+    testNum = fracWeight * float(sum(sizeList))
+    minIndex = np.argmin(np.asarray(sizeList) / np.asarray(testNum))
+
+    testSize = sizeList[minIndex] / fracWeight[minIndex]
+
+    weightNum = np.around(fracWeight * testSize).astype(int)
+    sizeOut = sum(weightNum)
+    samplesOut = np.empty(sizeOut, dtype=datatypes)
+
+    indexSize = weightNum
+
+
+print("Using number of samples ", indexSize)
+
+
+startIndex = 0
+for posIndex in range(0,nPos):
+    stopIndex = startIndex + indexSize[posIndex]
+
+    for paramIndex, paramItem in enumerate(paramsOut):
+        samplesOut[paramItem][startIndex:stopIndex] = samples[posIndex][paramItem][0:indexSize[posIndex]]
+
+    startIndex = stopIndex
+
+
+#Mix samples
+if args.mix:
+    np.random.shuffle(samplesOut)
+
+
+#Save output
+if args.hdf:
+    #HDF5 file with metadata
+    with h5py.File(path, "w") as outFile:
+        group = outFile.create_group("lalinference")
+        group = group.create_group(combineID)
+        group = group.create_group(posterior_grp_name)
+        for key in samplesOut.dtype.names:
+            group.create_dataset(key, data=samplesOut[key], shuffle=True, compression="gzip")
+
+        for level in metadata:
+            for key in metadata[level]:
+                outFile[level].attrs[key] = metadata[level][key]
+
+else:
+    #Standard textt output
+    paramHeader = "\t".join(paramsOut)
+    np.savetxt(args.outfilename, samplesOut.T, delimiter="\t", header=paramHeader, comments="")
+
+
+#Done!