fargopy 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

fargopy/__init__.py

@@ -1,10 +1,7 @@
 ###############################################################
-# Import montu modules
+# Version
 ###############################################################
 from fargopy.version import *
-from fargopy.util import *
-from fargopy.sys import *
-from fargopy.fargo3d import *
 
 ###############################################################
 # External modules
@@ -23,88 +20,59 @@ import numpy as np
 DEG = np.pi/180
 RAD = 1/DEG
 
-FP_HOME = os.environ['HOME']
-FP_DOTDIR = f"{FP_HOME}/.fargopy" 
-FP_RCFILE = f"{FP_DOTDIR}/fargopyrc"
-
-# Default configuration
-FP_CONFIGURATION = f"""# This is the configuration variables for FARGOpy
-# Package
-FP_VERSION = '{version}'
-# System
-FP_HOME = '{FP_HOME}'
-# Directories
-FP_DOTDIR = '{FP_DOTDIR}'
-FP_RCFILE = '{FP_RCFILE}'
-# Behavior
-FP_VERBOSE = False
-# FARGO3D variablles
-FP_FARGO3D_CLONECMD = 'git clone https://bitbucket.org/fargo3d/public.git'
-FP_FARGO3D_BASEDIR = './'
-FP_FARGO3D_PACKDIR = 'fargo3d/'
-FP_FARGO3D_BINARY = 'fargo3d'
-FP_FARGO3D_HEADER = 'src/fargo3d.h'
-"""
-
-FP_INITIAL_SCRIPT = """
-import sys
-import fargopy as fp
-fp.initialize(' '.join(sys.argv))
-"""
-
 ###############################################################
-# Base routines
+# Base classes
 ###############################################################
 class Debug(object):
+    """The Debug class control the Debugging messages of the package.
+
+    Attribute:
+        VERBOSE: bool, default = False:
+            If True all the trace messages are shown.
+
+    Static methods:
+        trace(msg):
+            Show a debugging message if VERBOSE=True
+            Example:
+            >>> import fargopy as fp
+            >>> fp.Debug.VERBOSE = True
+            >>> fp.initialize('configure') 
+    """
     VERBOSE = False
     @staticmethod
     def trace(msg):
         if Debug.VERBOSE:
             print("::"+msg)
 
-def initialize(options='', force=False):
-    if ('configure' in options) or ('all' in options):
-        # Create configuration directory
-        if not os.path.isdir(FP_DOTDIR) or force:
-            Debug.trace(f"Configuring FARGOpy...")
-            # Create directory
-            os.system(f"mkdir -p {FP_DOTDIR}")
-            # Create configuration variables
-            f = open(f"{FP_DOTDIR}/fargopyrc",'w')
-            f.write(FP_CONFIGURATION)
-            f.close()
-            # Create initialization script
-            f = open(f"{FP_DOTDIR}/ifargopy.py",'w')
-            f.write(FP_INITIAL_SCRIPT)
-            f.close()
-
-    if ('download' in options) or ('all' in options):
-        print("Downloading FARGOpy...")
-        fargo_dir = f"{FP_FARGO3D_BASEDIR}/{FP_FARGO3D_PACKDIR}".replace('//','/')
-        if not os.path.isdir(fargo_dir):
-            fargopy.Sys.simple(f"{FP_FARGO3D_CLONECMD} {FP_FARGO3D_PACKDIR}")
-            print(f"\tFARGO3D downloaded to {fargo_dir}")
-        else:
-            print(f"\tFARGO3D directory already present in '{fargo_dir}'")
-        
-        fargo_header = f"{fargo_dir}/{FP_FARGO3D_HEADER}"
-        if not os.path.isfile(fargo_header):
-            print(f"No header file for fargo found in '{fargo_header}'")
-        
-    if ('compile' in options) or ('all' in options):
-        print("Test compilation")
-        pass
-
 class Dictobj(object):
     """Convert a dictionary to an object
 
+    Initialization attributes:
+        dict: dictionary:
+            Dictionary containing the attributes.
+
+    Attributes:
+        All the keys in the initialization dictionary.
+
     Examples:
-        ob = Dictobj(a=2,b=3)
-        print(ob.a,ob.b)
-        ob = Dictobj(dict=dict(a=2,b=3))
-        print(ob.a,ob.b)
-        ob = Dictobj(dict={'a':2,'b':3})
-        print(ob.a,ob.b)
+        Three ways to initialize the same `Dictobj`:
+        >>> ob = Dictobj(a=2,b=3)
+        >>> ob = Dictobj(dict=dict(a=2,b=3))
+        >>> ob = Dictobj(dict={'a':2,'b':3})
+
+        In the three cases you may access the attributes using:
+        >>> print(ob.a,ob.b)
+
+    Methods:
+        keys():
+            It works like the keys() method of a dictionary.
+        item(key):
+            Recover the value of an attribute as it was a dictionary.
+            Example:
+                >>> ob.item('a') 
+        print_keys():
+            Print a list of keys
+        
     """
 
     def __init__(self, **kwargs):
