We Keep Coding

Pulp obtains results as problem is infeasible, while problem is not feasible

I'm trying to solve an assignment problem with pulp. The basic part of the code is as follows:
set_I = range(1, numberOfPoints)
set_J = range(1, numberOfCentroids)
tau = 0.15
Q = 15
# decision variable
x_vars = LpVariable.dicts(name="x_vars", indexs=(set_I, set_J), lowBound=0, upBound=1, cat=LpInteger)
# model name
prob = LpProblem("MIP_Model", LpMinimize)
# constraints
for i in set_I:
prob += lpSum(x_vars[i][j] for j in set_J) == 1, ""
for j in set_J:
prob += lpSum(x_vars[i][j] for i in set_I) >= 1, ""
for j in set_J:
prob += lpSum(x_vars[i][j] for i in set_I) <= Q*(1-tau), ""
for j in set_J:
prob += lpSum(x_vars[i][j] for i in set_I) >= Q*(1+tau), ""
# objective
prob += lpSum(d[i, j]*x_vars[i][j] for i in set_I for j in set_J)
prob.solve()
The result is like this:
Problem MODEL has 31 rows, 76 columns and 304 elements
Coin0008I MODEL read with 0 errors
Problem is infeasible - 0.01 seconds
Option for printingOptions changed from normal to all
However, the problem is not infeasible and results are obtained with other solvers.
I wonder if there is a syntax error and is the problem caused by this?
I have asked a similar question in the next link:
Infeasible solution by pulp

When I run the problem locally, with d a matrix of ones, 20 points, and 3 centroids. It also becomes infeasible for me. Look at the constraints:
_C22: x_vars_10_1 + x_vars_11_1 + x_vars_12_1 + x_vars_13_1 + x_vars_14_1
+ x_vars_15_1 + x_vars_16_1 + x_vars_17_1 + x_vars_18_1 + x_vars_19_1
+ x_vars_1_1 + x_vars_2_1 + x_vars_3_1 + x_vars_4_1 + x_vars_5_1 + x_vars_6_1
+ x_vars_7_1 + x_vars_8_1 + x_vars_9_1 <= 12.75
_C23: x_vars_10_2 + x_vars_11_2 + x_vars_12_2 + x_vars_13_2 + x_vars_14_2
+ x_vars_15_2 + x_vars_16_2 + x_vars_17_2 + x_vars_18_2 + x_vars_19_2
+ x_vars_1_2 + x_vars_2_2 + x_vars_3_2 + x_vars_4_2 + x_vars_5_2 + x_vars_6_2
+ x_vars_7_2 + x_vars_8_2 + x_vars_9_2 <= 12.75
_C24: x_vars_10_1 + x_vars_11_1 + x_vars_12_1 + x_vars_13_1 + x_vars_14_1
+ x_vars_15_1 + x_vars_16_1 + x_vars_17_1 + x_vars_18_1 + x_vars_19_1
+ x_vars_1_1 + x_vars_2_1 + x_vars_3_1 + x_vars_4_1 + x_vars_5_1 + x_vars_6_1
+ x_vars_7_1 + x_vars_8_1 + x_vars_9_1 >= 17.25
_C25: x_vars_10_2 + x_vars_11_2 + x_vars_12_2 + x_vars_13_2 + x_vars_14_2
+ x_vars_15_2 + x_vars_16_2 + x_vars_17_2 + x_vars_18_2 + x_vars_19_2
+ x_vars_1_2 + x_vars_2_2 + x_vars_3_2 + x_vars_4_2 + x_vars_5_2 + x_vars_6_2
+ x_vars_7_2 + x_vars_8_2 + x_vars_9_2 >= 17.25
You require
x_vars_10_2 + x_vars_11_2 + x_vars_12_2 + x_vars_13_2 + x_vars_14_2
+ x_vars_15_2 + x_vars_16_2 + x_vars_17_2 + x_vars_18_2 + x_vars_19_2
+ x_vars_1_2 + x_vars_2_2 + x_vars_3_2 + x_vars_4_2 + x_vars_5_2 + x_vars_6_2
+ x_vars_7_2 + x_vars_8_2 + x_vars_9_2
to be greater than 17.25 and smaller than 12.75 at the same time. That's not possible, of course.

argument must be a string or a number, not 'LpAffineExpression'

