fargopy 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

fargopy/__init__.py

@@ -8,6 +8,7 @@ from fargopy.version import *
 ###############################################################
 import warnings
 import os
+import json
 import numpy as np
 
 ###############################################################
@@ -122,6 +123,24 @@ class Fargobj(object):
         self.fobject = True
         self.kwargs = kwargs
 
+    def save_object(self,filename=None,verbose=False):
+        """Save Fargobj into a filename in JSON format
+        
+        Args:
+            filename: string, default = None:
+                Path of the file where the object will be saved.
+                If None the filename will be '/tmp/fargobj_{hash}.json' 
+                where {hash} is the hash of the object attributes dictionary.
+        """
+        if filename is None:
+            object_hash = str(abs(hash(str(self.__dict__))))
+            filename = f"/tmp/fargobj_{object_hash}.json"
+        if verbose:
+            print(f"Saving object to {filename}...")
+        with open(filename,'w') as file_object:
+            file_object.write(json.dumps(self.__dict__,default=lambda obj:'<not serializable>'))
+            file_object.close()
+        
     def set_property(self,property,default,method=lambda prop:prop):
         """Set a property of object using a given method
 

fargopy/simulation.py

@@ -7,6 +7,7 @@ import fargopy
 # Required packages
 ###############################################################
 import os
+import json
 import numpy as np
 import re
 import subprocess
@@ -68,7 +69,31 @@ class Simulation(fargopy.Fargobj):
         super().__init__(**kwargs)
         
         # Load simulation configuration from a file
-
+        if ('load' in kwargs.keys()) and kwargs['load']:
+            if not 'setup' in kwargs.keys():
+                raise AssertionError(f"You must provide a setup name.")
+            else:
+                setup = kwargs['setup']
+            if 'fargo3d_dir' in kwargs.keys():
+                fargo3d_dir = kwargs['fargo3d_dir']
+            else:
+                fargo3d_dir = fargopy.Conf.FP_FARGO3D_DIR
+            
+            load_from = f"{fargo3d_dir}/setups/{setup}".replace('//','/')
+            if not os.path.isdir(load_from):
+                print(f"Directory for loading simulation '{load_from}' not found.")
+            json_file = f"{load_from}/fargopy_simulation.json"
+            print(f"Loading simulation from '{json_file}'")
+            if not os.path.isfile(json_file):
+                print(f"Loading data '{json_file}' not found.")
+            with open(json_file) as file_handler:
+                attributes = json.load(file_handler)
+                self.__dict__.update(attributes)
+                self.set_fargo3d_dir(self.fargo3d_dir)
+                self.set_setup(self.setup)
+                self.set_output_dir(self.output_dir)
+            return
+        
         # Set units by default
         self.set_units(UL=AU,UM=MSUN)
         
@@ -207,7 +232,7 @@ class Simulation(fargopy.Fargobj):
             print(f"Cleaning FARGO3D directory {self.fargo3d_dir}...")
             cmd = f"make -C {self.fargo3d_dir} clean mrproper"
             compl = f"rm -rf {self.fargo3d_dir}/fargo3d_*"
-            error,self.output_clean = fargopy.Sys.run(cmd + '&&' + compl)
+            error,output_clean = fargopy.Sys.run(cmd + '&&' + compl)
             
         # Prepare compilation
         compile_options = f"SETUP={self.setup} PARALLEL={parallel} GPU={gpu} "+options
@@ -215,9 +240,10 @@ class Simulation(fargopy.Fargobj):
 
         # Compile binary
         print(f"Compiling {fargo3d_binary}...")
-        cmd = f"cd {self.fargo3d_dir};make {compile_options}"
+        cmd = f"cd {self.fargo3d_dir};make {compile_options} 2>&1 |tee {self.setup_dir}/compilation.log"
         compl = f"mv fargo3d {fargo3d_binary}"
-        error,self.output_compilation = fargopy.Sys.run(cmd+' && '+compl)
+        pipe = f""
+        error,output_compilation = fargopy.Sys.run(cmd+' && '+compl)
 
         # Check compilation result
         if os.path.isfile(f"{self.fargo3d_dir}/{fargo3d_binary}"):
@@ -229,7 +255,7 @@ class Simulation(fargopy.Fargobj):
                 options=options
             )
         else:
-            print(f"Something failed when compiling FARGO3D. For details check Simulation.output_compilation")
+            print(f"Something failed when compiling FARGO3D. For details check '{self.setup_dir}/compilation.log")
             
     def run(self,
             mode='async',
@@ -237,7 +263,8 @@ class Simulation(fargopy.Fargobj):
             mpioptions='-np 1',
             resume=False,
             cleanrun=False,
-            test=False):
+            test=False,
+            unlock=True):
 
         if self.fargo3d_binary is None:
             print("You must first compile your simulation with: <simulation>.compile(<option>).")
@@ -271,8 +298,12 @@ class Simulation(fargopy.Fargobj):
 
         # Preparing command
         run_cmd = f"{precmd} ./{self.fargo3d_binary} {options} setups/{self.setup}/{self.setup}.par"
-        
+
+        self.json_file = f"{self.setup_dir}/fargopy_simulation.json"
         if mode == 'sync':
+            # Save object 
+            self.save_object(self.json_file)
+
             # Run synchronously
             cmd = f"cd {self.fargo3d_dir};{run_cmd} |tee {self.logfile}"
             print(f"Running synchronously: {cmd}")
@@ -289,6 +320,16 @@ class Simulation(fargopy.Fargobj):
             # Launch process
             print(f"Running asynchronously (test = {test}): {run_cmd}")
             if not test:
+
+                # Check it is not locked
+                lock_info = fargopy.Sys.is_locked(dir=self.setup_dir)
+                if lock_info:
+                    if unlock:
+                        self._unlock_simulation(lock_info)
+                    else:
+                        print(f"Output directory {self.setup_dir} is locked by a running process")
+                        return
+
                 process = subprocess.Popen(run_cmd.split(),cwd=self.fargo3d_dir,
                                         stdout=logfile_handler,stderr=logfile_handler)
                 # Introduce a short delay to verify if the process has failed
@@ -298,16 +339,29 @@ class Simulation(fargopy.Fargobj):
                     # Check if program is effectively running
                     self.fargo3d_process = process            
                     
-                    # Create a lock on fargopy with the process id
-                    # fargopy.lock(self.frago3d_process.pid)
+                    # Lock
+                    fargopy.Sys.lock(
+                        dir=self.setup_dir,
+                        content=dict(pid=self.fargo3d_process.pid)
+                    )
 
                     # Setup output directory 
                     self.set_output_dir(f"{self.outputs_dir}/{self.setup}".replace('//','/'))    
+
+                    # Save object 
+                    self.save_object(self.json_file)
                 else:
                     print(f"Process running failed. Please check the logfile {self.logfile}")
+        else:
+            print(f"Mode {mode} not recognized (valid are 'sync', 'async')")
+            return
                     
     def stop(self):
+        # Check if the directory is locked
+        lock_info = fargopy.Sys.is_locked(self.setup_dir)
+        
         if not self._check_process():
+            self._unlock_simulation(lock_info)
             return
 
         poll = self.fargo3d_process.poll()
@@ -317,13 +371,16 @@ class Simulation(fargopy.Fargobj):
             del self.fargo3d_process
             self.fargo3d_process = None
         else:
-            print(f"The process has already finished. Check logfile {self.logfile}.")
-
-    def _save_simultation(self):
-        """Save simulation configuration 
-        """
-        pass
-
+            self._unlock_simulation(lock_info)
+            print(f"The process has finished. Check logfile {self.logfile}.")
+
+    def _unlock_simulation(self,lock_info):
+        if lock_info:
+            pid = lock_info['pid']
+            fargopy.Debug.trace(f"Unlocking simulation (pid = {pid})")
+            error,output = fargopy.Sys.run(f"kill -9 {pid}")    
+            fargopy.Sys.unlock(self.setup_dir)
+        
     def status(self,mode='isrunning',verbose=True,**kwargs):
         """Check the status of the running process
 
