ladim 1.3.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

ladim/gridforce/legacy.py

@@ -1,103 +0,0 @@
-"""
-Main gridforce controller
-"""
-
-import os
-import sys
-import importlib
-
-# from ladim.configuration import config
-
-
-class Grid:
-    def __init__(self, modules, **conf):
-        legacy_conf = dict(
-            gridforce=conf,
-            start_time=conf.get('start_time', None),
-        )
-
-        # Allow gridforce module in current directory
-        sys.path.insert(0, os.getcwd())
-        # Import correct gridforce_module
-        # gridforce_module = importlib.import_module(config["gridforce_module"])
-        gridforce_module = importlib.import_module(conf["legacy_module"])
-        self.grid = gridforce_module.Grid(legacy_conf)
-        self.xmin = self.grid.xmin
-        self.xmax = self.grid.xmax
-        self.ymin = self.grid.ymin
-        self.ymax = self.grid.ymax
-
-    def sample_metric(self, X, Y):
-        """Sample the metric coefficients"""
-        return self.grid.sample_metric(X, Y)
-
-    def sample_depth(self, X, Y):
-        """Return the depth of grid cells"""
-        return self.grid.sample_depth(X, Y)
-
-    def lonlat(self, X, Y, method=None):
-        """Return the longitude and latitude from grid coordinates"""
-        return self.grid.lonlat(X, Y, method=method)
-
-    def ingrid(self, X, Y):
-        """Returns True for points inside the subgrid"""
-        return self.grid.ingrid(X, Y)
-
-    def onland(self, X, Y):
-        """Returns True for points on land"""
-        return self.grid.onland(X, Y)
-
-    # Error if point outside
-    def atsea(self, X, Y):
-        """Returns True for points at sea"""
-        return self.grid.atsea(X, Y)
-
-    def ll2xy(self, lon, lat):
-        return self.grid.ll2xy(lon, lat)
-
-    def xy2ll(self, X, Y):
-        return self.grid.xy2ll(X, Y)
-
-
-class Forcing:
-    def __init__(self, modules, **conf):
-        self.modules = modules
-
-        grid_ref = GridReference(modules)
-        legacy_conf = dict(
-            gridforce=conf,
-            ibm_forcing=conf.get('ibm_forcing', []),
-            start_time=conf.get('start_time', None),
-            stop_time=conf.get('stop_time', None),
-            dt=conf.get('dt', None),
-        )
-
-        # Allow gridforce module in current directory
-        sys.path.insert(0, os.getcwd())
-        # Import correct gridforce_module
-        gridforce_module = importlib.import_module(conf["legacy_module"])
-        self.forcing = gridforce_module.Forcing(legacy_conf, grid_ref)
-        # self.steps = self.forcing.steps
-        # self.U = self.forcing.U
-        # self.V = self.forcing.V
-
-    def update(self):
-        t = self.modules['state'].timestep
-        return self.forcing.update(t)
-
-    def velocity(self, X, Y, Z, tstep=0.0):
-        return self.forcing.velocity(X, Y, Z, tstep=tstep)
-
-    def field(self, X, Y, Z, name):
-        return self.forcing.field(X, Y, Z, name)
-
-    def close(self):
-        return self.forcing.close()
-
-
-class GridReference:
-    def __init__(self, modules):
-        self.modules = modules
-
-    def __getattr__(self, item):
-        return getattr(self.modules['grid'].grid, item)

ladim/ibms/legacy.py

@@ -1,34 +0,0 @@
-class Legacy_IBM:
-    def __init__(self, modules, **config):
-        self.modules = modules
-
-        legacy_conf = dict(
-            ibm=config,
-            dt=config['dt'],
-            start_time=config['start_time'],
-            output_instance=config['output_instance'],
-            nc_attributes=config['nc_attributes'],
-        )
-
-        if config["legacy_module"] is not None:
-            # Import the module
-            import logging
-            import sys
-            import os
-            import importlib
-            logging.info("Initializing the IBM")
-            sys.path.insert(0, os.getcwd())
-            ibm_module = importlib.import_module(config["legacy_module"])
-            # Initiate the IBM object
-            self.ibm = ibm_module.IBM(legacy_conf)
-
-        else:
-            self.ibm = None
-
-    def update(self):
-        if self.ibm is not None:
-            self.ibm.update_ibm(
-                self.modules['grid'],
-                self.modules['state'],
-                self.modules['forcing'],
-            )