I am trying to use python IRR function with PULP maximisation but i am getting the following error
TypeError: float() argument must be a string or a number, not 'LpAffineExpression'
TypeError Traceback (most recent call last)
in
11 name[6]*rate[6]*ratesList2[2] + name[7]*rate[7]*ratesList2[2] + name[8]*rate[8]*ratesList2[2] + name[9]*rate[9]*ratesList2[2] + name[10]*rate[10]*ratesList2[2] + name[11]*rate[11]*ratesList2[2] +
12 name[12]*rate[12]*ratesList2[2] + name[13]*rate[13]*ratesList2[2] + name[14]*rate[14]*ratesList2[2] + name[15]*rate[15]*ratesList2[2] + name[16]*rate[16]*ratesList2[2] + name[17]*rate[17]*ratesList2[2] +
---> 13 name[18]*rate[18]*ratesList2[2])])
14
15
problem += np.irr([(-19660528.00),
(name[0]*rate[0] + name[1]*rate[1] + name[2]*rate[2] + name[3]*rate[3] + name[4]*rate[4] + name[5]*rate[5] +
name[6]*rate[6] + name[7]*rate[7] + name[8]*rate[8] + name[9]*rate[9] + name[10]*rate[10] + name[11]*rate[11] +
name[12]*rate[12] + name[13]*rate[13] + name[14]*rate[14] + name[15]*rate[15] + name[16]*rate[16] + name[17]*rate[17] +
name[18]*rate[18]),
(name[0]*rate[0]*ratesList1[1] + name[1]*rate[1]*ratesList2[1] + name[2]*rate[2]*ratesList2[1] + name[3]*rate[3]*ratesList2[1] + name[4]*rate[4]*ratesList2[1] + name[5]*rate[5]*ratesList2[1] +
name[6]*rate[6]*ratesList2[1] + name[7]*rate[7]*ratesList2[1] + name[8]*rate[8]*ratesList2[1] + name[9]*rate[9]*ratesList2[1] + name[10]*rate[10]*ratesList2[1] + name[11]*rate[11]*ratesList2[1] +
name[12]*rate[12]*ratesList2[1] + name[13]*rate[13]*ratesList2[1] + name[14]*rate[14]*ratesList2[1] + name[15]*rate[15]*ratesList2[1] + name[16]*rate[16]*ratesList2[1] + name[17]*rate[17]*ratesList2[1] +
name[18]*rate[18]*ratesList2[1]),
(name[0]*rate[0]*ratesList1[2] + name[1]*rate[1]*ratesList2[2] + name[2]*rate[2]*ratesList2[2] + name[3]*rate[3]*ratesList2[2] + name[4]*rate[4]*ratesList2[2] + name[5]*rate[5]*ratesList2[2] +
name[6]*rate[6]*ratesList2[2] + name[7]*rate[7]*ratesList2[2] + name[8]*rate[8]*ratesList2[2] + name[9]*rate[9]*ratesList2[2] + name[10]*rate[10]*ratesList2[2] + name[11]*rate[11]*ratesList2[2] +
name[12]*rate[12]*ratesList2[2] + name[13]*rate[13]*ratesList2[2] + name[14]*rate[14]*ratesList2[2] + name[15]*rate[15]*ratesList2[2] + name[16]*rate[16]*ratesList2[2] + name[17]*rate[17]*ratesList2[2] +
name[18]*rate[18]*ratesList2[2])])
problem += (name[0] + name[1] + name[2] + name[3] + name[4] + name[5] + name[6] + name[7] + name[8] + name[9] + name[10] +
name[11] + name[12] + name[13] + name[14] + name[15] + name[16] + name[17] + name[18]) <= sum(marketMix['GLA']), "1st constraint"

The numpy function irr() takes as argument a list of values. You are instead passing a list of linear expressions containing variables that are subject to optimization. irr() is not prepared to handle that. It assumes that all arguments can be coerced into a float. Instead of using function irr() you will have to state the respective expression explicitly.

Expand parent prefix number to a given child number

I have a parent prefix number and a child number that begins with the same prefix. I want to expand the parent number up to the target child number
in a way that all prefixes be included and show the target, for example.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
+ Example #1 + Example #2 + Example #3 +
+ parent=123, target=1235 + parent=123, target=12354 + parent=123, target=123073 +
+ + + +
+ Expansion would be: + Expansion would be: + Expansion would be: +
+ + + +
+ 123-0 + 123-0 + 123-0-0 +
+ 123-1 + 123-1 + 123-0-1 +
+ 123-2 + 123-2 + 123-0-2 +
+ 123-4 + 123-4 + 123-0-3 +
+ 123-5 --> target + 123-5-0 + 123-0-4 +
+ 123-6 + 123-5-1 + 123-0-5 +
+ 123-7 + 123-5-2 + 123-0-6 +
+ 123-8 + 123-5-4 --> target + 123-0-7-0 +
+ 123-9 + 123-5-5 + 123-0-7-1 +
+ + 123-5-6 + 123-0-7-2 +
+ + 123-5-7 + 123-0-7-3 --> target +
+ + 123-5-8 + 123-0-7-4 +
+ + 123-5-9 + 123-0-7-5 +
+ + 123-6 + 123-0-7-6 +
+ + 123-7 + 123-0-7-7 +
+ + 123-8 + 123-0-7-8 +
+ + 123-9 + 123-0-7-9 +
+ + + 123-0-8 +
+ + + 123-0-9 +
+ + + 123-1 +
+ + + 123-2 +
+ + + 123-3 +
+ + + 123-4 +
+ + + 123-5 +
+ + + 123-6 +
+ + + 123-7 +
+ + + 123-8 +
+ + + 123-9 +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Like you see,
In example #1, target is 4 digit length and only one level expansion
was needed
In example #2, target is 5 digit length and two level
expansion was needed
In example #3, target is 6 digit length and three level expansion
was needed
In my current code shown below, I'm only able to print one level expansion and only for one target. I'm stuck in how to expand the parent number when target length is greater in 2 or more digits compared with length of parent and if input targets are more than one. Help would be appreciated.
parent="1312314"
child="13123147674"
l = len(parent)
target=child[l:]
t=int(target[0])
for k in range(t):
print(parent + str(k))
print(parent + str(t) + " --> target")
for k in range(t+1,10):
print(parent + str(k))
Current output:
13123140
13123141
13123142
13123143
13123144
13123145
13123146
13123147 --> target
13123148
13123149
Update
Example #4
parent=12345, target1=1234538, target2=1234570924, target3=123459
Expansion would be:
123450
123451
123452
1234530
1234531
1234532
1234533
1234534
1234535
1234536
1234537
1234538 --> target
1234539
123454
123455
123456
12345700
12345701
12345702
12345703
12345704
12345705
12345706
12345707
12345708
123457090
123457091
1234570920
1234570921
1234570922
1234570923
1234570924 --> target
1234570925
1234570926
1234570927
1234570928
1234570929
123457093
123457094
123457095
123457096
123457097
123457098
123457099
1234571
1234572
1234573
1234574
1234575
1234576
1234577
1234578
1234579
123458
123459 --> target