@@ -115,6 +83,10 @@ class Dictobj(object):
             setattr(self, key, value)
 
     def keys(self):
+        """Show the list of attributes of Dictobj
+
+        This method works as the keys() method of a regular dictionary.
+        """
         props = []
         for i,prop in enumerate(self.__dict__.keys()):
             if '__' in prop:
@@ -122,7 +94,16 @@ class Dictobj(object):
             props += [prop]
         return props
 
+    def item(self,key):
+        """Get the value of an item of a Dictobj.
+        """
+        if key not in self.keys():
+            raise ValueError(f"Key 'key' not in Dictobj")
+        return self.__dict__[key]
+
     def print_keys(self):
+        """Print all the keys of a Dictobj.
+        """
         prop_list=''
         for i,prop in enumerate(self.keys()):
             prop_list += f"{prop}, "
@@ -130,17 +111,135 @@ class Dictobj(object):
                 prop_list += '\n'
         print(prop_list.strip(', '))
 
-    def item(self,key):
-        if key not in self.keys():
-            raise ValueError(f"Key 'key' not in Dictobj")
-        return self.__dict__[key]
-
     def __str__(self):
         return str(self.__dict__)
 
     def __repr__(self):
         return self.__str__()
 
+class Fargobj(object):
+    def __init__(self,**kwargs):
+        self.fobject = True
+        self.kwargs = kwargs
+
+    def set_property(self,property,default,method=lambda prop:prop):
+        """Set a property of object using a given method
+
+        Examples:
+            >>> obj = Fargobj()
+            >>> obj.set_property('a',1)
+            >>> print(obj.a)
+            1
+        """
+        if property in self.kwargs.keys():
+            method(self.kwargs[property])
+            self.__dict__[property] = self.kwargs[property]
+            return True
+        else:
+            method(default)
+            self.__dict__[property] = default
+            return False
+        
+    def has(self,key):
+        """Check if a key is an attribute of Fargobj object
+
+        Examples:
+            >>> obj = Fargobj(a=1)
+            >>> print(obj.has('a'))
+            True
+        """
+        if key in self.__dict__.keys():
+            return True
+        else:
+            return False
+
+###############################################################
+# Package configuration
+###############################################################
+# Basic (unmodifiable) variables
+Conf = Dictobj()
+Conf.FP_HOME = os.environ['HOME']
+Conf.FP_DOTDIR = f"{Conf.FP_HOME}/.fargopy" 
+Conf.FP_RCFILE = f"{Conf.FP_DOTDIR}/fargopyrc"
+
+# Default configuration file content
+Conf.FP_CONFIGURATION = f"""# This is the configuration variables for FARGOpy
+# Package
+FP_VERSION = '{version}'
+# System
+FP_HOME = '{Conf.FP_HOME}/'
+# Directories
+FP_DOTDIR = '{Conf.FP_DOTDIR}'
+FP_RCFILE = '{Conf.FP_RCFILE}'
+# Behavior
+FP_VERBOSE = False
+# FARGO3D variablles
+FP_FARGO3D_CLONECMD = 'git clone https://bitbucket.org/fargo3d/public.git'
+FP_FARGO3D_BASEDIR = '{Conf.FP_HOME}'
+FP_FARGO3D_PACKDIR = 'fargo3d/'
+FP_FARGO3D_BINARY = 'fargo3d'
+FP_FARGO3D_HEADER = 'src/fargo3d.h'
+"""
+
+# Default initialization script
+Conf.FP_INITIAL_SCRIPT = """
+import sys
+import fargopy as fp
+fp.initialize(' '.join(sys.argv))
+"""
+
+def initialize(options='', force=False):
+    """Initialization routine
+
+    Args:
+        options: string, default = '':
+            Action(s) to be performed. Valid actions include:
+                'configure': configure the package.
+                'download': download FARGO3D directory.
+                'compile': attempt to compile FARGO3D in the machine.
+                'all': all actions.
+
+        force: bool, default = False:
+            If True, force any action that depends on a previous condition.
+            For instance if options = 'configure' and force = True it will
+            override FARGOpy directory.
+    """
+    if ('configure' in options) or ('all' in options):
+        # Create configuration directory
+        if not os.path.isdir(Conf.FP_DOTDIR) or force:
+            Debug.trace(f"Configuring FARGOpy at {Conf.FP_DOTDIR}...")
+            # Create directory
+            os.system(f"mkdir -p {Conf.FP_DOTDIR}")
+            # Create configuration variables
+            f = open(f"{Conf.FP_DOTDIR}/fargopyrc",'w')
+            f.write(Conf.FP_CONFIGURATION)
+            f.close()
+            # Create initialization script
+            f = open(f"{Conf.FP_DOTDIR}/ifargopy.py",'w')
+            f.write(Conf.FP_INITIAL_SCRIPT)
+            f.close()
+        else:
+            Debug.trace(f"Configuration already in place.")
+
+    if ('download' in options) or ('all' in options):
+        print("Downloading FARGOpy...")
+        fargo_dir = f"{Conf.FP_FARGO3D_BASEDIR}/{Conf.FP_FARGO3D_PACKDIR}".replace('//','/')
+        if not os.path.isdir(fargo_dir) or force:
+            fargopy.Sys.simple(f"cd {Conf.FP_FARGO3D_BASEDIR};{Conf.FP_FARGO3D_CLONECMD} {Conf.FP_FARGO3D_PACKDIR}")
+            print(f"\tFARGO3D downloaded to {fargo_dir}")
+        else:
+            print(f"\tFARGO3D directory already present in '{fargo_dir}'")
+        
+        fargo_header = f"{fargo_dir}/{Conf.FP_FARGO3D_HEADER}"
+        if not os.path.isfile(fargo_header):
+            print(f"No header file for fargo found in '{fargo_header}'")
+        else:
+            print(f"Header file for FARGO3D is in the fargo directory {fargo_dir}")
+        
+    if ('compile' in options) or ('all' in options):
+        print("Test compilation")
+        pass
+
 ###############################################################
 # Initialization
 ###############################################################
