CosmoSim 2.7.0__tar.gz → 2.8.1__tar.gz

{cosmosim-2.7.0 → cosmosim-2.8.1}/PKG-INFO

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

{cosmosim-2.7.0 → cosmosim-2.8.1}/src/CosmoSim/CosmoSim.cpp

@@ -14,8 +14,10 @@
 
 
 CosmoSim::CosmoSim() {
-   std::cout << "CosmoSim Constructor\n" ;
-   std::cout << "Number of CPU cores: " << std::thread::hardware_concurrency() << std::endl ; 
+   if (DEBUG) {
+      std::cout << "CosmoSim Constructor\n" ;
+      std::cout << "Number of CPU cores: " << std::thread::hardware_concurrency() << std::endl ; 
+   }
    rPos = -1 ;
 }
 
@@ -124,24 +126,24 @@ void CosmoSim::setModelMode(int m) {
 }
 void CosmoSim::setLensMode(int m) { 
    if ( lensmode != m ) {
-      std::cout << "[CosmoSim.cpp] setLensMode(" << lensmode 
+      if (DEBUG) std::cout << "[CosmoSim.cpp] setLensMode(" << lensmode 
          << " -> " << m << ")\n" ;
       lensmode = m ; 
       modelchanged = 1 ;
    } else {
-      std::cout << "[CosmoSim.cpp] setLensMode(" << lensmode << ") unchanged\n" ;
+      if (DEBUG) std::cout << "[CosmoSim.cpp] setLensMode(" << lensmode << ") unchanged\n" ;
    }
 }
 void CosmoSim::setLens(PsiFunctionLens *l) { 
-   std::cout << "[CosmoSim::setLens]\n" ;
+   if (DEBUG) std::cout << "[CosmoSim::setLens]\n" ;
    lensmode = CSIM_PSI_CLUSTER ; 
    modelchanged = 1 ;
    lens = psilens = l ;
-   std::cout << "[CosmoSim::setLens] returning\n" ;
+   if (DEBUG) std::cout << "[CosmoSim::setLens] returning\n" ;
 }
 void CosmoSim::setSampled(int m) { 
    if ( sampledlens != m ) {
-      std::cout << "[CosmoSim.cpp] setSampled(" << m << " -> " << m << ")\n" ;
+      if (DEBUG) std::cout << "[CosmoSim.cpp] setSampled(" << m << " -> " << m << ")\n" ;
       sampledlens = m ; 
       modelchanged = 1 ;
    }
@@ -152,10 +154,10 @@ void CosmoSim::initLens() {
    if (DEBUG) std::cout << "[initLens] ellipseratio = " << ellipseratio << "\n" ;
    if ( ! modelchanged ) return ;
    if ( sim ) {
-      std::cout << "[initLens] delete sim\n" ;
+      if (DEBUG) std::cout << "[initLens] delete sim\n" ;
       delete sim ;
    }
-   std::cout << "switch( lensmode )\n" ;
+   if (DEBUG) std::cout << "switch( lensmode )\n" ;
    switch ( lensmode ) {
        case CSIM_PSI_CLUSTER:
           std::cout << "[initLens] ClusterLens - no further init\n" ;
@@ -181,9 +183,9 @@ void CosmoSim::initLens() {
          std::cerr << "No such lens model!\n" ;
          throw NotImplemented();
    }
-   std::cout << "[initLens] instantiated lens\n" ;
+   if (DEBUG) std::cout << "[initLens] instantiated lens\n" ;
 
-   std::cout << "switch( modelmode )\n" ;
+   if (DEBUG) std::cout << "switch( modelmode )\n" ;
    switch ( modelmode ) {
        case CSIM_MODEL_POINTMASS_ROULETTE:
          if (DEBUG) std::cout << "Running Roulette Point Mass Lens (mode=" 
@@ -226,9 +228,9 @@ void CosmoSim::configLens() {
          psilens->setRatio( ellipseratio ) ;
          psilens->setOrientation( orientation ) ;
       }
-      if (DEBUG) std::cout << "[runSim] ready for initAlphasBetas\n" ;
+      if (DEBUG) std::cout << "[configLens] ready for initAlphasBetas\n" ;
       psilens->initAlphasBetas() ;
-      if (DEBUG) std::cout << "[runSim] done initAlphasBetas\n" ;
+      if (DEBUG) std::cout << "[configLens] done initAlphasBetas\n" ;
    }
 
    std::cout << "[initLens] ready to sample lens\n" ;
@@ -249,18 +251,18 @@ void CosmoSim::setResolution(int sz ) {
    basesize = sz ; 
 }
 int CosmoSim::setSource( Source *src ) {
-    std::cout  << "[setSource]\n" ;
+    if (DEBUG) std::cout  << "[setSource]\n" ;
     srcmode = CSIM_SOURCE_EXTERN ;
     this->src = src ;
     return 1 ; 
 }
 bool CosmoSim::runSim() { 
-   std::cout  << "[runSim] starting \n" ;
+   if (DEBUG) std::cout  << "[runSim] starting \n" ;
 
    // Configure the lens
    initLens() ;   // initLens() implements changing lens and model modes
    if ( sim == NULL ) {
-      std::cout << "Simulator not initialised after initLens().\n" ;
+      if (DEBUG) std::cout << "Simulator not initialised after initLens().\n" ;
       throw std::logic_error("Simulator not initialised") ;
    }
    configLens() ; // configLens() implements parameter changes
@@ -284,13 +286,13 @@ bool CosmoSim::runSim() {
    // Py_BEGIN_ALLOW_THREADS
    if (DEBUG) std::cout << "[runSim] thread section\n" ;
    if ( sim == NULL ) {
-      std::cout << "Simulator not initialised in thread section.\n" ;
+      if (DEBUG) std::cout << "Simulator not initialised in thread section.\n" ;
       throw std::logic_error("Simulator not initialised") ;
    }
    sim->update() ;
    // Py_END_ALLOW_THREADS
 
-   std::cout << "[runSim] completes\n" ;
+   if (DEBUG) std::cout << "[runSim] completes\n" ;
    return true ;
 }
 bool CosmoSim::moveSim( double rot, double scale ) { 

cosmosim-2.8.1/src/CosmoSim/Helper/Parameters.py

@@ -0,0 +1,51 @@
+# (C) 2024,2026: Hans Georg Schaathun <georg@schaathun.net> 
+
+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`) or
+    a flat `dict` structure (`cfg`) as well as a nested `dict` (`hcfg`)
+    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,args=None,cfg=None,hcfg=None):
+        if args:
+            self._args = args.__dict__
+            if cfg is not None:
+                raise ValueError( "Cannot specify both args and cfg." )
+        elif cfg:
+            self._args = cfg
+        else:
+            self._args = {}
+        self._row = {}
+        if hcfg:
+            cfg1 = hcfg["simulator"]
+            if "cropsize" not in self._args:
+                self._args.cropsize = cfg1.get( "cropsize", 256 )
+            if "imagesize" not in self._args:
+                self._args.imagesize = cfg1.get( "imagesize", 512 )
+            if "source" not in self._args:
+                try:
+                    self._args.source = hcfg["source"]["mode"]
+                except:
+                    self._args.source = None
+    def setRow(self,row):
+        self._row = row
+    def get(self,key,default=None,verbose=0):
+        r = self._args.get( key, default )
+        r = self._row.get(key,r)
+        return r
+    def __getitem__(self,key):
+        return self.get(key)
+    def __setitem__(self,key,v):
+        self._row[key] = v
+

cosmosim-2.8.1/src/CosmoSim/Simulator.py

@@ -0,0 +1,160 @@
+#! /usr/bin/env python3
+# (C) 2026: Hans Georg Schaathun <georg@schaathun.net>
+
+"""
+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.
+
+The constructor may takes a data row, typically a pandas Series object,
+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.
+
+The constructor may take a backend simulator instance as parameter.  This saves
+the cost of reinstantiation in bulk simulation, and it also leaves the possibility
+to set defaults in advance.
+"""
+
+import tomllib as tl
+
+import cv2 as cv
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+from . import CosmoSim
+
+from .Image import centreImage, drawAxes, crop, annotatePoint, annotateCircle, translateImage
+
+from .Arguments import CosmoParser
+from . import Parameters
+import pandas as pd
+
+defaultoutcols = [ "index", "filename", "source", "lens", "chi", "R", "phi", "einsteinR", "sigma", "sigma2", "theta", "x", "y" ]
+
+class GenericSim:
+    """
+    This is a generic superclass for shared methods.
+    """
+    def __init__(self,param=None,row=None,name=None,outcols=None,verbose=1):
+        if verbose > 1: print( "[GenericSim] init ..." )
+        self.verbose = verbose
+
+        self.outcols = outcols
+
+        self.name = name
+        if param is None: 
+            if verbose: print( "[GenericSim] No parameters give. Using defaults" )
+            param = Parameters()
+        self.param = param
+        self.directory = param.get( "directory" )
+        if self.directory:
+            os.makedirs( self.directory, exist_ok=True )
+
+        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):
+        """
+        Run the simulator with the given data row.
+        """
+        if not row is None:
+            if self.verbose > 1: print( "[initSim] using row" )
+            self.setParameters( row )
+            if self.verbose > 1: print( "index", row.get( "index", None ) )
+            self.param.setRow( row )
+            try:
+                name = row.name.split(".")[0]
+            except:
+                name = row["filename"].split(".")[0]
+            self.row = row
+            self.name = name
+        elif self.verbose > 1: print( "[initSim] row is None" )
+        if self.name is None:
+            self.name = self.param.get( "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(
+                "[datagen.py] Centre Point", self.centrepoint,
+                "(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 setParameters(self):
+        raise Exception("Not implemented")
+    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 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 ) )
+        return im
+    def getImage(self,centred=None,cropsize=None,reflines=None):
+        if centred is None: centred = self.param.get( "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 ) )
+        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:
+            fn = str(name) + ".png"
+        else:
+            fn = os.path.join(self.directory, str(name) + ".png" )
+        if self.verbose: print( "[saveImage]", fn )
+        cv.imwrite(fn,im)

{cosmosim-2.7.0 → cosmosim-2.8.1}/src/CosmoSim/__init__.py

@@ -1,4 +1,4 @@
-# (C) 2022-24: Hans Georg Schaathun <georg@schaathun.net> 
+# (C) 2022-26: Hans Georg Schaathun <georg@schaathun.net> 
 
 """
 The CosmoSim package comprises several components, including scripts,
@@ -11,21 +11,53 @@ import threading as th
 import os, sys
 
 import traceback
+from .Helper.Parameters import Parameters 
 
-__version__ = "2.7.0"
+__version__ = "2.8.1"
 
 ModelSpec = cs.ModelSpec
 SourceSpec = cs.SourceSpec
 PsiSpec = cs.PsiSpec
 LightProfileSpec = cs.LightProfileSpec
-
-RouletteRegenerator = cs.RouletteRegenerator 
 Point = cs.Point 
 
-def makeSourceConstellation(src,size):
+class RouletteRegenerator(cs.RouletteRegenerator):
+    def __init__(self,*a,verbose=1,**kw):
+        super().__init__(*a,**kw)
+        self.verbose = verbose
+        self.bgcolour = 0
+    def makeSource(self,param):
+        if param.get( "imagesize" ) is None:
+            raise Exception( "Image size not specified" )
+        self._src = makeSource(param)
+        self.setSource( self._src )
+        if self.verbose>1:
+            print( "RouletteRegenerator.makeSource() returns" )
+    def getDistortedImage(self,reflines=False,critical=False,mask=False,showmask=False):
+        """
+        Return the Distorted Image from the simulator as a numpy array.
+        """
+        try:
+            if mask: self.maskImage()
+            if showmask: self.showMask()
+        except:
+            print( "Masking not supported for this lens model." )
+        try:
+            im = np.array(self.getDistorted(),copy=False)
+        except Exception as e:
+            print( "self", type(self) )
+            print( "reflines", reflines )
+            print( "critical", critical )
+            im = np.array(self.getDistorted(),copy=False)
+            raise e
+        if im.shape[2] == 1 : im.shape = im.shape[:2]
+        return np.maximum(im,self.bgcolour)
+
+def makeSourceConstellation(src,size,verbose=1):
     ss = src.split(";")
     sl = [ x.split("/") for x in ss ]
-    print( "makeSourceConstellation: src=", src, "size=", size, "sl=", sl )
+    if verbose:
+        print( "makeSourceConstellation: src=", src, "size=", size, "sl=", sl )
     constellation = SourceConstellation(size)
     for s in sl:
         mode = sourceDict[s[0]]
@@ -43,24 +75,27 @@ def makeSourceConstellation(src,size):
             raise Exception( "Unknown Source Mode" )
 
         constellation.addSource( constituent, float(s[1]), float(s[2]))
-    print( "makeSourceConstellation() returns" )
+    if verbose>1:
+        print( "makeSourceConstellation() returns" )
     return constellation
 
-def makeSource(param):
+def makeSource(param,verbose=0):
     """
     Factory function to create a Source object given the parameter list.
     """
     size = int( param.get( "imagesize" ) )
     src = param.get("source")
     ltprf0 = param.get( "lightprofile", None )
-    print( f"[makeSource] src={src}, ltprf0={ltprf0}" )
+    if verbose:
+        print( f"[makeSource] src={src}, ltprf0={ltprf0}" )
     if src.find("/") < 0:
        mode = sourceDict[src]
        if ltprf0 is None:
            ltprf = lightProfileDict.get( src, LightProfileSpec.Gaussian ) 
        else:
            ltprf = lightProfileDict.get( ltprf0, LightProfileSpec.Gaussian ) 
-       print( f"[makeSource] mode={mode}, ltprf={ltprf}" )
+       if verbose:
+          print( f"[makeSource] mode={mode}, ltprf={ltprf}" )
        if mode == sourceDict.get( "Spherical" ):
            r = cs.SphericalSource( size, float(param.get( "sigma" )), ltprf)
        elif mode == sourceDict.get( "Ellipsoid" ):
@@ -75,8 +110,10 @@ def makeSource(param):
            raise Exception( "Unknown Source Mode" )
     else:
         r = makeSourceConstellation(src,size)
-        print( "makeSource() - makeSourceConstellation() has returned" )
-    print( "makeSource() returns" )
+        if verbose:
+            print( "makeSource() - makeSourceConstellation() has returned" )
+    if verbose>1:
+        print( "makeSource() returns" )
     return r 
 
 lensDict = {
@@ -183,9 +220,10 @@ def getSourceFileName():
     
 
 class SourceConstellation(cs.SourceConstellation):
-    def __init__(self,size):
+    def __init__(self,size,verbose=1):
         self._sources = []
-        print( "SourceConstellation.__init__" )
+        self.verbose = 1
+        if verbose: print( "SourceConstellation.__init__" )
         super().__init__(size)
     def addSource(self,src,*a):
         self._sources.append(src)
@@ -307,8 +345,8 @@ class CosmoSim(cs.CosmoSim):
         print( f"setModelMode({s})")
         # traceback.print_stack()
         return super().setModelMode( int( modelDict[s] ) ) 
-    def setConfigMode(self,s):
-        print( f"setConfigMode({s})")
+    def setConfigMode(self,s,verbose=0):
+        if verbose > 1: print( f"setConfigMode({s})")
         (model,lens,sampleMode) = configDict[s]
         super().setSampled( int( sampleMode ) ) 
         super().setLensMode( int( lens ) ) 
@@ -376,50 +414,14 @@ class CosmoSim(cs.CosmoSim):
             if showmask: self.showMask()
         except:
             print( "Masking not supported for this lens model." )
-        im = np.array(self.getDistorted(reflines,critical),copy=False)
-        if im.shape[2] == 1 : im.shape = im.shape[:2]
-        return np.maximum(im,self.bgcolour)
-class RouletteSim:
-    """
-    Simulator for gravitational lensing.
-    This wraps the CosmoSim library written in C++.  In particular,
-    it wraps functions returning images, to convert the data to 
-    numpy arrays.
-    """
-    def __init__(self,*a,maxm=50,**kw):
-        super().__init__(*a,**kw)
-
-        self.bgcolour = 0
-
-    def setBGColour(self,s):
-        self.bgcolour = s
-
-    def getApparentImage(self,reflines=True):
-        """
-        Return the Apparent Image from the simulator as a numpy array.
-        """
-        im = np.array(self._rsim.getApparent(),copy=False)
-        if im.shape[2] == 1 : im.shape = im.shape[:2]
-        return np.maximum(im,self.bgcolour)
-    def getActualImage(self,reflines=True,caustics=False):
-        """
-        Return the Actual Image from the simulator as a numpy array.
-        """
-        im = np.array(self._rsim.getActual(),copy=False)
-        if im.shape[2] == 1 : im.shape = im.shape[:2]
-        return np.maximum(im,self.bgcolour)
-    def initSim(self,rsim):
-        self._rsim = rsim
-
-    def getDistortedImage(self,reflines=False,mask=False,showmask=False):
-        """
-        Return the Distorted Image from the simulator as a numpy array.
-        """
         try:
-            if mask: self._rsim.maskImage()
-            if showmask: self._rsim.showMask()
-        except:
-            print( "Masking not supported for this lens model." )
-        im = np.array(self._rsim.getDistorted(),copy=False)
+            im = np.array(self.getDistorted(reflines,critical),copy=False)
+        except Exception as e:
+            print( "self", type(self) )
+            print( "reflines", reflines )
+            print( "critical", critical )
+            im = np.array(self.getDistorted(),copy=False)
+            raise e
         if im.shape[2] == 1 : im.shape = im.shape[:2]
         return np.maximum(im,self.bgcolour)
+