you can try this. the trick is result.sort()
parent="123"
child= "12354"
p = len(parent)
c = len(child)
result = []
for i in range(p, c):
for x in range(0, 10):
y = child[0:i] + str(x)
result.append(y)
result.sort()
for a in result:
print (a + ("--> target" if a == child else ""))
Result:
1230
1231
1232
1233
1234
1235
12350
12351
12352
12353
12354--> target
12355
12356
12357
12358
12359
1236
1237
1238
1239
for multiple targets:
parent="12345"
target1="1234538"
target2="1234570924"
target3="123459"
targets = [target1, target2, target3]
result = []
for target in targets:
for i in range(len(parent), len(target)):
for x in range(0, 10):
y = target[0:i] + str(x)
result.append(y)
result = list(set(result))
result.sort()
for a in result:
print (a + ("--> target" if a in targets else ""))

u can do as below:
parent='123'
child='123073'
if len(child)> len(parent):
tuple_list =[]
nums_to_append=child[len(parent):]
l = len(nums_to_append)
for i,num in enumerate(nums_to_append):
for j in range(10):
if num == str(j):
tuple_list.append((parent,j+1))
parent = parent+num
if i==(l-1):
print(parent, "--> target")
break
else:
print(parent+str(j))
for parent,num in tuple_list[::-1]:
for j in range(num,10):
print(parent+str(j))
12300
12301
12302
12303
12304
12305
12306
123070
123071
123072
123073 --> target
123074
123075
123076
123077
123078
123079
12308
12309
1231
1232
1233
1234
1235
1236
1237
1238
1239

Generate a Bode-form transfer function using ratsimp