@@ -148,23 +247,39 @@ class Dictobj(object):
 warnings.filterwarnings("ignore")
 
 # Read FARGOpy configuration variables
-if not os.path.isdir(FP_DOTDIR):
-    Debug.trace(f"Configuring for the first time")
+if not os.path.isdir(Conf.FP_DOTDIR):
+    print(f"Configuring FARGOpy for the first time")
     initialize('configure')
 Debug.trace(f"::Reading configuration variables")
-exec(open(f"{FP_RCFILE}").read())
-Debug.VERBOSE = FP_VERBOSE
+
+# Load configuration variables into Conf
+conf_dict = dict()
+exec(open(f"{Conf.FP_RCFILE}").read(),dict(),conf_dict)
+Conf.__dict__.update(conf_dict)
+
+# Derivative configuration variables
+Debug.VERBOSE = Conf.FP_VERBOSE
+Conf.FP_FARGO3D_DIR = (Conf.FP_FARGO3D_BASEDIR + '/' + Conf.FP_FARGO3D_PACKDIR).replace('//','/')
+Conf.FP_FARGO3D_LOCKFILE = f"{Conf.FP_DOTDIR}/fargopy.lock"
 
 # Check if version in RCFILE is different from installed FARGOpy version
-if FP_VERSION != version:
-    print(f"Your configure file version '{FP_VERSION}' it is different than the installed version of FARGOpy '{version}'")
-    ans = input(f"Do you want to update configuration file '{FP_RCFILE}'? [Y/n]: ")
+if Conf.FP_VERSION != version:
+    print(f"Your configuration file version '{Conf.FP_VERSION}' it is different than the installed version of FARGOpy '{version}'")
+    ans = input(f"Do you want to update configuration file '{Conf.FP_RCFILE}'? [Y/n]: ")
     if ans and ('Y' not in ans.upper()):
         if 'N' in ans.upper():
-            print("We will keeping asking you until you update it, sorry!")
+            print("We will keeping asking you this until you update it, sorry!")
     else:
-        os.system(f"cp -rf {FP_RCFILE} {FP_RCFILE}.save")
+        os.system(f"cp -rf {Conf.FP_RCFILE} {Conf.FP_RCFILE}.save")
         initialize('configure',force=True)
 
