CosmoSim 3.0.5__tar.gz → 3.1.0b1__tar.gz

{cosmosim-3.0.5 → cosmosim-3.1.0b1}/PKG-INFO

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

{cosmosim-3.0.5 → cosmosim-3.1.0b1}/src/CosmoSim/CLI/Arguments.py

@@ -108,7 +108,6 @@ paramap = {
         "orientation" : ( "lens", "orientation" ),
         "ratio" : ( "lens", "ellipseratio" ), # relabelled
         "ellipseratio" : ( "lens", "ellipseratio" ), # duplicate
-        "einsteinR" : ( "lens", "einsteinR" ), 
         "cluster" : ( "lens", "cluster" ), 
 
         "sigma" :  ( "source", "sigma" ),
@@ -303,8 +302,8 @@ def setParameters(sim,row,verbose=1):
     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("einsteinradius",None) != None:
+        sim.setEinsteinR( row.get( "einsteinradius" ) )
     if row.get("ellipseratio",None) != None:
         sim.setRatio( row.get( "ellipseratio" ) )
     if row.get("orientation",None) != None:

{cosmosim-3.0.5 → cosmosim-3.1.0b1}/src/CosmoSim/CosmoSim.cpp

@@ -63,14 +63,14 @@ double CosmoSim::getAlphaXi( int m, int s ) {
 
    // cv::Point2d xi = lens->getXi( sim->getEta() ) ;
    cv::Point2d xi = sim->getXi() ;
-   if (DEBUG) std::cout << "[getAlphaXi] xi = " << xi << std::endl ;
+   if (DEBUG>1) std::cout << "[getAlphaXi] xi = " << xi << std::endl ;
    return getAlpha( xi.x, xi.y, m, s ) ;
 
 }
 double CosmoSim::getBetaXi( int m, int s ) {
    // cv::Point2d xi = lens->getXi( sim->getEta() ) ;
    cv::Point2d xi = sim->getXi( ) ;
-   if (DEBUG) std::cout << "[getBetaXi] xi = " << xi << std::endl ;
+   if (DEBUG>1) std::cout << "[getBetaXi] xi = " << xi << std::endl ;
    return getBeta( xi.x, xi.y, m, s ) ;
 }
 double CosmoSim::getAlpha(

{cosmosim-3.0.5 → cosmosim-3.1.0b1}/src/CosmoSim/Makefile

@@ -8,8 +8,13 @@ P=./Roulettes
 %.txt: %.raw
 	sort $< > $@
 
+sis%sie.raw:  $P/__main__.py
+	time python3 -m CosmoSim.Roulettes.sie --circular --lens SIS --output $@ $* 8
+pm%sie.raw:  $P/__main__.py
+	time python3 -m CosmoSim.Roulettes.sie --circular --lens PM --output $@ $* 8
+
 sis%.raw:  $P/__main__.py
-	time python3 -m CosmoSim.Roulettes --output $@ $* 8
+	time python3 -m CosmoSim.Roulettes --lens SIS --output $@ $* 8
 pm%.raw:  $P/__main__.py
 	time python3 -m CosmoSim.Roulettes --lens PM --output $@ $* 8
 

cosmosim-3.1.0b1/src/CosmoSim/Roulettes/Parser.py

@@ -0,0 +1,75 @@
+# (C) 2026: Hans Georg Schaathun <georg@schaathun.net> 
+
+"""
+Evaluate roulette amplitudes using `sympy` in python.
+
+This module has been created for debugging, to validate calculations made in
+C++.  It seems to be easier to compute with arbitrary precision in python/sympy
+than in C++/symengine.
+"""
+
+import sympy
+from sympy.parsing.sympy_parser import parse_expr
+
+import numpy as np
+import pandas as pd
+from .. import getMS
+
+def eval1(expr,x,y,g,precision=64):
+    """
+    Evaluate the expression `expr` substituting for `x`, `y`, and `g` in 
+    high precision.
+
+    This is a sketch.
+    """
+    x0,y0,g0 = sympy.symbols("x,y,g")
+    return expr.evalf( precision, subs={ x0: x, y0: y, g0: g } )
+
+
+class RouletteParser:
+    """ Parse, manage, and evaluate algebraic expressions for roulette amplitudes.
+    """
+    def __init__(self,fn,g=None,verbose=1):
+        self.verbose = verbose
+        with open(fn, 'r') as f:
+            if verbose: print( "Opened file", fn ) 
+            c = f.read()
+        cs = [ x.split(":") for x in c.split( "\n" ) if x != "" ]
+        print( cs[:2] )
+        self.alpha = {}
+        self.beta = {}
+        self.einstein = g
+        for x in cs:
+            try:
+                m,s,a,b = x
+                m = int( m )
+                s = int( s )
+                a = parse_expr( a )
+                b = parse_expr( b )
+            except:
+                print( x )
+                raise RuntimeException( "Parse error in amplitudes file." )
+            self.alpha[(m,s)] = a
+            self.beta[(m,s)] = b
+    def getAlpha(self,x,y,g,m,s):
+         """get `alpha[m][s]` for Einstein radius `g` at the point (`x`,`y`). """
+         return eval1(self.alpha[(m,s)],x,y,g)
+    def getBeta(self,x,y,g,m,s):
+         """get `beta[m][s]` for Einstein radius `g` at the point (`x`,`y`). """
+         return eval1(self.beta[(m,s)],x,y,g)
+    def getAlphaBetas(self,pt,g=None,maxm=5):
+        """
+        Get the roulette amplitudes for a given point in the source plane.
+        """
+        if self.verbose>1:
+            print ( "[getAlphaBetas] pt=", pt, "in Planar Co-ordinates"  )
+        try:
+            (x,y) = (pt[0],pt[1])
+        except:
+            (x,y) = np.array(pt)
+        # Scaling is done in getAlpha/getBeta
+        if g is None:
+            g = self.einstein
+        ab1 = { f"alpha[{m}][{s}]" : self.getAlpha(x,y,g,m,s) for (m,s) in getMS(maxm) }
+        ab2 = { f"beta[{m}][{s}]" : self.getBeta(x,y,g,m,s) for (m,s) in getMS(maxm) }
+        return pd.concat( [ pd.Series( ab1 ), pd.Series( ab2 ) ] )

{cosmosim-3.0.5 → cosmosim-3.1.0b1}/src/CosmoSim/Roulettes/sie.py

@@ -39,13 +39,10 @@ def firstworker(q,resDict,maxm=6):
         # `q.task_done()` is called.  Hence the queue will not be
         # empty if the current job should spawn new ones. 
     print ( "I.", os.getpid(),"returning" )
-def secondworker(q,psidiff,diff1,vars,circular=False ):
-    print ( os.getpid(),"working" )
+def secondworker(q,psidiff,diff1,vars):
+    print ( "secondworker", os.getpid(),"working" )
     cont = True
-    if circular:
-        theta = 0
-    else:
-        theta = symbols("p",real=True)
+    theta = symbols("p",real=True)
     x,y = vars
     x1,y1 = symbols("x1 y1",real=True)
     while cont:
@@ -70,6 +67,29 @@ def secondworker(q,psidiff,diff1,vars,circular=False ):
         print ( "II.", os.getpid(), "completes" )
         cont = False
     print ( "II.", os.getpid(),"returning" )
+def cworker(q,psidiff,diff1,vars):
+    print ( "cworker", os.getpid(),"working" )
+    cont = True
+    x,y = vars
+    while cont:
+      try:
+        m,n = q.get(False)   # does not block
+        res = sum( [
+                  binomial( m, i )*
+                  binomial( n, j )*
+                  1**(m-i+j)*
+                  0**(n-j+i)*
+                  (-1)**i
+                  * diff1[(m+n-i-j,j+i)]
+                  for i in range(m+1) for j in range(n+1) ] ) 
+        res = sympy.expand( res )    # This is too slow
+        # res = sympy.simplify( res )  # This is too slow
+        print( "II. (circular)", os.getpid(), m, n )
+        psidiff[(m,n)] = res
+      except queue.Empty:
+        print ( "II. (circular)", os.getpid(), "completes" )
+        cont = False
+    print ( "II. (circular)", os.getpid(),"returning" )
 
 def thirdworker(q,ampdict,indict, var=[] ):
     print ( os.getpid(),"working" )
@@ -92,12 +112,14 @@ def thirdworker(q,ampdict,indict, var=[] ):
         if s == 0:
                a /= 2
         print( "III (Chris).", os.getpid(), m, s )
+        sys.stdout.flush()
         ampdict[(m,s)] = (a,b)
       except queue.Empty:
         print ( "III.", os.getpid(), "completes" )
         cont = False
 
     print ( "III.", os.getpid(),"returning" )
+    sys.stdout.flush()
 
 class RouletteManager():
     def __init__(self,psivec=None,secondworker=secondworker,thirdworker=thirdworker):
@@ -140,9 +162,9 @@ class RouletteManager():
 
         for k in self.diff1.keys():
            q.put( k )
-        pool = mp.Pool(nproc, secondworker,(q,psidiff,self.diff1,self.vars))
+        # All jobs are submitted before the Pool starts
+        pool = mp.Pool(nproc, self.secondworker,(q,psidiff,self.diff1,self.vars))
 
-        q.close()
         pool.close()
         pool.join()
 
@@ -170,7 +192,6 @@ class RouletteManager():
                q.put((m,s))
         pool = mp.Pool(nproc, self.thirdworker,(q,rdict,self.psidiff,self.vars))
 
-        q.close()
         pool.close()
         pool.join()
 
@@ -180,7 +201,6 @@ class RouletteManager():
         print( "Time spent:", time.time() - start)
         return rdict
 
-def cworker(*a,**kw): return secondworker( *a, circular=True, **kw )
 
 def main(f=thirdworker):
     parser = argparse.ArgumentParser(description='Generate roulette amplitude formulæ for CosmoSim.')

{cosmosim-3.0.5 → cosmosim-3.1.0b1}/src/CosmoSim/__init__.py

@@ -10,6 +10,7 @@ to make the python API more streamlined.
 
 import CosmoSim.CosmoSimPy as cs
 import numpy as np
+import pandas as pd
 import threading as th
 import os, sys
 from .CLI import Arguments
@@ -19,7 +20,7 @@ Parameters = Arguments.Parameters
 
 import traceback
 
-__version__ = "3.0.5"
+__version__ = "3.1.0b1"
 
 class SphericalSource(cs.SphericalSource):
     """Spherical source model.
@@ -154,11 +155,6 @@ def getMS(minm,maxm=None):
         minm = 0
     return [ (m,s) for m in range(minm,maxm+1)
                                     for s in range(1-m%2,m+2,2) ]
-def getMSheaders(maxm): 
-    if maxm is None:
-        raise RuntimeError( "None argument to getMSheaders()." )
-    r = [ ( f"alpha[{m}][{s}]", f"beta[{m}][{s}]") for (m,s) in getMS(maxm) ]
-    return [ x for p in r for x in p ]
 
 maxmlist = [ 50, 100, 200 ]
 def getFileName(maxm):
@@ -241,6 +237,7 @@ class CosmoSim(cs.CosmoSim):
         if self.verbose > 2:
             print ( "[getOffset] r=", a )
         return (a[0],a[1])
+
     def getAlphaBetas(self,maxm=2,pt=None):
         """
         Get the roulette amplitudes for a given point in the source plane.
@@ -248,14 +245,18 @@ class CosmoSim(cs.CosmoSim):
         if self.verbose>1:
             print ( "[getAlphaBetas] pt=", pt, "in Planar Co-ordinates"  )
         if pt == None:
-           r = [ (self.getAlphaXi(m,s),self.getBetaXi(m,s)) for (m,s) in getMS(maxm) ]
+           ab1 = { f"alpha[{m}][{s}]" : self.getAlphaXi(m,s) 
+                   for (m,s) in getMS(maxm) }
+           ab2 = { f"beta[{m}][{s}]" : self.getBetaXi(m,s) 
+                   for (m,s) in getMS(maxm) }
         else:
             (x,y) = pt
             # Scaling is done in getAlpha/getBeta
-            r = [ (self.getAlpha(x,y,m,s),self.getBeta(x,y,m,s)) 
-                    for (m,s) in getMS(maxm) ]
-        return [ x for p in r for x in p ]
-
+            ab1 = { f"alpha[{m}][{s}]" : self.getAlpha(x,y,m,s) 
+                    for (m,s) in getMS(maxm) }
+            ab2 = { f"beta[{m}][{s}]" : self.getBeta(x,y,m,s) 
+                    for (m,s) in getMS(maxm) }
+        return pd.concat( [ pd.Series( ab1 ), pd.Series( ab2 ) ] )
     def close(self):
         """
         Terminate the worker thread.
@@ -407,4 +408,3 @@ class CosmoSim(cs.CosmoSim):
             raise e
         if im.shape[2] == 1 : im.shape = im.shape[:2]
         return np.maximum(im,self.bgcolour)
-

{cosmosim-3.0.5 → cosmosim-3.1.0b1}/src/CosmoSim/datagen.py

@@ -16,10 +16,11 @@ import matplotlib.pyplot as plt
 from .dataset import datasetgen
 
 from .Image import centreImage, drawAxes, crop, annotatePoint, annotateCircle, translateImage
-from . import getMSheaders,CosmoSim,__version__
+from . import CosmoSim,__version__
 
 from .CLI.Simulator import GenericSim
 from .CLI.Arguments import setParameters,Parameters
+from .Roulettes.Parser import RouletteParser
 
 import pandas as pd
 
@@ -55,6 +56,53 @@ class SimImage(GenericSim):
         """
         if self.verbose: print( "[SimImage] setParameters()" )
         return setParameters(self.sim,row,verbose=self.verbose)
+    def getRoulette(self,precision=None,fn=None,verbose=None):
+        if verbose is None: verbose = self.verbose
+        sim = self.sim
+        if self.param.get( "centred" ):
+            centrepoint = self.centrepoint
+        else:
+            centrepoint = (0,0)
+        maxm = self.param.get( ( "simulator", "nterms" ), 16 )
+        xireference = self.param.get( "xireference", True )
+
+        releta = sim.getRelativeEta(centrepoint=centrepoint)
+        offset = sim.getOffset(centrepoint=centrepoint)
+        if verbose: print( "[getRoulette] ", offset, centrepoint )
+
+        xioffset = sim.getXiOffset(centrepoint)
+        if xireference:
+            xi = sim.getNu()
+        else:
+            xi = centrepoint
+        
+        relcols = [ "centreX", "centreY",
+                   "reletaX", "reletaY",
+                   "offsetX", "offsetY",
+                   "xiX", "xiY" ]
+        r1 = pd.Series(
+                { "source" : self.param.get( "source" )
+                , "x" : self.param.get( "x" )
+                , "y" : self.param.get( "y" )
+                , "sigma" : self.param.get( "sigma" )
+                , "sigma2" : self.param.get( "sigma2" )
+                , "theta" : self.param.get( "theta" )
+                } )
+        r2 = pd.Series(
+              [ centrepoint[0], centrepoint[1], releta[0], releta[1],
+               offset[0], offset[1], xioffset[0], xioffset[1] ],
+              index=relcols ) 
+        if fn is None:
+            fn = self.getAmplitudeFile() 
+        g = self.param.get( ( "lens", "einsteinradius" ) )
+        if verbose: print( "Einstein radius", g )
+        rp = RouletteParser( fn, g=g, verbose=self.verbose )
+        r1 = pd.concat( [ r1, r2, rp.getAlphaBetas(xi,maxm=maxm) ] )
+        r1.name = self.param.get( "filename" )
+        if verbose > 1:
+            print( f"New row (verbosity={verbose})" )
+            print( r1 )
+        return r1
     def getData(self,verbose=None):
         if verbose is None: verbose = self.verbose
         sim = self.sim
@@ -64,11 +112,10 @@ class SimImage(GenericSim):
         else:
             if verbose: print( "[getData] not centred" )
             centrepoint = (0,0)
-        maxm = self.param.get( "nterms", 16 )
+        maxm = self.param.get( ( "simulator", "nterms" ), 16 )
         xireference = self.param.get( "xireference", True )
         if 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)
         if verbose > 2: print( "[SimImage.getData] ", centrepoint )
         offset = sim.getOffset(centrepoint=centrepoint)
@@ -99,8 +146,7 @@ class SimImage(GenericSim):
               [ centrepoint[0], centrepoint[1], releta[0], releta[1],
                offset[0], offset[1], xioffset[0], xioffset[1] ],
               index=relcols ) 
