def fit_nls( df_data, md=None, verbose=True, **kwargs, ): r"""Fit a model with Nonlinear Least Squares (NLS) Estimate best-fit variable levels with nonlinear least squares (NLS), and return an executable model with those frozen best-fit levels. Note: This is a *synonym* for eval_nls(); see the documentation for eval_nls() for keyword argument options available beyond those listed here. Args: df_data (DataFrame): Data for estimating best-fit variable levels. Variables not found in df_data optimized for fitting. md (gr.Model): Model to analyze. All model variables selected for fitting must be bounded or random. Deterministic variables may have semi-infinite bounds. Returns: gr.Model: Model for evaluation with best-fit variables frozen to optimized levels. """ ## Check invariants if md is None: raise ValueError("Must provide model md") ## Run eval_nls to fit model parameter values df_fit = eval_nls(md, df_data=df_data, append=True, **kwargs) ## Select best-fit values df_best = df_fit.sort_values(by="mse", axis=0).iloc[[0]] if verbose: print(df_best) ## Determine variables to fix var_fixed = list(set(md.var).intersection(set(df_best.columns))) var_remain = list(set(md.var).difference(set(var_fixed))) if len(var_remain) == 0: raise ValueError("Resulting model is constant!") ## Assemble and return fitted model if md.name is None: name = "(Fitted Model)" else: name = md.name + " (Fitted)" md_res = (Model(name) >> cp_function( lambda x: df_best[var_fixed].values, var=var_remain, out=var_fixed, name="Fix variable levels", ) >> cp_md_det(md=md)) return md_res
def make_test(): md = Model() >> \ cp_function(fun=fun, var=3, out=1) >> \ cp_bounds(x0=(-1,+1), x1=(-1,+1), x2=(-1,+1)) >> \ cp_marginals( x0={"dist": "uniform", "loc": -1, "scale": 2}, x1={"dist": "uniform", "loc": -1, "scale": 2} ) >> \ cp_copula_independence() return md
def make_plate_buckle(): r"""Initialize a buckling plate model Variables (deterministic): w (in): Plate width h (in): Plate height t (in): Plate thickness m (-): Wavenumber L (kips): Applied (compressive) load; uniformly applied along top and bottom edges Variables (random): E (kips/in^2): Elasticity mu (-): Poisson's ratio Outputs: k_cr (-): Prefactor for buckling stress g_buckle (kips/in^2): Buckling limit state: critical stress - applied stress """ md = ( Model("Plate Buckling") >> cp_vec_function( fun=lambda df: df_make( k_cr=(df.m*df.h/df.w + df.w/df.m/df.h)**2 ), var=["w", "h", "m"], out=["k_cr"], ) >> cp_vec_function( fun=lambda df: df_make( g_buckle=df.k_cr * pi**2/12 * df.E / (1 - df.mu**2) * (df.t/df.h)**2 - df.L / df.t / df.w ), var=["k_cr", "t", "h", "w", "E", "mu", "L"], out=["g_buckle"], name="limit state", ) >> cp_bounds( t=(0.5 * THICKNESS, 2 * THICKNESS), h=(6, 18), w=(6, 18), m=(1, 5), L=(LOAD / 2, LOAD * 2), ) >> cp_marginals( E=marg_fit("norm", df_stang.E), mu=marg_fit("beta", df_stang.mu), ) >> cp_copula_gaussian(df_data=df_stang) ) return md
def make_trajectory_linear(): ## Assemble model md_trajectory = ( Model("Trajectory Model") >> cp_vec_function(fun=fun_x, var=var_list, out=["x"], name="x_trajectory",) >> cp_vec_function(fun=fun_y, var=var_list, out=["y"], name="y_trajectory",) >> cp_bounds( u0=[0.1, Inf], v0=[0.1, Inf], tau=[0.05, Inf], t=[0, 600] ) ) return md_trajectory
def make_poly(): md = Model("Polynomials") >> \ cp_function(fun=lambda x: x, var=1, out=1, name="linear") >> \ cp_function(fun=lambda x: x**2, var=1, out=1, name="quadratic") >> \ cp_function(fun=lambda x: x**3, var=1, out=1, name="cubic") >> \ cp_marginals( x0={"dist": "uniform", "loc": -1, "scale": 2}, x1={"dist": "uniform", "loc": -1, "scale": 2}, x2={"dist": "uniform", "loc": -1, "scale": 2} ) >> \ cp_copula_independence() return md
def make_channel_nondim(): r"""Make 1d channel model; dimensionless form Instantiates a model for particle and fluid temperature rise; particles are suspended in a fluid with bulk velocity along a square cross-section channel. The walls of said channel are transparent, and radiation heats the particles as they travel down the channel. References: Banko, A.J. "RADIATION ABSORPTION BY INERTIAL PARTICLES IN A TURBULENT SQUARE DUCT FLOW" (2018) PhD Thesis, Stanford University, Chapter 2 """ md = ( Model("1d Particle-laden Channel with Radiation; Dimensionless Form") >> cp_vec_function( fun=lambda df: df_make(beta=120 * (1 + df.Phi_M * df.chi)), var=["Phi_M", "chi"], out=["beta"], ) >> cp_vec_function( fun=lambda df: df_make( T_f=(df.Phi_M * df.chi) / (1 + df.Phi_M * df.chi) * (df.I * df.xst - df.beta**(-1) * df.I * (1 - exp(-df.beta * df.xst))), T_p=1 / (1 + df.Phi_M * df.chi) * (df.Phi_M * df.chi * df.I * df.xst + df.beta**(-1) * df.I * (1 - exp(-df.beta * df.xst))), ), var=["xst", "Phi_M", "chi", "I", "beta"], out=["T_f", "T_p"], ) >> cp_bounds( ## Dimensionless axial location (-) xst=(0, 5), ) >> cp_marginals( ## Mass loading ratio (-) Phi_M={ "dist": "uniform", "loc": 0, "scale": 1 }, ## Particle-fluid heat capacity ratio (-) chi={ "dist": "uniform", "loc": 0.1, "scale": 0.9 }, ## Normalized radiative intensity (-) I={ "dist": "uniform", "loc": 0.1, "scale": 0.9 }, ) >> cp_copula_independence()) return md
def make_linear_normal(): md = Model("Linear-Normal Reliability Problem") >> \ cp_function( fun=limit_state, var=2, out=["g_linear"], name="limit state" ) >> \ cp_marginals( x0={"dist": "norm", "loc": 0, "scale": 1, "sign":+1}, x1={"dist": "norm", "loc": 0, "scale": 1, "sign":+1} ) >> \ cp_copula_independence() return md
def make_pareto_random(twoDim=True): """ Create a model of random points for a pareto frontier evaluation Args: twoDim (bool): determines whether to create a 2D or 3D model """ if twoDim == True: # Model to make dataset md_true = (Model() >> cp_vec_function( fun=lambda df: df_make( y1=df.x1 * cos(df.x2), y2=df.x1 * sin(df.x2), ), var=["x1", "x2"], out=["y1", "y2"], ) >> cp_marginals( x1=dict(dist="uniform", loc=0, scale=1), x2=dict(dist="uniform", loc=0, scale=pi / 2), ) >> cp_copula_independence()) return md_true else: # Model to make dataset md_true = (Model() >> cp_vec_function( fun=lambda df: df_make( y1=df.x1 * cos(df.x2), y2=df.x1 * sin(df.x2), y3=df.x1 * tan(df.x2), ), var=["x1", "x2", "x3"], out=["y1", "y2", "y3"], ) >> cp_marginals(x1=dict(dist="uniform", loc=0, scale=1), x2=dict(dist="uniform", loc=0, scale=pi / 2), x3=dict(dist="uniform", loc=0, scale=pi / 4)) >> cp_copula_independence()) return md_true
def fit_nls( df_data, md=None, out=None, var_fix=None, df_init=None, verbose=True, uq_method=None, **kwargs, ): r"""Fit a model with Nonlinear Least Squares (NLS) Estimate best-fit variable levels with nonlinear least squares (NLS), and return an executable model with those frozen best-fit levels. Optionally, fit a distribution on the parameters to quantify parametric uncertainty. Note: This is a *synonym* for eval_nls(); see the documentation for eval_nls() for keyword argument options available beyond those listed here. Args: df_data (DataFrame): Data for estimating best-fit variable levels. Variables not found in df_data optimized for fitting. md (gr.Model): Model to analyze. All model variables selected for fitting must be bounded or random. Deterministic variables may have semi-infinite bounds. var_fix (list or None): Variables to fix to nominal levels. Note that variables with domain width zero will automatically be fixed. df_init (DataFrame): Initial guesses for parameters; overrides n_restart n_restart (int): Number of restarts to try; the first try is at the nominal conditions of the model. Returned model will use the least-error parameter set among restarts tested. n_maxiter (int): Optimizer maximum iterations verbose (bool): Print best-fit parameters to console? uq_method (str OR None): If string, select method to quantify parameter uncertainties. If None, provide best-fit values only. Methods: uq_method = "linpool": assume normal errors; linearly approximate parameter effects; equally pool variance matrices for each output Returns: gr.Model: Model for evaluation with best-fit variables frozen to optimized levels. Examples: >>> import grama as gr >>> from grama.data import df_trajectory_windowed >>> from grama.models import make_trajectory_linear >>> X = gr.Intention() >>> >>> md_trajectory = make_trajectory_linear() >>> md_fitted = ( >>> df_trajectory_windowed >>> >> gr.ft_nls( >>> md=md_trajectory, >>> uq_method="linpool", >>> ) >>> ) """ ## Check `out` invariants if out is None: out = md.out print("... fit_nls setting out = {}".format(out)) ## Check invariants if md is None: raise ValueError("Must provide model md") ## Determine variables to be fixed if var_fix is None: var_fix = set() else: var_fix = set(var_fix) for var in md.var_det: wid = md.domain.get_width(var) if wid == 0: var_fix.add(var) ## Run eval_nls to fit model parameter values df_fit = eval_nls( md, df_data=df_data, var_fix=var_fix, df_init=df_init, append=True, verbose=verbose, **kwargs, ) ## Select best-fit values df_best = df_fit.sort_values(by="mse", axis=0).iloc[[0]].reset_index(drop=True) if verbose: print(df_fit.sort_values(by="mse", axis=0)) ## Determine variables that were fitted var_fitted = list(set(md.var).intersection(set(df_best.columns))) var_remain = list(set(md.var).difference(set(var_fitted))) if len(var_remain) == 0: raise ValueError("Resulting model is constant!") ## Assemble and return fitted model if md.name is None: name = "(Fitted Model)" else: name = md.name + " (Fitted)" ## Calibrate parametric uncertainty, if requested if uq_method == "linpool": ## Precompute data df_nom = eval_nominal(md, df_det="nom") df_base = tran_outer( df_data, concat((df_best[var_fitted], df_nom[var_fix]), axis=1)) df_pred = eval_df(md, df=df_base) df_grad = eval_grad_fd(md, df_base=df_base, var=var_fitted) ## Pool variance matrices n_obs = df_data.shape[0] n_fitted = len(var_fitted) Sigma_pooled = zeros((n_fitted, n_fitted)) for output in out: ## Approximate sigma_sq sigma_sq = npsum( nppow(df_data[output].values - df_pred[output].values, 2)) / (n_obs - n_fitted) ## Approximate (pseudo)-inverse hessian var_grad = list(map(lambda v: "D" + output + "_D" + v, var_fitted)) Z = df_grad[var_grad].values Hinv = pinv(Z.T.dot(Z), hermitian=True) ## Add variance matrix to pooled Sigma Sigma_pooled = Sigma_pooled + sigma_sq * Hinv / n_fitted ## Check model for identifiability kappa_out = cond(Sigma_pooled) if kappa_out > 1e10: warn( "Model is locally unidentifiable as measured by the " + "condition number of the pooled covariance matrix; " + "kappa = {}".format(kappa_out), RuntimeWarning, ) ## Convert to std deviations and correlation sigma_comp = npsqrt(diag(Sigma_pooled)) corr_mat = Sigma_pooled / (atleast_2d(sigma_comp).T.dot( atleast_2d(sigma_comp))) corr_data = [] I, J = triu_indices(n_fitted, k=1) for ind in range(len(I)): i = I[ind] j = J[ind] corr_data.append([var_fitted[i], var_fitted[j], corr_mat[i, j]]) df_corr = DataFrame(data=corr_data, columns=["var1", "var2", "corr"]) ## Assemble marginals marginals = {} for ind, var_ in enumerate(var_fitted): marginals[var_] = { "dist": "norm", "loc": df_best[var_].values[0], "scale": sigma_comp[ind], } ## Construct model with Gaussian copula if len(var_fix) > 0: md_res = (Model(name) >> cp_function( lambda x: df_nom[var_fix].values, var=set(var_remain).difference(var_fix), out=var_fix, name="Fix variable levels", ) >> cp_md_det(md=md) >> cp_marginals(**marginals) >> cp_copula_gaussian(df_corr=df_corr)) else: md_res = (Model(name) >> cp_md_det(md=md) >> cp_marginals( **marginals) >> cp_copula_gaussian(df_corr=df_corr)) ## Return deterministic model elif uq_method is None: md_res = (Model(name) >> cp_function( lambda x: df_best[var_fitted].values, var=var_remain, out=var_fitted, name="Fix variable levels", ) >> cp_md_det(md=md)) else: raise ValueError( "uq_method option {} not recognized".format(uq_method)) return md_res
def fit_kmeans(df, var=None, colname="cluster_id", seed=None, **kwargs): r"""K-means cluster a dataset Create a cluster-labeling model on a dataset using the K-means algorithm. Args: df (DataFrame): Hybrid point results from gr.eval_hybrid() var (list or None): Variables in df on which to cluster. Use None to cluster on all variables. colname (string): Name of cluster id; will be output in cluster model. seed (int): Random seed for kmeans clustering Kwargs: n_clusters (int): Number of clusters to fit random_state (int or None): Returns: gr.Model: Model that labels input data Notes: - A wrapper for sklearn.cluster.KMeans References: Scikit-learn: Machine Learning in Python, Pedregosa et al. JMLR 12, pp. 2825-2830, 2011. Examples: >>> import grama as gr >>> from grama.data import df_stang >>> from grama.fit import ft_kmeans >>> X = gr.Intention() >>> md_cluster = ( >>> df_stang >>> >> ft_kmeans(var=["E", "mu"], n_clusters=2) >>> ) >>> ( >>> md_cluster >>> >> gr.ev_df(df_stang) >>> >> gr.tf_group_by(X.cluster_id) >>> >> gr.tf_summarize( >>> thick_mean=gr.mean(X.thick), >>> thick_sd=gr.sd(X.thick), >>> n=gr.n(X.index), >>> ) >>> ) """ ## Check invariants if var is None: var = list(df.columns).copy() else: var = list(var).copy() diff = set(var).difference(set(df.columns)) if len(diff) > 0: raise ValueError("`var` must be subset of `df.columns`\n" "diff = {}".format(diff)) ## Generate clustering try: kmeans = KMeans(random_state=seed, **kwargs).fit(df[var].values) except NameError as e: error_string = str(e) raise NameError(error_string + "\n\nThis function requires the `sklearn` package. " + "Try running the following to install the package:\n" " pip install scikit-learn") ## Build grama model def fun_cluster(df): res = kmeans.predict(df[var].values) return DataFrame(data={colname: res}) md = Model() >> cp_vec_function(fun=fun_cluster, var=var, out=[colname]) return md
def fit_lm(df, md=None, var=None, out=None, domain=None, density=None, seed=None, suppress_warnings=True, **kwargs): r"""Fit a linear model Fit a linear model to given data. Specify inputs and outputs, or inherit from an existing model. Args: df (DataFrame): Data for function fitting md (gr.Model): Model from which to inherit metadata var (list(str) or None): List of features or None for all except outputs out (list(str)): List of outputs to fit domain (gr.Domain): Domain for new model density (gr.Density): Density for new model seed (int or None): Random seed for fitting process suppress_warnings (bool): Suppress warnings when fitting? Returns: gr.Model: A grama model with fitted function(s) Notes: - Wrapper for sklearn.ensemble.RandomForestRegressor """ if suppress_warnings: filterwarnings("ignore") n_obs, n_in = df.shape ## Infer fitting metadata, if available if not (md is None): domain = md.domain density = md.density out = md.out ## Check invariants if not set(out).issubset(set(df.columns)): raise ValueError("out must be subset of df.columns") ## Default input value if var is None: var = list(set(df.columns).difference(set(out))) ## Check more invariants set_inter = set(out).intersection(set(var)) if len(set_inter) > 0: raise ValueError( "outputs and inputs must be disjoint; intersect = {}".format( set_inter)) if not set(var).issubset(set(df.columns)): raise ValueError("var must be subset of df.columns") ## Construct gaussian process for each output functions = [] try: for output in out: lm = LinearRegression(**kwargs) lm.fit(df[var], df[output]) name = "LM" fun = FunctionRegressor(lm, var, [output], name, 0) functions.append(fun) except NameError as e: error_string = str(e) raise NameError(error_string + "\n\nThis function requires the `sklearn` package. " + "Try running the following to install the package:\n" " pip install scikit-learn") ## Construct model return Model(functions=functions, domain=domain, density=density)
def fit_gp( df, md=None, var=None, out=None, domain=None, density=None, kernels=None, seed=None, suppress_warnings=True, n_restart=5, alpha=1e-10, ): r"""Fit a gaussian process Fit a gaussian process to given data. Specify var and out, or inherit from an existing model. Note that the new model will have two outputs `y_mean, y_sd` for each original output `y`. The quantity `y_mean` is the best-fit value, while `y_sd` is a measure of predictive uncertainty. Args: df (DataFrame): Data for function fitting md (gr.Model): Model from which to inherit metadata var (list(str) or None): List of features or None for all except outputs out (list(str)): List of outputs to fit domain (gr.Domain): Domain for new model density (gr.Density): Density for new model seed (int or None): Random seed for fitting process kernels (sklearn.gaussian_process.kernels.Kernel or dict or None): Kernel for GP n_restart (int): Restarts for optimization alpha (float or iterable): Value added to diagonal of kernel matrix suppress_warnings (bool): Suppress warnings when fitting? Returns: gr.Model: A grama model with fitted function(s) Notes: - Wrapper for sklearn.gaussian_process.GaussianProcessRegressor """ if suppress_warnings: filterwarnings("ignore") n_obs, n_in = df.shape ## Infer fitting metadata, if available if not (md is None): domain = md.domain density = md.density out = md.out ## Check invariants if not set(out).issubset(set(df.columns)): raise ValueError("out must be subset of df.columns") ## Default input value if var is None: var = list(set(df.columns).difference(set(out))) ## Check more invariants set_inter = set(out).intersection(set(var)) if len(set_inter) > 0: raise ValueError( "out and var must be disjoint; intersect = {}".format(set_inter)) if not set(var).issubset(set(df.columns)): raise ValueError("var must be subset of df.columns") ## Pre-process kernel selection try: if kernels is None: # Vectorize kernels = {o: None for o in out} elif isinstance(kernels, Kernel): kernels = {o: kernels for o in out} except NameError as e: error_string = str(e) raise NameError(error_string + "\n\nThis function requires the `sklearn` package. " + "Try running the following to install the package:\n" " pip install scikit-learn") ## Pre-process data var_min = df[var].min() var_max = df[var].max() df_sd = standardize_cols(df, var_min, var_max, var) ## Construct gaussian process for each output functions = [] try: for output in out: # Define and fit model gpr = GaussianProcessRegressor( kernel=deepcopy(kernels[output]), random_state=seed, normalize_y=True, copy_X_train=True, n_restarts_optimizer=n_restart, alpha=alpha, ) gpr.fit(df_sd[var], df_sd[output]) name = "GP ({})".format(str(gpr.kernel_)) fun = FunctionGPR(gpr, var, [output], name, 0, var_min, var_max) functions.append(fun) except NameError as e: error_string = str(e) raise NameError(error_string + "\n\nThis function requires the `sklearn` package. " + "Try running the following to install the package:\n" " pip install scikit-learn") ## Construct model return Model(functions=functions, domain=domain, density=density)
def fit_lolo(df, md=None, var=None, out=None, domain=None, density=None, seed=None, return_std=True, suppress_warnings=True, **kwargs): r"""Fit a random forest Fit a random forest to given data. Specify inputs and outputs, or inherit from an existing model. Args: df (DataFrame): Data for function fitting md (gr.Model): Model from which to inherit metadata var (list(str) or None): List of features or None for all except outputs out (list(str)): List of outputs to fit domain (gr.Domain): Domain for new model density (gr.Density): Density for new model seed (int or None): Random seed for fitting process return_std (bool): Return predictive standard deviations? suppress_warnings (bool): Suppress warnings when fitting? Keyword Arguments: num_trees (int): use_jackknife (bool): bias_learner (): leaf_learner (): subset_strategy (str): min_leaf_instances (int): max_depth (int): uncertainty_calibration (bool): randomize_pivot_location (bool): randomly_rotate_features (bool): Returns: gr.Model: A grama model with fitted function(s) Notes: - Wrapper for lolopy.learners.RandomForestRegressor """ if suppress_warnings: filterwarnings("ignore") n_obs, n_in = df.shape ## Check minimum rows if n_obs < 8: raise ValueError("The lolo random forest requires at least 8 rows") ## Infer fitting metadata, if available if not (md is None): domain = md.domain density = md.density out = md.out ## Check invariants if not set(out).issubset(set(df.columns)): raise ValueError("out must be subset of df.columns") ## Default input value if var is None: var = list(set(df.columns).difference(set(out))) ## Check more invariants set_inter = set(out).intersection(set(var)) if len(set_inter) > 0: raise ValueError( "outputs and inputs must be disjoint; intersect = {}".format( set_inter)) if not set(var).issubset(set(df.columns)): raise ValueError("var must be subset of df.columns") ## Construct gaussian process for each output functions = [] try: for output in out: rf = RandomForestRegressor(**kwargs) set_seed(seed) rf.fit(df[var].values, df[output].values) name = "RF" fun = FunctionRFR(rf, var, [output], name, 0, return_std) functions.append(fun) except NameError as e: error_string = str(e) raise NameError(error_string + "\n\nThis function requires the `lolopy` package. " + "Try running the following to install the package:\n" " pip install lolopy") ## Construct model return Model(functions=functions, domain=domain, density=density)
def make_cantilever_beam(): """Cantilever beam A standard reliability test-case, often used for benchmarking reliability analysis and design algorithms. Generally used in the following optimization problem: min_{w,t} c_area s.t. P[g_stress <= 0] <= 1.35e-3 P[g_disp <= 0] <= 1.35e-3 1 <= w, t <= 4 Deterministic Variables: w: Beam width t: Beam thickness Random Variables: H: Horizontal applied force V: Vertical applied force E: Elastic modulus Y: Yield stress Outputs: c_area: Cost; beam cross-sectional area g_stress: Limit state; stress g_disp: Limit state; tip displacement References: Wu, Y.-T., Shin, Y., Sues, R., and Cesare, M., "Safety-factor based approach for probability-based design optimization," American Institute of Aeronautics and Astronautics, Seattle, Washington, April 2001. Sues, R., Aminpour, M., and Shin, Y., "Reliability-based Multi-Disciplinary Optimiation for Aerospace Systems," American Institute of Aeronautics and Astronautics, Seattle, Washington, April 2001. """ md = Model(name = "Cantilever Beam") >> \ cp_vec_function( fun=function_area, var=["w", "t"], out=["c_area"], name="cross-sectional area", runtime=1.717e-7 ) >> \ cp_vec_function( fun=function_stress, var=["w", "t", "H", "V", "E", "Y"], out=["g_stress"], name="limit state: stress", runtime=8.88e-7 ) >> \ cp_vec_function( fun=function_displacement, var=["w", "t", "H", "V", "E", "Y"], out=["g_disp"], name="limit state: displacement", runtime=3.97e-6 ) >> \ cp_bounds( w=(2, 4), t=(2, 4) ) >> \ cp_marginals( H={"dist": "norm", "loc": MU_H, "scale": TAU_H, "sign": +1}, V={"dist": "norm", "loc": MU_V, "scale": TAU_V, "sign": +1}, E={"dist": "norm", "loc": MU_E, "scale": TAU_E, "sign": 0}, Y={"dist": "norm", "loc": MU_Y, "scale": TAU_Y, "sign": -1} ) >> \ cp_copula_independence() return md
def make_channel(): r"""Make 1d channel model; dimensional form Instantiates a model for particle and fluid temperature rise; particles are suspended in a fluid with bulk velocity along a square cross-section channel. The walls of said channel are transparent, and radiation heats the particles as they travel down the channel. Note that this takes the same inputs as the builtin dataset `df_channel`. References: Banko, A.J. "RADIATION ABSORPTION BY INERTIAL PARTICLES IN A TURBULENT SQUARE DUCT FLOW" (2018) PhD Thesis, Stanford University, Chapter 2 Examples: >>> import grama as gr >>> from grama.data import df_channel >>> from grama.models import make_channel >>> md_channel = make_channel() >>> ( >>> df_channel >>> >> gr.tf_md(md_channel) >>> >> gr.ggplot(gr.aes("T_f", "T_norm")) >>> + gr.geom_abline(slope=1, intercept=0, linetype="dashed") >>> + gr.geom_point() >>> + gr.labs(x="1D Model", y="3D DNS") >>> ) """ md = ( Model("1d Particle-laden Channel with Radiation; Dimensional Form") >> cp_vec_function( fun=lambda df: df_make( Re=df.U * df.H / df.nu_f, chi=df.cp_p / df.cp_f, Pr=df.nu_f / df.alpha_f, Phi_M=df.rho_p * 0.524 * df.d_p**3 * df.n / df.rho_f, tau_flow=df.L / df.U, tau_pt=(df.rho_p * df.cp_p * 0.318 * df.d_p) / df.h_p, tau_rad=(df.rho_p * df.cp_p * 0.667 * df.d_p * df.T_0) / (df.Q_abs * 0.78 * df.I_0), ), var=[ "U", # Fluid bulk velocity "H", # Channel width "nu_f", # Fluid kinematic viscosity "cp_p", # Particle isobaric heat capacity "cp_f", # Fluid isobaric heat capacity "alpha_f", # Fluid thermal diffusivity "rho_p", # Particle density "rho_f", # Fluid density "d_p", # Particle diameter "n", # Particle number density "h_p", # Particle-to-gas convection coefficient "T_0", # Initial temperature "Q_abs", # Particle radiation absorption coefficient "I_0", # Incident radiation ], out=[ "Re", # Reynolds number "Pr", # Prandtl number "chi", # Particle-fluid heat capacity ratio "Phi_M", # Mass Loading Ratio "tau_flow", # Fluid residence time "tau_pt", # Particle thermal time constant "tau_rad", # Particle temperature doubling time (approximate) ], name="Dimensionless Numbers", ) >> cp_vec_function( fun=lambda df: df_make( ## Let xi = x / L xst=(df.xi * df.L) / df.H / df.Re / df.Pr, ## Assume an optically-thin scenario; I/I_0 = 1 Is=df.Re * df.Pr * (df.H / df.L) * (df.tau_flow / df.tau_rad) * 1, beta=df.Re * df.Pr * (df.H / df.L) * (df.tau_flow / df.tau_pt) * (1 + df.Phi_M * df.chi), ), var=[ "xi", "chi", "H", "L", "Phi_M", "tau_flow", "tau_rad", "tau_pt" ], out=[ "xst", # Flow-normalized channel axial location "Is", # Normalized heat flux "beta", # Spatial development coefficient ], name="Intermediate Dimensionless Numbers", ) >> cp_vec_function( fun=lambda df: df_make( T_f=(df.Phi_M * df.chi) / (1 + df.Phi_M * df.chi) * (df.Is * df.xst - df.Is / df.beta * (1 - exp(-df.beta * df.xst))), T_p=1 / (1 + df.Phi_M * df.chi) * (df.Phi_M * df.chi * df.Is * df.xst + df.Is / df.beta * (1 - exp(-df.beta * df.xst))), ), var=["xst", "Phi_M", "chi", "Is", "beta"], out=["T_f", "T_p"], ) >> cp_bounds( ## Normalized axial location; xi = x/L (-) xi=(0, 1), ) >> cp_marginals( ## Channel width (m) H={ "dist": "uniform", "loc": 0.038, "scale": 0.004 }, ## Channel length (m) L={ "dist": "uniform", "loc": 0.152, "scale": 0.016 }, ## Fluid bulk velocity (m/s) U={ "dist": "uniform", "loc": 1, "scale": 2.5 }, ## Fluid kinematic viscosity (m^2/s) nu_f={ "dist": "uniform", "loc": 1.4e-5, "scale": 0.1e-5 }, ## Particle isobaric heat capacity (J/(kg K)) cp_p={ "dist": "uniform", "loc": 100, "scale": 900 }, ## Fluid isobaric heat capacity (J/(kg K)) cp_f={ "dist": "uniform", "loc": 1000, "scale": 1000 }, ## Fluid thermal diffusivity (m^2/s) alpha_f={ "dist": "uniform", "loc": 50e-6, "scale": 50e-6 }, ## Particle density (kg / m^3) rho_p={ "dist": "uniform", "loc": 1e3, "scale": 9e3 }, ## Fluid density (kg / m^3) rho_f={ "dist": "uniform", "loc": 0.5, "scale": 1.0 }, ## Particle diameter (m) d_p={ "dist": "uniform", "loc": 1e-6, "scale": 9e-6 }, ## Particle number density (1 / m^3) n={ "dist": "uniform", "loc": 9.5e9, "scale": 1.0e9 }, ## Particle-to-gas convection coefficient (W / (m^2 K)) h_p={ "dist": "uniform", "loc": 1e3, "scale": 9e3 }, ## Initial temperature (K) T_0={ "dist": "uniform", "loc": 285, "scale": 30 }, ## Particle radiation absorption coefficient (-) Q_abs={ "dist": "uniform", "loc": 0.25, "scale": 0.50 }, ## Incident radiation (W/m^2) I_0={ "dist": "uniform", "loc": 9.5e6, "scale": 1.0e6 }, ) >> cp_copula_independence()) return md