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))