I have to simplify a transfer function using sympy. I am used to maxima and I am looking for advice to get similar performances in a python environment.
Using the following Maxima code:
A:-Avol0/(1+s/(2*pi*fp));
Zph:Rsh/(1+Rsh*Cj*s);
Zf:Rf/(1+Rf*Cf*s);
alpha:Zf*Zph/(Zf+Zph);
beta:Zph/(Zf+Zph);
BetaA:ratsimp(beta*A,s);
H:ratsimp(alpha*A/(1-BetaA),s);
I get the following:
(H)-> -(2*Avol0*Rf*Rsh*fp*pi)/((Cj+Cf)*Rf*Rsh*s^2+((2*Cj+(2*Avol0+2)*Cf)*Rf*Rsh*fp*pi+Rsh+Rf)*s+((2*Avol0+2)*Rsh+2*Rf)*fp*pi)
The same opertions in sympy do not get to such a nice result:
import numpy as np
import sympy as sy
"""
Formulas
"""
s, Rf, Cf, Rsh, Cj, Cd, Ccm, GBP, Avol0, fp, w = \
sy.symbols("s Rf Cf Rsh Cj Cd Ccm GBP Avol0 fp w")
A = -Avol0/(1+s/(2*np.pi*fp))
Zph = Rsh/(1+Rsh*Cj*s)
Zf = Rf/(1+Rf*Cf*s)
alpha = Zf*Zph/(Zf+Zph)
beta = Zph/(Zf+Zph)
Gloop = sy.ratsimp(beta*A)
H = alpha*A/(1-Gloop)
sy.ratsimp(H)
returns an unreadable result:
-1.0*(1.0*Avol0*Cf**2*Cj*Rf**3*Rsh**3*fp**2*s**3 + 0.159154943091895*Avol0*Cf**2*Cj*Rf**3*Rsh**3*fp*s**4 + 1.0*Avol0*Cf**2*Rf**3*Rsh**2*fp**2*s**2 + 0.159154943091895*Avol0*Cf**2*Rf**3*Rsh**2*fp*s**3 + 1.0*Avol0*Cf*Cj**2*Rf**3*Rsh**3*fp**2*s**3 + 0.159154943091895*Avol0*Cf*Cj**2*Rf**3*Rsh**3*fp*s**4 + 2.0*Avol0*Cf*Cj*Rf**3*Rsh**2*fp**2*s**2 + 0.318309886183791*Avol0*Cf*Cj*Rf**3*Rsh**2*fp*s**3 + 2.0*Avol0*Cf*Cj*Rf**2*Rsh**3*fp**2*s**2 + 0.318309886183791*Avol0*Cf*Cj*Rf**2*Rsh**3*fp*s**3 + 1.0*Avol0*Cf*Rf**3*Rsh*fp**2*s + 0.159154943091895*Avol0*Cf*Rf**3*Rsh*fp*s**2 + 2.0*Avol0*Cf*Rf**2*Rsh**2*fp**2*s + 0.318309886183791*Avol0*Cf*Rf**2*Rsh**2*fp*s**2 + 1.0*Avol0*Cj**2*Rf**2*Rsh**3*fp**2*s**2 + 0.159154943091895*Avol0*Cj**2*Rf**2*Rsh**3*fp*s**3 + 2.0*Avol0*Cj*Rf**2*Rsh**2*fp**2*s + 0.318309886183791*Avol0*Cj*Rf**2*Rsh**2*fp*s**2 + 1.0*Avol0*Cj*Rf*Rsh**3*fp**2*s + 0.159154943091895*Avol0*Cj*Rf*Rsh**3*fp*s**2 + 1.0*Avol0*Rf**2*Rsh*fp**2 + 0.159154943091895*Avol0*Rf**2*Rsh*fp*s + 1.0*Avol0*Rf*Rsh**2*fp**2 + 0.159154943091895*Avol0*Rf*Rsh**2*fp*s)/(1.0*Avol0*Cf**3*Cj*Rf**3*Rsh**3*fp**2*s**4 + 0.159154943091895*Avol0*Cf**3*Cj*Rf**3*Rsh**3*fp*s**5 + 1.0*Avol0*Cf**3*Rf**3*Rsh**2*fp**2*s**3 + 0.159154943091895*Avol0*Cf**3*Rf**3*Rsh**2*fp*s**4 + 1.0*Avol0*Cf**2*Cj**2*Rf**3*Rsh**3*fp**2*s**4 + 0.159154943091895*Avol0*Cf**2*Cj**2*Rf**3*Rsh**3*fp*s**5 + 2.0*Avol0*Cf**2*Cj*Rf**3*Rsh**2*fp**2*s**3 + 0.318309886183791*Avol0*Cf**2*Cj*Rf**3*Rsh**2*fp*s**4 + 3.0*Avol0*Cf**2*Cj*Rf**2*Rsh**3*fp**2*s**3 + 0.477464829275686*Avol0*Cf**2*Cj*Rf**2*Rsh**3*fp*s**4 + 1.0*Avol0*Cf**2*Rf**3*Rsh*fp**2*s**2 + 0.159154943091895*Avol0*Cf**2*Rf**3*Rsh*fp*s**3 + 3.0*Avol0*Cf**2*Rf**2*Rsh**2*fp**2*s**2 + 0.477464829275686*Avol0*Cf**2*Rf**2*Rsh**2*fp*s**3 + 2.0*Avol0*Cf*Cj**2*Rf**2*Rsh**3*fp**2*s**3 + 0.318309886183791*Avol0*Cf*Cj**2*Rf**2*Rsh**3*fp*s**4 + 4.0*Avol0*Cf*Cj*Rf**2*Rsh**2*fp**2*s**2 + 0.636619772367581*Avol0*Cf*Cj*Rf**2*Rsh**2*fp*s**3 + 3.0*Avol0*Cf*Cj*Rf*Rsh**3*fp**2*s**2 + 0.477464829275686*Avol0*Cf*Cj*Rf*Rsh**3*fp*s**3 + 2.0*Avol0*Cf*Rf**2*Rsh*fp**2*s + 0.318309886183791*Avol0*Cf*Rf**2*Rsh*fp*s**2 + 3.0*Avol0*Cf*Rf*Rsh**2*fp**2*s + 0.477464829275686*Avol0*Cf*Rf*Rsh**2*fp*s**2 + 1.0*Avol0*Cj**2*Rf*Rsh**3*fp**2*s**2 + 0.159154943091895*Avol0*Cj**2*Rf*Rsh**3*fp*s**3 + 2.0*Avol0*Cj*Rf*Rsh**2*fp**2*s + 0.318309886183791*Avol0*Cj*Rf*Rsh**2*fp*s**2 + 1.0*Avol0*Cj*Rsh**3*fp**2*s + 0.159154943091895*Avol0*Cj*Rsh**3*fp*s**2 + 1.0*Avol0*Rf*Rsh*fp**2 + 0.159154943091895*Avol0*Rf*Rsh*fp*s + 1.0*Avol0*Rsh**2*fp**2 + 0.159154943091895*Avol0*Rsh**2*fp*s + 1.0*Cf**3*Cj*Rf**3*Rsh**3*fp**2*s**4 + 0.318309886183791*Cf**3*Cj*Rf**3*Rsh**3*fp*s**5 + 0.0253302959105844*Cf**3*Cj*Rf**3*Rsh**3*s**6 + 1.0*Cf**3*Rf**3*Rsh**2*fp**2*s**3 + 0.318309886183791*Cf**3*Rf**3*Rsh**2*fp*s**4 + 0.0253302959105844*Cf**3*Rf**3*Rsh**2*s**5 + 2.0*Cf**2*Cj**2*Rf**3*Rsh**3*fp**2*s**4 + 0.636619772367581*Cf**2*Cj**2*Rf**3*Rsh**3*fp*s**5 + 0.0506605918211689*Cf**2*Cj**2*Rf**3*Rsh**3*s**6 + 4.0*Cf**2*Cj*Rf**3*Rsh**2*fp**2*s**3 + 1.27323954473516*Cf**2*Cj*Rf**3*Rsh**2*fp*s**4 + 0.101321183642338*Cf**2*Cj*Rf**3*Rsh**2*s**5 + 3.0*Cf**2*Cj*Rf**2*Rsh**3*fp**2*s**3 + 0.954929658551372*Cf**2*Cj*Rf**2*Rsh**3*fp*s**4 + 0.0759908877317533*Cf**2*Cj*Rf**2*Rsh**3*s**5 + 2.0*Cf**2*Rf**3*Rsh*fp**2*s**2 + 0.636619772367581*Cf**2*Rf**3*Rsh*fp*s**3 + 0.0506605918211689*Cf**2*Rf**3*Rsh*s**4 + 3.0*Cf**2*Rf**2*Rsh**2*fp**2*s**2 + 0.954929658551372*Cf**2*Rf**2*Rsh**2*fp*s**3 + 0.0759908877317533*Cf**2*Rf**2*Rsh**2*s**4 + 1.0*Cf*Cj**3*Rf**3*Rsh**3*fp**2*s**4 + 0.318309886183791*Cf*Cj**3*Rf**3*Rsh**3*fp*s**5 + 0.0253302959105844*Cf*Cj**3*Rf**3*Rsh**3*s**6 + 3.0*Cf*Cj**2*Rf**3*Rsh**2*fp**2*s**3 + 0.954929658551372*Cf*Cj**2*Rf**3*Rsh**2*fp*s**4 + 0.0759908877317533*Cf*Cj**2*Rf**3*Rsh**2*s**5 + 4.0*Cf*Cj**2*Rf**2*Rsh**3*fp**2*s**3 + 1.27323954473516*Cf*Cj**2*Rf**2*Rsh**3*fp*s**4 + 0.101321183642338*Cf*Cj**2*Rf**2*Rsh**3*s**5 + 3.0*Cf*Cj*Rf**3*Rsh*fp**2*s**2 + 0.954929658551372*Cf*Cj*Rf**3*Rsh*fp*s**3 + 0.0759908877317533*Cf*Cj*Rf**3*Rsh*s**4 + 8.0*Cf*Cj*Rf**2*Rsh**2*fp**2*s**2 + 2.54647908947033*Cf*Cj*Rf**2*Rsh**2*fp*s**3 + 0.202642367284676*Cf*Cj*Rf**2*Rsh**2*s**4 + 3.0*Cf*Cj*Rf*Rsh**3*fp**2*s**2 + 0.954929658551372*Cf*Cj*Rf*Rsh**3*fp*s**3 + 0.0759908877317533*Cf*Cj*Rf*Rsh**3*s**4 + 1.0*Cf*Rf**3*fp**2*s + 0.318309886183791*Cf*Rf**3*fp*s**2 + 0.0253302959105844*Cf*Rf**3*s**3 + 4.0*Cf*Rf**2*Rsh*fp**2*s + 1.27323954473516*Cf*Rf**2*Rsh*fp*s**2 + 0.101321183642338*Cf*Rf**2*Rsh*s**3 + 3.0*Cf*Rf*Rsh**2*fp**2*s + 0.954929658551372*Cf*Rf*Rsh**2*fp*s**2 + 0.0759908877317533*Cf*Rf*Rsh**2*s**3 + 1.0*Cj**3*Rf**2*Rsh**3*fp**2*s**3 + 0.318309886183791*Cj**3*Rf**2*Rsh**3*fp*s**4 + 0.0253302959105844*Cj**3*Rf**2*Rsh**3*s**5 + 3.0*Cj**2*Rf**2*Rsh**2*fp**2*s**2 + 0.954929658551372*Cj**2*Rf**2*Rsh**2*fp*s**3 + 0.0759908877317533*Cj**2*Rf**2*Rsh**2*s**4 + 2.0*Cj**2*Rf*Rsh**3*fp**2*s**2 + 0.636619772367581*Cj**2*Rf*Rsh**3*fp*s**3 + 0.0506605918211689*Cj**2*Rf*Rsh**3*s**4 + 3.0*Cj*Rf**2*Rsh*fp**2*s + 0.954929658551372*Cj*Rf**2*Rsh*fp*s**2 + 0.0759908877317533*Cj*Rf**2*Rsh*s**3 + 4.0*Cj*Rf*Rsh**2*fp**2*s + 1.27323954473516*Cj*Rf*Rsh**2*fp*s**2 + 0.101321183642338*Cj*Rf*Rsh**2*s**3 + 1.0*Cj*Rsh**3*fp**2*s + 0.318309886183791*Cj*Rsh**3*fp*s**2 + 0.0253302959105844*Cj*Rsh**3*s**3 + 1.0*Rf**2*fp**2 + 0.318309886183791*Rf**2*fp*s + 0.0253302959105844*Rf**2*s**2 + 2.0*Rf*Rsh*fp**2 + 0.636619772367581*Rf*Rsh*fp*s + 0.0506605918211689*Rf*Rsh*s**2 + 1.0*Rsh**2*fp**2 + 0.318309886183791*Rsh**2*fp*s + 0.0253302959105844*Rsh**2*s**2)

