Exemplo n.º 1
0
class Lagrangian:

    """
    This class provides pure Lagrangian kernels. 
    The particle just follows the local velocity flow field.


    Attributes:
        -Vi (function): The interpolant function, to evaluate the
        local flow velocity field V(r(t),t).
    """

    def __init__(self,json_dict):
        """
        Lagrangian kernel constructor.

        Args:
            Vi (function): Interpolant function.
        """
        
        self.Vi = InputFields()
        self.Vi.get_info(json_dict['velocity'])
        self.Vi.get_mfds()
        self.Vi.get_grid()
        self.Vi.get_interpolants()
        
        self.boundaries = []


        

    def F(self, r, t):
        """

        Model Kernel function to send to the solver module.

        Args:
            r (array): Array containing the position of the particles [space_units].
            t (float): Time instant [time_units]

        Returns:
            array: Array containing the velocity componentes evaluted. [space_units/time_units]
        """
        if self.boundaries:
                r = self.boundaries.F(r)

        
        return self.Vi.F(r, t)
Exemplo n.º 2
0
class LagrangianSpherical2D:

    """
    This class provides Lagrangian Kernels, for spherical (lat,lon) integrations,
    considering a perfectly spherical earth with a 6370Km radius.
    The particle just follows the local flow velocity field.

    Attributes:
        - m_to_deg (float): Conversion from [m/s] to [degrees/s].
        - Vi (function):  The interpolant function, to evaluate the local flow velocity field V(r(t),t).
    """

    def __init__(self, json_dict):
        """
        Lagrangian kernel constructor.

        Args:
            Vi (function): Interpolant function.
        """
        self.m_to_deg = (np.pi/180.)*6370000.
        self.Vi = InputFields()
        self.Vi.get_info(json_dict['velocity'])
        self.Vi.get_mfds()
        self.Vi.get_grid()
        self.Vi.get_interpolants()
        

    def F(self, r, t):
        """

        Model Kernel function to send to the solver module.

        Args:
            - r (array): Array containing the position of the particles [space_units].
            - t (float): Time instant [time_units].

        Returns:
            - array: Array containing the velocity componentes evaluted [space_units/time_units].

        """
        
        drdt = self.Vi.F(r, t)
        drdt[:,0] = drdt[:,0]/(self.m_to_deg*np.cos((np.pi/180.)*r[:,1]))
        drdt[:,1] = drdt[:,1]/self.m_to_deg

        
        return drdt
Exemplo n.º 3
0
class BoundaryConditions:

    def __init__(self):
        self.boundaries= []
        self.type = []

    def read_config(self,json_dict):
        self.boundaries = json_dict['boundaries']
        self.type = json_dict['type']
        if self.type == 'mask':
            self.mask_boundaries(json_dict['mask'])
        return    

    def mask_boundaries(self,json_dict):
        self.boundaries = InputFields()
        self.boundaries.get_info(json_dict)
        self.boundaries.get_mfds(json_dict)
        self.boundaries.get_get_grid(json_dict)
        self.boundaries.get_interpolants(method='nearest')

    def F(self,r):
        if self.type == 'mask':
            return self.boundaries.F_s(r)
            
        if self.type != 'mask':
            for i in range(0,len(self.boundaries)):
                if self.type[i] == 'periodic':
                    mask_0 = r[:,i] < self.boundaries[i][0] 
                    r[mask_0,i] = self.boundaries[i][1] - np.abs(r[mask_0,i] - self.boundaries[i][0])
                    mask_1 = r[:,i] > self.boundaries[i][1]
                    r[mask_1,i] = self.boundaries[i][0] + np.abs(r[mask_1,i] - self.boundaries[i][1])
                elif self.type[i] == 'fixed':
                    mask_0 = r[:,i] < self.boundaries[i][0] 
                    r[mask_0,i] = self.boundaries[i][0]
                    mask_1 = r[:,i] > self.boundaries[i][1]
                    r[mask_1,i] = self.boundaries[i][1]
                elif self.type[i] == 'void':
                    mask_0 = r[:,i] < self.boundaries[i][0] 
                    r[mask_0,i] = np.nan
                    mask_1 = r[:,i] > self.boundaries[i][1]
                    r[mask_1,i] = np.nan
                elif self.type[i] == 'none':
                    continue
        return r
