def generateSystemSteadyState(self, replacements, full_output = False):
# taking the RHS of the steady state equations in order to add the
# constraint Tr(ρ) = 1, needed to solve the system of equations
eqns_rhs = self.equations_steady_state.rhs.subs(replacements)
eqns_rhs = flatten(eqns_rhs.tolist())
eqns_rhs[0] += self.density_matrix_steady_state.trace()-1
for i in range(self.levels):
for j in range(i,self.levels):
tmp = Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j)))
tmp1 = Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+j),
chr(0x2080+i)))
for idx in range(len(eqns_rhs)):
eqns_rhs[idx] = eqns_rhs[idx].subs(conjugate(tmp), tmp1)
syms = []
for i in range(self.levels):
for j in range(self.levels):
syms.append(Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j))))
matrix_eq = linear_eq_to_matrix(eqns_rhs, syms)
if full_output:
return matrix_eq, syms
else:
return matrix_eq
def rewrite_odes_as_linear_combination_in_parameters(odes_sym,state_symbols,ode_param_symbols,ext_input_symbols):
'''Rewrites each ODE as a Linear Combination in all ODE Parameters'''
# number of hidden states
numb_hidden_states = len(state_symbols)
# append state symbols with constant vector
symbols_all = [lst for sublist in [state_symbols,ext_input_symbols,sym.symbols(['one_vector'])] for lst in sublist]
# initialize vectors B and b
B=[[] for k in range(numb_hidden_states)]
b=[[] for k in range(numb_hidden_states)]
# rewrite ODEs as linear combinations in parameters (locally w.r.t. individual ODE)
for k in range(numb_hidden_states):
expr_B,expr_b = sym.linear_eq_to_matrix([odes_sym[k].expand()],ode_param_symbols)
expr_b = -expr_b # see the documentation of the function "sympy.linear_eq_to_matrix"
# replace scalar constant by vector populated by the same constant
for i in range(len(expr_B)):
if len(expr_B[i].free_symbols) == 0: expr_B[i] = sym.symbols('one_vector')
for i in range(len(expr_b)):
if len(expr_b[i].free_symbols) == 0: expr_b[i] = sym.symbols('one_vector')
# transform symbolic expressions for B and b into functions
B[k] = sym.lambdify(symbols_all,expr_B)
b[k] = sym.lambdify(symbols_all,expr_b)
return B,b
def linalg_test():
system = equations()
M, c = sp.linear_eq_to_matrix(system, [x1, x2, x3])
M, c = np.asarray(M, dtype=np.float32), np.asarray(c, dtype=np.float32)
y = np.linalg.solve(M, c)
print('\nsolutions')
print(y)
def _analyse(self):
if self.kind == 'time':
raise ValueError(
'Cannot put time domain equations into matrix form')
subsdict = {}
for node, v in self._unknowns.items():
if v == 0:
continue
subsdict[v.expr] = 'X_X' + node
exprs = []
for node, (lhs, rhs) in self._equations.items():
lhs = lhs.subs(subsdict).expr.expand()
rhs = rhs.subs(subsdict).expr.expand()
exprs.append(lhs - rhs)
y = []
for y1 in self._y:
y.append(y1.subs(subsdict).expr)
A, b = sym.linear_eq_to_matrix(exprs, *y)
y = [y1.expr for y1 in self._y]
return SystemEquations(A, b, y)
def equations_to_matrices(equations: list):
"""Equations to Matrix:
Transform a list of equations into two matrices A(the coefficients matrix)
and b(the r.h.s matrix).
Keyword arguments:
equations: list -- A list of containing the string representation of the equations.
return:
1) The matrix A containing the coefficients of the equation
sorted according to the alphabetical order of their symbols.
2) The vector b containing the r.h.s of the equations
3) The symbols sorted in alphabetical order.
"""
print(equations)
parsed_equations = []
symbols = set()
for eq in equations:
parts = eq.replace('==', '=').split('=')
assert len(parts) == 2
lhs, rhs = parts
parsed_eqn = sympy.Eq(sympy.sympify(lhs), sympy.sympify(rhs))
symbols |= parsed_eqn.free_symbols
parsed_equations.append(parsed_eqn)
symbol_list = sorted(list(symbols), key=str)
A, b = sympy.linear_eq_to_matrix(parsed_equations, symbol_list)
# asserts that both matrices do not contain any symbols
# since bool(empty_set) returns False and bool(non_empty_set) returns true
assert not bool(A.free_symbols) and not bool(b.free_symbols)
return A, b, symbol_list
def rewrite_odes_as_linear_combination_in_states(odes,state_symbols,ode_param_symbols,observed_states,\
state_couplings,clamp_states_to_observation_fit=1):
'''Rewrite each ODE as a Linear Combination in an Individual State'''
# number of hidden states
numb_hidden_states = len(state_symbols)
# number of ODEs
numb_odes = len(odes(*state_symbols, *ode_param_symbols))
# unpack state and parameter symbols
symbols_all = [
lst for sublist in
[ode_param_symbols, state_symbols,
sym.symbols(['one_vector'])] for lst in sublist
]
# determine set of hidden states to infer
if clamp_states_to_observation_fit == 1:
# indices of observed states
hidden_states_to_infer = [
u for u in range(len(state_symbols))
if state_symbols[u] not in observed_states
]
else:
hidden_states_to_infer = range(len(state_symbols))
# initialize matrices R and r
# R=[[[],[],[]] for k in range(numb_hidden_states)]
# r=[[[],[],[]] for k in range(numb_hidden_states)]
R = [[[] for k in range(numb_odes)] for u in range(numb_hidden_states)]
r = [[[] for k in range(numb_odes)] for u in range(numb_hidden_states)]
# rewrite ODEs as linear combinations in individual states (locally w.r.t. individual ODE)
for u in range(numb_hidden_states):
for k in state_couplings[u]:
expr_R, expr_r = sym.linear_eq_to_matrix(
[odes(*state_symbols, *ode_param_symbols)[k].expand()],
state_symbols[u])
expr_r = -expr_r # see the documentation of the function "sympy.linear_eq_to_matrix"
# replace scalar by vector populated by the same scalar
for i in range(len(expr_R)):
if len(expr_R[i].free_symbols) == 0:
expr_R[i] *= sym.symbols('one_vector')
for i in range(len(expr_r)):
if len(expr_r[i].free_symbols) == 0:
expr_r[i] *= sym.symbols('one_vector')
# transform symbolic expressions for R and r into functions
R[u][k] = sym.lambdify(symbols_all, expr_R)
r[u][k] = sym.lambdify(symbols_all, expr_r)
# R[u][k] = sym.lambdify(*(ode_param_symbols,state_symbols),expr_R)
# r[u][k] = sym.lambdify(*[ode_param_symbols,state_symbols],expr_r)
return R, r
def _calc_regressor(self):
print("Calculating regressor...")
A, b = sympy.linear_eq_to_matrix(self.tau, self.rbt_def.bary_params)
self.H = A
input_vars = tuple(self.rbt_def.coordinates + self.rbt_def.d_coordinates + self.rbt_def.dd_coordinates)
# print('input_vars', input_vars)
self.H_func = sympy.lambdify(input_vars, self.H)
def linear_to_matrix(equs, coeff):
A, b = linear_eq_to_matrix(equs, coeff)
A = np.array(A).astype(np.float64)
b = np.array(b).astype(np.float64)
# np.savetxt("A.csv", A, delimiter=",")
# np.savetxt("b.csv", b, delimiter=",")
#print(A, b)
s = np.linalg.solve(A, b)
return s
def linear_to_matrix(equs, coeff):
#print(equs)
x, y = linear_eq_to_matrix(equs, coeff)
x = np.array(x).astype(np.float64)
y = np.array(y).astype(np.float64)
#print(x, '',y)
#print(y)
s = np.linalg.solve(x, y)
return s
def equations_to_matrix(equations):
symbols = set()
system = []
for equation in equations:
sides = equation.split("=")
LHS, RHS = sides
expression = sympy.Eq(sympy.simplify(LHS), sympy.simplify(RHS))
system.append(expression)
add_symbols_to_set(symbols, expression.free_symbols)
symbols = sorted(list(symbols), key=str)
coeffs, b = sympy.linear_eq_to_matrix(system, symbols)
return coeffs, b, symbols, system
def get_Sv(A, J, N1, N2, Ut):
"""
Solve for Sv
Input
=========
(The inputs are obtained from solve_habit_persistence)
A: stable dynamic matrix A
J: matrix J
N1, N2: stable dynamics for costates
Ut: the utility function
Output
=========
Su: The row vector (Su)'
"""
##== Calculate Su ==##
## Express Ut in terms of Z_{t} and Z_{t+1}
MKt, MHt, Kt, Ht, X1t, X2t, X2tL1 = symbols('MKt MHt Kt Ht X1t X2t X2tL1')
MKt1, MHt1, Kt1, Ht1, X1t1, X2t1 = symbols('MKt1 MHt1 Kt1 Ht1 X1t1 X2t1')
TT,_ = linear_eq_to_matrix([Ut],
MKt, MHt, Kt, Ht, X1t, X2t, X2tL1,
MKt1, MHt1, Kt1, Ht1, X1t1, X2t1)
#t1: Ut's coefficient under Z_t
t1 = TT[:7]
t1 = np.array([t1]).astype(float)
#t2: Ut's coefficient under Z_{t+1}
t2 = TT[7:]
t2.append(0) #X2t is 0 in t2 entry
t2 = np.array([t2]).astype(float)
## Get Su
K = np.vstack([np.hstack([N1,N2]),np.identity(5)])
JK = np.matmul(J, K)
T1 = np.matmul(t1, K)
T2 = np.matmul(t2, JK)
Su = T1 + T2
##== Calculate Sv ==##
"""
We rearranged the equation from the note to get: (Sv)' * A_Sv = b_Sv
"""
b_Sv = (1 - np.exp(-δ)) * Su + np.exp(-δ) * np.hstack([0,0,Sy])
A_Sv = (np.identity(5) - np.exp(-δ) * A)
Sv = np.matmul(b_Sv, np.linalg.inv(A_Sv))
return Sv
def sc_ode_to_matrix(sc_ode, op_func_map, t):
"""
Convert a set of semiclassical equations of motion to matrix form.
"""
ops = operator_sort_by_order(sc_ode.keys())
A = Matrix([op_func_map[op] for op in ops])
subs = [(op_func_map[op], Symbol(op_func_map[op].name)) for op in ops]
eqns = [sc_ode[op].rhs.subs(subs) for op in ops]
M, C = linear_eq_to_matrix(eqns, list(zip(*subs))[1])
A_eq = Eq(-Derivative(A, t),
Add(-C, MatMul(M, A), evaluate=False),
evaluate=False)
return A_eq, A, M, -C
def solve(equations_lst, unkn_lst):
"""solves the problem from list of equation and list of Unknown values
:param equations_lst: ['x+y = 40', '2*x+4*y = 108'] -> list of strings
:param unkn_lst: ['x', 'y'] -> list of strings
:return: {(26,14)}' -> list of float or ints
"""
unkn_lst_s = unkn_lst[:]
s_case = False
if handle_unkn(unkn_lst_s):
s_case = True
unkn_lst = ['x']
if len(equations_lst) < len(unkn_lst):
return []
A, b = sy.linear_eq_to_matrix(replace_equ(equations_lst), unkn_lst)
sol = [eval(str(x)) for b in sy.linsolve((A, b), unkn_lst) for x in b]
if not s_case:
return sol
return [eval(i.replace('x', str(sol[0]))) for i in unkn_lst_s]
def generateSystem(self, replacements, full_output = False):
eqns_rhs = self.equations.rhs.subs(replacements)
# converting the symbolic functions ρ(t) to ρ in order to create the
# matrix representing the linear equations (Ax=b)
t = Symbol('t', real = True)
for i in range(self.levels):
for j in range(i,self.levels):
tmp = Function(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j)))
tmp1 = Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+j),
chr(0x2080+i)))
eqns_rhs = eqns_rhs.subs(conjugate(tmp(t)), tmp1)
for i in range(self.levels):
for j in range(i,self.levels):
tmp = Function(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j)))
tmp1 = Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j)))
eqns_rhs = eqns_rhs.subs(tmp(t), tmp1)
syms = []
for i in range(self.levels):
for j in range(self.levels):
syms.append(Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j))))
# creating the matrix A (from Ax = b) for the ODE system
matrix_eq = linear_eq_to_matrix(eqns_rhs, syms)[0]
# check if there is still time dependence inside the matrix, return
# a lambdified function if yes, else return a numpy array
if t in matrix_eq.free_symbols:
t_dependent = True
matrix_eq = lambdify(t, matrix_eq, 'numpy')
else:
t_dependent = False
matrix_eq = np.array(matrix_eq).astype(complex)
if full_output:
return matrix_eq, t_dependent, syms
else:
return matrix_eq, t_dependent
def test_equations2():
equations = [
"x = a*x(-1) + e",
"y = b*y(-1) + c*x(-1) + d*p(-1)",
"p = p(-1) + f",
]
structural = ["a", "b", "c", "d"]
shocks = ["e", "f"]
print(sympify("f(1)"))
print(dotprint(sympify("f(1)")))
lhs, rhs = [], []
for equation in equations:
s_lhs, s_rhs = equation.split("=")
p_lhs = sympify(s_lhs)
p_rhs = sympify(s_rhs)
print(dotprint(p_rhs))
lhs.append(p_lhs)
rhs.append(p_rhs)
print(lhs)
print(rhs)
x, y, p = symbols('x y z')
left, right = linear_eq_to_matrix(rhs, [x, y, p])
print(left)
print(right)
transition, shock = DsgeModelBuilder.prepare_state_matrices(equations, ['e', 'f'], ['x', 'y', 'p'])
print("State matrices")
print(transition)
print(shock)
def _svd_solve(self, eqs_list, var_list, eps=1e-5):
M, rhs = [
np.array(i).astype(np.float64)
for i in linear_eq_to_matrix(eqs_list, var_list)
]
M_NS = null(M, eps=eps)
some_solution, resid, rank, sigma = linalg.lstsq(M, rhs)
self.aux_symbols = [
Symbol('a_{}'.format(i)) for i in range(M_NS.shape[1])
]
aux_vector = Matrix(self.aux_symbols)
self._verbose_print('Nullspace shape: {}'.format(M_NS.shape))
answer = {
var: (Matrix(some_solution) + Matrix(M_NS) * aux_vector)[i, 0]
for i, var in enumerate(var_list)
}
self.I_lr = self.I_lr.subs(answer).applyfunc(round_expression)
self.I_rl = self.I_rl.subs(answer).applyfunc(round_expression)
free_symbols = self.I_lr.free_symbols
return M_NS.shape[1] != 0, free_symbols
def _obj_func(self, x):
# objective
q, dq, ddq = self.fourier_traj.fourier_base_x2q(x)
# print('q:', q)
# print('dq: ', dq)
# print('ddq: ', ddq)
for n in range(self.sample_num):
vars_input = q[n, :].tolist() + dq[n, :].tolist() + ddq[
n, :].tolist()
self.H[n * self._dyn.dof:(n + 1) *
self._dyn.dof, :] = self._dyn.H_b_func(*vars_input)
#print('H: ', self.H[n*self._dyn.dof:(n+1)*self._dyn.dof, :])
self.H /= np.subtract(self.H.max(axis=0), self.H.min(axis=0))
f = np.linalg.cond(self.H)
if self._obj_cnt % (self._joint_coef_num * self._dyn.dof) == 0:
print("Condition number: {}".format(f))
self._obj_cnt += 1
# y = self.H
# xmax, xmin = y.max(), y.min()
# y = (y - xmin) / (xmax - xmin)
# #print(y[0,:])
#
# f = np.linalg.cond(y)
# print('f: ', f)
# constraint
g = [0.0] * (self._const_num * self.sample_num)
g_cnt = 0
# Joint constraints (old)
# for j_c in self._joint_constraints:
# q_s, q_l, q_u, dq_l, dq_u = j_c
# co_num = self._dyn.coordinates.index(q_s)
#
# for qt, dqt in zip(q[:, co_num], dq[:, co_num]):
# g[g_cnt] = qt - q_u
# g_cnt += 1
# g[g_cnt] = q_l - qt
# g_cnt += 1
# g[g_cnt] = dqt - dq_u
# g_cnt += 1
# g[g_cnt] = dq_l - dqt
# g_cnt += 1
# Joint constraints (with composite joint angle considered)
q_ss = [c[0] for c in self._joint_constraints]
A, _ = sympy.linear_eq_to_matrix(q_ss, self._dyn.coordinates)
A_T = np.matrix(A).astype(np.float).transpose()
q_c = np.matmul(q, A_T)
dq_c = np.matmul(dq, A_T)
for j, j_c in enumerate(self._joint_constraints):
_, q_l, q_u, dq_l, dq_u = j_c
for qt, dqt in zip(q_c[:, j], dq_c[:, j]):
g[g_cnt] = qt - q_u
g_cnt += 1
g[g_cnt] = q_l - qt
g_cnt += 1
g[g_cnt] = dqt - dq_u
g_cnt += 1
g[g_cnt] = dq_l - dqt
g_cnt += 1
# Cartesian Constraints
# print(q.shape[0])
for c_c in self._cartesian_constraints:
frame_num, bool_max, c_x, c_y, c_z = c_c
for num in range(q.shape[0]):
vars_input = q[num, :].tolist()
p_num = self._dyn.p_n_func[frame_num](*vars_input)
self.frame_pos[num, 0] = p_num[0, 0]
self.frame_pos[num, 1] = p_num[1, 0]
self.frame_pos[num, 2] = p_num[2, 0]
if bool_max == 'max':
g[g_cnt] = p_num[0, 0] - c_x
g_cnt += 1
g[g_cnt] = p_num[1, 0] - c_y
g_cnt += 1
g[g_cnt] = p_num[2, 0] - c_z
g_cnt += 1
elif bool_max == 'min':
g[g_cnt] = -p_num[0, 0] + c_x
g_cnt += 1
g[g_cnt] = -p_num[1, 0] + c_y
g_cnt += 1
g[g_cnt] = -p_num[2, 0] + c_z
g_cnt += 1
fail = 0
return f, g, fail
eq = eq.subs({y[int(x1_ab)]: int(y_ab1)})
eq = eq.subs({y[int(x2_ab)]: int(y_ab2)})
equations = np.append(equations, eq)
print(equations[i - 2])
eq_Deriv_CC2 = Eq(
(((y[3] - y[1]) / (2 * t)) - 0.5 * VA * (x[2]**2) + 4 * VA * (x[2])),
((-5 * (x[2]**3) + 240 * (x[2])) * M1EI))
eq_Deriv_CC2 = eq_Deriv_CC2.subs({y[int(x3_ab)]: int(dy_ab)})
eq_Deriv_CC2 = eq_Deriv_CC2.subs({y[int(x1_ab)]: int(y_ab1)})
eq_Deriv_CC2 = eq_Deriv_CC2.subs({y[int(x2_ab)]: int(y_ab2)})
equations = np.append(equations, eq_Deriv_CC2)
print(equations[i - 2])
system, equality = sp.linear_eq_to_matrix(
equations, y_1[2:31]
) ## ALTERAR aqui também, sempre nodes+1 ## Sempre a quantidade desejada de variaveis + 1 !!!
system_array = np.array(system).astype(np.float64)
##system_array2 = np.delete(system_array, 2, 1)
system_equality = np.array(equality).astype(np.float64)
print("\nCoefficient Matrix")
print(system_array)
print("\nEquality Matrix")
print(system_equality)
ans = np.linalg.solve(system_array, system_equality)
ans2 = np.insert(ans, 0, y_ab1)
ans3 = np.insert(ans2, (int(nodes) - 1),
y_ab2) ## O valor de VA está sendo subst. pela cond contorno.
print("\nVA valor Teste")
phi_subs_y = sym.N(
phi_diff_y.subs(x0,
x_min).subs(x1, x_max).subs(y0, y_min).subs(
y1,
y_max).subs(phi0,
z_0).subs(phix,
z_x).subs(phiy, z_y),
2)
solution_list.append(phi_subs_0)
solution_list.append(phi_subs_x)
solution_list.append(phi_subs_y)
var_list.append([z_0, z_x, z_y])
solution_matrices.append(
sym.linear_eq_to_matrix(solution_list, [z_0, z_x, z_y]))
solution_equations.append(solution_list)
else:
zero_vals.append(z_matrix[ycounter][xcounter])
z_vars = [
z_matrix[countery][counterx] for countery in range(len(z_matrix))
for counterx in range(len(z_matrix[0]))
]
equation_system = [
0 for countery in range(len(z_matrix))
for counterx in range(len(z_matrix[0]))
]
# print(sym.latex(sym.Matrix(equation_system)))
def __init__(self, cct, node_voltages=True, branch_currents=False):
if not node_voltages and not branch_currents:
raise ValueError('No outputs')
inductors = []
capacitors = []
independent_sources = []
# Determine state variables (current through inductors and
# voltage across acapacitors) and replace inductors with
# current sources and capacitors with voltage sources.
sscct = cct._new()
cpt_map = {}
for key, elt in cct.elements.items():
ssnet = elt._ss_model()
sselt = sscct._add(ssnet)
name = elt.name
cpt_map[name] = sselt.name
if elt.is_inductor:
if sselt.name in cct.elements:
raise ValueError(
'Name conflict %s, either rename the component or improve the code!'
% sselt.name)
inductors.append(elt)
elif elt.is_capacitor:
if sselt.name in cct.elements:
raise ValueError(
'Name conflict %s, either rename the component or improve the code!'
% sselt.name)
capacitors.append(elt)
elif isinstance(elt, (I, V)):
independent_sources.append(elt)
self.cct = cct
self.sscct = sscct
# sscct can be analysed in the time domain since it has no
# reactive components. However, for large circuits
# this can take a long time due to inversion of the MNA matrix.
dotx_exprs = []
statevars = []
statenames = []
initialvalues = []
for elt in inductors + capacitors:
name = cpt_map[elt.name]
if isinstance(elt, L):
# Inductors v = L di/dt so need v across the L
expr = sscct[name].v / elt.cpt.L
var = -sscct[name].isc
x0 = elt.cpt.i0
else:
# Capacitors i = C dv/dt so need i through the C
# The current is negated since it is from a source V_Cx
expr = -sscct[name].i / elt.cpt.C
var = sscct[name].voc
x0 = elt.cpt.v0
dotx_exprs.append(expr)
statevars.append(var)
statenames.append(name)
initialvalues.append(x0)
statesyms = sympify(statenames)
# Determine independent sources.
sources = []
sourcevars = []
sourcenames = []
for elt in independent_sources:
name = cpt_map[elt.name]
if isinstance(elt, V):
expr = elt.cpt.voc
var = sscct[name].voc
else:
expr = elt.cpt.isc
var = sscct[name].isc
sources.append(expr)
sourcevars.append(var)
sourcenames.append(name)
sourcesyms = sympify(sourcenames)
# linear_eq_to_matrix expects only Symbols and not AppliedUndefs,
# so substitute.
subsdict = {}
for var, sym1 in zip(statevars, statesyms):
subsdict[var.expr] = sym1
for var, sym1 in zip(sourcevars, sourcesyms):
subsdict[var.expr] = sym1
for m, expr in enumerate(dotx_exprs):
dotx_exprs[m] = expr.subs(subsdict).expr.expand()
A, b = sym.linear_eq_to_matrix(dotx_exprs, *statesyms)
if sourcesyms != []:
B, b = sym.linear_eq_to_matrix(dotx_exprs, *sourcesyms)
else:
B = []
# Determine output variables.
yexprs = []
y = []
if node_voltages:
for node in cct.node_list:
if node == '0':
continue
yexprs.append(self.sscct[node].v.subs(subsdict).expand().expr)
# Note, this can introduce a name conflict
y.append(Vt('v_%s(t)' % node))
if branch_currents:
for name in cct.branch_list:
# Perhaps ignore L since the current through it is a
# state variable?
name2 = cpt_map[name]
yexprs.append(self.sscct[name2].i.subs(subsdict).expand().expr)
y.append(It('i_%s(t)' % name))
Cmat, b = sym.linear_eq_to_matrix(yexprs, *statesyms)
if sourcesyms != []:
D, b = sym.linear_eq_to_matrix(yexprs, *sourcesyms)
else:
D = []
# Rewrite vCanon1(t) as vC(t) etc if appropriate.
_hack_vars(statevars)
_hack_vars(sources)
# Note, Matrix strips the class from each element...
self.x = tMatrix(statevars)
self.x0 = Matrix(initialvalues)
self.dotx = tMatrix([sym.Derivative(x1, t) for x1 in self.x])
self.u = tMatrix(sources)
self.A = Matrix(A)
self.B = Matrix(B)
# Perhaps could use v_R1(t) etc. as the output voltages?
self.y = Matrix(y)
self.C = Matrix(Cmat)
self.D = Matrix(D)
ret = {}
# symbols = [x if type(x) == Symbol else None for x in symbols]
for sym in symbols:
if sym in knowledge_base:
ret[sym] = knowledge_base[sym]
return ret
def add_to_knowledge_base(expr):
symbols = expr.free_symbols
for sym in symbols:
# won't add duplicatese because its a set
all_symbols.add(sym)
knowledge_base.append(expr)
# some expressions
add_to_knowledge_base(tiles[0,0])
add_to_knowledge_base(tiles[1,0]-1)
#add_to_knowledge_base(tiles[1,1])
add_to_knowledge_base(tiles[0,1] + tiles[1,0] + tiles[1,1] - 2)
print(tiles[1,0])
print(all_symbols)
A,b = linear_eq_to_matrix(knowledge_base, all_symbols)
print(A,b)
# use array of exprs
print(all_symbols)
t = linsolve((A,b), all_symbols)
print(t)
def _calc_M(self):
A, b = sympy.linear_eq_to_matrix(self.tau, self.rbt_def.dd_coordinates)
self.M = A
def optimizeParametersNumeric(self, replacements, tspan, y0, level,
parameters, bounds, max_step = 1e-1,
method = 'RK45', optimize = "minimum"):
"""
Use a differential evolution optimizer to find the parameters that get
the minimum or maximum population in the specified level (ii) after
solving the system of ODEsdρ(t)/dt = -i[H,ρ]+L.
Parameters:
replacements : list of tuples, each tuple contains a symbolic
variable and the numeric replacement value for that
variable
tspan : start and stop time for ODE solver
y0 : initial conditions of ODE system
level : level (ii) to minimize or maximize
parameters : list of parameters to optimize
bounds : which range to search in
max_step : maximum timestep of ODE solver
method : method of ODE solver
optimize : specify to find minimum or maximum
Returns:
solution : solution of the differential evolution optimizer
"""
eqns_rhs = self.equations.rhs.subs(replacements)
# converting the symbolic functions ρ(t) to ρ in order to create the
# matrix representing the linear equations (Ax=b)
t = Symbol('t', real = True)
for i in range(self.levels):
for j in range(i,self.levels):
tmp = Function(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j)))
tmp1 = Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+j),
chr(0x2080+i)))
eqns_rhs = eqns_rhs.subs(conjugate(tmp(t)), tmp1)
for i in range(self.levels):
for j in range(i,self.levels):
tmp = Function(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j)))
tmp1 = Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j)))
eqns_rhs = eqns_rhs.subs(tmp(t), tmp1)
syms = []
for i in range(self.levels):
for j in range(self.levels):
syms.append(Symbol(u'\u03C1{0}{1}'.format(chr(0x2080+i),
chr(0x2080+j))))
# creating the matrix A (from Ax = b) for the ODE system, has symbolic
# variables specified in parameters in matrix
matrix_eq = linear_eq_to_matrix(eqns_rhs, syms)[0]
# turning matrix into a function with variables parameters
a = lambdify(parameters, matrix_eq, 'numpy')
# Set-up ODE solver function for differential evolution
ode = lambda t, rho, param_values: a(*param_values)@rho
if optimize == "minimum":
funEvo = lambda x: solve_ivp(ode, tspan, y0, method, args = (x,),
vectorized = True, max_step = max_step) \
.y[self.levels*level + level,-1].real
elif optimize == "maximum":
funEvo = lambda x: -solve_ivp(ode, tspan, y0, method, args = (x,),
vectorized = True, max_step = max_step)\
.y[self.levels*level + level,-1].real
else:
raise ValueError('Specify optimize either as minimum or maximum.')
sol = differential_evolution(funEvo, bounds = bounds, tol = 1e-4)
return sol
def _analyse(self):
eqns = matrix(list(self.equations_dict.values()))
return sym.linear_eq_to_matrix(eqns.expand(), *self.y)
if xcounter < number_of_divisions - 1:
solution_list = []
x_high = x_range[xcounter]
x_low = x_range[xcounter + 1]
y_high = y_vars[xcounter]
y_low = y_vars[xcounter + 1]
eq0 = phi_diff_0.subs(xstart, x_high).subs(xend, x_low).subs(
ystart, y_high).subs(yend, y_low)
eq1 = phi_diff_x.subs(xstart, x_high).subs(xend, x_low).subs(
ystart, y_high).subs(yend, y_low)
solution_list.append(eq0)
solution_list.append(eq1)
var_list.append([y_high, y_low])
solution_equations.append(solution_list)
solution_matrices.append(
sym.linear_eq_to_matrix(solution_list, [y_high, y_low]))
else:
zero_boundaries.append(y_high)
equation_system = [0 for derp in range(number_of_divisions)]
# print(sym.latex(solution_matrices))
for solution_counter in range(len(solution_equations)):
for eq_counter in range(len(solution_equations[solution_counter])):
equation_system[y_vars.index(
var_list[solution_counter]
[eq_counter])] += solution_equations[solution_counter][eq_counter]
B.col_del(-1)
M = K_H - B
equations = []
for r in range(M.shape[0]):
for c in range(M.shape[1]):
equation = sp.Eq(M[r, c])
if equation not in equations and type(equation) == sp.Eq:
equations.append(equation)
solution = sp.solve(equations, low_kernel)
## coefficient matrix to find scaled up kernel
coefficient_matrix = sp.linear_eq_to_matrix(equations, high_kernel)[0]
###################################################################
####################### find downscaled avg pooling #########################
# method = 'linear'
# coarse_scale = 10
# fine_scale = 20
#
# P = get_prolongation(method, coarse_scale, fine_scale, __zero_padding=False)
# R = get_restriction(method, fine_scale // 2, coarse_scale // 2, __zero_padding=False)
#
def from_circuit(cls, cct, node_voltages=None, branch_currents=None):
"""`node_voltages` is a list of node names to use as voltage outputs.
If `None` use all the unique node names. Use `()`
if want no branch currents.
`branch_currents` is a list of component names to use as
current outputs. If `None` use all the components. Use `()`
if want no branch currents."""
if node_voltages is None:
node_voltages = cct.node_list
if branch_currents is None:
branch_currents = cct.branch_list
if node_voltages == [] and branch_currents == []:
raise ValueError('State-space: no outputs')
inductors = []
capacitors = []
independent_current_sources = []
independent_voltage_sources = []
# Determine state variables (current through inductors and
# voltage across acapacitors) and replace inductors with
# current sources and capacitors with voltage sources.
sscct = cct._new()
cpt_map = {}
for key, elt in cct.elements.items():
ssnet = elt._ss_model()
sselt = sscct._add(ssnet)
name = elt.name
cpt_map[name] = sselt.name
if elt.is_inductor:
if sselt.name in cct.elements:
raise ValueError(
'Name conflict %s, either rename the component or improve the code!'
% sselt.name)
inductors.append(elt)
elif elt.is_capacitor:
if sselt.name in cct.elements:
raise ValueError(
'Name conflict %s, either rename the component or improve the code!'
% sselt.name)
capacitors.append(elt)
elif elt.is_independent_current_source:
independent_current_sources.append(elt)
elif elt.is_independent_voltage_source:
independent_voltage_sources.append(elt)
independent_sources = independent_voltage_sources + independent_current_sources
# Build circuit graph and check if have inductor in series with
# current source.
if independent_current_sources != [] and inductors != []:
cg = CircuitGraph(cct)
for elt in independent_current_sources:
for name in cg.in_series(elt.name):
if cct[name].is_inductor:
raise ValueError(
'Cannot create state-space model since have inductor %s in series with independent current source %s'
% (name, elt.name))
cct = cct
sscct = sscct
# sscct can be analysed in the time domain since it has no
# reactive components. However, for large circuits
# this can take a long time due to inversion of the MNA matrix.
try:
# Analyse node voltages and branch currents.
sscct[0].V
except ValueError as e:
reasons = []
if len(inductors) > 0:
reasons.append(
'Check for cut set consisting only of current sources and/or inductors.'
)
if len(capacitors) > 0:
reasons.append(
'Check for a loop consisting of voltage sources and/or capacitors.'
)
raise ValueError("State-space analysis failed.\n%s\n %s" %
(e, '\n '.join(reasons)))
dotx_exprs = []
statevars = []
statenames = []
initialvalues = []
for elt in inductors + capacitors:
name = cpt_map[elt.name]
if isinstance(elt, L):
# Inductors v = L di/dt so need v across the L
expr = sscct[name].v / elt.cpt.L
var = -sscct[name].isc
x0 = elt.cpt.i0
else:
# Capacitors i = C dv/dt so need i through the C
# The current is negated since it is from a source V_Cx
expr = -sscct[name].i / elt.cpt.C
var = sscct[name].voc
x0 = elt.cpt.v0
dotx_exprs.append(expr)
statevars.append(var)
statenames.append(name)
initialvalues.append(x0)
statesyms = sympify(statenames)
# Determine independent sources.
sources = []
sourcevars = []
sourcenames = []
for elt in independent_sources:
name = cpt_map[elt.name]
if isinstance(elt, V):
expr = elt.cpt.voc
var = sscct[name].voc
else:
expr = elt.cpt.isc
var = sscct[name].isc
sources.append(expr)
sourcevars.append(var)
sourcenames.append(name)
sourcesyms = sympify(sourcenames)
# linear_eq_to_matrix expects only Symbols and not AppliedUndefs,
# so substitute.
subsdict = {}
for var, sym1 in zip(statevars, statesyms):
subsdict[var.expr] = sym1
for var, sym1 in zip(sourcevars, sourcesyms):
subsdict[var.expr] = sym1
for m, expr in enumerate(dotx_exprs):
dotx_exprs[m] = expr.subs(subsdict).expr.expand()
if dotx_exprs == []:
warn('State-space: no state variables found')
if sourcesyms == []:
warn('State-space: no independent sources found')
if dotx_exprs != []:
A, b = sym.linear_eq_to_matrix(dotx_exprs, *statesyms)
else:
A = sym.zeros(len(dotx_exprs), len(dotx_exprs))
if sourcesyms != [] and dotx_exprs != []:
B, b = sym.linear_eq_to_matrix(dotx_exprs, *sourcesyms)
else:
B = sym.zeros(len(dotx_exprs), len(sources))
# Determine output variables.
yexprs = []
y = []
for node in node_voltages:
if node == '0':
continue
yexprs.append(sscct[node].v.subs(subsdict).expand().expr)
# Note, this can introduce a name conflict
y.append(voltage('v_%s(t)' % node))
for name in branch_currents:
# Perhaps ignore L since the current through it is a
# state variable?
name2 = cpt_map[name]
yexprs.append(sscct[name2].i.subs(subsdict).expand().expr)
y.append(current('i_%s(t)' % name))
if statesyms != [] and yexprs != []:
C, b = sym.linear_eq_to_matrix(yexprs, *statesyms)
else:
C = sym.zeros(len(yexprs), len(statesyms))
if sourcesyms != [] and yexprs != []:
D, b = sym.linear_eq_to_matrix(yexprs, *sourcesyms)
else:
D = sym.zeros(len(yexprs), len(sourcesyms))
# Rewrite vCanon1(t) as vC(t) etc if appropriate.
_hack_vars(statevars)
_hack_vars(sources)
# Note, Matrix strips the class from each element...
x = TimeDomainMatrix(statevars)
x0 = Matrix(initialvalues)
u = TimeDomainMatrix(sources)
# Perhaps could use v_R1(t) etc. as the output voltages?
y = TimeDomainMatrix(y)
A = Matrix(A)
B = Matrix(B)
C = Matrix(C)
D = Matrix(D)
return StateSpace(A, B, C, D, u, y, x, x0)
# Se definen las variables
#sx, sy, sz, txy, txz, tyz = sp.symbols('sx, sy, sz, txy, txz, tyz')
sx, sy, sz = sp.symbols('sigma_x, sigma_y, sigma_z')
txy, txz, tyz = sp.symbols('tau_xy, tau_xz, tau_yz')
alpha1, alpha2, alpha3 = sp.symbols('alpha1:4')
beta1, beta2, beta3 = sp.symbols('beta1:4')
gamma1, gamma2, gamma3 = sp.symbols('gamma1:4')
# Se define la matriz de tensiones en coordenadas rectangulares sigma
sigma = sp.Matrix([[sx, txy, txz], [txy, sy, tyz], [txz, tyz, sz]])
# Se define la matriz de transformación T
T = sp.Matrix([[alpha1, alpha2, alpha3], [beta1, beta2, beta3],
[gamma1, gamma2, gamma3]])
# Se calcula la matriz de tensiones sigmaP en el sistema de coordenadas
# especificado por los vectores definidos en la matriz T
sigmaP = T.T * sigma * T
# Se extraen los términos de la matriz de tensiones sigmaP
sxp = sp.expand(sigmaP[1 - 1, 1 - 1]) # elemento 1,1 de la matriz sigmaP
syp = sp.expand(sigmaP[2 - 1, 2 - 1])
szp = sp.expand(sigmaP[3 - 1, 3 - 1])
typzp = sp.expand(sigmaP[2 - 1, 3 - 1]) # elemento 2,3 de la matriz sigmaP
txpzp = sp.expand(sigmaP[1 - 1, 3 - 1])
txpyp = sp.expand(sigmaP[1 - 1, 2 - 1])
# Se organizan las ecuaciones anteriores en una matriz
T_sigma, _ = sp.linear_eq_to_matrix([sxp, syp, szp, typzp, txpzp, txpyp],
[sx, sy, sz, tyz, txz, txy])
eqList = []
n = 0
for i in range(0, node):
for j in range(0, node):
value1 = symengine.sympify(nodeMatrix[i, j + 1])
value2 = symengine.sympify(nodeMatrix[i + 1, j])
value3 = symengine.sympify(nodeMatrix[i + 2, j + 1])
value4 = symengine.sympify(nodeMatrix[i + 1, j + 2])
equation = symengine.Eq(
value1 + value2 + value3 + value4 -
4 * symengine.sympify(nodeMatrixSymbolsList[i + j + n]), 0)
eqList.append(equation)
n += (node - 1)
symatA, symatB = sym.linear_eq_to_matrix(eqList, nodeMatrixSolving)
matA = np.array(symatA, dtype=float)
matB = np.array(symatB, dtype=float)
solution = linalg.solve(matA, matB)
"""The fifth part of the code is to replace the variables in the original matrix into the result from the solved equations."""
n = 0
for i in range(0, node):
for j in range(0, node):
nodeMatrix[i + 1, j + 1] = solution[i + j + n]
n += (node - 1)
"""The sixth part of the code is to plot the original matrix into a heatmap."""
result = np.array(nodeMatrix, dtype=float)
sns.heatmap(result[1:node + 1, 1:node + 1])
"""The seventh part of the code is to ask the user if they want to export the data to Excel."""
saveYes = str.lower(input('Save data to Excel? (y/n): '))
replacement_eq.append(eq)
# print(sym.latex(sym.Matrix(replacement_eq)))
#Conditions where the equation already solves to zero are a problem, because 0 = 0 will not evaluate
#This replaces the boundary condition and sets a specific variable to 0 so it can be solved.
boundary_eq_with_result = []
for z_index, variable in enumerate(z_vars):
if variable not in zero_vals:
boundary_eq_with_result.append(replacement_eq[z_index])
else:
boundary_eq_with_result.append(sym.Eq(variable, 0))
# print(sym.latex(sym.Matrix(boundary_eq_with_result)))
a = sym.linear_eq_to_matrix(boundary_eq_with_result, z_vars)
print(sym.latex(a))
#6. Solve the System. Sympy linsolve makes short work of that.
resultset = sym.linsolve(boundary_eq_with_result, z_vars)
# print(sym.latex(sym.Matrix(boundary_eq_with_result)))
print(sym.latex(resultset))
#7 Use the computed results to determine desired results.
#In most FEA solutions, this would be stresses or fluid flow, but in this case, it's just the Z-Values.
result_vals = [resultset.args[0][counter] for counter in range(len(z_vars))]
# print(sym.latex(sym.Matrix(result_vals)))
result_grid = num.zeros([len(XGrid_expanded), len(XGrid_expanded[0])])
#Make a meshgrid with the Z-Values in it
# varcount = 0
def __init__(self, cct, node_voltages=True, branch_currents=False):
if not node_voltages and not branch_currents:
raise ValueError('No outputs')
inductors = []
capacitors = []
independent_sources = []
# Determine state variables (current through inductors and
# voltage across acapacitors) and replace inductors with
# current sources and capacitors with voltage sources.
sscct = cct._new()
cpt_map = {}
for key, elt in cct.elements.items():
ssnet = elt.ss_model()
sselt = sscct._add(ssnet)
name = elt.name
cpt_map[name] = sselt.name
if isinstance(elt, L):
if sselt.name in cct.elements:
raise ValueError('Name conflict %s, either rename the component or iprove the code!' % sselt.name)
inductors.append(elt)
elif isinstance(elt, C):
if sselt.name in cct.elements:
raise ValueError('Name conflict %s, either rename the component or iprove the code!' % sselt.name)
capacitors.append(elt)
elif isinstance(elt, (I, V)):
independent_sources.append(elt)
self.cct = cct
self.sscct = sscct
# sscct can be analysed in the time domain since it has not
# reactive components.
dotx_exprs = []
statevars = []
statenames = []
initialvalues = []
for elt in inductors + capacitors:
name = cpt_map[elt.name]
if isinstance(elt, L):
# Inductors v = L di/dt so need v across the L
expr = sscct[name].v / elt.cpt.L
var = sscct[name].isc
x0 = elt.cpt.i0
else:
# Capacitors i = C dv/dt so need i through the C
expr = sscct[name].i / elt.cpt.C
var = sscct[name].voc
x0 = elt.cpt.v0
dotx_exprs.append(expr)
statevars.append(var)
statenames.append(name)
initialvalues.append(x0)
statesyms = sympify(statenames)
# Determine independent sources.
sources = []
sourcevars = []
sourcenames = []
for elt in independent_sources:
name = cpt_map[elt.name]
if isinstance(elt, V):
expr = elt.cpt.voc
var = sscct[name].voc
else:
expr = elt.cpt.isc
var = sscct[name].isc
sources.append(expr)
sourcevars.append(var)
sourcenames.append(name)
sourcesyms = sympify(sourcenames)
# linear_eq_to_matrix expects only Symbols and not AppliedUndefs,
# so substitute.
subsdict = {}
for var, sym1 in zip(statevars, statesyms):
subsdict[var.expr] = sym1
for var, sym1 in zip(sourcevars, sourcesyms):
subsdict[var.expr] = sym1
for m, expr in enumerate(dotx_exprs):
dotx_exprs[m] = expr.subs(subsdict).expr.expand()
A, b = sym.linear_eq_to_matrix(dotx_exprs, *statesyms)
B, b = sym.linear_eq_to_matrix(dotx_exprs, *sourcesyms)
# Determine output variables.
yexprs = []
y = []
if node_voltages:
for node in cct.node_list:
if node == '0':
continue
yexprs.append(self.sscct[node].v.subs(subsdict).expand())
y.append(Vt('vn%s(t)' % node))
if branch_currents:
for name in cct.branch_list:
# Perhaps ignore L since the current through it is a
# state variable?
name2 = cpt_map[name]
yexprs.append(self.sscct[name2].i.subs(subsdict).expand())
y.append(It('i%s(t)' % name))
Cmat, b = sym.linear_eq_to_matrix(yexprs, *statesyms)
D, b = sym.linear_eq_to_matrix(yexprs, *sourcesyms)
# Rewrite vCanon1(t) as vC(t) etc if appropriate.
_hack_vars(statevars)
_hack_vars(sources)
# Note, Matrix strips the class from each element...
self.x = tMatrix(statevars)
self.x0 = Matrix(initialvalues)
self.dotx = tMatrix([sym.Derivative(x1, t) for x1 in self.x])
self.u = tMatrix(sources)
self.A = Matrix(A)
self.B = Matrix(B)
# Perhaps could use v_R1(t) etc. as the output voltages?
self.y = Matrix(y)
self.C = Matrix(Cmat)
self.D = Matrix(D)
