CosmoSim 3.0.4b1__cp313-cp313-win_amd64.whl

CosmoSim/.gitignore

@@ -0,0 +1,2 @@
+*05.txt
+*.raw

CosmoSim/CLI/Arguments.py

@@ -0,0 +1,315 @@
+# (C) 2026: Hans Georg Schaathun <georg@schaathun.net> 
+
+"""
+This defines the `ArgumentParser` for the CosmoSim scripts.
+Several scripts use the same arguments, and thus share this module.
+
+The argument list is not complete.  For ease of maintenance, we should
+abandon support for command line arguments and refer to CSV and TOML 
+files instead.
+
+`paramap` is a mapping from the command line options into the
+structure of the TOML config files.  The key is the parameter
+name used in CSV and on the command line, while the value is
+the key used in TOML and nested `dict`s.
+"""
+
+import argparse
+from cascadict import CascaDict
+from copy import deepcopy
+
+class Parameters:
+    """
+    The Parameters class wraps the commandline arguments as well as a CSV 
+    row as a dict-like object.
+
+    The constructor can take either an `ArgumentParser` object (`args`) 
+    as well as a nested `dict` (`cfg`) as given by a TOML file.  
+    Only selected parameters are used from the
+    TOML format, and they will never override `args`/`cfg` parameters.
+
+    For executable scripts, one can use `CosmoParser` object directly as
+    the `args` argument, in addition to a TOML file if available.
+    For API use, one should normally use the `cfg` argument.
+
+    To add a row from the dataset, use the `serRow()` method.  Values
+    from the row will always override other parameters.
+    """
+    def __init__(self,fileconfig=None,cliconfig=None,verbosity=0):
+
+        self._cliconfig = cliconfig
+        self._fileconfig = fileconfig
+        self.verbosity = verbosity
+
+        cfg = CascaDict( skel )
+        if fileconfig:
+           cfg = cfg.cascade( fileconfig  )
+        if cliconfig:
+           cfg = cfg.cascade( cliconfig )
+        self._base = cfg
+        self.reset()
+    def copy(self):
+        return deepcopy(self)
+    def reset(self):
+        self.config = self._base.cascade( {})
+    def __str__(self): 
+        return self.config.__str__()
+    def setRow(self,row):
+        if self.verbosity > 1: print( row )
+        self._row = row
+        c = getConfig( self._row, verbose=self.verbosity ) 
+        if self.verbosity: print( c )
+        self.config = self._base.cascade( c )
+    def get(self,key,default=None,verbose=0):
+        if isinstance( key, str ):
+            return self.get( paramap[key], default, verbose )
+        elif isinstance( key, tuple ):
+            cf = self.config
+            for k in key:
+                cf = cf.get( k, None )
+                if cf is None: break
+            if cf is None:
+                return default
+            else: 
+                return cf
+        else:
+            print( key )
+            raise Exception( "Key should be string or tuple." )
+    def __getitem__(self,key):
+        return self.config.get(key)
+    def __setitem__(self,key,v):
+        self._row[key] = v
+
+skel = { "simulator" : { "imagesize": 512 }
+        , "source" : { "sigma" : 10, "sigma2" : 20, "theta" : 45 }
+         , "lens" : {}
+         , "dataset" : {}
+         , "annotation" : {}
+         , "management" : { "maxcount" : None ,"filename" : "test.png" },
+         }
+
+paramap = {
+        "config" : ( "simulator", "config" ), # renamed
+        "lens" : ( "lens", "mode" ),
+        "model" : ( "simulator", "model" ),
+        "sampled" : ( "simulator", "sampled" ),
+        "nterms" : ( "simulator", "nterms" ),
+        "imagesize" : ( "simulator", "imagesize" ),
+        "cropsize" : ( "simulator", "cropsize" ),
+        "xireference" : ( "simulator", "xireference" ), # new
+        "centred" : ( "simulator", "centred" ), # new
+        "source" : ( "source", "mode" ), # used differently
+        "lightprofile" : ( "source", "lightprofile" ), 
+        "n_sersic" : ( "source", "n_sersic" ), 
+        "luminosity" : ( "source", "luminosity" ), 
+
+        "einsteinradius" : ( "lens", "einsteinradius" ),
+        "orientation" : ( "lens", "orientation" ),
+        "ratio" : ( "lens", "ellipseratio" ), # relabelled
+        "ellipseratio" : ( "lens", "ellipseratio" ), # duplicate
+        "einsteinR" : ( "lens", "einsteinR" ), 
+        "cluster" : ( "lens", "cluster" ), 
+
+        "sigma" :  ( "source", "sigma" ),
+        "sigma2" : ( "source", "sigma2" ),
+        "theta" : ( "source", "theta" ),
+        "x" : ( "position", "x" ),
+        "y" : ( "position", "y" ),
+        "phi" : ( "position", "phi" ),
+
+        "directory" : ( "dataset", "directory" ) ,
+        "reflines" : ( "annotation", "reflines" ),
+        "criticalcurves" : ( "annotation", "criticalcurves" ),
+        "criticalcurves" : ( "annotation", "criticalcurves" ),
+
+        "maxcount" : ( "management", "maxcount" ),
+        "showmask" : ( "management", "showmask" ),
+        "mask" : ( "management", "mask" ),
+        "join" : ( "management", "join" ),
+        "family" : ( "management", "family" ),
+        "psiplot" : ( "management", "psiplot" ),
+        "kappaplot" : ( "management", "kappaplot" ),
+        "apparent" : ( "management", "apparent" ),
+        "actual" : ( "management", "actual" ),
+        "filename" : ( "management", "filename" ),
+        "index" : ( "management", "index" ),
+        }
+
+def getConfig( data, verbose=0 ):
+      cfg = skel.copy()
+      if verbose: print( "[getConfig]", data )
+      flat = dict(data)
+      if not "filename" in flat:
+          try:
+             flat["filename"] = data.name
+          except:
+              if verbose: print( "No filename given" )
+
+      for k in flat:
+          if k in paramap:
+              key = paramap[k]
+              d = cfg
+              for subkey in key[:-1]:
+                  try:
+                     d = d[subkey]
+                  except KeyError:
+                      d[subkey] = {}
+                      d = d[subkey]
+              d[key[-1]] = flat[k]
+              if verbose: print( f"[getConfig] {k} -> {key} ({flat[k]})" )
+          else:
+              if verbose: print( f"[getConfig] {k} -> not found ({flat[k]})" )
+      return cfg
+class CosmoParser(argparse.ArgumentParser):
+  """Argument Parser for CosmoSim.
+  The class provides standardised CLI options for many scripts
+  in the CosmoSim suite.  
+  """
+  def getArgs(self,*a,**kw):
+      """Parse the arguments and return the resulting `args` object.
+      """
+      if not hasattr(self,"_args"):
+          self._args = super().parse_args(*a,**kw)
+      return self._args
+  def getConfig(self,*a,verbose=0,**kw):
+      """Return the configuration as a nested `dict` structure.
+      The arguments are parsed if required.
+      """
+      if not hasattr(self,"_args"):
+          self._args = super().parse_args(*a,**kw)
+      d = self._args.__dict__
+      ks = [ k for k in d if d[k] is None ]
+      for k in ks: del d[k]
+      return getConfig( d, verbose=verbose )
+  def __init__(self,*a,**kw):
+    super().__init__(*a,**kw)
+
+    # Model selection
+    self.add_argument('-l', '--lens',
+            help="lens model")
+    self.add_argument('--cluster', help="cluster lens")
+    self.add_argument('-L', '--model',
+            help="simulation model")
+    self.add_argument('-S', '--source',
+            default="Spherical", help="source model")
+    self.add_argument('-G', '--sampled', action=argparse.BooleanOptionalAction,
+            default=None, help="Sample the lens model")
+
+    # Model Parameters
+    self.add_argument('-x', '--x', type=float, default=0, help="x coordinate")
+    self.add_argument('-y', '--y', type=float, default=0, help="y coordinate")
+    self.add_argument('-T', '--phi', type=float, help="polar coordinate angle (phi)")
+
+    self.add_argument('-s', '--sigma', type=float, default=20, help="source size (sigma)")
+    self.add_argument('-2', '--sigma2', type=float, default=10, help="secondary source size (sigma2)")
+    self.add_argument('-t', '--theta', type=float, default=45, help="source rotation angle (theta)")
+
+    self.add_argument('-E', '--einsteinradius', type=float, default=20, help="Einstein radius")
+    self.add_argument('-r', '--ratio', type=float, help="Ratio (usually Elliptic eccentricity)")
+    self.add_argument('--orientation', default=0, type=float, help="Orientation of the lens")
+    self.add_argument('--config', type=str, help="Configuration (Model and Lens)")
+
+    # Other parameters
+    self.add_argument('-n', '--nterms', type=int,
+                      help="Number of Roulettes terms", default=15)
+    self.add_argument('-Z', '--imagesize', type=int, default=512, help="image size for calculations")
+    self.add_argument('-z', '--cropsize', type=int, help="Final image size")
+
+    # Output configuration 
+    self.add_argument('-R', '--reflines',action='store_true',
+            help="Add reference (axes) lines")
+    self.add_argument( '--criticalcurves',action='store_true',
+            help="Add critical curves to the distorted image")
+    self.add_argument('-C', '--centred',action='store_true', help="centre image")
+    self.add_argument('--maskradius',
+            help="Set explicit masking radius")
+    self.add_argument('-M', '--mask',action='store_true',
+            help="Mask out the convergence circle")
+    self.add_argument('-m', '--showmask',action='store_true',
+            help="Mark the convergence circle")
+    self.add_argument('-O', '--maskscale',default="0.9",
+            help="Scaling factor for the mask radius")
+    self.add_argument('-P', '--psiplot',action='store_true',default=False,
+            help="Plot lens potential as 3D surface")
+    self.add_argument('-K', '--kappaplot',action='store_true',default=False,
+            help="Plot mass distribution as 3D surface")
+    self.add_argument('-f', '--family',action='store_true',
+            help="Several images moving the viewpoint")
+    self.add_argument('-F', '--amplitudes',help="Amplitudes file")
+    self.add_argument('-A', '--apparent',action='store_true',help="write apparent image")
+    self.add_argument('--mldata',action='store_true',help="Make roulette output for ML without redundant colums")
+    self.add_argument('-a', '--actual',action='store_true',help="write actual image")
+
+    # Output file names
+    self.add_argument('-N', '--name', default="test",
+            help="simulation name")
+    self.add_argument('-D', '--directory',default="./",
+            help="directory path (for output files)")
+
+    # Joining images
+    self.add_argument('-c', '--components',default="6",
+            help="Number of components for joined image")
+    self.add_argument('-J', '--join',action='store_true',
+            help="Join several images from different viewpoints")
+
+    # Using CSV data sets
+    self.add_argument('-o', '--outfile',
+            help="Output CSV file")
+    self.add_argument('-i', '--csvfile',
+            help="Dataset to generate (CSV file)")
+    self.add_argument('--toml',
+            help="TOML file defining a random dataset to generate.")
+
+    self.add_argument('--maxcount',
+            help="Maximum number of images to process")
+    self.add_argument('--xireference',default=True, action=argparse.BooleanOptionalAction,
+            help="Use apparent position as reference for roulette amplitudes")
+    # Command mode
+    self.add_argument('--rnd', action='store_true',
+            default=False, help="Generate random dataset")
+    self.add_argument('--version', action='store_true',
+            default=False, help="Show version number")
+    self.add_argument('--roulette', type=str,
+            help="Input file for roulette resimulation")
+
+    self.add_argument('-v','--verbose', action="count",default=0,
+            help="Debug output")
+
+def setParameters(sim,row,verbose=1):
+    if verbose > 2:
+       print( "[CLI.Arguments] setParameters()" )
+       print( row ) 
+    if row.get("y") is not None:
+        if verbose > 1:
+            print( "[setParameters] XY", row.get( "x" ), row.get( "y" ) )
+        sim.setXY( row.get( "x" ), row.get( "y" ) )
+    elif row.get("phi",None) != None:
+        if verbose > 1: print( "Polar", row.get( "x" ), row.get( "phi" ) )
+        sim.setPolar( row.get( "x" ), row.get( "phi" ) )
+    if row.get("config",None) != None:
+        try:
+           sim.setConfigMode( row.get( "config" ) )
+        except KeyError as e:
+            print( f"config={row.get( "config" )}" )
+            raise e
+    elif row.get("cluster",None) != None:
+        if verbose > 1: print( "setCluster from CSV" )
+        sim.setCluster( row.get( "cluster" ) )
+    elif row.get("lens",None) != None:
+        sim.setLensMode( row.get( "lens" ) )
+    if row.get("model",None) != None:
+        sim.setModelMode( row.get( "model" ) )
+    if row.get("sampled",None) != None:
+        if verbose>1: print( row )
+        sim.setSampled( row.get( "sampled" ) )
+    if row.get("einsteinR",None) != None:
+        sim.setEinsteinR( row.get( "einsteinR" ) )
+    if row.get("ellipseratio",None) != None:
+        sim.setRatio( row.get( "ellipseratio" ) )
+    if row.get("orientation",None) != None:
+        sim.setOrientation( row.get( "orientation" ) )
+    if row.get("imagesize",None) != None:
+        sim.setImageSize( row.get( "imagesize" ) )
+        sim.setResolution( row.get( "imagesize" ) )
+    if row.get("nterms",None) != None:
+        sim.setNterms( row.get( "nterms" ) )