Exemplo n.º 4
0
class InitialConditions:
    """
    This module creates regular meshes of multidimensional initial conditions,
    and turn it into arrays of points, using the order: [variable, solution_id].
    
    Example: Given 10 Lagrangian particles in cartesian coordinates. we require x,y,z position
    to describe its state at t time, so the resulting array will be: [3,10]. 

    Using this,
    ::
        r0[1]

    we take the x-component for all the particles.

    Also, if a mask is provided, the points can be masked and suppressed in
    order to create regular initial conditions with any shape considered.


    Future: The idea is to increase its functionality by adding new functions for 
    multidimensional problems and non-regular geometries.

    Attributes:
        - r0 (np.array): An array of initial points.
        - r0_raw (list): Copy of the original array with a mask included, to
        - create a np.masked array.
        - mask (bool): Array of booleans to select the valid points to compute.
        - span (np.array): The initial grid of points to generate the initial conditions domain.
    """
    def __init__(self):
        """
        Init the object to create the initial conditions.

        Args:
            - **r0_dict: The information provided by the dictionary "r0" in the setup JSON file.
        """
        self.setup = []
        self.names = []
        self.ranges = []
        self.step = []
        self.span = []
        self.mask = []
        self.maski = []
        self.r0 = []
        self.r0_raw = []
        self.t0 = []
        self.time_range = []
        self.dt = []
        self.r = []
        self.t = []
        self.t_fmt = []
        self.t0_fmt = []
        self.dt_fmt = []
        self.ds = []
        self.coords_names = []
        self.tspan = []
        self.tspan_fmt = []
        self.parameters = []

    def read_config(self, json_dict):
        self.names = json_dict['names']
        if 'file' in json_dict:
            self.file = json_dict['file']
        else:
            self.ranges = json_dict['ranges']
            self.step = json_dict['step']
        self.time_range = json_dict['time_range']
        if 'reference_time' in json_dict:
            self.time_ref = json_dict['reference_time']
        if 'parameters' in json_dict:
            self.parameters = json_dict['parameters']

        return

    def spanning(self):
        """
        
        Turns the information provided by the by the dictionary "r0" in the setup JSON file,  
        regarding variables into arrays of initial conditions to define the initial mesh axis. 

        Returns:
            - list: List of np.arrays.
        """

        for k in range(0, len(self.names)):
            self.span.append(
                np.arange(self.ranges[k][0], self.ranges[k][1], self.step[k]))

        return

    def set_array(self):
        """
        
        It creates the array of initial conditions.


        Returns:
            - array: np.array of initial conditions in the form [varible, particle_id]

        """

        mesh = np.meshgrid(*self.span, indexing='ij')
        # here we use indexing ij, this is to work with the correspondence
        # x,y,z --> i,j,k indexing. Then, when the netcdf is writen, this is
        # tranposed in order to keep the netcdf convection (k,j,i indexing)

        self.coords_names = [name + "_0" for name in self.names]
        nvars = len(self.names)
        coords = dict(zip(self.coords_names, zip(self.coords_names,
                                                 self.span)))

        variables = dict(
            zip(self.names, zip(nvars * [self.coords_names], mesh)))
        self.ds = xr.Dataset(variables, coords=coords)
        self.ds = self.ds.expand_dims(dim='time', axis=len(self.coords_names))

        for var in self.names:
            self.ds[var].values.setflags(write=True)

        self.r0 = np.stack((list(map(np.ravel, mesh))))
        self.r0 = self.r0.transpose()

        return

    def set_mask(self, json_dict):
        self.maski = InputFields()
        self.maski.get_info(json_dict['mask'])
        self.maski.get_mfds()
        self.maski.get_grid()
        self.maski.get_interpolants(method='nearest')

    def apply_mask(self):
        """

        Apply the mask to the points, and filter the non-true points.
        It also generates a copy of the array with the mask included (numpy masked array) 
        to reconstruct the initial array, in the postprocessing stage. 

        WARNING:: 
            The masked array cannot be passed directly to computations (it is heavily slow).
    

        """
        print('\n')
        print('*************************************')
        print('LAGAR InitialConditions Information ')
        print('*************************************')
        print('Info: True condition => Point masked by position')
        print('Info: Points True condition => not integrate')
        print('Points pre-mask:', self.r0.shape[0])
        print('Stage: Appliying mask filter points')

        self.mask = self.maski.F_s(self.r0) == 1
        # Added tuple to avoid the Future Warning.
        remove_mask = (~self.mask).any(axis=1)
        self.r0 = self.r0[(remove_mask)]

        if self.ds:
            self.ds['mask'] = (self.coords_names,
                               self.mask.reshape(self.get_dims()))

        print('Points post-mask:', self.r0.shape[0])
        print('\n')

        return

    def read_points_file(self, delimiter=';'):
        """
        Read the information of initial conditions from a CSV file.
        
        Args:
            delimiter (str, optional): delimiter for CSV files.
        
        Returns:
            void: sets the array with the CSV readed values.
        
        """

        if self.file[-4:] == '.csv':
            csv = pd.read_csv(self.file, delimiter=delimiter)
            self.r0 = csv[self.names].values

        elif self.file[-3:] == '.nc':
            ds = xr.open_dataset(self.file)
            try:
                self.r0 = np.stack([ds[name].values for name in self.names],
                                   axis=1)
            except:
                self.r0 = np.array([ds[name].values for name in self.names])
        return

    def span_time(self):

        if isinstance(self.time_range[0], str):
            self.tspan_fmt = pd.date_range(start=self.time_range[0],
                                           end=self.time_range[1],
                                           freq=self.time_range[2])
            self.reference_time = pd.datetime.strptime(self.time_ref,
                                                       '%Y-%m-%d %H:%M:%S')
            self.dt_fmt = self.time_range[2]
            self.t0_fmt = self.tspan_fmt[0]
            self.tspan = (self.tspan_fmt - self.reference_time
                          ).astype('timedelta64[s]').astype('f8').values
            self.t0 = self.tspan[0]
            self.dt = float(self.time_range[2][0:-1])

            print('+++++++++++++++++++++++++++++++')
            print('LAGAR InitialCondtions time')
            print('+++++++++++++++++++++++++++++++')
            print('Reference_time:', self.reference_time)
            print('Number of steps:', self.tspan)
            print('Time step used:', self.dt)
            print('Date started:', self.t0_fmt)
            print('Date end:', self.tspan_fmt[-1])
            print('Date started in seconds', self.t0)
            print('Date end in seconds:', self.tspan_fmt[-1])

        else:

            self.tspan = np.arange(self.time_range[0], self.time_range[1],
                                   self.time_range[2])
            self.t0 = self.tspan[0]
            self.dt = self.time_range[2]

            print('+++++++++++++++++++++++++++++++')
            print('LAGAR InitialCondtions time')
            print('+++++++++++++++++++++++++++++++')
            print('Number of steps:', self.tspan.size)
            print('Time step used:', self.dt)
            print('Date started in seconds', self.t0)

        return

    def get_dims(self):
        """

        Get the dimensions of the initial conditions domain.

        Returns:
            list: the list containing the dimensions of the initial conditions domain.
        """

        return list(map(np.size, self.span))

    def generate(self, json_dict):
        self.read_config(json_dict)
        if 'file' in json_dict:
            self.read_points_file()
        else:
            self.spanning()
            self.set_array()
        if 'mask' in json_dict:
            self.set_mask(json_dict)
            self.apply_mask()
        self.span_time()

    def update(self, json_dict):
        self.read_config(json_dict)
        self.span_time()