CosmoSim 2.6.3__tar.gz → 2.6.5__tar.gz

cosmosim-2.6.5/Datasets/dataset.toml

@@ -0,0 +1,34 @@
+# (C) 2026: Hans Georg Schaathun <georg@schaathun.net> 
+[simulator]
+configs = [ "raysie" ]
+size = 10
+nterms = 4
+
+[lens]
+chi = 50
+einstein-min = 1
+einstein-max = 39
+# orientation and ellipseratio are used for SIE lenses
+orientation-min = 0
+orientation-max = 180
+ellipseratio-min = 0.1
+ellipseratio-max = 1.0
+
+[source]
+mode = "SersicSphere"
+sigma-min = 1
+sigma-max = 10
+sigma2-min = 1
+sigma2-max = 10
+# source.theta is the rotation of the source (relevant for non-spherical sources)
+theta-min = 0
+theta-max = 180
+position = "polar"
+
+[position]
+# (phi,r) is the source position in polar co-ordinates, angle in degrees
+phi-min = 0
+phi-max = 360
+r-min = 1
+r-max = 10
+

cosmosim-2.6.5/Datasets/dataset2.toml

@@ -0,0 +1,34 @@
+# (C) 2026: Hans Georg Schaathun <georg@schaathun.net> 
+[simulator]
+configs = [ "raysie" ]
+size = 10
+nterms = 4
+
+[lens]
+chi = 50
+einstein-min = 2.5
+einstein-max = 75
+# orientation and ellipseratio are used for SIE lenses
+orientation-min = 0
+orientation-max = 180
+ellipseratio-min = 0.1
+ellipseratio-max = 1.0
+
+[source]
+mode = "SersicSphere"
+sigma-min = 1.25
+sigma-max = 20
+sigma2-min = 1.25
+sigma2-max = 20
+# source.theta is the rotation of the source (relevant for non-spherical sources)
+theta-min = 0
+theta-max = 180
+position = "polar"
+
+[position]
+# (phi,r) is the source position in polar co-ordinates, angle in degrees
+phi-min = 0
+phi-max = 360
+r-min = 1
+r-max = 75
+