@@ -350,6 +407,10 @@ class Simulation(fargopy.Fargobj):
                 if poll is None:
                     vprint("\tThe process is running.")
                 else:
+                    # Unlock any remaining process
+                    lock_info = fargopy.Sys.is_locked(self.setup_dir)
+                    self._unlock_simulation(lock_info)
+                    
                     vprint(f"\tThe process has ended with termination code {poll}.")
             else:
                 vprint(f"\tThe process is stopped.")
@@ -411,7 +472,7 @@ class Simulation(fargopy.Fargobj):
 
         # Infinite loop checking for output
         n = 0
-        print(f"Progress of the simulation (numstatus = {numstatus}):")
+        print(f"Progress of the simulation (numstatus = {numstatus}, interrupting may stop the process):")
         while True and (n<numstatus):
             if not self._is_running():
                 print("The simulation is not running anymore")
@@ -440,6 +501,8 @@ class Simulation(fargopy.Fargobj):
             try:
                 time.sleep(frequency)
             except KeyboardInterrupt:
+                time.sleep(1)
+                print("In some environment (IPython, Colab) stopping the progress status will stop the simulation. In that case just resume.")
                 self.status('isrunning')
                 return
             
@@ -487,6 +550,11 @@ class Simulation(fargopy.Fargobj):
         error,output = fargopy.Sys.run(cmd)
 
     def _is_running(self,verbose=False):
