tau = sympy.var("tau") dis = sympy.var("dis") TatList = [] for _ in range(11 - 1): dis1 = eval("p" + str(_))[0] dis2 = eval("p" + str(_ + 1))[0] temp1 = eval("p" + str(_))[1] temp2 = eval("p" + str(_ + 1))[1] # print(dis1,dis2,temp1,temp2) equa = ((dis - dis2) * sympy.Rational(1, dis1 - dis2) * (temp1 - temp2) + temp2).subs(dis, v * t) condition = sympy.And(t >= dis1 / v, t <= dis2 / v) # sympy.pprint(equa) TatList.append((equa, condition)) TatList.append((sympy.S(0), True)) Tat = sympy.Piecewise(*TatList) # Ta(t) ######################计算T(t)########################## # 提取条件:Tat.args[方程号][1:条件].args[第几个条件]._args[0:t,1:数值] # 提取公式:Tat.args[方程号][0:公式].as_poly(t).coeffs() -> 其中,0为a,1为b T0 = 25 C0 = ((T0 - Tat.args[0][0].as_poly(t).coeffs()[1]) + \ Tat.args[0][0].as_poly(t).coeffs()[0] * (tau - Tat.args[0][1].args[0]._args[1])) \ / sympy.exp(-1 * Tat.args[0][1].args[0]._args[1] / tau) temp0 = C0 * sympy.exp(-1 * Tat.args[0][1].args[1]._args[1] / tau) + \ Tat.args[0][0].as_poly(t).coeffs()[1] \ - Tat.args[0][0].as_poly(t).coeffs()[0] * (tau - Tat.args[0][1].args[1]._args[1]) C1 = (temp0 - Tat.args[1][0]) \ / sympy.exp(-1 * Tat.args[1][1].args[0]._args[1] / tau) temp1 = C1 * sympy.exp(-1 * Tat.args[1][1].args[1]._args[1] / tau) + \
def _linprog(self, x, f, f_range, G, T, h=sympy.Piecewise((1.0, True)), verbose=True, epsilon=1e-8): ''' builds and solves the LP problem using scipy.linprog ''' #print(h) #this is the weighting function (partition of unity) hval = np.array([[ float(h.subs(list(zip(x, T[j, :])))) for j in range(0, T.shape[0]) ]]).T #print(hval) #define matrix A of the linear constraints A = np.multiply(np.ones((T.shape[0], 1)), hval) #this multiplies lambda_0 for i in range(0, len(G)): col = [ float(G[i].subs(list(zip(x, T[j, :])))) for j in range(0, T.shape[0]) ] #this multiplies lambda_i #print(col) if np.max(col) < 0: print('Warning: gamble ' + str(i) + ' is always negative in T') A = np.hstack([A, np.array([col]).T]) #b vector col = [ float(hval[j] * f.subs(list(zip(x, T[j, :])))) for j in range(0, T.shape[0]) ] b = np.array([col]).T + epsilon #c vector c = np.zeros(A.shape[1]) c[0] = -1 #we minimize -lambda_0 #bounds if len(self.lambda_bounds) > 0: bnd = np.array(self.lambda_bounds.copy()) bnd = np.vstack([[f_range[0], f_range[1]], bnd]) else: bnd = np.vstack([[f_range[0], f_range[1]]]) #Lower=np.hstack([f_range[0], np.zeros(A.shape[1]-1)]) #Upper=[None]*A.shape[1] #Upper[0]=f_range[1]; #bnd=tuple(zip(Lower, Upper)) res = linprog(c, A_ub=A, b_ub=b, A_eq=None, b_eq=None, bounds=bnd, method='interior-point') xopt = np.array([res.x]).T sol = { 'x': res.x, 'fun': -res.fun, 'LP max constraint violation': np.max(np.dot(A, xopt) - b) } if verbose: print('LP max constraint violation:', np.max(np.dot(A, xopt) - b)) return sol
# - Helmholtz free energy $\psi(\boldsymbol{\mathcal{E}})$ # - Threshold on thermodynamical forces $f(\boldsymbol{\mathcal{S}},\boldsymbol{\mathcal{E}})$ / Yield condition # - Flow potential $\varphi(\boldsymbol{\mathcal{S}},\boldsymbol{\mathcal{E}})$ # # as symbolic equations using the sympy package. The time-stepping algorithm gets generated automatically within the thermodynamically framework. The derived evolution equations and return-mapping to the yield surface is performed using Newton scheme. import sympy as sp from bmcs_matmod.slide.cymbol import Cymbol, ccode import traits.api as tr import numpy as np from bmcs_matmod.slide.f_double_cap import FDoubleCap import bmcs_utils.api as bu from ibvpy.tmodel import MATSEval H_switch = Cymbol(r'H(\sigma^\pi)', real=True) H = lambda x: sp.Piecewise((0, x <= 0), (1, True)) # **Code generation** The derivation is adopted for the purpose of code generation both in Python and C utilizing the `codegen` package provided in `sympy`. The expressions that are part of the time stepping algorithm are transformed to an executable code directly at the place where they are derived. At the end of the notebook the C code can be exported to external files and applied in external tools. # This code is needed to lambdify expressions named with latex symbols # it removes the backslashes and curly braces upon before code generation. # from sympy.utilities.codegen import codegen # import re # def _print_Symbol(self, expr): # CodePrinter = sp.printing.codeprinter.CodePrinter # name = super(CodePrinter, self)._print_Symbol(expr) # return re.sub(r'[\{^}]','_',re.sub(r'[\\\{\}]', '', name)) # sp.printing.codeprinter.CodePrinter._print_Symbol = _print_Symbol # ## Material parameters
def eval_piecewise(substeps, integrand, symbol): return sympy.Piecewise(*[(_manualintegrate(substep), cond) for substep, cond in substeps])
(0, 1): 0.0, (1, 0, 0): 0.0, (0, 1, 0): 0.0, (0, 0, 1): 0.0, (2,): -56.0/(3.0*_EPS**2), (2, 0): -56.0/(3.0*_EPS**2), (0, 2): -56.0/(3.0*_EPS**2), (2, 0, 0): -56.0/(3.0*_EPS**2), (0, 2, 0): -56.0/(3.0*_EPS**2), (0, 0, 2): -56.0/(3.0*_EPS**2), (1, 1): 0.0, (1, 1, 0): 0.0, (1, 0, 1): 0.0, (0, 1, 1): 0.0} wen10 = RBF(sympy.Piecewise(((1 - _R/_EPS) , _R < _EPS), (0.0, True)), tol=1e-8*_EPS, limits=_wen10_limits) wen11 = RBF(sympy.Piecewise(((1 - _R/_EPS)**3*(3*_R/_EPS + 1) , _R < _EPS), (0.0, True)), tol=1e-8*_EPS, limits=_wen11_limits) wen12 = RBF(sympy.Piecewise(((1 - _R/_EPS)**5*(8*_R**2/_EPS**2 + 5*_R/_EPS + 1) , _R < _EPS), (0.0, True)), tol=1e-8*_EPS, limits=_wen12_limits) wen30 = RBF(sympy.Piecewise(((1 - _R/_EPS)**2 , _R < _EPS), (0.0, True)), tol=1e-8*_EPS, limits=_wen30_limits) wen31 = RBF(sympy.Piecewise(((1 - _R/_EPS)**4*(4*_R/_EPS + 1) , _R < _EPS), (0.0, True)), tol=1e-8*_EPS, limits=_wen31_limits) wen32 = RBF(sympy.Piecewise(((1 - _R/_EPS)**6*(35*_R**2/_EPS**2 + 18*_R/_EPS + 3)/3, _R < _EPS), (0.0, True)), tol=1e-8*_EPS, limits=_wen32_limits) # sparse Wendland spwen10 = SparseRBF( (1 - _R/_EPS) , _EPS, tol=1e-8*_EPS, limits=_wen10_limits) spwen11 = SparseRBF( (1 - _R/_EPS)**3*(3*_R/_EPS + 1) , _EPS, tol=1e-8*_EPS, limits=_wen11_limits)
class PO_ELF_RLM_Symb(bu.SymbExpr): """Pullout of elastic Long fiber, fromm rigid long matrix """ E_f, A_f = sp.symbols(r'E_\mathrm{f}, A_\mathrm{f}', positive=True) E_m, A_m = sp.symbols(r'E_\mathrm{m}, A_\mathrm{m}', positive=True) tau, p = sp.symbols(r'\bar{\tau}, p', positive=True) C, D = sp.symbols(r'C, D') P, w = sp.symbols(r'P, w', positive=True) x, a, L_b = sp.symbols(r'x, a, L_b') d_sig_f = p * tau / A_f sig_f = sp.integrate(d_sig_f, x) + C eps_f = sig_f / E_f u_f = sp.integrate(eps_f, x) + D eq_C = {P - sig_f.subs({x:0}) * A_f} C_subs = sp.solve(eq_C,C) eqns_D = {u_f.subs(C_subs).subs(x, a)} D_subs = sp.solve(eqns_D, D) u_f.subs(C_subs).subs(D_subs) eqns_a = {eps_f.subs(C_subs).subs(D_subs).subs(x, a)} a_subs = sp.solve(eqns_a, a) var_subs = {**C_subs,**D_subs,**a_subs} u_f_x = u_f.subs(var_subs) u_fa_x = sp.Piecewise((u_f_x, x > var_subs[a]), (0, x <= var_subs[a])) eps_f_x = sp.diff(u_fa_x,x) sig_f_x = E_f * eps_f_x tau_x = sp.simplify(sig_f_x.diff(x) * A_f / p) u_f_x.subs(x, 0) - w Pw_pull = sp.solve(u_f_x.subs({x: 0}) - w, P)[0] w_L_b = u_fa_x.subs(x, -L_b).subs(P, Pw_pull) aw_pull = a_subs[a].subs(P, Pw_pull) eps_m_x = eps_f_x * 1e-8 sig_m_x = sig_f_x * 1e-8 u_ma_x = u_fa_x * 1e-8 #------------------------------------------------------------------------- # Declaration of the lambdified methods #------------------------------------------------------------------------- symb_model_params = ['E_f', 'A_f', 'tau', 'p', 'L_b'] symb_expressions = [ ('eps_f_x', ('x','P',)), ('eps_m_x', ('x','P',)), ('sig_f_x', ('x','P',)), ('sig_m_x', ('x','P',)), ('tau_x', ('x','P',)), ('u_fa_x', ('x','P',)), ('u_ma_x', ('x','P',)), ('w_L_b', ('w',)), ('aw_pull', ('w',)), ('Pw_pull', ('w',)), ]
glover = implemented_function('glover', glovert) # Derivative of Glover HRF _dgexpr = _gexpr.diff(T) _dpos = sympy.Derivative((T >= 0), T) _dgexpr = _dgexpr.subs(_dpos, 0) _dgexpr = _dgexpr / _get_sym_int(sympy.Abs(_dgexpr)) # Numerical function dglovert = lambdify_t(_dgexpr) # Symbolic function dglover = implemented_function('dglover', dglovert) del(_gexpr); del(_dpos); del(_dgexpr) # AFNI's HRF _aexpr = sympy.Piecewise((T, T >= 0), (0, True))**8.6 * sympy.exp(-T/0.547) _aexpr = _aexpr / _get_sym_int(_aexpr) # Numerical function afnit = lambdify_t(_aexpr) # Symbolic function afni = implemented_function('afni', afnit) del(_aexpr) # SPMs HRF def spm_hrf_compat(t, peak_delay=6, under_delay=16, peak_disp=1, under_disp=1, p_u_ratio = 6,
def urisi2dae(grid): buses_name_list = [item['bus'] for item in grid.buses] nodes_list = grid.nodes I_node = grid.I_node V_node = grid.V_node Y_vv = grid.Y_vv Y_ii = grid.Y_ii.toarray() Y_iv = grid.Y_iv Y_vi = grid.Y_vi inv_Y_ii = np.linalg.inv(Y_ii) N_nz_nodes = grid.params_pf[0].N_nz_nodes N_v = grid.params_pf[0].N_nodes_v buses_list = [bus['bus'] for bus in grid.buses] N_v = Y_iv.shape[1] # number of nodes with known voltages I_node_sym_list = [] V_node_sym_list = [] v_cplx_list = [] v_list = [] v_m_list = [] i_list = [] v_list_str = [] i_list_str = [] i_node = [] v_num_list = [] i_num_list = [] h_v_m_dict = {} h_i_m_dict = {} xy_0_dict = {} params_dict = {} h_dict = {} n2a = {'1': 'a', '2': 'b', '3': 'c', '4': 'n'} a2n = {'a': '1', 'b': '2', 'c': '3', 'n': '4'} # every voltage bus and current bus injection is generted as sympy symbol # the voltages ar named as v_{bus_name}_{n2a[phase]}_r # the currents ar named as i_{bus_name}_{n2a[phase]}_r inode = 0 for node in nodes_list: bus_name, phase = node.split('.') i_real = sym.Symbol(f"i_{bus_name}_{n2a[phase]}_r", real=True) i_imag = sym.Symbol(f"i_{bus_name}_{n2a[phase]}_i", real=True) v_real = sym.Symbol(f"v_{bus_name}_{n2a[phase]}_r", real=True) v_imag = sym.Symbol(f"v_{bus_name}_{n2a[phase]}_i", real=True) v_list += [v_real, v_imag] v_cplx_list += [v_real + 1j * v_imag] i_list += [i_real, i_imag] v_m = (v_real**2 + v_imag**2)**0.5 #i_m = (i_real**2+i_imag**2)**0.5 h_v_m_dict.update({f"v_{bus_name}_{n2a[phase]}_m": v_m}) #h_i_m_dict.update({f"i_{bus_name}_{n2a[phase]}_m":i_m}) v_list_str += [str(v_real), str(v_imag)] i_list_str += [str(i_real), str(i_imag)] v_num_list += [V_node[inode].real[0], V_node[inode].imag[0]] i_num_list += [I_node[inode].real[0], I_node[inode].imag[0]] V_node_sym_list += [v_real + sym.I * v_imag] I_node_sym_list += [i_real + sym.I * i_imag] inode += 1 # symbolic voltage and currents vectors (complex) V_known_sym = sym.Matrix(V_node_sym_list[:N_v]) V_unknown_sym = sym.Matrix(V_node_sym_list[N_v:]) I_known_sym = sym.Matrix(I_node_sym_list[N_v:]) I_unknown_sym = sym.Matrix(I_node_sym_list[:N_v]) inv_Y_ii_re = inv_Y_ii.real inv_Y_ii_im = inv_Y_ii.imag inv_Y_ii_re[np.abs(inv_Y_ii_re) < 1e-8] = 0 inv_Y_ii_im[np.abs(inv_Y_ii_im) < 1e-8] = 0 inv_Y_ii = inv_Y_ii_re + sym.I * inv_Y_ii_im #I_aux = ( I_known_sym - Y_iv @ V_known_sym) # with current injections I_aux = (-Y_iv @ V_known_sym) # without current injections #g_cplx = -V_unknown_sym + inv_Y_ii @ I_aux g_cplx = -Y_ii @ V_unknown_sym + I_aux g_list = [] for item in g_cplx: g_list += [sym.re(item)] g_list += [sym.im(item)] f_list = [] x_list = [] x_0_list = [] y_list = v_list[2 * N_v:] y_0_list = v_num_list[2 * N_v:] for item_y, item_y_0 in zip(y_list, y_0_list): xy_0_dict.update({f'{item_y}': item_y_0}) u_dict = dict(zip(v_list_str[:2 * N_v], v_num_list[:2 * N_v])) u_dict.update(dict(zip(i_list_str[2 * N_v:], i_num_list[2 * N_v:]))) # to make grid former voltage input an output grid_formers = grid.grid_formers for gformer in grid_formers: if 'monitor' in gformer: if gformer['monitor']: bus_name = gformer['bus'] for phase in ['a', 'b', 'c']: v_real = sym.Symbol(f"v_{bus_name}_{phase}_r", real=True) v_imag = sym.Symbol(f"v_{bus_name}_{phase}_i", real=True) h_dict.update({f'{v_real}': v_real}) h_dict.update({f'{v_imag}': v_imag}) lines = grid.lines Y_primitive = grid.Y_primitive_sp.toarray() A_matrix = grid.A_sp.toarray() V_results = sym.Matrix([[V_known_sym], [V_unknown_sym]]) I_lines = Y_primitive @ A_matrix.T @ V_results it_single_line = 0 for trafo in grid.transformers: if 'conductors_j' in trafo: cond_1 = trafo['conductors_j'] else: cond_1 = trafo['conductors_1'] if 'conductors_k' in trafo: cond_2 = trafo['conductors_k'] else: cond_2 = trafo['conductors_2'] I_1a = (I_lines[it_single_line, 0]) I_1b = (I_lines[it_single_line + 1, 0]) I_1c = (I_lines[it_single_line + 2, 0]) I_1n = (I_lines[it_single_line + 3, 0]) I_2a = (I_lines[it_single_line + cond_1 + 0, 0]) I_2b = (I_lines[it_single_line + cond_1 + 1, 0]) I_2c = (I_lines[it_single_line + cond_1 + 2, 0]) if cond_1 > 3: I_1n = (I_lines[it_single_line + cond_1 + 3, 0]) if cond_2 > 3: I_2n = (I_lines[it_single_line + cond_2 + 3, 0]) #I_n = (I_lines[it_single_line+3,0]) if cond_1 <= 3: I_1n = I_1a + I_1b + I_1c if cond_2 <= 3: I_2n = I_2a + I_2b + I_2c if 'monitor' in trafo: if trafo['monitor']: bus_j_name = trafo['bus_j'] bus_k_name = trafo['bus_k'] i_t_a_r = sym.Symbol(f"i_t_{bus_j_name}_{bus_k_name}_a_r") i_t_a_i = sym.Symbol(f"i_t_{bus_j_name}_{bus_k_name}_a_i") i_t_b_r = sym.Symbol(f"i_t_{bus_j_name}_{bus_k_name}_b_r") i_t_b_i = sym.Symbol(f"i_t_{bus_j_name}_{bus_k_name}_b_i") i_t_c_r = sym.Symbol(f"i_t_{bus_j_name}_{bus_k_name}_c_r") i_t_c_i = sym.Symbol(f"i_t_{bus_j_name}_{bus_k_name}_c_i") g_list += [-i_t_a_r + sym.re(I_lines[it_single_line + 0, 0])] g_list += [-i_t_a_i + sym.im(I_lines[it_single_line + 0, 0])] g_list += [-i_t_b_r + sym.re(I_lines[it_single_line + 1, 0])] g_list += [-i_t_b_i + sym.im(I_lines[it_single_line + 1, 0])] g_list += [-i_t_c_r + sym.re(I_lines[it_single_line + 2, 0])] g_list += [-i_t_c_i + sym.im(I_lines[it_single_line + 2, 0])] y_list += [i_t_a_r] y_list += [i_t_a_i] y_list += [i_t_b_r] y_list += [i_t_b_i] y_list += [i_t_c_r] y_list += [i_t_c_i] it_single_line += cond_1 + cond_2 for line in lines: N_conductors = len(line['bus_j_nodes']) if N_conductors == 3: if 'monitor' in line: if line['monitor']: bus_j_name = line['bus_j'] bus_k_name = line['bus_k'] i_l_a_r = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_a_r") i_l_a_i = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_a_i") i_l_b_r = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_b_r") i_l_b_i = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_b_i") i_l_c_r = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_c_r") i_l_c_i = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_c_i") g_list += [ -i_l_a_r + sym.re(I_lines[it_single_line + 0, 0]) ] g_list += [ -i_l_a_i + sym.im(I_lines[it_single_line + 0, 0]) ] g_list += [ -i_l_b_r + sym.re(I_lines[it_single_line + 1, 0]) ] g_list += [ -i_l_b_i + sym.im(I_lines[it_single_line + 1, 0]) ] g_list += [ -i_l_c_r + sym.re(I_lines[it_single_line + 2, 0]) ] g_list += [ -i_l_c_i + sym.im(I_lines[it_single_line + 2, 0]) ] y_list += [i_l_a_r] y_list += [i_l_a_i] y_list += [i_l_b_r] y_list += [i_l_b_i] y_list += [i_l_c_r] y_list += [i_l_c_i] if line['type'] == 'z': it_single_line += N_conductors if line['type'] == 'pi': it_single_line += 3 * N_conductors if N_conductors == 4: if 'monitor' in line: if line['monitor']: bus_j_name = line['bus_j'] bus_k_name = line['bus_k'] i_l_a_r = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_a_r") i_l_a_i = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_a_i") i_l_b_r = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_b_r") i_l_b_i = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_b_i") i_l_c_r = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_c_r") i_l_c_i = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_c_i") i_l_n_r = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_n_r") i_l_n_i = sym.Symbol(f"i_l_{bus_j_name}_{bus_k_name}_n_i") g_list += [ -i_l_a_r + sym.re(I_lines[it_single_line + 0, 0]) ] g_list += [ -i_l_a_i + sym.im(I_lines[it_single_line + 0, 0]) ] g_list += [ -i_l_b_r + sym.re(I_lines[it_single_line + 1, 0]) ] g_list += [ -i_l_b_i + sym.im(I_lines[it_single_line + 1, 0]) ] g_list += [ -i_l_c_r + sym.re(I_lines[it_single_line + 2, 0]) ] g_list += [ -i_l_c_i + sym.im(I_lines[it_single_line + 2, 0]) ] g_list += [-i_l_n_r + i_l_a_r + i_l_b_r + i_l_c_r] g_list += [-i_l_n_i + i_l_a_i + i_l_b_i + i_l_c_i] y_list += [i_l_a_r] y_list += [i_l_a_i] y_list += [i_l_b_r] y_list += [i_l_b_i] y_list += [i_l_c_r] y_list += [i_l_c_i] y_list += [i_l_n_r] y_list += [i_l_n_i] if line['type'] == 'z': it_single_line += N_conductors if line['type'] == 'pi': it_single_line += 3 * N_conductors if hasattr(grid, 'loads'): loads = grid.loads else: loads = [] for load in loads: if load['type'] == '1P+N': bus_name = load['bus'] phase_1 = str(load['bus_nodes'][0]) i_real_1 = sym.Symbol(f"i_load_{bus_name}_{n2a[phase_1]}_r", real=True) i_imag_1 = sym.Symbol(f"i_load_{bus_name}_{n2a[phase_1]}_i", real=True) v_real_1 = sym.Symbol(f"v_{bus_name}_{n2a[phase_1]}_r", real=True) v_imag_1 = sym.Symbol(f"v_{bus_name}_{n2a[phase_1]}_i", real=True) i_1 = i_real_1 + 1j * i_imag_1 v_1 = v_real_1 + 1j * v_imag_1 phase_2 = str(load['bus_nodes'][1]) i_real_2 = sym.Symbol(f"i_load_{bus_name}_{n2a[phase_2]}_r", real=True) i_imag_2 = sym.Symbol(f"i_load_{bus_name}_{n2a[phase_2]}_i", real=True) v_real_2 = sym.Symbol(f"v_{bus_name}_{n2a[phase_2]}_r", real=True) v_imag_2 = sym.Symbol(f"v_{bus_name}_{n2a[phase_2]}_i", real=True) i_2 = i_real_2 + 1j * i_imag_2 v_2 = v_real_2 + 1j * v_imag_2 v_12 = v_1 - v_2 s_1 = v_12 * sym.conjugate(i_1) p_1, p_2 = sym.symbols(f'p_{bus_name}_1,p_{bus_name}_2', real=True) q_1, q_2 = sym.symbols(f'q_{bus_name}_1,q_{bus_name}_2', real=True) g_list += [-p_1 + sym.re(s_1)] g_list += [-q_1 + sym.im(s_1)] y_list += [i_real_1, i_imag_1] g_list += [sym.re(i_1 + i_2)] g_list += [sym.im(i_1 + i_2)] # add phase 1 current to g bus_idx = grid.nodes.index(f"{bus_name}.{load['bus_nodes'][0]}") g_idx = bus_idx - grid.N_nodes_v g_list[2 * g_idx + 0] += i_real_1 g_list[2 * g_idx + 1] += i_imag_1 print(g_list[2 * g_idx + 0]) print(i_real_1) print(g_list[2 * g_idx + 1]) print(i_imag_1) # add phase 2 current to g bus_idx = grid.nodes.index(f"{bus_name}.{load['bus_nodes'][1]}") g_idx = bus_idx - grid.N_nodes_v g_list[2 * g_idx + 0] += i_real_2 g_list[2 * g_idx + 1] += i_imag_2 print(g_list[2 * g_idx + 0]) print(i_real_2) print(g_list[2 * g_idx + 1]) print(i_imag_2) y_list += [i_real_2, i_imag_2] i_real, i_imag = sym.symbols( f'i_{bus_name}_{phase}_r,i_{bus_name}_{phase}_i', real=True) i_cplx_1 = I_node[grid.nodes.index(f'{bus_name}.{phase_1}')][0] y_0_list += [i_cplx_1.real, i_cplx_1.imag] i_cplx_2 = I_node[grid.nodes.index(f'{bus_name}.{phase_2}')][0] y_0_list += [i_cplx_2.real, i_cplx_2.imag] u_dict.pop(f'i_{bus_name}_{n2a[phase_1]}_r') u_dict.pop(f'i_{bus_name}_{n2a[phase_1]}_i') u_dict.pop(f'i_{bus_name}_{n2a[phase_2]}_r') u_dict.pop(f'i_{bus_name}_{n2a[phase_2]}_i') p_value = grid.buses[buses_list.index( bus_name)][f'p_{n2a[phase_1]}'] q_value = grid.buses[buses_list.index( bus_name)][f'q_{n2a[phase_1]}'] u_dict.update({f'p_{bus_name}_{phase_1}': p_value}) u_dict.update({f'q_{bus_name}_{phase_1}': q_value}) if load['type'] == '3P+N': bus_name = load['bus'] v_a = V_node_sym_list[nodes_list.index(f'{bus_name}.1')] v_b = V_node_sym_list[nodes_list.index(f'{bus_name}.2')] v_c = V_node_sym_list[nodes_list.index(f'{bus_name}.3')] v_n = V_node_sym_list[nodes_list.index(f'{bus_name}.4')] # i_a = I_node_sym_list[nodes_list.index(f'{bus_name}.1')] # i_b = I_node_sym_list[nodes_list.index(f'{bus_name}.2')] # i_c = I_node_sym_list[nodes_list.index(f'{bus_name}.3')] # i_n = I_node_sym_list[nodes_list.index(f'{bus_name}.4')] i_a_r, i_a_i = sym.symbols( f'i_load_{bus_name}_a_r,i_load_{bus_name}_a_i', real=True) i_b_r, i_b_i = sym.symbols( f'i_load_{bus_name}_b_r,i_load_{bus_name}_b_i', real=True) i_c_r, i_c_i = sym.symbols( f'i_load_{bus_name}_c_r,i_load_{bus_name}_c_i', real=True) i_n_r, i_n_i = sym.symbols( f'i_load_{bus_name}_n_r,i_load_{bus_name}_n_i', real=True) i_a = i_a_r + sym.I * i_a_i i_b = i_b_r + sym.I * i_b_i i_c = i_c_r + sym.I * i_c_i i_n = i_n_r + sym.I * i_n_i v_an = v_a - v_n v_bn = v_b - v_n v_cn = v_c - v_n s_a = v_an * sym.conjugate(i_a) s_b = v_bn * sym.conjugate(i_b) s_c = v_cn * sym.conjugate(i_c) s = s_a + s_b + s_c p_a, p_b, p_c = sym.symbols( f'p_{bus_name}_a,p_{bus_name}_b,p_{bus_name}_c', real=True) q_a, q_b, q_c = sym.symbols( f'q_{bus_name}_a,q_{bus_name}_b,q_{bus_name}_c', real=True) g_list += [-p_a + sym.re(s_a)] g_list += [-p_b + sym.re(s_b)] g_list += [-p_c + sym.re(s_c)] g_list += [-q_a + sym.im(s_a)] g_list += [-q_b + sym.im(s_b)] g_list += [-q_c + sym.im(s_c)] g_list += [sym.re(i_a + i_b + i_c + i_n)] g_list += [sym.im(i_a + i_b + i_c + i_n)] i_abc_list = [i_a_r, i_a_i, i_b_r, i_b_i, i_c_r, i_c_i] for itg in [1, 2, 3]: bus_idx = grid.nodes.index(f'{bus_name}.{itg}') g_idx = bus_idx - grid.N_nodes_v g_list[2 * g_idx + 0] += i_abc_list[2 * (itg - 1)] g_list[2 * g_idx + 1] += i_abc_list[2 * (itg - 1) + 1] for phase in ['a', 'b', 'c']: i_real, i_imag = sym.symbols( f'i_load_{bus_name}_{phase}_r,i_load_{bus_name}_{phase}_i', real=True) y_list += [i_real, i_imag] i_cplx = I_node[grid.nodes.index( f'{bus_name}.{a2n[phase]}')][0] y_0_list += [i_cplx.real, i_cplx.imag] u_dict.pop(f'i_{bus_name}_{phase}_r') u_dict.pop(f'i_{bus_name}_{phase}_i') p_value = grid.buses[buses_list.index(bus_name)][f'p_{phase}'] q_value = grid.buses[buses_list.index(bus_name)][f'q_{phase}'] u_dict.update({f'p_{bus_name}_{phase}': p_value}) u_dict.update({f'q_{bus_name}_{phase}': q_value}) xy_0_dict.update({ f'{i_real}': i_cplx.real, f'{i_imag}': i_cplx.imag }) i_real, i_imag = sym.symbols( f'i_load_{bus_name}_n_r,i_load_{bus_name}_n_i', real=True) y_list += [i_real, i_imag] i_cplx = I_node[grid.nodes.index(f'{bus_name}.{a2n["n"]}')][0] y_0_list += [i_cplx.real, i_cplx.imag] xy_0_dict.update({ f'{i_real}': i_cplx.real, f'{i_imag}': i_cplx.imag }) if hasattr(grid, 'grid_feeders'): gfeeders = grid.grid_feeders else: gfeeders = [] for gfeeder in gfeeders: bus_name = gfeeder['bus'] v_a = V_node_sym_list[nodes_list.index(f'{bus_name}.1')] v_b = V_node_sym_list[nodes_list.index(f'{bus_name}.2')] v_c = V_node_sym_list[nodes_list.index(f'{bus_name}.3')] #v_n = V_node_sym_list[nodes_list.index(f'{bus_name}.4')] i_a = I_node_sym_list[nodes_list.index(f'{bus_name}.1')] i_b = I_node_sym_list[nodes_list.index(f'{bus_name}.2')] i_c = I_node_sym_list[nodes_list.index(f'{bus_name}.3')] #i_n = I_node_sym_list[nodes_list.index(f'{bus_name}.4')] #v_an = v_a - v_n #v_bn = v_b - v_n #v_cn = v_c - v_n s_a = v_a * sym.conjugate(i_a) s_b = v_b * sym.conjugate(i_b) s_c = v_c * sym.conjugate(i_c) #s = s_a + s_b + s_c p_a, p_b, p_c = sym.symbols( f'p_{bus_name}_a,p_{bus_name}_b,p_{bus_name}_c') q_a, q_b, q_c = sym.symbols( f'q_{bus_name}_a,q_{bus_name}_b,q_{bus_name}_c') g_list += [-p_a + sym.re(s_a)] g_list += [-p_b + sym.re(s_b)] g_list += [-p_c + sym.re(s_c)] g_list += [-q_a + sym.im(s_a)] g_list += [-q_b + sym.im(s_b)] g_list += [-q_c + sym.im(s_c)] # g_list += [sym.re(i_a+i_b+i_c+i_n)] # g_list += [sym.im(i_a+i_b+i_c+i_n)] p_total_value = 0.0 q_total_value = 0.0 for phase in ['a', 'b', 'c']: i_real, i_imag = sym.symbols( f'i_{bus_name}_{phase}_r,i_{bus_name}_{phase}_i', real=True) y_list += [i_real, i_imag] i_cplx = I_node[grid.nodes.index(f'{bus_name}.{a2n[phase]}')][0] y_0_list += [i_cplx.real, i_cplx.imag] xy_0_dict.update({ f'{i_real}': i_cplx.real, f'{i_imag}': i_cplx.imag }) u_dict.pop(f'i_{bus_name}_{phase}_r') u_dict.pop(f'i_{bus_name}_{phase}_i') p_value = grid.buses[buses_list.index(bus_name)][f'p_{phase}'] q_value = grid.buses[buses_list.index(bus_name)][f'q_{phase}'] p_total_value += p_value q_total_value += q_value if 'ctrl_mode' in gfeeder: if gfeeder['ctrl_mode'] == 'pq': # Q control u_dict.update({f'p_ref_{bus_name}': p_total_value}) u_dict.update({f'q_ref_{bus_name}': q_total_value}) u_dict.update({f'T_pq_{bus_name}': 0.2}) p_ref, q_ref, T_pq = sym.symbols( f'p_ref_{bus_name},q_ref_{bus_name},T_pq_{bus_name}', real=True) f_list += [1 / T_pq * (-p_a + p_ref / 3)] f_list += [1 / T_pq * (-p_b + p_ref / 3)] f_list += [1 / T_pq * (-p_c + p_ref / 3)] f_list += [1 / T_pq * (-q_a + q_ref / 3)] f_list += [1 / T_pq * (-q_b + q_ref / 3)] f_list += [1 / T_pq * (-q_c + q_ref / 3)] x_list += [p_a] x_list += [p_b] x_list += [p_c] x_list += [q_a] x_list += [q_b] x_list += [q_c] x_0_list += [p_total_value / 3] * 3 xy_0_dict.update({ f'{p_a}': p_total_value / 3, f'{p_b}': p_total_value / 3, f'{p_c}': p_total_value / 3 }) xy_0_dict.update({ f'{q_a}': q_total_value / 3, f'{q_b}': q_total_value / 3, f'{q_c}': q_total_value / 3 }) if gfeeder['ctrl_mode'] == 'ctrl_4': # Q control u_dict.update({f'p_ref_{bus_name}': p_total_value}) u_dict.update({f'q_ref_{bus_name}': q_total_value}) u_dict.update({f'T_pq_{bus_name}': 0.2}) p_ref, q_ref, T_pq = sym.symbols( f'p_ref_{bus_name},q_ref_{bus_name},T_pq_{bus_name}', real=True) f_list += [1 / T_pq * (-p_a + p_ref / 3)] f_list += [1 / T_pq * (-p_b + p_ref / 3)] f_list += [1 / T_pq * (-p_c + p_ref / 3)] f_list += [1 / T_pq * (-q_a + q_ref / 3)] f_list += [1 / T_pq * (-q_b + q_ref / 3)] f_list += [1 / T_pq * (-q_c + q_ref / 3)] x_list += [p_a] x_list += [p_b] x_list += [p_c] x_list += [q_a] x_list += [q_b] x_list += [q_c] x_0_list += [p_total_value / 3] * 3 xy_0_dict.update({ f'{p_a}': p_total_value / 3, f'{p_b}': p_total_value / 3, f'{p_c}': p_total_value / 3 }) xy_0_dict.update({ f'{q_a}': q_total_value / 3, f'{q_b}': q_total_value / 3, f'{q_c}': q_total_value / 3 }) # V control ## compute voltage module bus_name_mv = gfeeder['vctrl_buses'][1] v_m_lv, v_m_mv = sym.symbols( f'v_m_{bus_name},v_m_{bus_name_mv}', real=True) V_base, V_base_mv, S_base = sym.symbols( f'V_base_{bus_name},V_base_{bus_name_mv},S_base_{bus_name}', real=True) u_ctrl_v = sym.Symbol(f'u_ctrl_v_{bus_name}', real=True) v_a_lv = V_node_sym_list[nodes_list.index(f'{bus_name}.1')] g_list += [ -v_m_lv + (sym.re(v_a_lv)**2 + sym.im(v_a_lv)**2)**0.5 / V_base ] y_list += [v_m_lv] xy_0_dict.update({f'{v_m_lv}': 1.0}) v_a_mv = V_node_sym_list[nodes_list.index(f'{bus_name_mv}.1')] if not v_m_mv in y_list: g_list += [ -v_m_mv + (sym.re(v_a_mv)**2 + sym.im(v_a_mv)**2)**0.5 / V_base_mv ] y_list += [v_m_mv] xy_0_dict.update({f'{v_m_mv}': 1.0}) params_dict.update({f'u_ctrl_v_{bus_name}': 0.0}) ## V -> q PI xi_v, K_p_v, K_i_v = sym.symbols( f'xi_v_{bus_name},K_p_v_{bus_name},K_p_v_{bus_name}', real=True) v_loc_ref, Dv_r, Dq_r = sym.symbols( f'v_loc_ref_{bus_name},Dv_r_{bus_name},Dq_r_{bus_name}', real=True) i_reac_ref, I_max = sym.symbols( f'i_reac_ref_{bus_name},I_max_{bus_name}', real=True) params_dict.update({ f'K_p_v_{bus_name}': 0.1, f'K_i_v_{bus_name}': 0.1, }) U_base_1 = grid.buses[buses_name_list.index( bus_name)]['U_kV'] * 1000 U_base_2 = grid.buses[buses_name_list.index( bus_name_mv)]['U_kV'] * 1000 params_dict.update({ f'V_base_{bus_name}': U_base_1 / np.sqrt(3), f'V_base_{bus_name_mv}': U_base_1 / np.sqrt(3), f'S_base_{bus_name}': 2e6, f'{I_max}': 0.5 }) v_ref = v_loc_ref + Dv_r epsilon_v = v_ref - (v_m_lv * (1.0 - u_ctrl_v) + v_m_mv * u_ctrl_v) # f_list += [epsilon_v] # x_list += [xi_v] g_list += [-i_reac_ref + K_p_v * epsilon_v + Dq_r ] # + K_i_v*xi_v g_list += [ -q_ref + S_base * sym.Piecewise( (-I_max, i_reac_ref < -I_max), (I_max, i_reac_ref > I_max), (i_reac_ref, True)) * v_m ] y_list += [i_reac_ref] y_list += [q_ref] y_0_list += [0.0] u_dict.update({ f'v_loc_ref_{bus_name}': 1, f'Dv_r_{bus_name}': 0, f'Dq_r_{bus_name}': 0 }) u_dict.pop(f'q_ref_{bus_name}') xy_0_dict.update({f'{xi_v}': 0.0, f'{q_ref}': 0.0}) #i_real,i_imag = sym.symbols(f'i_{bus_name}_n_r,i_{bus_name}_n_i', real=True) #y_list += [i_real,i_imag] #i_cplx = I_node[grid.nodes.index(f'{bus_name}.{a2n["n"]}')][0] #y_0_list += [i_cplx.real,i_cplx.imag] Y_ii = grid.Y_ii.toarray() Y_vv = grid.Y_vv Y_vi = grid.Y_vi inv_Y_ii = np.linalg.inv(Y_ii) N_nz_nodes = grid.params_pf[0].N_nz_nodes N_v = grid.params_pf[0].N_nodes_v nodes_list = grid.nodes Y_primitive = grid.Y_primitive_sp.toarray() A_conect = grid.A_sp.toarray() node_sorter = grid.node_sorter N_v = grid.N_nodes_v np.savez('matrices', Y_primitive=Y_primitive, A_conect=A_conect, nodes_list=nodes_list, node_sorter=node_sorter, N_v=N_v, Y_vv=Y_vv, Y_vi=Y_vi) with open("grid_data.json", "w") as fobj: json.dump(grid.data, fobj, indent=4, sort_keys=True) return { 'g': g_list, 'y': y_list, 'f': f_list, 'x': x_list, 'params': params_dict, 'xy_0_dict': xy_0_dict, 'u': u_dict, 'x_0_list': x_0_list, 'y_0_list': y_0_list, 'v_list': v_list, 'v_m_list': v_m_list, 'v_cplx_list': v_cplx_list, 'h_dict': h_dict, 'h_v_m_dict': h_v_m_dict }
def ac3ph3wvdcq(grid, vsc_data): ''' Converter type v_dc,q_ac 3 phase 3 wire ''' bus_ac_name = vsc_data['bus_ac'] bus_dc_name = vsc_data['bus_dc'] to_bus_dc_name = vsc_data['to_bus_dc'] a_value = vsc_data['a'] b_value = vsc_data['b'] c_value = vsc_data['c'] g_vsc = [] y_vsc = [] ### AC-side p_ac, q_ac, p_dc, p_loss = sym.symbols( f'p_{bus_ac_name},q_{bus_ac_name},p_{bus_dc_name},p_loss_{bus_ac_name}', real=True) #### AC voltages: v_a_r, v_a_i = sym.symbols(f'v_{bus_ac_name}_a_r,v_{bus_ac_name}_a_i', real=True) v_b_r, v_b_i = sym.symbols(f'v_{bus_ac_name}_b_r,v_{bus_ac_name}_b_i', real=True) v_c_r, v_c_i = sym.symbols(f'v_{bus_ac_name}_c_r,v_{bus_ac_name}_c_i', real=True) v_n_r, v_n_i = sym.symbols(f'v_{bus_ac_name}_n_r,v_{bus_ac_name}_n_i', real=True) #### AC currents: i_a_r, i_a_i = sym.symbols( f'i_vsc_{bus_ac_name}_a_r,i_vsc_{bus_ac_name}_a_i', real=True) i_b_r, i_b_i = sym.symbols( f'i_vsc_{bus_ac_name}_b_r,i_vsc_{bus_ac_name}_b_i', real=True) i_c_r, i_c_i = sym.symbols( f'i_vsc_{bus_ac_name}_c_r,i_vsc_{bus_ac_name}_c_i', real=True) v_a = v_a_r + 1j * v_a_i v_b = v_b_r + 1j * v_b_i v_c = v_c_r + 1j * v_c_i v_n = v_n_r + 1j * v_n_i i_a = i_a_r + 1j * i_a_i i_b = i_b_r + 1j * i_b_i i_c = i_c_r + 1j * i_c_i s_a = (v_a - v_n) * sym.conjugate(i_a) s_b = (v_b - v_n) * sym.conjugate(i_b) s_c = (v_c - v_n) * sym.conjugate(i_c) eq_i_a_r = sym.re(s_a) - p_ac / 3 eq_i_b_r = sym.re(s_b) - p_ac / 3 eq_i_c_r = sym.re(s_c) - p_ac / 3 eq_i_a_i = sym.im(s_a) - q_ac / 3 eq_i_b_i = sym.im(s_b) - q_ac / 3 eq_i_c_i = sym.im(s_c) - q_ac / 3 grid.dae['g'] += [ eq_i_a_r, eq_i_a_i, eq_i_b_r, eq_i_b_i, eq_i_c_r, eq_i_c_i ] grid.dae['y'] += [i_a_r, i_a_i, i_b_r, i_b_i, i_c_r, i_c_i] i_abc_list = [i_a_r, i_a_i, i_b_r, i_b_i, i_c_r, i_c_i] for itg in [1, 2, 3]: bus_idx = grid.nodes.index(f'{bus_ac_name}.{itg}') g_idx = bus_idx - grid.N_nodes_v grid.dae['g'][2 * g_idx + 0] += i_abc_list[2 * (itg - 1)] grid.dae['g'][2 * g_idx + 1] += i_abc_list[2 * (itg - 1) + 1] a, b, c = sym.symbols(f'a_{bus_ac_name},b_{bus_ac_name},c_{bus_ac_name}', real=True) i_rms = sym.sqrt(i_a_r**2 + i_a_i**2 + 0.1) p_simple = a + b * i_rms + c * i_rms * i_rms p_vsc_loss = p_simple i_l_a_r, i_l_n_r = sym.symbols( f'i_l_{bus_dc_name}_{to_bus_dc_name}_a_r,i_l_{bus_dc_name}_{to_bus_dc_name}_n_r' ) v_dc_a_r, v_dc_n_r = sym.symbols( f'v_{bus_dc_name}_a_r,v_{bus_dc_name}_n_r') eq_p_loss = p_loss - p_vsc_loss eq_p_ac = p_ac + p_dc + sym.Piecewise((-p_loss, p_dc < 0), (p_loss, p_dc > 0), (p_loss, True)) eq_p_dc = -p_dc + i_l_a_r * v_dc_a_r + i_l_n_r * v_dc_n_r grid.dae['g'] += [eq_p_ac, eq_p_dc, eq_p_loss] grid.dae['y'] += [p_ac, p_dc, p_loss] grid.dae['u'].update({f'v_dc_{bus_dc_name}': 0.0, f'q_{bus_ac_name}': 0.0}) grid.dae['params'].update({ f'a_{bus_ac_name}': a_value, f'b_{bus_ac_name}': b_value, f'c_{bus_ac_name}': c_value })
def f(self, yvec, params): import sympy as sp f_penalty = [sp.Piecewise((yi**2, yi < 0), (0, True)) for yi in yvec] return super(_NumSysLinNegPenalty, self).f(yvec, params) + f_penalty
import numpy as np import sympy from sympy import cos, sin, sqrt, pi sympy.var('A, An, T, rho') t = sympy.Symbol('t') n = sympy.Symbol('n', integer=True, positive=True) x = sympy.Symbol('x', positive=True) L = 7 a = 3 * L / 4 y0 = sympy.Piecewise((A * x / a, ((x >= 0) & (x <= a))), (A * (L - x) / (L - a), ((x > a) & (x <= L)))) Yn = An * sympy.sin(n * pi * x / L) exp = sympy.integrate(rho * Yn**2, (x, 0, L)) - 1 An = sympy.solve(exp, An)[1].simplify() Yn = An * sin(n * pi * x / L) # Finding Modal Force F0 = 1. Omega = 0.99 * 1 * pi * sqrt(T / (rho * L**2)) Fx = F0 Fn = sympy.integrate(Fx * Yn, (x, 0, L)) # Finding modal initial conditions eta0 = sympy.integrate(rho * Yn * y0, (x, 0, L)).simplify() omegan = n * pi * sqrt(T / (rho * L**2)) k1 = eta0 - Fn / (omegan**2 - Omega**2) etan = Fn / (omegan**2 - Omega**2) * cos(Omega * t) + k1 * cos(omegan * t) import matplotlib matplotlib.use('TkAgg')
def Zhfun_exact_taylor(self, j): Z_e = self.Zhfun_exact(j) Z_t = Z_e.series(z, 0, self.order).removeO() return sp.Piecewise((Z_e, self.zswd <= 0), (Z_t, self.zswd > 0))
def process(self, p, conn, param, alpha): mu, Ex, Kp, Kg1, Kg2, Kvb, Gco, Gcf = const = sp.symbols( "mu,Ex,Kp,Kg1,Kg2,Kvb,Gco,Gcf") Ug1k, Ug2k, Uak = v = sp.symbols("Ug1k,Ug2k,Uak") t = Kp * (1 / mu + Ug1k / Ug2k) E1 = Ug2k / Kp * sp.log(1 + sp.exp(t)) E1_ = Ug2k / Kp * t #sign = sp.sign sign = lambda x: 2 * sp.Heaviside(x) - 1 calc_Ia = sp.Piecewise( (0, Ug2k <= 0), (0, t < -500), (-pow(E1_, Ex) / Kg1 * (1 + sign(E1_)) * sp.atan(Uak / Kvb), t > 500), (-pow(E1, Ex) / Kg1 * (1 + sign(E1)) * sp.atan(Uak / Kvb), True)) calc_Ia = calc_Ia.subs(dict([(k, param[str(k)]) for k in const])) calc_Ig = sp.Piecewise((0, Ug1k < Gco), (-Gcf * pow(Ug1k - Gco, 1.5), True)) calc_Ig = calc_Ig.subs(dict([(k, param[str(k)]) for k in const])) t = Ug2k / mu + Ug1k calc_Is = sp.Piecewise((0, t <= 0), (-sp.exp(Ex * sp.log(t)) / Kg2, True)) calc_Is = calc_Is.subs(dict([(k, param[str(k)]) for k in const])) # def calc_Ia(v): # Ug1k = float(v[0]) # Ug2k = float(v[1]) # Uak = float(v[2]) # if Ug2k <= 0.0: # return 0 # t = Kp * (1 / mu + Ug1k / Ug2k) # if t > 500: # E1 = Ug2k / Kp * t # elif t < -500: # return 0 # else: # E1 = Ug2k / Kp * math.log(1 + math.exp(t)) # r = pow(E1,Ex)/Kg1 * 2*(E1 > 0.0) * math.atan(Uak/Kvb); # #print Ug1k, Ug2k, Uak, r # return -r # def calc_Ig(v): # Ugk = float(v[0]) # if Ugk < Gco: # return 0 # r = Gcf*pow(Ugk-Gco, 1.5) # return -r # def calc_Is(v): # Ug1k = float(v[0]) # Ug2k = float(v[1]) # t = Ug2k / mu + Ug1k # if t <= 0: # return 0 # r = math.exp(Ex*math.log(t)) / Kg2 # return -r idx1 = p.new_row("N", self, "Ig") p.add_2conn("Nl", idx1, (conn[0], conn[3])) p.add_2conn("Nr", idx1, (conn[0], conn[3])) p.set_function(idx1, calc_Ig, v[:1], idx1) idx2 = p.new_row("N", self, "Is") p.add_2conn("Nl", idx2, (conn[1], conn[3])) p.add_2conn("Nr", idx2, (conn[1], conn[3])) p.set_function(idx2, calc_Is, v, idx1) idx3 = p.new_row("N", self, "Ip") p.add_2conn("Nl", idx3, (conn[2], conn[3])) p.add_2conn("Nr", idx3, (conn[2], conn[3])) p.set_function(idx3, calc_Ia, v, idx1)
if __name__ == "__main__": import time mesh = msh.Mesh(coords_fname="meshes/coords_unit_square.dat", elements_fname="meshes/elements_unit_square.dat") num_refine = 3 # l2_errors = np.zeros(num_refine + 1) # h1_errors = np.zeros(num_refine + 1) mesh.plot_mesh(show_indices=True) start = time.time() r, t, b = sm.symbols("r t b") step_r = sm.Piecewise((1, x**2 + y**2 < 1), (0, x**2 + y**2 >= 1)) theta = sm.atan2(y, x) + sm.Piecewise((2 * sm.pi, y < 0), (0, y >= 0)) beta = 2. / 3 u_D_full_sm = (1 - r**2) * r**b * sm.sin(b * t) f_full_sm = sm.diff(r * sm.diff(u_D_full_sm, r), r) / r + \ sm.diff(u_D_full_sm, (t, 2)) / r**2 u_D_full_sm = u_D_full_sm.subs(b, beta).simplify() f_full_sm = f_full_sm.subs(b, beta).simplify() u_D_full_sm = u_D_full_sm.subs(r, sm.sqrt(x**2 + y**2)) f_full_sm = f_full_sm.subs(r, sm.sqrt(x**2 + y**2)) u_D_full_sm = u_D_full_sm.subs(t, theta).simplify()
def _ex_if(self, e): # Sympy piecewise takes only (expression, condition) pairs pairs = [] pairs.append((self.ex(e._t), self.ex(e._i))) pairs.append((self.ex(e._e), True)) return sp.Piecewise(*pairs)
def ac3ph3wpq(grid, vsc_data): ''' Converter type p_ac,q_ac 3 phase 3 wire ''' ## Model data bus_ac_name = vsc_data['bus_ac'] bus_dc_name = vsc_data['bus_dc'] a_value = vsc_data['a'] b_value = vsc_data['b'] c_value = vsc_data['c'] ## Voltages: v_a_r, v_a_i = sym.symbols(f'v_{bus_ac_name}_a_r,v_{bus_ac_name}_a_i', real=True) v_b_r, v_b_i = sym.symbols(f'v_{bus_ac_name}_b_r,v_{bus_ac_name}_b_i', real=True) v_c_r, v_c_i = sym.symbols(f'v_{bus_ac_name}_c_r,v_{bus_ac_name}_c_i', real=True) v_n_r, v_n_i = sym.symbols(f'v_{bus_ac_name}_n_r,v_{bus_ac_name}_n_i', real=True) v_dc_a_r, v_dc_n_r = sym.symbols( f'v_{bus_dc_name}_a_r,v_{bus_dc_name}_n_r', real=True) ## Currents: i_a_r, i_a_i = sym.symbols( f'i_vsc_{bus_ac_name}_a_r,i_vsc_{bus_ac_name}_a_i', real=True) i_b_r, i_b_i = sym.symbols( f'i_vsc_{bus_ac_name}_b_r,i_vsc_{bus_ac_name}_b_i', real=True) i_c_r, i_c_i = sym.symbols( f'i_vsc_{bus_ac_name}_c_r,i_vsc_{bus_ac_name}_c_i', real=True) i_dc_a_r, i_dc_n_r = sym.symbols( f'i_vsc_{bus_dc_name}_a_r,i_vsc_{bus_dc_name}_n_r', real=True) ## Body: ### AC-side p_ac, q_ac, p_dc, p_loss = sym.symbols( f'p_{bus_ac_name},q_{bus_ac_name},p_{bus_dc_name},p_loss_{bus_ac_name}', real=True) coef_a, coef_b, coef_c = sym.symbols( f'coef_a_{bus_ac_name},coef_b_{bus_ac_name},coef_c_{bus_ac_name}', real=True) v_a = v_a_r + 1j * v_a_i v_b = v_b_r + 1j * v_b_i v_c = v_c_r + 1j * v_c_i v_n = v_n_r + 1j * v_n_i i_a = i_a_r + 1j * i_a_i i_b = i_b_r + 1j * i_b_i i_c = i_c_r + 1j * i_c_i s_a = (v_a - v_n) * sym.conjugate(i_a) s_b = (v_b - v_n) * sym.conjugate(i_b) s_c = (v_c - v_n) * sym.conjugate(i_c) eq_i_a_r = sym.re(s_a) - p_ac * coef_a eq_i_b_r = sym.re(s_b) - p_ac * coef_b eq_i_c_r = sym.re(s_c) - p_ac * coef_c eq_i_a_i = sym.im(s_a) - q_ac * coef_a eq_i_b_i = sym.im(s_b) - q_ac * coef_b eq_i_c_i = sym.im(s_c) - q_ac * coef_c i_abc_list = [i_a_r, i_a_i, i_b_r, i_b_i, i_c_r, i_c_i] for itg in [1, 2, 3]: bus_idx = grid.nodes.index(f'{bus_ac_name}.{itg}') g_idx = bus_idx - grid.N_nodes_v grid.dae['g'][2 * g_idx + 0] += i_abc_list[2 * (itg - 1)] grid.dae['g'][2 * g_idx + 1] += i_abc_list[2 * (itg - 1) + 1] ### DC side a, b, c = sym.symbols(f'a_{bus_ac_name},b_{bus_ac_name},c_{bus_ac_name}', real=True) i_rms = sym.sqrt(i_a_r**2 + i_a_i**2 + 0.1) p_simple = a + b * i_rms + c * i_rms * i_rms p_vsc_loss = p_simple eq_p_loss = p_loss - p_vsc_loss eq_i_dc_a_r = i_dc_a_r + p_dc / (v_dc_a_r - v_dc_n_r + 1e-8) eq_i_dc_n_r = i_dc_n_r + p_dc / (v_dc_n_r - v_dc_a_r + 1e-8) eq_p_dc = p_dc - p_ac - sym.Piecewise((-p_loss, p_dc < 0), (p_loss, p_dc > 0), (p_loss, True)) ## DAE system update grid.dae['g'] += [ eq_i_a_r, eq_i_a_i, eq_i_b_r, eq_i_b_i, eq_i_c_r, eq_i_c_i ] grid.dae['y'] += [i_a_r, i_a_i, i_b_r, i_b_i, i_c_r, i_c_i] grid.dae['g'] += [eq_i_dc_a_r, eq_i_dc_n_r, eq_p_dc, eq_p_loss] grid.dae['y'] += [i_dc_a_r, i_dc_n_r, p_dc, p_loss] grid.dae['u'].update({f'p_{bus_ac_name}': 0.0, f'q_{bus_ac_name}': 0.0}) grid.dae['xy_0_dict'].update({ f'v_{bus_dc_name}_a_r': 800.0, f'v_{bus_dc_name}_n_r': 10.0 }) grid.dae['u'].pop(f'i_{bus_dc_name}_a_r') grid.dae['u'].pop(f'i_{bus_dc_name}_n_r') grid.dae['params'].update({ f'a_{bus_ac_name}': a_value, f'b_{bus_ac_name}': b_value, f'c_{bus_ac_name}': c_value }) grid.dae['params'].update({ f'coef_a_{bus_ac_name}': 1 / 3, f'coef_b_{bus_ac_name}': 1 / 3, f'coef_c_{bus_ac_name}': 1 / 3 }) ## Add current injections to grid equations: bus_idx = grid.nodes.index(f'{bus_dc_name}.{1}') g_idx = bus_idx - grid.N_nodes_v grid.dae['g'][2 * g_idx + 0] += i_dc_a_r grid.dae['g'][2 * g_idx + 1] += 0.0 bus_idx = grid.nodes.index(f'{bus_dc_name}.{4}') g_idx = bus_idx - grid.N_nodes_v grid.dae['g'][2 * g_idx + 0] += i_dc_n_r grid.dae['g'][2 * g_idx + 1] += 0.0
class PO_ESF_RLM_Symb(PO_ELF_RLM_Symb): E_f, A_f = sp.symbols(r'E_\mathrm{f}, A_\mathrm{f}', positive=True) E_m, A_m = sp.symbols(r'E_\mathrm{m}, A_\mathrm{m}', positive=True) tau, p = sp.symbols(r'\bar{\tau}, p', positive=True) C, D = sp.symbols(r'C, D') P, w = sp.symbols(r'P, w', positive=True) x, a, L_b = sp.symbols(r'x, a, L_b') d_sig_f = p * tau / A_f sig_f = sp.integrate(d_sig_f, x) + C eps_f = sig_f / E_f u_f = sp.integrate(eps_f, x) + D eq_C = {P - sig_f.subs({x:0}) * A_f} C_subs = sp.solve(eq_C,C) eqns_D = {u_f.subs(C_subs).subs(x, a)} D_subs = sp.solve(eqns_D, D) u_f.subs(C_subs).subs(D_subs) eqns_a = {eps_f.subs(C_subs).subs(D_subs).subs(x, a)} a_subs = sp.solve(eqns_a, a) var_subs = {**C_subs,**D_subs,**a_subs} u_f_x = u_f.subs(var_subs) u_fa_x = sp.Piecewise((u_f_x, x > var_subs[a]), (0, x <= var_subs[a])) eps_f_x = sp.diff(u_fa_x,x) sig_f_x = E_f * eps_f_x tau_x = sp.simplify(sig_f_x.diff(x) * A_f / p) u_f_x.subs(x, 0) - w Pw_pull = sp.solve(u_f_x.subs({x: 0}) - w, P)[0] w_L_b = u_fa_x.subs(x, -L_b).subs(P, Pw_pull) aw_pull = a_subs[a].subs(P, Pw_pull) eps_m_x = eps_f_x * 1e-8 sig_m_x = sig_f_x * 1e-8 u_ma_x = u_fa_x * 1e-8 P_max = p * tau * L_b w_argmax = sp.solve(P_max - Pw_pull, w)[0] Pw_up_pull = Pw_pull b, P_down = sp.symbols(r'b, P_\mathrm{down}') sig_down = P_down / A_f eps_down = 1 / E_f * sig_down w_down = (L_b + b) - sp.Rational(1, 2) * eps_down * b Pw_down_pull, Pw_down_push = sp.solve( w_down.subs(b, -P_down / p / tau) - w, P_down ) Pw_short = sp.Piecewise((0, w <= 0), (Pw_up_pull, w <= w_argmax), (Pw_down_pull, w <= L_b), (0, True) ) w_L_b_a = L_b - Pw_down_pull / p / tau w_L_b = sp.Piecewise((0, w <= w_argmax), (w_L_b_a, (w > w_argmax) & (w <= L_b)), (w, True)) aw_pull = - (Pw_short / p / tau) Pw_pull = Pw_short #------------------------------------------------------------------------- # Declaration of the lambdified methods #------------------------------------------------------------------------- symb_model_params = ['E_f', 'A_f', 'E_m', 'A_m', 'tau', 'p', 'L_b'] symb_expressions = [ ('eps_f_x', ('x','P',)), ('eps_m_x', ('x','P',)), ('sig_f_x', ('x','P',)), ('sig_m_x', ('x','P',)), ('tau_x', ('x','P',)), ('u_fa_x', ('x','P',)), ('u_ma_x', ('x','P',)), ('w_L_b', ('w',)), ('aw_pull', ('w',)), ('Pw_pull', ('w',)), ]
def ac1ph2wpq(grid, vsc_data): ''' Converter type p_ac,q_ac 1 phase 2 ac wire ''' bus_ac_name = vsc_data['bus_ac'] bus_dc_name = vsc_data['bus_dc'] a_value = vsc_data['a'] b_value = vsc_data['b'] c_value = vsc_data['c'] ### AC-side p_ac, q_ac, p_dc = sym.symbols( f'p_{bus_ac_name},q_{bus_ac_name},p_{bus_dc_name}', real=True) #### AC voltages: v_a_r, v_a_i = sym.symbols(f'v_{bus_ac_name}_a_r,v_{bus_ac_name}_a_i', real=True) v_b_r, v_b_i = sym.symbols(f'v_{bus_ac_name}_b_r,v_{bus_ac_name}_b_i', real=True) v_c_r, v_c_i = sym.symbols(f'v_{bus_ac_name}_c_r,v_{bus_ac_name}_c_i', real=True) v_n_r, v_n_i = sym.symbols(f'v_{bus_ac_name}_n_r,v_{bus_ac_name}_n_i', real=True) #### AC currents: i_a_r, i_a_i = sym.symbols( f'i_vsc_{bus_ac_name}_a_r,i_vsc_{bus_ac_name}_a_i', real=True) i_b_r, i_b_i = sym.symbols( f'i_vsc_{bus_ac_name}_b_r,i_vsc_{bus_ac_name}_b_i', real=True) i_c_r, i_c_i = sym.symbols( f'i_vsc_{bus_ac_name}_c_r,i_vsc_{bus_ac_name}_c_i', real=True) i_n_r, i_n_i = sym.symbols( f'i_vsc_{bus_ac_name}_n_r,i_vsc_{bus_ac_name}_n_i', real=True) coef_a, coef_b, coef_c = sym.symbols( f'coef_a_{bus_ac_name},coef_b_{bus_ac_name},coef_c_{bus_ac_name}', real=True) v_a = v_a_r + 1j * v_a_i v_b = v_b_r + 1j * v_b_i v_c = v_c_r + 1j * v_c_i v_n = v_n_r + 1j * v_n_i i_a = i_a_r + 1j * i_a_i i_b = i_b_r + 1j * i_b_i i_c = i_c_r + 1j * i_c_i s_a_g = (v_a - v_n) * sym.conjugate(i_a) s_b_g = (v_b - v_n) * sym.conjugate(i_b) s_c_g = (v_c - v_n) * sym.conjugate(i_c) eq_i_a_r = sym.re(s_a_g) - p_ac * coef_a eq_i_b_r = sym.re(s_b_g) - p_ac * coef_b eq_i_c_r = sym.re(s_c_g) - p_ac * coef_c eq_i_a_i = sym.im(s_a_g) - q_ac * coef_a eq_i_b_i = sym.im(s_b_g) - q_ac * coef_b eq_i_c_i = sym.im(s_c_g) - q_ac * coef_c eq_i_n_r = i_n_r + i_a_r + i_b_r + i_c_r eq_i_n_i = i_n_i + i_a_i + i_b_i + i_c_i grid.dae['g'] += [ eq_i_a_r, eq_i_a_i, eq_i_b_r, eq_i_b_i, eq_i_c_r, eq_i_c_i, eq_i_n_r, eq_i_n_i, ] grid.dae['y'] += [i_a_r, i_a_i, i_b_r, i_b_i, i_c_r, i_c_i, i_n_r, i_n_i] i_abc_list = [i_a_r, i_a_i, i_b_r, i_b_i, i_c_r, i_c_i, i_n_r, i_n_i] for itg in [1, 2, 3, 4]: bus_idx = grid.nodes.index(f'{bus_ac_name}.{itg}') g_idx = bus_idx - grid.N_nodes_v grid.dae['g'][2 * g_idx + 0] += i_abc_list[2 * (itg - 1)] grid.dae['g'][2 * g_idx + 1] += i_abc_list[2 * (itg - 1) + 1] ### DC side a, b, c = sym.symbols(f'a_{bus_ac_name},b_{bus_ac_name},c_{bus_ac_name}', real=True) i_rms = sym.sqrt(i_a_r**2 + i_a_i**2 + 0.1) p_vsc_loss = a + b * i_rms + c * i_rms * i_rms v_dc_a_r, v_dc_n_r = sym.symbols( f'v_{bus_dc_name}_a_r,v_{bus_dc_name}_n_r', real=True) i_dc_a_r, i_dc_n_r = sym.symbols( f'i_vsc_{bus_dc_name}_a_r,i_vsc_{bus_dc_name}_n_r', real=True) eq_i_dc_a_r = i_dc_a_r + p_dc / (v_dc_a_r - v_dc_n_r + 1e-8) eq_i_dc_n_r = i_dc_n_r + p_dc / (v_dc_n_r - v_dc_a_r + 1e-8) eq_p_dc = p_dc - p_ac + sym.Piecewise( (p_vsc_loss, p_dc < 0), (-p_vsc_loss, p_dc > 0), (p_vsc_loss, True)) grid.dae['g'] += [eq_i_dc_a_r, eq_i_dc_n_r, eq_p_dc] grid.dae['y'] += [i_dc_a_r, i_dc_n_r, p_dc] grid.dae['u'].update({f'p_{bus_ac_name}': 0.0, f'q_{bus_ac_name}': 0.0}) grid.dae['xy_0_dict'].update({ f'v_{bus_dc_name}_a_r': 800.0, f'v_{bus_dc_name}_n_r': 10.0 }) grid.dae['u'].pop(f'i_{bus_dc_name}_a_r') grid.dae['u'].pop(f'i_{bus_dc_name}_n_r') grid.dae['params'].update({ f'a_{bus_ac_name}': a_value, f'b_{bus_ac_name}': b_value, f'c_{bus_ac_name}': c_value }) grid.dae['params'].update({ f'coef_a_{bus_ac_name}': 1 / 3, f'coef_b_{bus_ac_name}': 1 / 3, f'coef_c_{bus_ac_name}': 1 / 3 }) bus_idx = grid.nodes.index(f'{bus_dc_name}.{1}') g_idx = bus_idx - grid.N_nodes_v grid.dae['g'][2 * g_idx + 0] += i_dc_a_r grid.dae['g'][2 * g_idx + 1] += 0.0 bus_idx = grid.nodes.index(f'{bus_dc_name}.{4}') g_idx = bus_idx - grid.N_nodes_v grid.dae['g'][2 * g_idx + 0] += i_dc_n_r grid.dae['g'][2 * g_idx + 1] += 0.0
class PO_ELF_ELM_Symb(bu.SymbExpr): """Pullout of elastic Long fiber, fromm elastic long matrix """ E_m, A_m = sp.symbols(r'E_\mathrm{m}, A_\mathrm{m}', nonnegative=True) E_f, A_f = sp.symbols(r'E_\mathrm{f}, A_\mathrm{f}', nonnegative=True) tau, p = sp.symbols(r'\bar{\tau}, p', nonnegative=True) C, D, E, F = sp.symbols('C, D, E, F') P, w = sp.symbols('P, w') x, a, L_b = sp.symbols('x, a, L_b') d_sig_f = p * tau / A_f d_sig_m = -p * tau / A_m sig_f = sp.integrate(d_sig_f, x) + C sig_m = sp.integrate(d_sig_m, x) + D eps_f = sig_f / E_f eps_m = sig_m / E_m u_f = sp.integrate(eps_f, x) + E u_m = sp.integrate(eps_m, x) + F eq_C = {P - sig_f.subs({x: 0}) * A_f} C_subs = sp.solve(eq_C, C) eq_D = {P + sig_m.subs({x: 0}) * A_m} D_subs = sp.solve(eq_D, D) F_subs = sp.solve({u_m.subs(x, 0) - 0}, F) eqns_u_equal = {u_f.subs(C_subs).subs(x, a) - u_m.subs(D_subs).subs(F_subs).subs(x, a)} E_subs = sp.solve(eqns_u_equal, E) eqns_eps_equal = {eps_f.subs(C_subs).subs(x, a) - eps_m.subs(D_subs).subs(x, a)} a_subs = sp.solve(eqns_eps_equal, a) var_subs = {**C_subs, **D_subs, **F_subs, **E_subs, **a_subs} u_f_x = u_f.subs(var_subs) u_m_x = u_m.subs(var_subs) u_fa_x = sp.Piecewise((u_f_x.subs(x, var_subs[a]), x <= var_subs[a]), (u_f_x, x > var_subs[a])) u_ma_x = sp.Piecewise((u_m_x.subs(x, var_subs[a]), x <= var_subs[a]), (u_m_x, x > var_subs[a])) eps_f_x = sp.diff(u_fa_x, x) eps_m_x = sp.diff(u_ma_x, x) sig_f_x = E_f * eps_f_x sig_m_x = E_m * eps_m_x tau_x = sig_f_x.diff(x) * A_f / p eps_f_0 = P / E_f / A_f eps_m_0 = -P / E_m / A_m a_subs = sp.solve({P - p * tau * a}, a) w_el = sp.Rational(1, 2) * (eps_f_0 - eps_m_0) * a Pw_pull_elastic = sp.solve(w_el.subs(a_subs) - w, P)[1] Pw_push, Pw_pull = sp.solve(u_f_x.subs({x: 0}) - w, P) w_L_b = u_fa_x.subs(x, -L_b).subs(P, Pw_pull) aw_pull = a_subs[a].subs(P, Pw_pull) #------------------------------------------------------------------------- # Declaration of the lambdified methods #------------------------------------------------------------------------- symb_model_params = ['E_f', 'A_f', 'E_m', 'A_m', 'tau', 'p', 'L_b'] symb_expressions = [ ('eps_f_x', ('x','P',)), ('eps_m_x', ('x','P',)), ('sig_f_x', ('x','P',)), ('sig_m_x', ('x','P',)), ('tau_x', ('x','P',)), ('u_fa_x', ('x','P',)), ('u_ma_x', ('x','P',)), ('w_L_b', ('w',)), ('aw_pull', ('w',)), ('Pw_pull', ('w',)), ]
def _print_Heaviside(self, expr): # NOTE : expr.rewrite(sym.Piecewise) almost does the right thing. P = sym.Piecewise((0, expr.args[0] < 0), (1, expr.args[0] >= 0), (sym.S(1) / 2, True)) return self._print(P)
import sympy as sp from sympy.abc import x sp.init_printing() # %% Se definen las cargas distribuidas de acuerdo con la Tabla # Caso 2: carga puntual qpunt = lambda p,a : p*sp.DiracDelta(x-a) # Caso 5: carga distribuida variable qdist = lambda f,a,b : sp.Piecewise((f, (a < x) & (x < b)), (0, True)) # Funcion rectangular: si x>a y x<b retorne 1 sino retorne 0 rect = lambda a,b : sp.Piecewise((1, (a < x) & (x < b)), (0, True)) # Se define una función que hace el código más corto y legible integre = lambda f, x : sp.integrate(f, x, meijerg=False) # %% Se define la geometría de la viga y las propiedades del material b = 0.1 # Ancho de la viga, m h = 0.3 # Altura de la viga, m E = 210e6 # Módulo de elasticidad de la viga, kPa I = (b*h*h*h)/12 # Momento de inercia en z, m^4 # %% FORMA 1: # Momento flector mflec = lambda m,a : -m*sp.DiracDelta(x-a, 1) # Se especifica el vector de cargas q(x) q = qpunt(-5,1) + qdist(-3*x/2,2,4) + mflec(-8,3.5) + mflec(3,5)
def eval_power(base, exp, integrand, symbol): return sympy.Piecewise((sympy.log(base), sympy.Eq(exp, -1)), ((base**(exp + 1)) / (exp + 1), True))
( '$PRED K_ = ATAN(1) - ASIN(X)/ACOS(X)', S('K_'), sympy.atan(1) - sympy.asin(S('X')) / sympy.acos(S('X')), ), ('$PRED CL = INT(-2.2)', S('CL'), -2), ('$PRED cl = int(-2.2)', S('CL'), -2), ('$PRED CL = INT(0.2)', S('CL'), 0), ('$PRED CL = SQRT(X)', S('CL'), sympy.sqrt(S('X'))), ('$PRED CL = MOD(1, 2)', S('CL'), sympy.Mod(1, 2)), ('$PRED CL = GAMLN(2 + X) ;COMMENT', S('CL'), sympy.loggamma(S('X') + 2)), ('$PRED C02 = PHI(2 + X)', S('C02'), (1 + sympy.erf(2 + S('X')) / sympy.sqrt(2)) / 2), ('$PRED IF (X.EQ.2) CL=23', S('CL'), sympy.Piecewise((23, sympy.Eq(S('X'), 2)))), ('$PRED if (x.EQ.2) Cl=23', S('CL'), sympy.Piecewise((23, sympy.Eq(S('X'), 2)))), ( '$PRED IF (X.NE.1.5) CL=THETA(1)', S('CL'), sympy.Piecewise((S('THETA(1)'), sympy.Ne(S('X'), 1.5))), ), ('$PRED IF (X.EQ.2+1) CL=23', S('CL'), sympy.Piecewise((23, sympy.Eq(S('X'), 3)))), ( '$PRED IF (X < ETA(1)) CL=23', S('CL'), sympy.Piecewise((23, sympy.Lt(S('X'), S('ETA(1)')))), ), (
points = [] expressions = [] symbols = set() T = None if args.expression: for expression in args.expression: expressions.append([sympy.sympify(expression.split(';')[0]), [expression.split(';')[1], None]]) [symbols.add(symbol) for symbol in expressions[-1][0].free_symbols] for (i, interval) in enumerate(expressions[-1][1][0].split(',')): expressions[-1][1][i] = sympy.sympify(interval) [symbols.add(symbol) for symbol in expressions[-1][1][i].free_symbols] symbols.remove(t) T = expressions[-1][1][1] s = sympy.Piecewise(*((expression[0], sympy.And(expression[1][0] <= t, t < expression[1][1])) for expression in expressions)) else: for point in args.points: points.append((sympy.sympify(point.split(',')[0]), sympy.sympify(point.split(',')[1]))) for coordinate in points[-1]: [symbols.add(symbol) for symbol in coordinate.free_symbols] T = points[-1][1] pieces = [] i = 0 while i < len(points) - 1: j = i if i > 0: if points[i][1] == points[i + 1][1]: j += 1
def populatebycolumn(self, x, f, f_range, G, T, prob, h=sympy.Piecewise((1.0, True)), verbose=False, epsilon=1e-8): ''' builds the LP problem for cplex ''' import cplex as cplex nvar = len(G) + 1 ncons = T.shape[0] #this is the weighting function (partition of unity) hval = np.array([ float(h.subs(list(zip(x, T[j, :])))) for j in range(0, T.shape[0]) ]) col = np.multiply(np.ones(ncons), hval) nonzeroind = np.nonzero(col)[0] #print(np.ndarray.tolist(col[nonzeroind])) #define matrix A of the linear constraints ind_cons = np.arange(0, ncons, 1) A = [] A.append([ np.ndarray.tolist(ind_cons[nonzeroind]), np.ndarray.tolist(col[nonzeroind]) ]) #this multiplies lambda_0 for i in range(0, len(G)): col = np.array([ float(G[i].subs(list(zip(x, T[j, :])))) for j in range(0, ncons) ]) #this multiplies lambda_i if np.max(col) < 0: print('Warning: gamble ' + str(i) + ' is always negative in T') nonzeroind = np.nonzero(col)[0] if len(nonzeroind) == 0: print('Warning: constraint ' + str(i) + ' is zeros for all discretised values') else: #print([np.ndarray.tolist(ind_cons[nonzeroind]),np.ndarray.tolist(col[nonzeroind])]) A.append([ np.ndarray.tolist(ind_cons[nonzeroind]), np.ndarray.tolist(col[nonzeroind]) ]) #b vector b = [ float(hval[j] * f.subs(list(zip(x, T[j, :]))) + epsilon) for j in range(0, ncons) ] #c vector c = np.zeros(nvar) c[0] = -1.0 #we minimize -lambda_0 #bounds if len(self.lambda_bounds) > 0: bnd = np.array(self.lambda_bounds.copy()) bnd = np.vstack([[f_range[0], f_range[1]], bnd]) else: bnd = np.vstack([[f_range[0], f_range[1]]]) bnd[:, 0] = [-cplex.infinity if v is None else v for v in bnd[:, 0]] bnd[:, 1] = [cplex.infinity if v is None else v for v in bnd[:, 1]] Lower = bnd[:, 0] Upper = bnd[:, 1] #Lower=np.hstack([f_range[0], np.zeros(nvar-1)]) #Upper=[cplex.infinity]*nvar #Upper[0]=f_range[1] prob.objective.set_sense(prob.objective.sense.minimize) #print(b) prob.linear_constraints.add(rhs=b, senses=["L"] * (ncons)) prob.variables.add(obj=c, lb=Lower, ub=Upper, columns=A)
def _print_ConditionalFieldAccess(self, node): return self._print(sp.Piecewise((node.outofbounds_value, node.outofbounds_condition), (node.access, True)))
def Cutting_plane(self, x, f, f_range, G, T, h=sympy.Piecewise((1.0, True)), verbose=True, solver='linprog', epsilonLP=1e-8, alpha_cut=-0.01): ''' implements the cutting plane algorithm to solve a SILP problem ''' loop = True niter = 0 while loop == True: niter = niter + 1 resLP = self.LP(x, f, f_range, G, T, h=h, verbose=False, solver=solver, epsilon=epsilonLP) if verbose: print('LP iteration ' + str(niter) + ' fun=', resLP['fun'], ' number of support points=' + str(T.shape[0])) #print('LP status:'+statusLP[resLP.status]) lam = resLP['x'] #print(h) condition = ((f - lam[0]) * h - np.sum([lam[i + 1] * G[i] for i in range(0, len(G))]) ) #the constraint we want to violate #D_condition=sp.diff(condition) #its jacobian #print(condition) #print(aaa+1) bestmin = np.inf for t in T: _z = np.ndarray.tolist(t) if self.is_mixed == True: minv = np.inf for d in self.DiscretePowerSet: val = _z + d cond = condition.subs(list(zip(x, val))) if cond < minv: minv = cond else: val = _z minv = condition.subs(list(zip(x, val))) if minv < bestmin: bestmin = minv #print(bestmin) def myfun(_z): _z = np.ndarray.tolist(_z) if self.is_mixed == True: minv = np.inf for d in self.DiscretePowerSet: val = _z + d cond = condition.subs(list(zip(x, val))) if cond < minv: minv = cond min_point = np.array(val) else: val = _z minv = condition.subs(list(zip(x, val))) min_point = np.array(val) c = np.zeros(1) c[0] = minv return c, min_point def myfun0(_z): c, none = myfun(_z) return c bnd = [] for ib in range(0, len(self.Symbols)): if self._TypeSymbols[ib] == 'c': bnd.append([ self._Domains[ib].boundary.inf, self._Domains[ib].boundary.sup ]) #bnd=np.array(bnd) #_z0 =self.make_SupportingPoints(1, criterion='random') best_x, best_f = self._nonlinear_solver(myfun0, bnd, bestmin, T=T, seed=T.shape[0], _x0=T[0, :], alpha_cut=alpha_cut) min_fun, min_point = myfun(best_x) if verbose: print('Violation of positivity of the constraint: ', min_fun) if min_fun <= alpha_cut: T = np.vstack([T, min_point]) if verbose: print('New support point:', best_x) else: if verbose: print( 'Violation of positivity of the constraint is below the threshold ', alpha_cut) loop = False return resLP, T
def test_hydrostatic_pressure(self): # Test mpfa_gravity in 2D Cartesian # and triangular grids # Should be exact for hydrostatic pressure # with stepwise gravity variation grids = ["cart", "triangular"] x, y = sympy.symbols("x y") g1 = 10 g2 = 1 p0 = 1 # reference pressure p = p0 + sympy.Piecewise(((1 - y) * g1, y >= 0.5), (0.5 * g1 + (0.5 - y) * g2, y < 0.5)) an_sol = _SolutionHomogeneousDomainFlowWithGravity(p, x, y) for gr in grids: domain = np.array([1, 1]) basedim = np.array([4, 4]) pert = 0.5 g = make_grid(gr, basedim, domain) g.compute_geometry() dx = np.max(domain / basedim) g = perturb(g, pert, dx) g.compute_geometry() xc = g.cell_centers xf = g.face_centers k = pp.SecondOrderTensor(np.ones(g.num_cells)) # Gravity gforce = np.zeros((2, g.num_cells)) gforce[0, :] = an_sol.gx_f(xc[0], xc[1]) gforce[1, :] = an_sol.gy_f(xc[0], xc[1]) gforce = gforce.ravel("F") # Set type of boundary conditions p_bound = np.zeros(g.num_faces) left_faces = np.ravel(np.argwhere(g.face_centers[0] < 1e-10)) right_faces = np.ravel( np.argwhere(g.face_centers[0] > domain[0] - 1e-10)) dir_faces = np.concatenate((left_faces, right_faces)) bound_cond = pp.BoundaryCondition(g, dir_faces, ["dir"] * dir_faces.size) # set value of boundary condition p_bound[dir_faces] = an_sol.p_f(xf[0, dir_faces], xf[1, dir_faces]) # GCMPFA discretization, and system matrix flux, bound_flux, _, _, div_g = pp.Mpfa("flow").mpfa( g, k, bound_cond, vector_source=True, inverter="python") div = pp.fvutils.scalar_divergence(g) a = div * flux flux_g = div_g * gforce b = -div * bound_flux * p_bound - div * flux_g p = scipy.sparse.linalg.spsolve(a, b) q = flux * p + bound_flux * p_bound + flux_g p_ex = an_sol.p_f(xc[0], xc[1]) q_ex = np.zeros(g.num_faces) self.assertTrue(np.allclose(p, p_ex)) self.assertTrue(np.allclose(q, q_ex))