pharmapy-org 0.1.0__py3-none-any.whl

PharmaPy/CakePhysics.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""
+Cake physics correlations shared by the solid-liquid separation units.
+
+These four functions carry no state and belong to no class. They were defined
+at the top of ``SolidLiquidSep`` and imported from there by ``Drying_Model``,
+which made a legacy module part of another module's public API. Keeping them
+here lets the legacy units, the refactored ones and the dryer draw on one copy
+instead of drifting apart.
+
+``SolidLiquidSep`` re-exports every name below, so the original import path
+still works.
+"""
+
+import numpy as np
+
+eps = np.finfo(float).eps * 1.1
+grav = 9.8  # m/s**2
+
+
+def high_resolution_fvm(f, boundary_cond, limiter_type='Van Leer'):
+
+    # Ghost cells -1, 0 and N + 1 (see LeVeque 2002, Chapter 9)
+    f_extrap = 2*f[-1] - f[-2]
+    f_aug = np.concatenate(([boundary_cond]*2, f, [f_extrap]))
+
+    f_diff = np.diff(f_aug, axis=0)
+
+    theta = (f_diff[:-1]) / (f_diff[1:] + eps)
+
+    if limiter_type == 'Van Leer':
+        limiter = (np.abs(theta) + theta) / (1 + np.abs(theta))
+    else:  # TODO: include more limiters
+        pass
+
+    fluxes = f_aug[1:-1] + 0.5 * f_diff[1:] * limiter
+
+    return fluxes
+
+
+def upwind_fvm(f, boundary_cond):
+    f_aug = np.concatenate(([boundary_cond], f))
+
+    return f_aug
+
+
+def get_alpha(solid_phase, porosity, sphericity, rho_sol, csd=None):
+    # if csd is None:
+    #     csd = solid_phase.distrib
+
+    # x_grid = solid_phase.x_distrib
+
+    # alpha_x = 180 * (1 - porosity) / \
+    #     (porosity**3 * (x_grid*1e-6)**2 * rho_sol * sphericity**2)
+
+    # numerator = trapezoidal_rule(x_grid, csd * alpha_x)
+    # denominator = solid_phase.moments[0]
+
+    # alpha = numerator / (denominator + eps)
+    csd = solid_phase.distrib
+    rho_sol = solid_phase.getDensity()
+    x_grid = solid_phase.x_distrib * 1e-6
+
+    kv = 0.524  # converting number based CSD to volume based:
+
+    del_x_dist = np.diff(x_grid)
+    node_x_dist = (x_grid[:-1] + x_grid[1:]) / 2
+    node_CSD = (csd[:-1] + csd[1:]) / 2
+
+    # Volume of crystals in each bin
+    vol_cry = node_CSD * del_x_dist * (kv * node_x_dist**3)
+    frac_vol_cry = vol_cry / (np.sum(vol_cry) + eps)
+
+    csd = vol_cry
+
+    # Calculate irreducible saturation in weighted csd (volume based)
+    vol_frac = vol_cry/ np.sum(vol_cry)
+    x_grid = node_x_dist
+    alpha_x = 180 * (1 - porosity) / porosity**3 / x_grid**2 / rho_sol
+    alpha = np.sum(alpha_x * vol_frac)
+
+    return alpha
+
+
+def get_sat_inf(x_vec, csd, deltaP, porosity, height, mu_zero, props):
+    surf_tens, rho_liq = props
+
+    kv = 0.524  # converting number based CSD to volume based:
+
+    del_x_dist = np.diff(x_vec)
+    node_x_dist = (x_vec[:-1] + x_vec[1:]) / 2
+    node_CSD = (csd[:-1] + csd[1:]) / 2
+
+    x_vec = node_x_dist
+    if isinstance(surf_tens, float) or isinstance(rho_liq, float):
+        capillary_number = porosity**3 * x_vec**2 * \
+            (rho_liq*grav*height + deltaP) / (1 - porosity)**2 / height / surf_tens
+    else:
+        capillary_number = np.outer(
+            porosity**3 * x_vec**2,
+            (rho_liq*grav*height + deltaP)/(1 - porosity)**2 / height / surf_tens
+            )
+    # Volume of crystals in each bin
+    vol_cry = node_CSD * del_x_dist * (kv * node_x_dist**3)
+    frac_vol_cry = vol_cry / (np.sum(vol_cry) + eps)
+
+    csd = vol_cry
+
+    s_inf = 0.155 * (1 + 0.031*capillary_number**(-0.49))
+    s_inf = np.where(s_inf > 1, 1, s_inf)
+
+    # Calculate irreducible saturation in weighted csd (volume based)
+    vol_frac = vol_cry/ np.sum(vol_cry)
+
+    s_inf = np.sum(vol_frac *s_inf)
+
+    return s_inf

PharmaPy/Calibration.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Nov  3 11:29:05 2020
+
+@author: dcasasor
+"""
+
+import numpy as np
+import itertools
+import matplotlib.pyplot as plt
+from matplotlib.ticker import AutoMinorLocator
+
+
+class PCR_calibration:
+    def __init__(self, data, num_comp=None, standardize=True, snv=False,
+                 y_name=None, y_suffixes=None):
+
+        self.data = data
+        self.standardize = standardize
+        self.snv = snv
+
+        data_mean = data.mean(axis=0)
+        data_std = data.std(axis=0)
+
+        if snv:
+            self.data_centered = self.__center_data(data)
+        else:
+            self.data_centered = self.__center_data(data, data_mean, data_std)
+            # self.data_centered = self.__center_data(data, None, None)
+
+        self.data_mean = data_mean
+        self.data_std = data_std
+
+        (self.projections, self.explained_variance,
+         self.svd_dict) = self.__get_projections()
+
+        if num_comp is None:
+            self.num_comp = len(self.svd_dict['sv'])
+        else:
+            self.num_comp = num_comp
+
+        if y_name is None:
+            y_name = 'y_'
+
+        self.y_name = y_name
+        self.y_suffixes = y_suffixes
+
+    def __center_data(self, data=None, mean=None, std=None):
+        if mean is None and std is None:
+            mean = data.mean(axis=0)
+            std = data.std(axis=0)
+
+        data_centered = data - mean
+
+        if self.snv or self.standardize:
+            data_centered *= 1 / std
+
+        return data_centered
+
+    def __get_projections(self, data=None, n_comp=None):
+
+        if data is None:
+            data = self.data_centered
+
+        # Perform SVD
+        u_m, sv, v_nt = np.linalg.svd(data)
+        v_n = v_nt.T
+
+        # Percent of explained variance
+        explained_var = sv**2 / (sv**2).sum() * 100
+
+        # Store SVD in a dict
+        v_trunc = v_nt[:len(sv)].T
+
+        svd_dict = {'U': u_m, 'sv': sv, 'V': v_n, 'V_trunc': v_trunc}
+
+        # Projections
+        projections = np.dot(data, v_n)
+
+        if n_comp is not None:
+            projections = projections[:, :n_comp]
+
+        return projections, explained_var, svd_dict
+
+    def plot_projections(self, fig_size=None, num_comp=None):
+
+        if num_comp is None:
+            num_comp = self.num_comp
+
+        comb = itertools.combinations(range(num_comp), 2)
+
+        combs = [item for item in comb]
+        num_plots = len(combs)
+
+        if num_plots == 1:
+            fig, axes = plt.subplots(figsize=fig_size)
+            axes = np.atleast_1d(axes)
+        else:
+            ncols = 2
+            nrows = num_plots // ncols + num_plots % ncols
+
+            fig, axes = plt.subplots(nrows, ncols, figsize=fig_size)
+
+        axes_flat = axes.flatten()
+        num_axes = len(axes_flat)
+        for ind in range(num_plots):
+            axis = axes_flat[ind]
+            pc_one, pc_two = combs[ind]
+
+            my_map = plt.get_cmap('Reds')
+            data_plot = self.projections[:, combs[ind]].T
+            axis.scatter(data_plot[0], data_plot[1],
+                         # 'o', mfc='None',
+                         s=30/(num_axes/2), c=range(data_plot.shape[1]),
+                         cmap=my_map,
+                         marker='o', edgecolor='k')
+
+            axis.text(0.5, -0.08, 'PC%i' % (pc_one + 1),
+                      transform=axis.transAxes, ha='center')
+
+            axis.text(-0.08, 0.5, 'PC%i' % (pc_two + 1), rotation=90,
+                      transform=axis.transAxes, va='center')
+
+            axis.spines['bottom'].set_position('zero')
+            axis.spines['left'].set_position('zero')
+
+            axis.spines['top'].set_visible(False)
+            axis.spines['right'].set_visible(False)
+
+        if num_plots < num_axes:
+            fig.delaxes(axes_flat[-1])
+
+        fig.tight_layout()
+
+        return fig, axes
+
+    def get_regression(self, y_data, num_comp=None, update_instance=True):
+
+        if self.y_suffixes is None:
+            self.y_suffixes = ['%i' % num for num in range(1, len(y_data))]
+
+        self.y_labels = [r'$' + self.y_name + ('{%s}' % suffix) + '$'
+                         for suffix in self.y_suffixes]
+
+        if num_comp is None:
+            num_comp = self.num_comp
+
+        # scores = self.projections[:, :num_comp]
+        scores = self.projections[:, :num_comp]
+
+        scores_inv = np.linalg.pinv(scores)  # pseudoinverse of scores
+
+        # Regression coefficients w.r.t. principal components
+        if y_data.ndim == 1:
+            y_data = y_data[..., np.newaxis]
+
+        y_means = y_data.mean(axis=0)
+        y_center = y_data - y_means
+        q_coeff = np.dot(scores_inv, y_center)
+
+        regression_coeff = q_coeff
+
+        self.y_data = y_data
+        self.y_center = y_center
+        self.y_means = y_means
+
+        if update_instance:
+            self.regression_coeff = regression_coeff
+            self.num_comp = num_comp
+
+            y_pred = self.predict(self.data)
+            residuals = y_data - y_pred
+            self.residuals = residuals
+
+        # # Regression coefficients w.r.t. original X
+        # regression_coeff = np.dot(self.svd_dict['V'][:, :num_comp],
+        #                           q_coeff)
+
+
+        # if update_instance:
+        #     self.regression_coeff = regression_coeff
+
+        #     y_pred = self.predict(self.data)
+        #     residuals = y_data - y_pred
+        #     self.residuals = residuals
+
+        return regression_coeff
+
+    def predict(self, inputs, num_comp=None, regression_coeff=None,
+                full_output=False):
+        inputs = np.atleast_2d(inputs)
+
+        if self.snv:
+            inputs_centered = self.__center_data(inputs)
+        else:
+            inputs_centered = self.__center_data(inputs)
+
+        if regression_coeff is None:
+            coeff = self.regression_coeff
+        else:
+            coeff = regression_coeff
+
+        if num_comp is None:
+            num_comp = self.num_comp
+
+        p_matrix = self.svd_dict['V'][:, :num_comp]
+        new_projections = np.dot(inputs_centered, p_matrix)
+
+        resid_x = inputs_centered[0] - np.dot(new_projections[0],
+                                              p_matrix.T)
+
+        SPE_x = np.dot(resid_x, resid_x)
+        print(SPE_x)
+
+        # new_projections, _, di = self.__get_projections(inputs_centered,
+        #                                                 num_comp)
+
+
+        response = np.dot(new_projections, coeff) + self.y_means
+
+        num_data = self.y_data.size
+
+        if full_output:
+            resid = response - self.y_data
+            mse = 1 / num_data * np.dot(resid.T, resid)
+            info_out = {'x_projected': new_projections, 'y_pred': response,
+                        'MSE': mse}
+
+            return info_out
+        else:
+
+            return response
+
+    def evaluate_mse(self, num_comp=None):
+
+        if num_comp is None:
+            pc_counter = range(len(self.svd_dict['sv']))
+        else:
+            pc_counter = range(num_comp)
+
+        mse = []
+        residuals = []
+
+        n_data = np.prod(self.y_data.shape)
+        for n_component in pc_counter:
+            coeff = self.get_regression(self.y_data, n_component + 1,
+                                        update_instance=False)
+
+            pred = self.predict(self.data, regression_coeff=coeff,
+                                num_comp=n_component + 1)
+
+            resid = self.y_data - pred
+
+            mse_val = 1 / n_data * (resid**2).sum()
+
+            mse.append(mse_val)
+            residuals.append(resid)
+
+        return mse, residuals
+
+    def plot_parity(self, figsize=None):
+        if figsize is None:
+            figsize = (4, 3.5)
+        fig, axis = plt.subplots(figsize=figsize)
+
+        markers = ['o', 's', 'd', '*']
+
+        y_pred = self.y_data - self.residuals
+
+        minim = (np.minimum(self.y_data, y_pred)).min()
+        maxim = (np.maximum(self.y_data, y_pred)).max()
+
+        range_vals = maxim - minim
+
+        left_bottom = [minim - range_vals*0.01]*2
+        right_top = [maxim + range_vals*0.01]*2
+
+        axis.plot(*zip(left_bottom, right_top), '--k', alpha=0.5)
+
+        for ind in range(self.y_data.shape[1]):
+            axis.plot(self.y_data[:, ind], y_pred[:, ind],
+                      marker=markers[ind], mfc='None', ls='',
+                      label=self.y_labels[ind])
+
+        axis.legend()
+
+        axis.set_xlabel('$%s{data}$' % self.y_name)
+        axis.set_ylabel('$%s{model}$' % self.y_name)
+
+        axis.xaxis.set_minor_locator(AutoMinorLocator(2))
+        axis.yaxis.set_minor_locator(AutoMinorLocator(2))
+
+        axis.text(1, 1.04, 'num_components = %i' % self.num_comp,
+                  transform=axis.transAxes, ha='right')
+
+        return fig, axis
+
+    def cross_validation(self, num_groups=10):
+        perm = np.random.permutation(self.data.shape[0])