CosmoSim/CLI/Simulator.py

@@ -0,0 +1,175 @@
+#! /usr/bin/env python3
+# (C) 2026: Hans Georg Schaathun <georg@schaathun.net>
+
+"""
+Abstract simulator class to manage bulk image generation.
+
+Different subclasses are required for different backend simulators, like
+`RouletteRegenerator` and `CosmoSim`.
+The `GenericSim` superclass contains shared methods.
+
+Subclasses shoulded override the constructor, calling the superclass constructor
+first and `initSim()` last.  In the middle, the `self.sim` must be set with a
+backend simulator.
+
+The `setParameters()` method must also be overridden.
+
+The `initSim` method reconfigures the backend simulator, and generates the 
+distorted image.
+Since the object retains much of the simulation data, extensive information
+and annotated images may be retrieved as well.
+"""
+
+import cv2 as cv
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+from ..CosmoSimPy import setDebug
+from .. import CosmoSim
+from ..Image import centreImage, drawAxes, crop, annotatePoint, annotateCircle, translateImage
+from .Arguments import CosmoParser, Parameters
+
+class GenericSim:
+    """
+    This is a generic superclass for shared methods.
+    """
+    def __init__(self,param=None,name=None,outcols=None,verbose=1):
+        """
+        Normally the constructor should be overridden, calling the superclass
+        constructor first and `initSim()` last.
+        """
+        if verbose is None: verbose=1
+        self.verbose = verbose
+        setDebug( verbose )
+        if verbose > 1: print( f"[GenericSim] init (verbose={verbose}) ..." )
+        sys.stdout.flush()
+
+        self.outcols = outcols
+
+        self.name = name
+        if param is None: 
+            if verbose: print( "[GenericSim] No parameters given. Using defaults" )
+            param = Parameters()
+        self.param = param
+        self.directory = param.get( "directory" )
+        if self.directory:
+            if self.verbose > 1: print( "[GenericSim] directory", self.param )
+            os.makedirs( self.directory, exist_ok=True )
+        if self.verbose > 2:
+            print( "[GenericSim]", self.param )
+
+        if self.verbose > 2:
+            print( "[GenericSim] xireference =", self.param.get( "xireference" ) )
+
+    def setParameters(self,row):
+        """
+        Reset parameters in the backend simulator, using the given data row.
+        This is an auxiliary for `initSim()` and will normally have to be 
+        overridden depending on the class of the backend simulator.
+        """
+        raise NotImplementedError()
+    def initSim(self,row=None):
+        """
+        Run the simulator with the given data row.
+        """
+        if row is None: row = self.param
+        if self.verbose > 1: print( "[initSim] using row" )
+        self.setParameters( row )
+        if self.verbose: print( f"[initSim] type(row)={type(row)}" )
+        # self.param.setRow( row )
+        fn = row.get( "filename" )
+        if fn is None: fn = row.name
+        if self.verbose > 1: print( "filename", fn )
+        name = fn.split(".")[0]
+        self.name = name
+
+        if self.verbose>1: print( "[initSim] item name:", self.name )
+
+        self.runSim()
+
+        self.image = self.getDistortedImage( )
+        (self.centreimage,self.centrepoint) = centreImage(self.image)
+        if self.verbose: 
+            print( f"[Simulator] Centre Point ({self.centrepoint[0]:.2f},{self.centrepoint[1]:.2f})",
+                "(Centre of Luminence in Planar Co-ordinates)" )
+    def getDistortedImage(self):
+        return  self.sim.getDistortedImage( 
+                         critical=self.param.get( "criticalcurves" ),
+                         showmask=self.param.get( "showmask" ) ) 
+    def runSim(self):
+        if self.verbose>2: print( "[runSim]" )
+        self.sim.makeSource( self.param )
+        if self.verbose > 1: print ( "[GenericSim] ready for runSim()\n" ) ;
+        self.sim.runSim()
+        if self.verbose > 1: print ( "[GenericSim] runSim() completed\n" ) ;
+    def getActualImage(self):
+        param = self.param
+        try:
+           return self.sim.getActualImage( reflines=param.get( "reflines" ) )
+        except:
+           im = np.array( self.sim.getActual() )
+           if self.verbose: print( "actual image", type(im) )
+           if im.shape[2] == 1 : im.shape = im.shape[:2]
+           return im
+    def getActual(self):
+        param = self.param
+        name = self.name
+        fn = os.path.join(param.get("directory"),"actual-" + str(name) + ".png" ) 
+        im = self.sim.getActualImage( reflines=param.get( "reflines" ) )
+        cv.imwrite(fn,im)
+    def getApparent(self):
+        param = self.param
+        name = self.name
+        fn = os.path.join(param.get("directory"),"apparent-" + str(name) + ".png" ) 
+        im = self.sim.getApparentImage( reflines=param.get( "reflines" ) )
+        cv.imwrite(fn,im)
+    def getAnnotated(self,centred=None,cropsize=None):
+        """
+        Get an image with annotations showing key points and the convergence ring.
+        This is incomplete and should be extended with addition annotations and
+        options.
+        """
+        if centred is not None:
+            raise NotImplementedError("centred option for getAnnotated() is not implemented yet.")
+        im = self.sim.getDistortedImage( critical=True )
+        im = annotatePoint( im, self.centrepoint, colour=( 64, 255, 64 ) )
+        pt = self.sim.getXiOffset( (0,0) )
+        im = annotatePoint( im, pt, colour=( 64, 64, 255 ) )
+        x, y = pt
+        convradius = np.sqrt( x*x + y*y )
+        im = annotateCircle( im, pt, radius=convradius, colour=( 64, 64, 255 ) )
+        if cropsize is None: cropsize = self.param.get( "cropsize" )
+        if cropsize:
+            im = crop(im,int( cropsize ), verbose=self.verbose  )
+        return im
+    def getImage(self,centred=None,cropsize=None,reflines=None,verbose=None):
+        if verbose is None: verbose = self.verbose
+        if centred is None:
+            centred = self.param.get( "centred" )
+            if verbose: print( "[getImage] centring from parameters:", centred )
+        if reflines is None: reflines = self.param.get( "reflines" )
+        if centred:
+            im = self.centreimage.copy()
+        else:
+            im = self.image.copy()
+        if cropsize is None: cropsize = self.param.get( "cropsize" )
+        if cropsize:
+            im = crop(im,int( cropsize ), verbose=self.verbose  )
+        if reflines:
+            drawAxes(im)
+        return im
+    def saveImage(self,name=None):
+        im = self.getImage()
+        if name is None:
+            name = self.name
+        if self.directory is None:
+            if self.verbose: print( "[saveImage] No directory" )
+            fn = str(name) + ".png"
+        else:
+            if self.verbose: print( "[saveImage] Directory", self.directory )
+            fn = os.path.join(self.directory, str(name) + ".png" )
+        if self.verbose: print( "[saveImage]", fn )
+        cv.imwrite(fn,im)