+        if not self.has('fargo3d_process'):
+            if verbose:
+                print("The simulation has not been run before.")
+            return False
+
         if self.fargo3d_process:
             poll = self.fargo3d_process.poll()
             if poll is None:
@@ -793,7 +861,8 @@ class Simulation(fargopy.Fargobj):
         return comps
 
     def __repr__(self):
-        return self.__str__()
+        repr = f"""FARGOPY simulation (fargo3d_dir = '{self.fargo3d_dir}', setup = '{self.setup}')"""
+        return repr
 
     def __str__(self):
         str = f"""Simulation information:

fargopy/sys.py

@@ -7,6 +7,7 @@ import fargopy
 # Required packages
 ###############################################################
 import os
+import json
 import subprocess
 import inspect
 import signal
@@ -142,3 +143,41 @@ class Sys(object):
                 print(f"There is a lockfile in {fargopy.FP_FARGO3D_LOCKFILE}")
             return True
         return False
+    
+    @staticmethod
+    def lock(dir,content=dict()):
+        """Lock a directory using content information
+        """
+        if not os.path.isdir(dir):
+            print(f"Locking directory '{dir}' not found.")
+            return
+        filename = f"{dir}/fargopy.lock"
+
+        with open(filename,'w') as file_object:
+            file_object.write(json.dumps(content,default=lambda obj:'<not serializable>'))
+            file_object.close()
+
+    @staticmethod
+    def unlock(dir):
+        """UnLock a directory
+        """
+        if not os.path.isdir(dir):
+            print(f"Locking directory '{dir}' not found.")
+            return
+        filename = f"{dir}/fargopy.lock"
+        if os.path.isfile(filename):
+            fargopy.Sys.simple(f"rm -rf {filename}")
+    
+    @staticmethod
+    def is_locked(dir,verbose=False):
+        if not os.path.isdir(dir):
+            if verbose:
+                print(f"Locking directory '{dir}' not found.")
+            return False
+        filename = f"{dir}/fargopy.lock"
+        if os.path.isfile(filename):
+            if verbose:
+                print(f"The directory '{dir}' is locked")
+            with open(filename) as file_handler:
+                info = json.load(file_handler)
+                return info

fargopy/version.py

@@ -1 +1 @@
-version='0.3.3'
+version='0.3.5'

{fargopy-0.3.3.dist-info → fargopy-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fargopy
-Version: 0.3.3
+Version: 0.3.5
 Summary: FARGO3D Wrapping
 Home-page: https://pypi.org/project/fargopy
 Author: Jorge Zuluaga, Matias Montesinos
@@ -39,12 +39,14 @@ This is an animation created with a few lines of code using `FARGOpy` (for the c
 `FARGOpy` is available at the `Python` package index and can be installed using:
 
 ```bash
-$ pip install fargopy
+$ sudo pip install fargopy
 ```
 as usual this command will install all dependencies (excluding `FARGO3D` which must be installed indepently as explained before) and download some useful data, scripts and constants.
 
 
 
+> **NOTE**: If you don't have access to `sudo`, you can install `FARGOpy` in your local environmen (usually at `~/.local/`). In that case you need to add to your `PATH` environmental variable the location of the local python installation. Add to `~/.bashrc` the line `export PATH=$HOME/.local/bin:$PATH`
+
 Since `FARGOpy` is a python wrap for `FARGO3D` the ideal environment to work with the package is `IPython`/`Jupyter`. It works really fine in `Google Colab` ensuing training and demonstration purposes. This README, for instance, can be ran in `Google Colab` 
 
 <a target="_blank" href="https://colab.research.google.com/github/seap-udea/fargopy/blob/main/README.ipynb">
@@ -55,7 +57,7 @@ If you are running in colab use:
 
 
 ```python
-#!pip install -Uq fargopy
+#!sudo pip install -Uq fargopy
 ```
 
 If you are working in `Jupyter` or in `Google Colab`, the configuration directory and its content will be crated the first time you import the package:
@@ -69,7 +71,7 @@ import fargopy as fp
 %autoreload 2
 ```
 
-    Running FARGOpy version 0.3.2
+    Running FARGOpy version 0.3.4
 
 
 If you are working on a remote Linux server, it is better to run the package using `IPython`. For this purpose, after installation, `FARGOpy` provides a special initialization command:
@@ -195,14 +197,12 @@ Or check the progress of the simulation:
 sim.status('progress')
 ```
 
-    Progress of the simulation (numstatus = 5):
-    1:OUTPUTS 2 at date t = 12.566371 OK [output pace = 0.1 secs]
-    2:OUTPUTS 3 at date t = 18.849556 OK [output pace = 0.1 secs]
-    3:OUTPUTS 4 at date t = 25.132741 OK [output pace = 0.7 secs]
-    
-    ################################################################################
-    Running status of the process:
-    	The process is running.
+    Progress of the simulation (numstatus = 5, interrupting may stop the process):
+    1:OUTPUTS 0 at date t = 0.000000 OK [output pace = 0.1 secs]
+    2:OUTPUTS 1 at date t = 6.283185 OK [output pace = 0.1 secs]
+    3:OUTPUTS 2 at date t = 12.566371 OK [output pace = 1.6 secs]
+    4:OUTPUTS 3 at date t = 18.849556 OK [output pace = 4.9 secs]
+    5:OUTPUTS 4 at date t = 25.132741 OK [output pace = 4.9 secs]
 
 
 You may stop the simulation at any time using:
@@ -212,7 +212,7 @@ You may stop the simulation at any time using:
 sim.stop()
 ```
 
-    Stopping FARGO3D process (pid = 24648)
+    Stopping FARGO3D process (pid = 18717)
 
 
 Check the status of the simulation using:
@@ -222,7 +222,7 @@ Check the status of the simulation using:
 sim.status('summary')
 ```
 
-    The simulation has been ran for 7 time-steps (including the initial one).
+    The simulation has been ran for 6 time-steps (including the initial one).
 
 
 Once stopped you may resume the simulation at any snapshot or at the latest resumable snapshot:
@@ -232,8 +232,8 @@ Once stopped you may resume the simulation at any snapshot or at the latest resu
 sim.resume()
 ```
 
-    Resuming from snapshot 5...
-    Running asynchronously (test = False):  ./fargo3d_SETUP-fargo_PARALLEL-0_GPU-0 -m -t -S 5 -t setups/fargo/fargo.par
+    Resuming from snapshot 4...
+    Running asynchronously (test = False):  ./fargo3d_SETUP-fargo_PARALLEL-0_GPU-0 -m -t -S 4 -t -S 4 -t setups/fargo/fargo.par
     Now you are connected with output directory '/home/jzuluaga/fargo3d/outputs/fargo'
 
 
@@ -365,13 +365,26 @@ fp.Simulation.download_precomputed(setup='fargo')
     Downloading...
     From: https://docs.google.com/uc?export=download&id=1YXLKlf9fCGHgLej2fSOHgStD05uFB2C3
     To: /tmp/fargo.tgz
-    100%|██████████| 54.7M/54.7M [00:01<00:00, 31.2MB/s]
+    100%|██████████| 54.7M/54.7M [01:14<00:00, 738kB/s] 
 
 
     Uncompressing fargo.tgz into /tmp/fargo
     Done.
 
 
+Once downloaded you may connect with simulation using:
+
+
+```python
+sim = fp.Simulation(output_dir = '/tmp/fargo')
+```
+
+    Your simulation is now connected with '/home/jzuluaga/fargo3d/'
+    Now you are connected with output directory '/tmp/fargo'
+
+
+and perform the postprocessing as explained before.
+
 We have prepared a set of precomputed simulations covering some interesting scientific cases. You may see the list of precomputed simulations available in the `FARGOpy` [cloud repository](https://drive.google.com/drive/folders/1NRdNOcmxRK-pHv_8vR-aAAJGWXxIOY0J?usp=sharing):
 
 

fargopy-0.3.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+fargopy/__init__.py,sha256=U_z9F-T_dHEGDdoMpMrnaaUsQYcf3WREWFh7leP8nxc,11917
+fargopy/fields.py,sha256=4sBm--gxgMdQcd6lsdPQ7ADnnGL550Cy_H2mNz80A-o,8837
+fargopy/simulation.py,sha256=AJ0v9CtKA4Id1dedRH-o6G7bzdd-Ft-UntCzONKY1WE,37375
+fargopy/sys.py,sha256=UQJXB4IHPujUNHsKX_hZChZBIlPaQbxafLShF2NDlsY,5589
+fargopy/util.py,sha256=y39aTcvK1lM3vbuK11lE2bfj-eCcOzc0lKMvyBRW2-M,1584
+fargopy/version.py,sha256=ZzAopkzJJDyniYfbnOQqEHng4wgVC2f65Lv2uZQOvsQ,16
+fargopy-0.3.5.data/scripts/ifargopy,sha256=t5E07jKzOLtNnlNyElQZbzjCW6wnR0bc8uCaZpw9yS8,382
+fargopy-0.3.5.dist-info/LICENSE,sha256=aIckKnNVrkXQMqEKlzGn_REfTwc82TF35BHMCRwPXCI,1097
+fargopy-0.3.5.dist-info/METADATA,sha256=mtwwYtXGfzdSqhVncvdhU7o4cqZOXfn3ZO9XuueAzTo,15355
+fargopy-0.3.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+fargopy-0.3.5.dist-info/entry_points.txt,sha256=555NPKYbLCN0fgJbdW4b4azZ5sqjhqVqTUxujBBYEJY,49
+fargopy-0.3.5.dist-info/top_level.txt,sha256=_r66v1_-9T7dB5sQa12AdxaAdsv9-OTwtR-vft4OPBU,8
+fargopy-0.3.5.dist-info/RECORD,,

fargopy-0.3.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-fargopy/__init__.py,sha256=IReUK0HAUK6YXzeGrQVohGFBpe2znllaTae7MFoUnsY,11091
-fargopy/fields.py,sha256=4sBm--gxgMdQcd6lsdPQ7ADnnGL550Cy_H2mNz80A-o,8837
-fargopy/simulation.py,sha256=0bSDZNKMFuokWuAsLEiBetyJo_OAp8xLFsDtN7pK4qg,34260
-fargopy/sys.py,sha256=-RnUZJ5GnYHwIlI7UtjPlnyS88ptnrSBa9FvnF_2gDM,4311
-fargopy/util.py,sha256=y39aTcvK1lM3vbuK11lE2bfj-eCcOzc0lKMvyBRW2-M,1584
-fargopy/version.py,sha256=-ZmYFrDcd4hQWTPKmNo0_Nd2rsa4wiEtEUrlb_4E2Co,16
-fargopy-0.3.3.data/scripts/ifargopy,sha256=t5E07jKzOLtNnlNyElQZbzjCW6wnR0bc8uCaZpw9yS8,382
-fargopy-0.3.3.dist-info/LICENSE,sha256=aIckKnNVrkXQMqEKlzGn_REfTwc82TF35BHMCRwPXCI,1097
-fargopy-0.3.3.dist-info/METADATA,sha256=mNN5hzV5yUneDAqrvkxWgWMHZQiBYGI9sXw7vjRJaeE,14718
-fargopy-0.3.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-fargopy-0.3.3.dist-info/entry_points.txt,sha256=555NPKYbLCN0fgJbdW4b4azZ5sqjhqVqTUxujBBYEJY,49
-fargopy-0.3.3.dist-info/top_level.txt,sha256=_r66v1_-9T7dB5sQa12AdxaAdsv9-OTwtR-vft4OPBU,8
-fargopy-0.3.3.dist-info/RECORD,,