There is a difference between the maxima code and the python one: const 'pi' is kept symbolic in the first case, and approximated to a floating-point value in the second. Replacing np.pi with pi solves the problem, anyway it is weird how sympy tries to simplify the expression when pi is numeric.

"out of memory" issue with PETsc in Ubuntu

I am running an OpenMDAO code that uses 2 parallel groups. I have installed PETSc4py and mpi4py inside a virtual python environment. I am getting the following error while running my code. The error reads as follows: "Out of memory. Allocated: 0, Used by process: 236814336"
Here is the full error message:
File "PETSc/Scatter.pyx", line 42, in petsc4py.PETSc.Scatter.create
petsc4py.PETSc.Error: error code 55
[1] VecScatterCreate() line 282 in /tmp/pycharm-packaging/petsc/src/vec/vscat/interface/vscreate.c
[1] VecScatterSetUp() line 211 in /tmp/pycharm-packaging/petsc/src/vec/vscat/interface/vscatfce.c
[1] VecScatterSetUp_MPI1() line 2543 in /tmp/pycharm-packaging/petsc/src/vec/vscat/impls/mpi1/vpscat_mpi1.c
[1] VecScatterSetUp_vectype_private() line 865 in /tmp/pycharm-packaging/petsc/src/vec/vscat/impls/vscat.c
[1] VecScatterCreate_PtoP() line 746 in /tmp/pycharm-packaging/petsc/src/vec/vscat/impls/vscat.c
[1] VecScatterCreateLocal_PtoP_MPI1() line 2436 in /tmp/pycharm-packaging/petsc/src/vec/vscat/impls/mpi1/vpscat_mpi1.c
[1] PetscMallocA() line 390 in /tmp/pycharm-packaging/petsc/src/sys/memory/mal.c
[1] VecScatterCreateLocal_PtoP_MPI1() line 2436 in /tmp/pycharm-packaging/petsc/src/vec/vscat/impls/mpi1/vpscat_mpi1.c
[1] Out of memory. Allocated: 0, Used by process: 237649920
[1] Memory requested 18446744062962991104
-------------------------------------------------------
Primary job terminated normally, but 1 process returned
a non-zero exit code.. Per user-direction, the job has been aborted.
-------------------------------------------------------
--------------------------------------------------------------------------
mpirun detected that one or more processes exited with non-zero status, thus causing
the job to be terminated. The first process to do so was:
Process name: [[43240,1],1]
Exit code: 1
--------------------------------------------------------------------------
I call the process with the following code:
mpirun -np 2 python ./parallel_processing.py
Here is the code for IDF optimization:
from __future__ import print_function
import pickle
import numpy as np
import pandas as pd
import matplotlib.pylab as plt
from openmdao.api import Problem, ScipyOptimizeDriver, SqliteRecorder
import time
import random
from openmdao.recorders.case_reader import CaseReader
from ssbj_vanaret_mda import SsbjMda
from ssbj_vanaret_idf2_mda import SsbjIdf2Mda
def idf_run2(nx, ny):
# make a counter for discipline calls
[str_count, aer_count, pro_count] = np.zeros(3)
a = ["str_count.p", "aer_count.p", "pro_count.p"]
for i in a:
with open(i, "wb") as f:
pickle.dump(0, f)
# Initialize an MDA to generate the starting point for IDF
prob_init = Problem() # initialize the optimization problem
prob_init.model = SsbjMda(nx_input=nx) # create the MDA
# Design variables
prob_init.model.add_design_var('z', lower=np.zeros(nx), upper=np.ones(nx))
prob_init.model.add_design_var('x1', lower=np.zeros(nx), upper=np.ones(nx))
prob_init.model.add_design_var('x2', lower=np.zeros(nx), upper=np.ones(nx))
prob_init.model.add_design_var('x3', lower=np.zeros(nx), upper=np.ones(nx))
# Objective function
prob_init.model.add_objective('range')
# Constraints
for i in range(nx):
prob_init.model.add_constraint('con_g1' + str(i + 1), upper=0)
prob_init.model.add_constraint('con_g2' + str(i + 1), upper=0)
prob_init.model.add_constraint('con_g3' + str(i + 1), upper=0)
prob_init.driver = ScipyOptimizeDriver(optimizer='SLSQP')
prob_init.driver.options['maxiter'] = 0
prob_init.setup(mode='fwd')
prob_init.set_solver_print(1)
prob_init.run_driver()
prob_init.cleanup()
y12_initial = prob_init['y12']
y23_initial = prob_init['y23']
y32_initial = prob_init['y32']
y21_initial = prob_init['y21']
y31_initial = prob_init['y31']
# : initialize MDA for IDF
prob = Problem()
prob.model = SsbjIdf2Mda(nx, ny, y12_initial, y23_initial, y32_initial, y21_initial, y31_initial)
# create the MDA
# Design variables
prob.model.add_design_var('z', lower=np.zeros(nx), upper=np.ones(nx)) # shared variables
prob.model.add_design_var('x1', lower=np.zeros(nx), upper=np.ones(nx)) # local variable for structural discipline
prob.model.add_design_var('x2', lower=np.zeros(nx), upper=np.ones(nx)) # local variable for aerodynamic discipline
prob.model.add_design_var('x3', lower=np.zeros(nx), upper=np.ones(nx)) # local variable for propulsion discipline
# # coupling variables
prob.model.add_design_var('y31')
prob.model.add_design_var('y12')
prob.model.add_design_var('y32')
prob.model.add_design_var('y23')
prob.model.add_design_var('y21')
# Objective function
prob.model.add_objective('obj')
# Constraints
for i in range(nx):
prob.model.add_constraint('con_g1' + str(i + 1), upper=0)
prob.model.add_constraint('con_g2' + str(i + 1), upper=0)
prob.model.add_constraint('con_g3' + str(i + 1), upper=0)
epsilon = 1e-9
# Coupling constraints
for i in range(ny):
prob.model.add_constraint('con_y12' + str(i + 1), upper=epsilon)
prob.model.add_constraint('con_y21' + str(i + 1), upper=epsilon)
prob.model.add_constraint('con_y23' + str(i + 1), upper=epsilon)
prob.model.add_constraint('con_y32' + str(i + 1), upper=epsilon)
prob.model.add_constraint('con_y31' + str(i + 1), upper=epsilon)
# Optimizer options
prob.driver = ScipyOptimizeDriver()
prob.set_solver_print(2)
prob.driver.options['optimizer'] = 'SLSQP'
for tol in [1e-3]:
prob.driver.options['maxiter'] = random.randint(40, 50)
prob.driver.options['tol'] = tol
prob.driver.add_recorder(SqliteRecorder("cases_idf.sql"))
# Run optimization
start_time = time.time()
prob.setup(mode='fwd')
# view_model(prob, outfile='n2_mdfgs.html', show_browser=True)
prob.run_driver()
prob.run_model()
# prob.check_partials()
prob.cleanup()
end_time = time.time()
total_time = end_time - start_time
if prob.driver.options['tol'] == 1e-6:
iters = len(CaseReader('cases_idf.sql').get_cases())
cr = CaseReader('cases_idf.sql')
case_ids = cr.get_cases()
obj_list = ['obj']
z = []
[z.append(case.get_objectives(case)[obj_list[0]]) for case in case_ids]
with open("df_idf.p", "rb") as f:
df_idf = pickle.load(f).append(pd.DataFrame({'total iterations[IDF]': [iters],
'total time[IDF]': [total_time],
'final_objective[IDF]': z[-1]}))
with open("df_idf.p", "wb") as f:
pickle.dump(df_idf, f)
elif prob.driver.options['tol'] == 1e-3:
iters = len(CaseReader('cases_idf.sql').get_cases())
cr = CaseReader('cases_idf.sql')
case_ids = cr.get_cases()
obj_list = ['obj']
z = []
a = ["str_count.p", "aer_count.p", "pro_count.p"]
k = []
for i in a:
with open(i, "rb") as f:
k.append(pickle.load(f))
[z.append(case.get_objectives(case)[obj_list[0]]) for case in case_ids]
with open("df_idf_tol.p", "rb") as f:
df_idf = pickle.load(f).append(pd.DataFrame({'10.total iterations[IDF_tol]': [iters],
'11.total time[IDF_tol]': [total_time],
'12.final_objective[IDF_tol]': z[-1],
'13.str_count[IDF_tol]': k[0],
'14.aer_count[IDF_tol]': k[1],
'15.pro_count[IDF_tol]': k[2]
}))
with open("df_idf_tol.p", "wb") as f:
pickle.dump(df_idf, f)
The MDA for IDF optimization goes here:
from openmdao.api import Group
import numpy as np
from openmdao.api import IndepVarComp, ExecComp, ParallelGroup
from ssbj_vanaret_discipline import StructureDisc
from ssbj_vanaret_discipline import AerodynamicsDisc
from ssbj_vanaret_discipline import PropulsionDisc
from ssbj_vanaret_discipline import PerformanceDisc
class SsbjIdf2Mda(Group):
"""
Analysis for IDF formulation where couplings are managed as additional constraints
on input/output variables of related disciplines.
"""
def __init__(self, nx_input, ny_input, y12_initial, y23_initial, y32_initial, y21_initial, y31_initial):
super(SsbjIdf2Mda, self).__init__()
self.nx = nx_input
self.ny = ny_input
self.y12 = y12_initial
self.y23 = y23_initial
self.y32 = y32_initial
self.y31 = y31_initial
self.y21 = y21_initial
def setup(self):
# Design variables
self.add_subsystem('z_ini', IndepVarComp('z', .5 * np.ones(self.nx)), promotes=['*'])
self.add_subsystem('x1_ini', IndepVarComp('x1', .5 * np.ones(self.nx)), promotes=['*'])
self.add_subsystem('x2_ini', IndepVarComp('x2', .5 * np.ones(self.nx)), promotes=['*'])
self.add_subsystem('x3_ini', IndepVarComp('x3', .5 * np.ones(self.nx)), promotes=['*'])
# Couplings
self.add_subsystem('y31_ini', IndepVarComp('y31', self.y31), promotes=['*'])
self.add_subsystem('y12_ini', IndepVarComp('y12', self.y12), promotes=['*'])
self.add_subsystem('y32_ini', IndepVarComp('y32', self.y32), promotes=['*'])
self.add_subsystem('y23_ini', IndepVarComp('y23', self.y23), promotes=['*'])
self.add_subsystem('y21_ini', IndepVarComp('y21', self.y21), promotes=['*'])
# Disciplines
parallel = self.add_subsystem('parallel', ParallelGroup())
parallel.add_subsystem('Structure', StructureDisc())
parallel.add_subsystem('Aerodynamics', AerodynamicsDisc())
self.add_subsystem('Propulsion', PropulsionDisc())
self.add_subsystem('Performance', PerformanceDisc())
# Shared variables z
self.connect('z', 'parallel.Structure.z')
self.connect('z', 'parallel.Aerodynamics.z')
self.connect('z', 'Propulsion.z')
self.connect('z', 'Performance.z')
# Local variables
self.connect('x1', 'parallel.Structure.x1')
self.connect('x2', 'parallel.Aerodynamics.x2')
self.connect('x3', 'Propulsion.x3')
self.connect('x1', 'Performance.x1')
self.connect('x2', 'Performance.x2')
self.connect('x3', 'Performance.x3')
# Coupling variables
self.connect('y21', 'parallel.Structure.y21')
self.connect('y31', 'parallel.Structure.y31')
self.connect('y32', 'parallel.Aerodynamics.y32')
self.connect('y12', 'parallel.Aerodynamics.y12')
self.connect('y23', 'Propulsion.y23')
# Objective function
self.add_subsystem('Obj', ExecComp('obj=range'), promotes=['obj'])
# Connections
self.connect('Performance.range', 'Obj.range')
# self.connect('Propulsion.y34', 'Performance.y34')
# self.connect('Aerodynamics.y24', 'Performance.y24')
# self.connect('Structure.y14', 'Performance.y14')
self.connect('parallel.Aerodynamics.y21', 'Performance.y21')
self.connect('Propulsion.y31', 'Performance.y31')
self.connect('Propulsion.y32', 'Performance.y32')
self.connect('parallel.Structure.y12', 'Performance.y12')
self.connect('parallel.Aerodynamics.y23', 'Performance.y23')
# Coupling constraints
for i in range(self.ny):
self.add_subsystem('con_Y12' + str(i + 1),
ExecComp('con_y12' + str(i + 1) + '=(y12[' + str(i) + '] - y12k[' + str(i) + ']) ** 2',
y12=self.y12,
y12k=self.y12
),
promotes=['con_y12' + str(i + 1)])
self.connect('parallel.Structure.y12', 'con_Y12' + str(i + 1) + '.y12')
self.connect('y12', 'con_Y12' + str(i + 1) + '.y12k')
for i in range(self.ny):
self.add_subsystem('con_Y21' + str(i + 1),
ExecComp('con_y21' + str(i + 1) + '=(y21[' + str(i) + '] - y21k[' + str(i) + ']) ** 2',
y21=self.y21,
y21k=self.y21
),
promotes=['con_y21' + str(i + 1)])
self.connect('parallel.Aerodynamics.y21', 'con_Y21' + str(i + 1) + '.y21')
self.connect('y21', 'con_Y21' + str(i + 1) + '.y21k')
for i in range(self.ny):
self.add_subsystem('con_Y32' + str(i + 1),
ExecComp('con_y32' + str(i + 1) + '=(y32[' + str(i) + '] - y32k[' + str(i) + ']) ** 2',
y32=self.y32,
y32k=self.y32
),
promotes=['con_y32' + str(i + 1)])
self.connect('Propulsion.y32', 'con_Y32' + str(i + 1) + '.y32')
self.connect('y32', 'con_Y32' + str(i + 1) + '.y32k')
for i in range(self.ny):
self.add_subsystem('con_Y23' + str(i + 1),
ExecComp('con_y23' + str(i + 1) + '=(y23[' + str(i) + '] - y23k[' + str(i) + ']) ** 2',
y23=self.y23,
y23k=self.y23
),
promotes=['con_y23' + str(i + 1)])
self.connect('parallel.Aerodynamics.y23', 'con_Y23' + str(i + 1) + '.y23')
self.connect('y23', 'con_Y23' + str(i + 1) + '.y23k')
for i in range(self.ny):
self.add_subsystem('con_Y31' + str(i + 1),
ExecComp('con_y31' + str(i + 1) + '=(y31[' + str(i) + '] - y31k[' + str(i) + ']) ** 2',
y31=self.y31,
y31k=self.y31
),
promotes=['con_y31' + str(i + 1)])
self.connect('Propulsion.y31', 'con_Y31' + str(i + 1) + '.y31')
self.connect('y31', 'con_Y31' + str(i + 1) + '.y31k')
# Local constraints
for i in range(self.nx):
self.add_subsystem('con_G1' + str(i + 1),
ExecComp('con_g1' + str(i + 1) + '=g1[' + str(i) + ']', g1=np.zeros(self.nx)),
promotes=['con_g1' + str(i + 1)])
self.connect('parallel.Structure.g1', 'con_G1' + str(i + 1) + '.g1')
for i in range(self.nx):
self.add_subsystem('con_G2' + str(i + 1),
ExecComp('con_g2' + str(i + 1) + '=g2[' + str(i) + ']', g2=np.zeros(self.nx)),
promotes=['con_g2' + str(i + 1)])
self.connect('parallel.Aerodynamics.g2', 'con_G2' + str(i + 1) + '.g2')
for i in range(self.nx):
self.add_subsystem('con_G3' + str(i + 1),
ExecComp('con_g3' + str(i + 1) + '=g3[' + str(i) + ']', g3=np.zeros(self.nx)),
promotes=['con_g3' + str(i + 1)])
self.connect('Propulsion.g3', 'con_G3' + str(i + 1) + '.g3')