make a boosted posteriors file from polychord

cosmosis/samplers/polychord/polychord_sampler.py

@@ -6,6 +6,7 @@
 import numpy as np
 import sys
 from ...runtime.utils import mkdir
+from ...output import TextColumnOutput
 import warnings
 
 prior_type = ct.CFUNCTYPE(None, 
@@ -302,6 +303,73 @@ def sample(self):
 
         self.converged = True
 
+        if self.is_master() and self.boost_posteriors:
+            self.make_boosted_posterior_file()
+
+    def make_boosted_posterior_file(self):
+        # two cases where there is nothing to boost
+        if not self.polychord_outfile_root:
+            return
+        if not self.boost_posteriors:
+            return
+
+        old = self.output
+
+        boosted_filename = os.path.join(self.base_dir, self.polychord_outfile_root + ".txt")
+
+        # This is a horribly awkward hack
+        if isinstance(self.output, TextColumnOutput):
+            # make sure everything is written out already
+            old.flush()
+
+            new_output_filename = old.filename_base + "_boosted.txt"
+            main_output_info = TextColumnOutput.load_from_options({"filename":old._filename, "delimiter":old.delimiter})
+
+            _, _, metadata, comments, final_metadata = main_output_info
+            metadata = metadata[0]
+            comments = comments[0]
+            final_metadata = final_metadata[0]
+
+            # make a new output object
+            new = TextColumnOutput.from_options({"filename":new_output_filename})
+
+            # write the main bits of metadata from the output file
+            new.metadata("sampler", "polychord")
+            new.comment("NOTE: Boosted posterior file")
+            self.write_header(new)
+            for md in metadata:
+                new.metadata(md, metadata[md])
+            for c in comments:
+                new.comment(c)
+
+
+            # write the parameter rows from the old file
+            with open(boosted_filename, "r")  as f:
+                for line in f:
+                    values = [float(x) for x in line.split()]
+                    weight = values[0]
+                    like = values[1]
+                    params = values[2:]
+                    prior = params[-1]
+                    post = like + prior
+                    new.parameters(params, like, post, weight)
+
+
+            # This hasn't been written yet because the original output file has not been closed.
+            # so we have to use the saved one in the old object. The * is because a comment is also included
+            for md in old._final_metadata:
+                new.final(md, *old._final_metadata[md])
+            new.final("log_z", self.log_z)
+            new.final("log_z_error", self.log_z_err)
+
+            # fake these first two, and add the completion marker.
+            new.final("evaluations", 0)
+            new.final("successes", 0)
+            new.final("complete", 1)
+            new.close()
+
+
+
     def output_params(self, ndead, nlive, npars, live, dead, logweights, log_z, log_z_err):
         # Polychord repeats output, but with changed weights, so reset to the start
         # of the chain to overwrite them.

cosmosis/samplers/sampler.py

@@ -54,19 +54,23 @@ def __init__(self, ini, pipeline, output=None):
         self.distribution_hints = Hints()
         self.write_header()
 
-    def write_header(self):
-        if self.output:
-            for p in self.pipeline.output_names():
-                self.output.add_column(p, float)
-            for p,ptype in self.sampler_outputs:
-                self.output.add_column(p, ptype)
-            self.output.metadata("n_varied", len(self.pipeline.varied_params))
-            self.attribution.write_output(self.output)
-            for key, value in self.collect_run_metadata().items():
-                self.output.metadata(key, value)
+    def write_header(self, output=None):
+        if output is None:
+            output = self.output
+        if output is None:
+            return
+
+        for p in self.pipeline.output_names():
+            output.add_column(p, float)
+        for p,ptype in self.sampler_outputs:
+            output.add_column(p, ptype)
+        output.metadata("n_varied", len(self.pipeline.varied_params))
+        self.attribution.write_output(output)
+        for key, value in self.collect_run_metadata().items():
+            output.metadata(key, value)
         blinding_header = self.ini.getboolean("output","blinding-header", fallback=False)
-        if blinding_header and self.output:
-            self.output.blinding_header()
+        if blinding_header:
+            output.blinding_header()
 
     def collect_run_metadata(self):
         info = {