+###############################################################
+# Import package modules
+###############################################################
+from fargopy.util import *
+from fargopy.sys import *
+from fargopy.fields import *
+from fargopy.simulation import *
+
 # Showing version 
 print(f"Running FARGOpy version {version}")

fargopy/fields.py

@@ -0,0 +1,221 @@
+###############################################################
+# FARGOpy interdependencies
+###############################################################
+import fargopy
+
+###############################################################
+# Required packages
+###############################################################
+import numpy as np
+import re
+
+###############################################################
+# Constants
+###############################################################
+# Map of coordinates into FARGO3D coordinates
+COORDS_MAP = dict(
+    cartesian = dict(x='x',y='y',z='z'),
+    cylindrical = dict(phi='x',r='y',z='z'),
+    spherical = dict(phi='x',r='y',theta='z'),
+)
+
+###############################################################
+# Classes
+###############################################################
+class Field(fargopy.Fargobj):
+    """Fields:
+
+    Attributes:
+        coordinates: type of coordinates (cartesian, cylindrical, spherical)
+        data: numpy arrays with data of the field
+
+    Methods:
+        slice: get an slice of a field along a given spatial direction.
+            Examples: 
+                density.slice(r=0.5) # Take the closest slice to r = 0.5
+                density.slice(ir=20) # Take the slice through the 20 shell
+                density.slice(phi=30*RAD,interp='nearest') # Take a slice interpolating to the nearest
+    """
+
+    def __init__(self,data=None,coordinates='cartesian',domains=None,type='scalar',**kwargs):
+        super().__init__(**kwargs)
+        self.data = data
+        self.coordinates = coordinates
+        self.domains = domains
+        self.type = type
+
+    def meshslice(self,slice=None,component=0):
+        """Perform a slice on a field and produce as an output the 
+        corresponding field slice and the associated matrices of
+        coordinates for plotting.
+        """
+        # Analysis of the slice 
+        if slice is None:
+            raise ValueError("You must provide a slice option.")
+
+        # Perform the slice
+        slice_cmd = f"self.slice({slice},pattern=True)"
+        slice,pattern = eval(slice_cmd)
+        
+        # Create the mesh
+        if self.coordinates == 'cartesian':
+            z,y,x = np.meshgrid(self.domains.z,self.domains.y,self.domains.x,indexing='ij')
+            x = eval(f"x[{pattern}]")
+            y = eval(f"y[{pattern}]")
+            z = eval(f"z[{pattern}]")
+            
+            mesh = fargopy.Dictobj(dict=dict(x=x,y=y,z=z))
+
+        if self.coordinates == 'cylindrical':
+            z,r,phi = np.meshgrid(self.domains.z,self.domains.r,self.domains.phi,indexing='ij')
+            x,y,z = r*np.cos(phi),r*np.sin(phi),z
+
+            x = eval(f"x[{pattern}]")
+            y = eval(f"y[{pattern}]")
+            z = eval(f"z[{pattern}]")
+            r = eval(f"r[{pattern}]")
+            phi = eval(f"phi[{pattern}]")
+
+            mesh = fargopy.Dictobj(dict=dict(r=r,phi=phi,x=x,y=y,z=z))
+
+        if self.coordinates == 'spherical':
+            theta,r,phi = np.meshgrid(self.domains.theta,self.domains.r,self.domains.phi,indexing='ij')
+            x,y,z = r*np.sin(theta)*np.cos(phi),r*np.sin(theta)*np.sin(phi),r*np.cos(theta)
+
+            x = eval(f"x[{pattern}]")
+            y = eval(f"y[{pattern}]")
+            z = eval(f"z[{pattern}]")
+            r = eval(f"r[{pattern}]")
+            phi = eval(f"phi[{pattern}]")
+            theta = eval(f"theta[{pattern}]")
+
+            mesh = fargopy.Dictobj(dict=dict(r=r,phi=phi,theta=theta,x=x,y=y,z=z))
+
+        return slice,mesh
+
+    def slice(self,quiet=True,pattern=False,**kwargs):
+        """Extract an slice of a 3-dimensional FARGO3D field
+
+        Parameters:
+            quiet: boolean, default = False:
+                If True extract the slice quietly.
+                Else, print some control messages.
+
+            pattern: boolean, default = False:
+                If True return the pattern of the slice, eg. [:,:,:]
+
+            ir, iphi, itheta, ix, iy, iz: string or integer:
+                Index or range of indexes of the corresponding coordinate.
+
+            r, phi, theta, x, y, z: float:
+                Value for slicing. The slicing search for the closest
+                value in the domain.
+
+        Returns:
+            slice: sliced field.
+
+        Examples:
+            # 0D: Get the value of the field in iphi = 0, itheta = -1 and close to r = 0.82
+            gasvz.slice(iphi=0,itheta=-1,r=0.82)
+
+            # 1D: Get all values of the field in radial direction at iphi = 0, itheta = -1
+            gasvz.slice(iphi=0,itheta=-1)
+
+            # 2D: Get all values of the field for values close to phi = 0
+            gasvz.slice(phi=0)
+        """
+        # By default slice
+        ivar = dict(x=':',y=':',z=':')
+
+        if len(kwargs.keys()) == 0:
+            pattern_str = f"{ivar['z']},{ivar['y']},{ivar['x']}"
+            if pattern:
+                return self.data, pattern_str
+            return self.data
+            
+        # Check all conditions
+        for key,item in kwargs.items():
+            match = re.match('^i(.+)',key)
+            if match:
+                index = item
+                coord = match.group(1)
+                if not quiet:
+                    print(f"Index condition {index} for coordinate {coord}")
+                ivar[COORDS_MAP[self.coordinates][coord]] = index
+            else:
+                if not quiet:
+                    print(f"Numeric condition found for coordinate {key}")
+                if key in self.domains.keys():
+                    # Check if value provided is in range
+                    domain = self.domains.item(key)
+                    extrema = self.domains.extrema[key]
+                    min, max = extrema[0][1], extrema[1][1]
+                    if (item<min) or (item>max):
+                        raise ValueError(f"You are attempting to get a slice in {key} = {item}, but the valid range for this variable is [{min},{max}]")
+                    find = abs(self.domains.item(key) - item)
+                    ivar[COORDS_MAP[self.coordinates][key]] = find.argmin()
+                    
+        pattern_str = f"{ivar['z']},{ivar['y']},{ivar['x']}"
+
+        if self.type == 'scalar':
+            slice_cmd = f"self.data[{pattern_str}]"
+            if not quiet:
+                print(f"Slice: {slice_cmd}")
+            slice = eval(slice_cmd)
+
+        elif self.type == 'vector':
+            slice = np.array(
+                [eval(f"self.data[0,{pattern_str}]"),
+                 eval(f"self.data[1,{pattern_str}]"),
+                 eval(f"self.data[2,{pattern_str}]")]
+            )
+
+        if pattern:
+            return slice,pattern_str
+        return slice
+
+    def to_cartesian(self):
+        if self.type == 'scalar':
+            # Scalar fields are invariant under coordinate transformations
+            return self
+        elif self.type == 'vector':
+            # Vector fields must be transformed according to domain
+            if self.coordinates == 'cartesian':
+                return self
+            
+            if self.coordinates == 'cylindrical':
+                z,r,phi = np.meshgrid(self.domains.z,self.domains.r,self.domains.phi,indexing='ij')
+                vphi = self.data[0]
+                vr = self.data[1]
+                vz = self.data[2]
+                vx = vr*np.cos(phi) 
+                vy = vr*np.sin(phi)
+                
+                return (Field(vx,coordinates=self.coordinates,domains=self.domains,type='scalar'),
+                        Field(vy,coordinates=self.coordinates,domains=self.domains,type='scalar'),
+                        Field(vz,coordinates=self.coordinates,domains=self.domains,type='scalar'))
+            
+            if self.coordinates == 'spherical':
+
+                theta,r,phi = np.meshgrid(self.domains.theta,self.domains.r,self.domains.phi,indexing='ij')
+                vphi = self.data[0]
+                vr = self.data[1]
+                vtheta = self.data[2]
+
+                vx = vr*np.sin(theta)*np.cos(phi) + vtheta*np.cos(theta)*np.cos(phi) - vphi*np.sin(phi)
+                vy = vr*np.sin(theta)*np.sin(phi) + vtheta*np.cos(theta)*np.sin(phi) + vphi*np.cos(phi)
+                vz = vr*np.cos(theta) - vtheta*np.sin(theta)
+
+                return (Field(vx,coordinates=self.coordinates,domains=self.domains,type='scalar'),
+                        Field(vy,coordinates=self.coordinates,domains=self.domains,type='scalar'),
+                        Field(vz,coordinates=self.coordinates,domains=self.domains,type='scalar'))
+            
+    def get_size(self):
+        return self.data.nbytes/1024**2
+
+    def __str__(self):
+        return str(self.data)
+    
+    def __repr__(self):
+        return str(self.data)
+