{cosmosim-2.6.3 → cosmosim-2.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CosmoSim
-Version: 2.6.3
+Version: 2.6.5
 Summary: Simulator of Gravitational Lenses
 Author: Hans Georg Schaathun et al
 Author-email: Hans Georg Schaathun <georg+github@schaathun.net>

{cosmosim-2.6.3 → cosmosim-2.6.5}/RegressionTest/Makefile

@@ -18,7 +18,7 @@ clean alltests:
 	cd cluster-sampled-roulette ; $(MAKE) $@
 	cd cluster-sampled-raytrace ; $(MAKE) $@
 	cd roulettegen-old ; $(MAKE) $@
-	# cd roulettegen ; $(MAKE) $@
+	cd roulettegen ; $(MAKE) $@
 	cd amplitudes ; $(MAKE) $@
 
 cpptests:
@@ -35,7 +35,7 @@ cpptests:
 	cd cluster-sampled-roulette ; $(MAKE) alltests
 	cd cluster-sampled-raytrace ; $(MAKE) alltests
 	cd roulettegen-old ; $(MAKE) alltests
-	# cd roulettegen ; $(MAKE) alltests
+	cd roulettegen ; $(MAKE) alltests
 
 baselines:
 	cd exactpm ; $(MAKE) baseline`date "+%Y%m%d"`

{cosmosim-2.6.3 → cosmosim-2.6.5}/RegressionTest/amplitudes/Makefile

@@ -22,5 +22,6 @@ sie%.txt:
 
 clean:
 	rm -f 50.* *.txt *.new
+	rm -f *.status
 
 alltests: all

cosmosim-2.6.5/RegressionTest/roulettegen/baseline.config

@@ -0,0 +1 @@
+baseline20260304

{cosmosim-2.6.3 → cosmosim-2.6.5}/src/CosmoSim/Arguments.py

@@ -38,7 +38,8 @@ class CosmoParser(argparse.ArgumentParser):
     self.add_argument('--config', default=0, help="Configuration (Model and Lens)")
 
     # Other parameters
-    self.add_argument('-n', '--nterms', help="Number of Roulettes terms", default=15)
+    self.add_argument('-n', '--nterms', type=int,
+                      help="Number of Roulettes terms", default=15)
     self.add_argument('-Z', '--imagesize', default=512, help="image size for calculations")
     self.add_argument('-z', '--cropsize', help="Final image size")
     self.add_argument('--lightprofile', help="light profile (sersic or gaussian)")

cosmosim-2.6.5/src/CosmoSim/Parameters.py

@@ -0,0 +1,52 @@
+# (C) 2024: Hans Georg Schaathun <georg@schaathun.net> 
+
+from CosmoSim import sourceDict
+import numpy as np
+
+class Args:
+    def __init__(self):
+        self.__dict__ = {}
+
+class Arg:
+    pass
+
+class Parameters:
+    """
+    The Parameters class wraps the commandline arguments as well as a CSV 
+    row as a dict-like object.
+    """
+    def __init__(self,args=None,cfg=None):
+        if args:
+            self._args = args
+        else:
+            self._args = Arg()
+        self._row = {}
+        if cfg:
+            cfg1 = cfg["simulator"]
+            if "cropsize" not in self._args.__dict__:
+                self._args.cropsize = cfg1.get( "cropsize", 256 )
+            if "imagesize" not in self._args.__dict__:
+                self._args.imagesize = cfg1.get( "imagesize", 512 )
+            if "source" not in self._args.__dict__:
+                try:
+                    self._args.source = cfg["source"]["mode"]
+                except:
+                    self._args.source = None
+    def setRow(self,row):
+        self._row = row
+    def get(self,key,default=None):
+        if self._args is None:
+            r = default
+        else:
+            try:
+                r = self._args.__dict__[key]
+            except KeyError:
+                print( self._args )
+                r = default
+        r = self._row.get(key,r)
+        return r
+    def __getitem__(self,key):
+        return get(key)
+    def __setitem__(self,key,v):
+        self._row[key] = v
+

{cosmosim-2.6.3 → cosmosim-2.6.5}/src/CosmoSim/__init__.py

@@ -12,7 +12,7 @@ import os, sys
 
 import traceback
 
-__version__ = "2.6.3"
+__version__ = "2.6.5"
 
 ModelSpec = cs.ModelSpec
 SourceSpec = cs.SourceSpec

{cosmosim-2.6.3 → cosmosim-2.6.5}/src/CosmoSim/datagen.py

@@ -13,7 +13,7 @@ import matplotlib.pyplot as plt
 from .dataset import datasetgen
 
 from .Image import centreImage, drawAxes
-from . import getMSheaders,CosmoSim
+from . import getMSheaders,CosmoSim,__version__
 
 from .Arguments import CosmoParser
 from .Parameters import Parameters
@@ -21,18 +21,20 @@ import pandas as pd
 
 defaultoutcols = [ "index", "filename", "source", "lens", "chi", "R", "phi", "einsteinR", "sigma", "sigma2", "theta", "x", "y" ]
 
-def setParameters(sim,row):
-    print( row ) 
+def setParameters(sim,row,verbose=1):
+    if verbose > 2:
+       print( "[datagen.py] setParameters()" )
+       print( row ) 
     if row.get("y",None) != None:
-        print( "XY", row["x"], row["y"] )
+        if verbose > 1: print( "XY", row["x"], row["y"] )
         sim.setXY( row["x"], row["y"] )
     elif row.get("phi",None) != None:
-        print( "Polar", row["x"], row["phi"] )
+        if verbose > 1: print( "Polar", row["x"], row["phi"] )
         sim.setPolar( row["x"], row["phi"] )
     if row.get("config",None) != None:
         sim.setConfigMode( row["config"] )
     elif row.get("cluster",None) != None:
-        print( "setCluster from CSV" )
+        if verbose > 1: print( "setCluster from CSV" )
         sim.setCluster( row["cluster"] )
     elif row.get("lens",None) != None:
         sim.setLensMode( row["lens"] )
@@ -56,8 +58,9 @@ def setParameters(sim,row):
 
 
 class SimImage:
-    def __init__(self,sim,param,name=None,row=None,outcols=None):
-        print( "[SimImage] init ..." )
+    def __init__(self,sim,param,name=None,row=None,outcols=None,verbose=1):
+        if verbose > 0: print( "[SimImage] init ..." )
+        self.verbose = verbose
         if not row is None:
             setParameters( sim, row )
             print( "index", row["index"] )
@@ -67,9 +70,9 @@ class SimImage:
         elif name == None:
             name = param.get( "name" )
         sim.makeSource( param )
-        print ( "[datagen.py] ready for runSim()\n" ) ;
+        if verbose > 0: print ( "[datagen.py] ready for runSim()\n" ) ;
         sim.runSim()
-        print ( "[datagen.py] runSim() completed\n" ) ;
+        if verbose > 0: print ( "[datagen.py] runSim() completed\n" ) ;
         centrepoint = makeOutput(sim,args,name,actual=args.actual,
                              apparent=args.apparent,original=args.original,
                              reflines=args.reflines,critical=args.criticalcurves)
@@ -80,13 +83,16 @@ class SimImage:
         self.name = name
         self.param = param
         self.directory = self.param.get( "directory" )
+        if self.directory:
+            os.makedirs( self.directory, exist_ok=True )
         self.outcols = outcols
     def getData(self):
         sim = self.sim
         centrepoint = self.centrepoint
         maxm = self.param.get( "nterms" )
         xireference = self.param.get( "xireference" )
-        print( "[datagen.py] Finding Alpha/beta; centrepoint=", centrepoint )
+        if self.verbose > 0:
+            print( "[datagen.py] Finding Alpha/beta; centrepoint=", centrepoint )
         # r = pd.Series([ row[x] for x in self.outcols ], index=self.outcols )
         releta = sim.getRelativeEta(centrepoint=centrepoint)
         offset = sim.getOffset(centrepoint=centrepoint)
@@ -105,7 +111,9 @@ class SimImage:
               index=relcols ) 
         r3 = pd.Series( ab, index=getMSheaders(maxm)) 
         r1 = pd.concat( [ self.row, r2, r3 ] )