ladim/output/__init__.py

@@ -1 +0,0 @@
-from .legacy import OutPut as Output

ladim/output/legacy.py

@@ -1,247 +0,0 @@
-"""Output module for the (py)ladim particle tracking model"""
-
-# ------------------------------------
-# Bjørn Ådlandsvik <bjorn@imr.no>
-# Institute of Marine Research
-# 2013-01-04
-# ------------------------------------
-
-import os
-import logging
-import datetime
-import re
-
-# from pathlib import Path
-import numpy as np
-from netCDF4 import Dataset
-
-
-# Gjør til en iterator
-class OutPut:
-    def __init__(self, modules, **config):
-        self.modules = modules
-
-        logging.info("Initializing output")
-
-        self.filename = config["output_file"]
-        self.instance_variables = config["output_instance"]
-        self.instance_count = 0
-        self.outcount = -1  # No output yet
-        self.file_counter = -1  # No file yer
-        self.skip_output = config["skip_initial"]
-        self.numrec = config["output_numrec"]
-
-        self.outconf = dict(
-            output_period=config['output_period'],
-            output_format=config['output_format'],
-            reference_time=config['reference_time'],
-            output_particle=config['output_particle'],
-            nc_attributes=config['nc_attributes'].copy(),
-            output_instance=config['output_instance'],
-        )
-
-        if self.numrec == 0:
-            self.multi_file = False
-            self.numrec = 999999  # A large number
-        else:
-            self.multi_file = True
-            # If multi_file and output_file ends with number "dddd.nc"
-            # start output number with dddd, else use zero
-            fname0, ext = os.path.splitext(self.filename)
-            # fname = f'{fname0}_{self.file_counter:04d}{ext}'
-            patt = r"_[0-9]{4}$"  # '_dddd' at end of string
-            m = re.search(patt, fname0)
-            # start with number in output_name
-            if m:
-                self.filename = fname0[:-5] + ext  # Strip the number
-                self.file_counter = int(m.group(0)[1:]) - 1
-
-        self.dt = config["dt"]
-        self.num_output = config["num_output"]
-        self.nc = None  # No open netCD file yet
-        # Indicator for lon/lat output
-        self.lonlat = (
-            "lat" in self.instance_variables or "lon" in self.instance_variables
-        )
-
-    # ----------------------------------------------
-    def write(self) -> None:
-        config = self.outconf
-        state = self.modules['state']
-        grid = self.modules['grid']
-
-        """Write the model state to NetCDF"""
-
-        # May skip initial output
-        if self.skip_output:
-            self.skip_output = False
-            return
-
-        self.outcount += 1
-        t = self.outcount % self.numrec  # in-file record counter
-
-        logging.debug(
-            "Writing: timestep, timestamp = {} {}".format(
-                state.timestep, state.timestamp
-            )
-        )
-
-        # Create new file?
-        if t == 0:
-            # Close old file and open a new
-            if self.nc:
-                self.nc.close()
-            self.file_counter += 1
-            self.pstart0 = self.instance_count  # Start of data in the file
-            self.nc = self._define_netcdf()
-            logging.info(f"Opened output file: {self.nc.filepath()}")
-
-        pcount = len(state)  # Present number of particles
-        pstart = self.instance_count
-
-        logging.debug(f"Writing {pcount} particles")
-
-        tdelta = state.timestamp - config["reference_time"]
-        seconds = tdelta.astype("m8[s]").astype("int")
-        self.nc.variables["time"][t] = float(seconds)
-
-        self.nc.variables["particle_count"][t] = pcount
-
-        # Compute lon, lat if needed
-        if self.lonlat:
-            lon, lat = grid.xy2ll(state.X, state.Y)
-
-        start = pstart - self.pstart0
-        end = pstart + pcount - self.pstart0
-        # print("start, end = ", start, end)
-        for name in self.instance_variables:
-            if name == "lon":
-                self.nc.variables["lon"][start:end] = lon
-            elif name == "lat":
-                self.nc.variables["lat"][start:end] = lat
-            else:
-                self.nc.variables[name][start:end] = state[name]
-
-        # Update counters
-        # self.outcount += 1
-        self.instance_count += pcount
-
-        # Flush the data to the file
-        self.nc.sync()
-
-        # Close final file
-        if self.outcount == self.num_output - 1:
-            self.nc.close()
-
-    # -----------------------------------------------
-    def _define_netcdf(self) -> Dataset:
-        """Define a NetCDF output file"""
-
-        config = self.outconf
-        release = self.modules['release']
-
-        # Generate file name
-        fname = self.filename
-        if self.multi_file:
-            # fname0 -> fname0_dddd.nc
-            fname0, ext = os.path.splitext(self.filename)
-            fname = f"{fname0}_{self.file_counter:04d}{ext}"
-
-        logging.debug(f"Defining output netCDF file: {fname}")
-        nc = Dataset(fname, mode="w", format=config["output_format"])
-        # --- Dimensions
-        nc.createDimension("particle", release.total_particle_count)
-        nc.createDimension("particle_instance", None)  # unlimited
-        # Sett output-period i config (bruk naturlig enhet)
-        # regne om til antall tidsteg og få inn under
-        outcount0 = self.outcount
-        outcount1 = min(outcount0 + self.numrec, self.num_output)
-        nc.createDimension("time", outcount1 - outcount0)
-
-        # ---- Coordinate variable for time
-        v = nc.createVariable("time", "f8", ("time",))
-        v.long_name = "time"
-        v.standard_name = "time"
-        timeref = str(config["reference_time"]).replace("T", " ")
-        v.units = f"seconds since {timeref}"
-
-        # instance_offset
-        v = nc.createVariable("instance_offset", "i", ())
-        v.long_name = "particle instance offset for file"
-
-        # Particle count
-        v = nc.createVariable("particle_count", "i4", ("time",))
-        v.long_name = "number of particles in a given timestep"
-        v.ragged_row_count = "particle count at nth timestep"
-
-        # Particle variables
-        for name in config["output_particle"]:
-            confname = config["nc_attributes"][name]
-            if confname["ncformat"][0] == "S":  # text
-                length = int(confname["ncformat"][1:])
-                lendimname = "len_" + name
-                nc.createDimension(lendimname, length)
-                v = nc.createVariable(
-                    varname=name,
-                    datatype="S1",
-                    dimensions=("particle", lendimname),
-                    zlib=True,
-                )
-            else:  # Numeric
-                v = nc.createVariable(
-                    varname=name,
-                    datatype=config["nc_attributes"][name]["ncformat"],
-                    dimensions=("particle",),
-                    zlib=True,
-                )
-            for attr, value in config["nc_attributes"][name].items():
-                if attr != "ncformat":
-                    setattr(v, attr, value)
-
-        # Instance variables
-        for name in config["output_instance"]:
-            v = nc.createVariable(
-                varname=name,
-                datatype=config["nc_attributes"][name]["ncformat"],
-                dimensions=("particle_instance",),
-                zlib=True,
-            )
-
-            for attr, value in config["nc_attributes"][name].items():
-                if attr != "ncformat":
-                    setattr(v, attr, value)
-
-        # --- Global attributes
-        # Burde ta f.eks. source fra setup
-        # hvis andre skulle bruke
-        nc.Conventions = "CF-1.5"
-        nc.institution = "Institute of Marine Research"
-        nc.source = "Lagrangian Advection and Diffusion Model, python version"
-        nc.history = "Created by pyladim"
-        nc.date = str(datetime.date.today())
-
-        logging.debug("Netcdf output file defined")
-
-        # Save particle variables
-        for name in config["output_particle"]:
-            var = nc.variables[name]
-            if var.datatype == np.dtype("S1"):  # Text
-                n = len(nc.dimensions[var.dimensions[-1]])
-                A = [
-                    list(s[:n].ljust(n))
-                    for s in release.particle_variables[name][:]
-                ]
-                var[:] = np.array(A)
-            else:  # Numeric
-                nc.variables[name][:] = release.particle_variables[name][:]
-
-        # Set instance offset
-        var = nc.variables["instance_offset"]
-        var[:] = self.instance_count
-
-        return nc
-
-    def update(self):
-        step = self.modules['state'].timestep
-        if step % self.outconf['output_period'] == 0:
-            self.write()

ladim/release/__init__.py

@@ -1 +0,0 @@
-from .legacy import ParticleReleaser as Releaser