-        r3 = pd.Series( ab, index=getMSheaders(maxm)) 
-        r1 = pd.concat( [ r1, r2, r3 ] )
+        r1 = pd.concat( [ r1, r2, ab ] )
         if verbose > 1:
             print( f"New row (verbosity={verbose})" )
             print( r1 )
@@ -194,6 +240,11 @@ class SimImage(GenericSim):
         fn = os.path.join(self.directory,"kappa-" + str(self.name) + ".svg" ) 
         plt.savefig( fn )
         plt.close()
+    def getAmplitudeFile(self):
+        fn = self.param.get( ( "lens", "amplitudefile" ) )
+        if fn is None: 
+            raise NotImplemented( "Not implemented lookup of default amplitudes file." )
+        return fn
 
 def makeSingle(param=None,name=None,outcols=None,sim=None,verbose=0):
     """Process a single parameter set, given either as a pandas row or

{cosmosim-3.0.5 → cosmosim-3.1.0b1}/src/CosmoSim/dataset.py

@@ -128,18 +128,18 @@ def rndsource(toml,einstein=50,verbose=1):
         )
 
 def rndlens(toml,verbose=1):
-    einsteinR = uniform( toml["lens"], "einstein", (10,50) )
+    einsteinradius = uniform( toml["lens"], "einstein", (10,50) )
     orientation = uniform( toml["lens"], "orientation", rng=None )
     ellipseratio = uniform( toml["lens"], "ellipseratio", rng=None )
 
     return pd.Series(
-        data=[  einsteinR, ellipseratio, orientation ],
-        index=[ "einsteinR", "ellipseratio", "orientation" ]
+        data=[  einsteinradius, ellipseratio, orientation ],
+        index=[ "einsteinradius", "ellipseratio", "orientation" ]
         )
 
 def lensSpec(toml,verbose=0):
     param = rndlens(toml,verbose)
-    eR = param["einsteinR"]
+    eR = param["einsteinradius"]
     c = toml.get( ("cluster","maxrelativelocation"), 1.2 )
     rmax = c*eR
     phi = random.uniform(0,359)
@@ -201,7 +201,7 @@ def getline(toml,idx=0,fn=None,verbose=1):
         cfg = lensmodes(toml)
         if cfg is not None: c["lens"] = random.choice( cfg )
         l =  rndlens( toml, verbose )
-        eR = l["einsteinR"]
+        eR = l["einsteinradius"]
     s = rndsource( toml, einstein=eR, verbose=verbose )
 
     return pd.concat( [ r, l, s ] )