-        print( "New row:", r1 )
+        if self.verbose > 1:
+            print( f"New row (verbosity={self.verbose})" )
+            print( r1 )
         return r1
     def join(self):
         # sim.setMaskMode(False)
@@ -173,7 +181,17 @@ def makeSingle(sim,param,name=None,row=None,outcols=None):
     print( "makeSingle() returns" )
     return imsim
 
-
+def crop(im,cropsize=256):
+    (m,n) = im.shape
+    if cropsize < min(m,n):
+            assert m == n
+            c = (m-cropsize)/2
+            c1 = int(np.floor(c))
+            c2 = int(np.ceil(c))
+            im = im[c1:-c2,c1:-c2]
+            assert cropsize == im.shape[0]
+            assert cropsize == im.shape[1]
+    return im
 def makeOutput(sim,args,name=None,rot=0,scale=1,
                actual=False,apparent=False,original=False,
                reflines=False,critical=False):
@@ -190,16 +208,7 @@ def makeOutput(sim,args,name=None,rot=0,scale=1,
            cv.imwrite(fn,im)
         im = centreIm
     if args.cropsize:
-        csize = int(args.cropsize)
-        (m,n) = im.shape
-        if csize < min(m,n):
-            assert m == n
-            c = (m-csize)/2
-            c1 = int(np.floor(c))
-            c2 = int(np.ceil(c))
-            im = im[c1:-c2,c1:-c2]
-            assert csize == im.shape[0]
-            assert csize == im.shape[1]
+        im = crop(im,int(args.cropsize))
     if args.reflines:
         drawAxes(im)
 
@@ -297,6 +306,7 @@ def main(args):
     print( "simulator closed" )
 
 if __name__ == "__main__":
+    print( "[CosmoSim] datagen", __version__ )
     parser = CosmoParser(
           prog = 'CosmoSim makeimage',
           description = 'Generate an image for given lens and source parameters',

{cosmosim-2.6.3 → cosmosim-2.6.5}/src/CosmoSim/dataset.py

@@ -35,10 +35,18 @@ def srcmode(toml):
     if isinstance(r, str): r = [ r ] 
     return r
 def uniform(toml,key,rng=(0,50)):
-    if key in toml: return toml[key]
-    mn = toml.get( f"{key}-min", rng[0] )
-    mx = toml.get( f"{key}-max", rng[1] )
-    return random.uniform(mn,mx)
+    if key in toml:
+        return toml[key]
+    if rng:
+        mn = toml.get( f"{key}-min", rng[0] )
+        mx = toml.get( f"{key}-max", rng[1] )
+        return random.uniform(mn,mx)
+    try:
+        mn = toml.get( f"{key}-min" )
+        mx = toml.get( f"{key}-max" )
+        return random.uniform(mn,mx)
+    except:
+        return None
 
 def getline(idx,toml):
 
@@ -53,6 +61,8 @@ def getline(idx,toml):
 
     # Lens
     einsteinR = uniform( toml["lens"], "einstein", (10,50) )
+    orientation = uniform( toml["lens"], "orientation", rng=None )
+    ellipseratio = uniform( toml["lens"], "ellipseratio", rng=None )
 
     if coor == "polar":
         # Polar Source Co-ordinates
@@ -79,10 +89,12 @@ def getline(idx,toml):
     src = random.choice( srcmode(toml) )
     cfg = random.choice( configs(toml) )
     return pd.Series(
-        data=[ idx,f"image-{idx:04}.png", src, cfg, chi, R, phi,
-               einsteinR, sigma, sigma2, theta, nterms, x, y ],
+        data=[ idx,f"image-{idx:06}.png", src, cfg, chi, R, phi,
+               einsteinR, ellipseratio, orientation, 
+               sigma, sigma2, theta, nterms, x, y ],
         index=[ "index", "filename", "source", "config", "chi", 
-          "R", "phi", "einsteinR", "sigma", "sigma2", "theta", "nterms", "x", "y" ]
+               "R", "phi", "einsteinR", "ellipseratio", "orientation",
+               "sigma", "sigma2", "theta", "nterms", "x", "y" ]
         )
     # return f'"{idx:04}","image-{idx:04}.png",{src},{cfg},{chi},' \
     #      + f'{R},{phi},{einsteinR},{sigma},{sigma2},{theta},{nterms},{x},{y}'

cosmosim-2.6.5/src/CosmoSim/roulettegen.py

@@ -0,0 +1,194 @@
+#! /usr/bin/env python3
+# (C) 2023: Hans Georg Schaathun <georg@schaathun.net>
+
+"""
+Generate an image for given parameters.
+"""
+
+import cv2 as cv
+import sys
+import os
+import numpy as np
+import pandas as pd
+
+from .Image import drawAxes
+from .Parameters import Parameters
+from .datagen import crop
+
+from .Arguments import CosmoParser
+
+from .RouletteAmplitudes import RouletteAmplitudes 
+from . import RouletteSim,RouletteRegenerator,makeSource
+
+class Resim:
+    """
+    Infrastructure to resimulate from roulette amplitudes.
+
+    The class sets up the infrastructure, and provides the methods to
+    run the simulator for each iaage on a CSV file.
+    """
+    def __init__(self,directory,args=None,cfg=None,nterms=None,xireference=True,reflines=False):
+        """
+        Note that `args` overrides Boolean parameters.
+        """
+        self.sim = RouletteSim()
+        self.directory = directory
+        self.rsim = RouletteRegenerator()
+        self.nterms = nterms 
+        self.param = Parameters( args, cfg=cfg )
+        self.xireference = xireference
+        self.reflines = reflines
+        if args is not None:
+            self.xireference = args.xireference
+            if nterms is None and args.nterms:
+                print( "[Resim] Set nterms from args", int(args.nterms) )
+                self.nterms = int(args.nterms)
+            self.loadData( args.csvfile )
+
+    def setAmplitudes( self, row ):
+        maxm = self.coefs.getNterms()
+        rsim = self.rsim
+        for m in range(maxm+1):
+            for s in range((m+1)%2, m+2, 2):
+                print( "row is",  type( row ) )
+                alpha = row.get( f"alpha[{m}][{s}]", 0.0 )
+                beta = row.get( f"beta[{m}][{s}]", 0.0 )
+                print( "alpha/beta are",  type( alpha ), type( beta ) )
+                print( f"alpha[{m}][{s}] = {alpha}\t\tbeta[{m}][{s}] = {beta}." )
+                rsim.setAlphaXi( m, s, alpha )
+                rsim.setBetaXi( m, s, beta )
+    def loadData( self, csvfile ):
+        if isinstance(csvfile,pd.DataFrame):
+            print( "Received dataframe for resimulation" )
+            frame = csvfile
+        else:
+            print( "Load CSV file:", csvfile )
+            frame = pd.read_csv(csvfile,index_col="filename")
+        cols = frame.columns
+        print( "columns:", cols )
+    
+        coefs = RouletteAmplitudes(cols)
+        print( "Number of roulette terms: ", coefs.getNterms() )
+        if self.nterms:
+            print( "[Resim.loadData()] Set nterms from self", int(self.nterms) )
+            self.rsim.setNterms( int(self.nterms) )
+        else:
+            print( "[Resim.loadData()] Set nterms from coefs", int(self.nterms) )
+            self.rsim.setNterms( coefs.getNterms() )
+        self.coefs = coefs
+        self.cols = cols
+        self.frame = frame
+    def makeSingle(self,fn,row,showmask=False):
+        print( "makeSingle" )
+
+        if self.xireference:
+            print( "xi", row["xiX"], row["xiY"], row["sigma"] )
+            pt = (0,0)
+        else:
+            print( "Offset", row["offsetX"], row["offsetY"], row["sigma"] )
+            pt = ( row["offsetX"], row["offsetY"] )
+        self.rsim.setCentrePy( *pt )
+        self.sim.initSim( self.rsim )
+        print( "Initialised simulator at point", pt )
+        self.setAmplitudes( row )
+        self.param.setRow( row )
+        src = makeSource( self.param )
+        self.rsim.setSource( src )
+    
+        self.sim._rsim.update()
+    
+        im = self.sim.getDistortedImage( showmask=showmask ) 
+        if self.xireference:
+              R = np.float32( [ [ 1, 0, row["xiX"] ], [ 0, 1, -row["xiY"] ] ] )
+              m,n = im.shape
+              im = cv.warpAffine(im,R,(n,m))
+        if self.reflines:
+            drawAxes(im)
+    
+        cropsize = self.param.get( "cropsize" )
+        if cropsize:
+            print( "Cropping; cropsize =", cropsize )
+            im = crop( im, cropsize )
+        print( "Distorted image", type(im), im.shape )
+        cv.imwrite(fn,im)
+    
+    def processFile(self,maxcount=None):
+
+        count = 0
+        for fn,row in self.frame.iterrows():
+            print( "[roulettegen.py] Processing", fn )
+
+            fn0 = os.path.join(self.directory, fn ) 
+            self.makeSingle(fn=fn0,row=row)
+            count += 1
+            if maxcount is not None and count > maxcount: break
+        return count
+    def makeActual(self,fn,reflines=False):
+        im = self.sim.getActualImage( reflines=reflines )
+        cv.imwrite(fn,im)
+    def makeApparent(self,fn,reflines=False):
+        im = sim.getApparentImage( reflines=reflines )
+        cv.imwrite(fn,im)
+
+def main(args):
+    """
+    This is the main procedure of the script, simulating a dataset of
+    roulette amplitudes based on a CLI args argument.
+    """
+    if not args.csvfile:
+        raise Exception( "No CSV file given; the --csvfile option is mandatory." )
+
+    resim = Resim( args.directory, args )
+
+    count = 1
+    if args.maxcount is None:
+        maxcount = 2**30
+    else:
+        maxcount = int(args.maxcount)
+
+    # Masking is not implemented in the Resim class.
+    rsim = resim.rsim
+    rsim.setMaskMode( args.mask )
+    if not args.maskradius is None:
+        rsim.setMaskRadius( float(args.maskradius) )
+        
+    for index,row in resim.frame.iterrows():
+            print( "[roulettegen.py] Processing", index )
+
+            fn = row.get("filename",None)
+            print( "filename", fn )
+            if fn is None:
+                try:
+                    namestem = f"image-{int(row['index']):05}" 
+                except:
+                    namestem = f"image-{row['index']}" 
+                fn = namestem + ".png"
+            else:
+                namestem = fn.split(".")[0]
+            fn0 = os.path.join(args.directory, fn ) 
+
+            resim.makeSingle( fn0, row, showmask=args.showmask )
+
+            if args.actual:
+               fn1 = os.path.join(args.directory,"actual-" + str(name) + ".png" ) 
+               resim.makeActual( fn1, args.reflines )
+            if args.apparent:
+                fn2 = os.path.join(args.directory,"apparent-" + str(name) + ".png" ) 
+                resim.makeApparent( fn2, args.reflines )
+
+            count += 1
+            if count > maxcount: break
+
+    print( "[roulettegen.py] Done" )
+
+if __name__ == "__main__":
+    print( "[roulettegen.py] Starting ..." )
+    parser = CosmoParser(
+          prog = 'CosmoSim makeimage',
+          description = 'Generaet an image for given lens and source parameters',
+          epilog = '')
+
+    args = parser.parse_args()
+    if args.directory:
+        os.makedirs( args.directory, exist_ok=True )
+    main(args)

{cosmosim-2.6.3 → cosmosim-2.6.5}/src/CosmoSim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CosmoSim
-Version: 2.6.3
+Version: 2.6.5
 Summary: Simulator of Gravitational Lenses
 Author: Hans Georg Schaathun et al
 Author-email: Hans Georg Schaathun <georg+github@schaathun.net>