PharmaPy/CheckModule.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Mar  7 14:49:31 2023
+
+@author: dcasasor
+"""
+
+import json
+import pathlib
+
+from PharmaPy.Errors import PharmaPySpecificationError
+import warnings
+
+
+root = pathlib.Path(__file__).parent / 'data'
+
+
+def check_modeling_objects(uo, instance_name=None):
+    with open(root / 'minimum_modeling_objects.json') as fi:
+        checks = json.load(fi)
+
+    class_name = uo.__class__.__name__
+
+    if instance_name is None:
+        instance_name = '<InstanceName>'
+        instance_descr = "a " + class_name + ' instance'
+    else:
+        instance_descr = "the '%s' %s instance" % (instance_name, class_name)
+
+    if class_name in checks['special']:
+        modeling_objs = checks['special'][class_name]
+    else:
+        modeling_objs = checks[uo.oper_mode]
+
+    module_name = uo.__module__.split('.')[-1]
+
+    cond_kin = (module_name in checks['has_kinetics']['modules'] or
+                class_name in checks['has_kinetics']['classes']) and \
+        'Kinetics' not in modeling_objs
+
+    cond_utility = (module_name in checks['has_utility']['modules'] or
+                    class_name in checks['has_utility']['classes']) and \
+        'Utility' not in modeling_objs
+
+    if cond_kin:
+        modeling_objs.append('Kinetics')
+
+    if cond_utility:
+        modeling_objs.append('Utility')
+
+    missing_obj = []
+    for obj in modeling_objs:
+        if not hasattr(uo, obj) or getattr(uo, obj) is None:
+            missing_obj.append(obj)
+
+    if len(missing_obj) > 0:
+        intro = "The following PharmaPy modeling objects were " \
+            "not detected in %s:\n" % instance_descr
+
+        obj_enum = '\t' + ',\n\t'.join(missing_obj) + '.\n\n'
+
+        recommend = "Please create the missing modeling objects listed above" \
+            " and then aggregate them one by one to the corresponding unit " \
+            "operation instance, e.g. %s.%s = <%sClass>(...)" % (
+                    instance_name, missing_obj[0], missing_obj[0])
+
+        message = intro + obj_enum + recommend
+
+        # raise PharmaPySpecificationError(message)
+        warnings.warn(message)