position lieklihood list now used in analysis

Author: Jammy2211

autolens/__init__.py

@@ -89,8 +89,7 @@
 from .lens.tracer import Tracer
 from .lens.sensitivity import SubhaloSensitivityResult
 from .lens.to_inversion import TracerToInversion
-from .analysis.positions import PositionsLHResample
-from .analysis.positions import PositionsLHPenalty
+from .analysis.positions import PositionsLH
 from .imaging.simulator import SimulatorImaging
 from .imaging.fit_imaging import FitImaging
 from .imaging.model.analysis import AnalysisImaging

autolens/analysis/analysis/dataset.py

@@ -13,8 +13,7 @@
 
 from autolens.analysis.analysis.lens import AnalysisLens
 from autolens.analysis.result import ResultDataset
-from autolens.analysis.positions import PositionsLHResample
-from autolens.analysis.positions import PositionsLHPenalty
+from autolens.analysis.positions import PositionsLH
 
 from autolens import exc
 
@@ -28,7 +27,7 @@ def __init__(
         self,
         dataset,
         positions_likelihood_list: Optional[
-            List[Union[PositionsLHResample, PositionsLHPenalty]]
+            List[PositionsLH]
         ] = None,
         adapt_image_maker: Optional[ag.AdaptImageMaker] = None,
         cosmology: ag.cosmo.LensingCosmology = ag.cosmo.Planck15(),
@@ -52,7 +51,8 @@ def __init__(
         positions_likelihood_list
             Alters the likelihood function to include a term which accounts for whether image-pixel coordinates in
             arc-seconds corresponding to the multiple images of each lensed source galaxy trace close to one another in
-            their source-plane.
+            their source-plane. This is a list, as it may support multiple planes, where a positions likelihood object
+            is input for each plane (e.g. double source plane lensing).
         adapt_images
             Contains the adapt-images which are used to make a pixelization's mesh and regularization adapt to the
             reconstructed galaxy's morphology.
@@ -62,7 +62,7 @@ def __init__(
             Settings controlling how an inversion is fitted during the model-fit, for example which linear algebra
             formalism is used.
         raise_inversion_positions_likelihood_exception
-            If an inversion is used without the `positions_likelihood` it is likely a systematic solution will
+            If an inversion is used without the `positions_likelihood_list` it is likely a systematic solution will
             be inferred, in which case an Exception is raised before the model-fit begins to inform the user
             of this. This exception is not raised if this input is False, allowing the user to perform the model-fit
             anyway.
@@ -124,7 +124,7 @@ def raise_exceptions(self, model):
 
         if has_pix:
             if (
-                self.positions_likelihood is None
+                self.positions_likelihood_list is None
                 and self.raise_inversion_positions_likelihood_exception
                 and not conf.instance["general"]["test"][
                     "disable_positions_lh_inversion_check"
@@ -133,7 +133,7 @@ def raise_exceptions(self, model):
                 raise exc.AnalysisException(
                     """
                     You have begun a model-fit which reconstructs the source using a pixelization.
-                    However, you have not input a `positions_likelihood` object.
+                    However, you have not input a `positions_likelihood_list` object.
                     It is likely your model-fit will infer an inaccurate solution.
                     
                     Please read the following readthedocs page for a description of why this is, and how to set up

autolens/analysis/analysis/lens.py

@@ -6,8 +6,7 @@
 import autoarray as aa
 import autogalaxy as ag
 
-from autolens.analysis.positions import PositionsLHResample
-from autolens.analysis.positions import PositionsLHPenalty
+from autolens.analysis.positions import PositionsLH
 from autolens.lens.tracer import Tracer
 
 from autolens.lens import tracer_util
@@ -23,7 +22,7 @@ class AnalysisLens:
     def __init__(
         self,
         positions_likelihood_list: Optional[
-            List[Union[PositionsLHResample, PositionsLHPenalty]]
+            List[PositionsLH]
         ] = None,
         cosmology: ag.cosmo.LensingCosmology = ag.cosmo.Planck15(),
     ):

autolens/analysis/positions.py

@@ -21,11 +21,12 @@
 from autolens import exc
 
 
-class AbstractPositionsLH:
+class PositionsLH:
     def __init__(
         self,
+        positions: aa.Grid2DIrregular,
         threshold: float,
-        positions: Optional[aa.Grid2DIrregular] = None,
+        log_likelihood_penalty_factor: float = 1e8,
         plane_redshift: Optional[float] = None,
     ):
         """
@@ -37,9 +38,17 @@ def __init__(
         on the basis that this indicates an unphysical or inaccurate mass model. If they trace within the
         threshold the penalty term is not applied.
 
+        For the `PositionsLH` object, if the multiple image coordinates do not trace within the source-plane
+        threshold of one another a penalty to the likelihood is applied:
+
+        `log_Likelihood_penalty_base - log_likelihood_penalty_factor * (max_source_plane_separation - threshold)`
+
+        The penalty term reduces as the source-plane coordinates trace closer to one another, meaning that the
+        initial stages of the non-linear search can sample mass models that reduce the threshold.
+
         For example, for one penalty term, if the multiple image coordinates are defined
         via `positions=aa.Grid2DIrregular([(1.0, 0.0), (-1.0, 0.0)]` and they do not trace within `threshold=0.3` of
-        one another, the mass model will be rejected and a new model sampled.
+        one another, the mass model will receive a large likelihood penalty.
 
         The default behaviour assumes a single lens plane and single source plane, meaning the input `positions`
         are the image-plane coordinates of one source galaxy at a specifc redshift.
@@ -55,11 +64,13 @@ def __init__(
         threshold
             If the maximum separation of any two source plane coordinates is above the threshold the penalty term
             is applied.
+        log_likelihood_penalty_factor
+            A factor which multiplies how far source pixels do not trace within the threshold of one another, with a
+            larger factor producing a larger penalty making the non-linear parameter space gradient steeper.
         plane_redshift
             The plane redshift of the lensed source multiple images, which is only required if position threshold
             for a double source plane lens system is being used where the specific plane is required.
         """
-
         self.positions = positions
         self.threshold = threshold
         self.plane_redshift = plane_redshift
@@ -71,10 +82,7 @@ def __init__(
                 "Please input more positions into the Positions."
             )
 
-    def log_likelihood_function_positions_overwrite(
-        self, instance: af.ModelInstance, analysis: AnalysisDataset
-    ) -> Optional[float]:
-        raise NotImplementedError
+        self.log_likelihood_penalty_factor = log_likelihood_penalty_factor
 
     def output_positions_info(self, output_path: str, tracer: Tracer):
         """
@@ -94,7 +102,7 @@ def output_positions_info(self, output_path: str, tracer: Tracer):
         -------
 
         """
-        with open_(path.join(output_path, "positions.info"), "w+") as f:
+        with open_(path.join(output_path, "positions.info"), "a+") as f:
 
             positions_fit = SourceMaxSeparation(
                 data=self.positions, noise_map=None, tracer=tracer, plane_redshift=self.plane_redshift
@@ -104,7 +112,11 @@ def output_positions_info(self, output_path: str, tracer: Tracer):
                 coordinate=(0.0, 0.0)
             )
 
-            f.write(f"Plane Redshift: {self.plane_redshift} \n")
+            if self.plane_redshift is None:
+                f.write(f"Plane Index: -1 \n")
+            else:
+                f.write(f"Plane Redshift: {self.plane_redshift} \n")
+
             f.write(f"Positions: \n {self.positions} \n\n")
             f.write(f"Radial Distance from (0.0, 0.0): \n {distances} \n\n")
             f.write(f"Threshold = {self.threshold} \n")
@@ -113,116 +125,6 @@ def output_positions_info(self, output_path: str, tracer: Tracer):
             )
             f.write("")
 
-
-class PositionsLHResample(AbstractPositionsLH):
-    """
-    The `PositionsLH` objects add a penalty term to the likelihood of the **PyAutoLens** `log_likelihood_function`
-    defined in the `Analysis` classes.
-
-    The penalty term inspects the distance that the locations of the multiple images of the lensed source galaxy
-    trace within one another in the source-plane and penalizes solutions where they trace far from one another,
-    on the basis that this indicates an unphysical or inaccurate mass model. If they trace within the
-    threshold the penalty term is not applied.
-
-    For the `PositionsLHResample` object, if the multiple image coordinates do not trace within the source-plane
-    threshold of one another the mass model is rejected and a new model is sampled.
-
-    The penalty term rejects any model where the source-plane coordinates do not trace within the threshold, meaning
-    that the initial stages of the non-linear search may need to sample many mass models randomly in order to sample
-    an initial set that that trace within the threshold.
-
-    Parameters
-    ----------
-    positions
-        The arcsecond coordinates of the lensed source multiple images which are used to compute the likelihood
-        penalty.
-    threshold
-        If the maximum separation of any two source plane coordinates is above the threshold the penalty term
-        is applied.
-    """
-
-    def log_likelihood_function_positions_overwrite(
-        self, instance: af.ModelInstance, analysis: AnalysisDataset
-    ) -> Optional[float]:
-        """
-        This is called in the `log_likelihood_function` of certain `Analysis` classes to add the penalty term of
-        this class, which rejects and resamples mass models which do not trace within the threshold of one another
-        in the source-plane.
-
-        Parameters
-        ----------
-        instance
-            The instance of the lens model that is being fitted for this iteration of the non-linear search.
-        analysis
-            The analysis class from which the log likliehood function is called.
-        """
-        tracer = analysis.tracer_via_instance_from(instance=instance)
-
-        if not tracer.has(cls=ag.mp.MassProfile) or len(tracer.planes) == 1:
-            return
-
-        positions_fit = SourceMaxSeparation(
-            data=self.positions,
-            noise_map=None,
-            tracer=tracer,
-            plane_redshift=self.plane_redshift,
-        )
-
-        if not positions_fit.max_separation_within_threshold(self.threshold):
-            if os.environ.get("PYAUTOFIT_TEST_MODE") == "1":
-                return
-
-            raise exc.RayTracingException
-
-
-class PositionsLHPenalty(AbstractPositionsLH):
-    def __init__(
-        self,
-        threshold: float,
-        log_likelihood_penalty_factor: float = 1e8,
-        positions: Optional[aa.Grid2DIrregular] = None,
-        plane_redshift: Optional[float] = None,
-    ):
-        """
-        The `PositionsLH` objects add a penalty term to the likelihood of the **PyAutoLens** `log_likelihood_function`
-        defined in the `Analysis` classes.
-
-        The penalty term inspects the distance that the locations of the multiple images of the lensed source galaxy
-        trace within one another in the source-plane and penalizes solutions where they trace far from one another,
-        on the basis that this indicates an unphysical or inaccurate mass model. If they trace within the
-        threshold the penalty term is not applied.
-
-        For the `PositionsLHPenalty` object, if the multiple image coordinates do not trace within the source-plane
-        threshold of one another a penalty to the likelihood is applied:
-
-        `log_Likelihood_penalty_base - log_likelihood_penalty_factor * (max_source_plane_separation - threshold)`
-
-        The penalty term reduces as the source-plane coordinates trace closer to one another, meaning that the
-        initial stages of the non-linear search can sample mass models that reduce the threshold.
-
-        Parameters
-        ----------
-        positions
-            The arcsecond coordinates of the lensed source multiple images which are used to compute the likelihood
-            penalty.
-        threshold
-            If the maximum separation of any two source plane coordinates is above the threshold the penalty term
-            is applied.
-        log_likelihood_penalty_factor
-            A factor which multiplies how far source pixels do not trace within the threshold of one another, with a
-            larger factor producing a larger penalty making the non-linear parameter space gradient steeper.
-        plane_redshift
-            The plane redshift of the lensed source multiple images, which is only required if position threshold
-            for a double source plane lens system is being used where the specific plane is required.
-        """
-        super().__init__(
-            positions=positions,
-            threshold=threshold,
-            plane_redshift=plane_redshift
-        )
-
-        self.log_likelihood_penalty_factor = log_likelihood_penalty_factor
-
     def log_likelihood_penalty_base_from(
         self, dataset: Union[aa.Imaging, aa.Interferometer]
     ) -> float: