Segmentation fault (core dumped)

Hi, I use Python to write a gurobi solver on a Linux system. When the problem size is small, it can be solved normally, but when the problem size increases, it reports an error: Segmentation fault. When I use the gdb tool to debug, the following message appears:

here is a part of my code

P_range = [i + 1 for i in range(len(self.LAYERS))]
S_range = [i for i in range(len(self.LAYERS))]
E_range = [i + 1 for i in range(len(self.LAYERS))]
W_range = [i for i in range(self.X+1)]
H_range = [i for i in range(self.Y+1)]
D_range = [0, 1]
self.Latency_Cache = np.load(os.path.join(self.result_path, self.name, 'Latency_Cache.npy'))
for S in S_range:
    for E in E_range:
        for W in W_range:
            for H in H_range:
                if not np.isnan(self.Latency_Cache[S][E][W][H]):
                    S_TEMP = S
                    E_TEMP = E
                    while (S_TEMP >= self.repeat_bottom and E_TEMP <= self.repeat_up):
                        self.Latency_Cache[S_TEMP + 1][E_TEMP + 1][W][H] = self.Latency_Cache[S_TEMP][E_TEMP][W][
                            H]
                        self.Latency_Cache[S_TEMP + 1][E_TEMP + 1][H][W] = self.Latency_Cache[S_TEMP][E_TEMP][W][
                            H]
                        S_TEMP = S_TEMP + 1
                        E_TEMP = E_TEMP + 1
                if W * H == 0:
                    self.Latency_Cache[S][E][W][H] == 1000
                if E-S == 0:
                    self.Latency_Cache[S][E][W][H] == 0
                if (self.Latency_Cache[S][E][W][H] == np.inf) or np.isnan(self.Latency_Cache[S][E][W][H]):
                    self.Latency_Cache[S][E][W][H] = 1000
print(self.Latency_Cache[0][24][16][16])


e = 0.001
M = 100 + e
model = grb.Model()
X = []
for S in S_range:
    X.append(model.addVars(P_range,  E_range[S:],vtype=grb.GRB.BINARY,name=f'X[{S}]'))

Y = model.addVars(P_range, D_range, W_range, H_range, vtype=grb.GRB.BINARY,name='Y')
Z = []#[S][E,W,H]
for S in S_range:
    Z.append(model.addVars(E_range[S:],W_range, H_range,vtype=grb.GRB.BINARY,name=f'Z[{S}]'))


SpVar = model.addVars(P_range, lb = 0, ub = S_range[-1], vtype=grb.GRB.INTEGER, name='SpVar')
EpVar = model.addVars(P_range, lb = 0, ub = E_range[-1], vtype=grb.GRB.INTEGER, name='EpVar')
maxEp = model.addVar( lb = 0, ub = E_range[-1], vtype=grb.GRB.INTEGER, name='maxEp')
minSp = model.addVar( lb = 0, ub = S_range[-1], vtype=grb.GRB.INTEGER, name='minSp')
CpVar = model.addVars(P_range, lb=W_range[0], ub=W_range[-1], vtype=grb.GRB.INTEGER, name='CpVar')
RpVar = model.addVars(P_range, lb=H_range[0], ub=H_range[-1], vtype=grb.GRB.INTEGER, name='RpVar')
maxCp = model.addVar(lb=0, ub=W_range[-1], vtype=grb.GRB.INTEGER, name='maxCp')
maxRp = model.addVar(lb=0, ub=H_range[-1], vtype=grb.GRB.INTEGER, name='maxRp')

PpXVar = model.addVars( P_range,vtype=grb.GRB.BINARY,name = 'PpXVar')
PpYVar = model.addVars(P_range, vtype=grb.GRB.BINARY, name='PpYVar')
TPpYVar = model.addVars(P_range, vtype=grb.GRB.BINARY, name='TPpYVar')
#constr_1_b = model.addVars(P_range[1:],vtype=grb.GRB.BINARY,name='constr_1_b')
AUX_OBJ = model.addVar(vtype=grb.GRB.CONTINUOUS,name='AUX_OBJ')
DpVar = model.addVars(P_range[1:],vtype=grb.GRB.BINARY,name= "DpVar")
Cp=[]
Rp=[]
Wp=[]
Hp=[]
Dp=[]
Sp=[]
Ep=[]
PpX=[]
PpY=[]
TPpY = []
expr_C = grb.LinExpr()
expr_R = grb.LinExpr()
expr_D = grb.LinExpr()
expr_W = grb.LinExpr()
expr_H = grb.LinExpr()
expr_TPY = grb.LinExpr()
expr_PY = grb.LinExpr()
expr_allP = grb.LinExpr()
for D in D_range:
    for W in W_range:
        for H in H_range:
            expr_C += Y[1, D, W, H] * W
            expr_R += Y[1, D, W, H] * H
            expr_D += Y[1, D, W, H] * D
            expr_W += Y[1, D, W, H] * W
            expr_H += Y[1, D, W, H] * H
            expr_PY += Y[1, D, W, H]
            if W * H > 0:
                expr_TPY += Y[1, D, W, H]
current_expr_C = expr_C.copy()
current_expr_R = expr_R.copy()
Dp.append(expr_D)
Cp.append(current_expr_C)
Rp.append(current_expr_R)
Wp.append(expr_W)
Hp.append(expr_H)
PpY.append(expr_PY)
TPpY.append(expr_TPY)
for P in P_range[1:]:
    expr_D = grb.LinExpr()
    expr_W = grb.LinExpr()
    expr_H = grb.LinExpr()
    expr_PY = grb.LinExpr()
    expr_TPY = grb.LinExpr()
    for D in D_range:
        for W in W_range:
            for H in H_range:
                if D == 0:
                    expr_C += Y[P,D,W,H]*W
                else:
                    expr_R += Y[P,D,W,H]*H
                current_expr_C = expr_C.copy()
                current_expr_R = expr_R.copy()#
                expr_D += Y[P, D, W, H] * D
                expr_W += Y[P, D, W, H] * W
                expr_H += Y[P, D, W, H] * H
                expr_PY += Y[P, D, W, H]
                if W*H > 0:
                    expr_TPY += Y[P, D, W, H]
    Dp.append(expr_D)
    Cp.append(current_expr_C)
    Rp.append(current_expr_R)
    Wp.append(expr_W)
    Hp.append(expr_H)
    PpY.append(expr_PY)
    TPpY.append(expr_TPY)
for P in P_range:
    expr_S = grb.LinExpr()
    expr_E = grb.LinExpr()
    expr_PX = grb.LinExpr()
    for S in S_range:
        for E in E_range[S:]:
            expr_S += X[S][P, E] * S
            expr_E += X[S][P, E] * E
            expr_PX += X[S][P, E]
            expr_allP += X[S][P, E]
    Sp.append(expr_S)
    Ep.append(expr_E)
    PpX.append(expr_PX)



model.addConstrs((DpVar[p] == Dp[p-1] for p in P_range[1:]),name="constr_1" )


model.addConstrs((Wp[p - 1] + M*(1 - DpVar[P]) >= Cp[p - 2] for p in P_range[1:]), name="constr_1_3_1")
model.addConstrs((Wp[p - 1] - M*(1 - DpVar[P]) <= Cp[p - 2] for p in P_range[1:]), name="constr_1_3_2")

model.addConstrs((Hp[p - 1] + M*DpVar[P] >= Rp[p - 2] for p in P_range[1:]), name="constr_1_3_3")
model.addConstrs((Hp[p - 1] - M*DpVar[P] <= Rp[p - 2] for p in P_range[1:]), name="constr_1_3_4")


model.addConstrs((PpXVar[p] == PpX[p - 1] for p in P_range),name = "constr_2_2")
model.addConstrs((EpVar[p] == Ep[p - 1] for p in P_range),name = "constr_2_3")
model.addConstrs((SpVar[p] == Sp[p - 1] for p in P_range),name = "constr_2_4")
model.addConstrs(((PpXVar[p] == 1) >> (SpVar[p] + e  <= EpVar[p])  for p in P_range), name = "constr_2_1")


model.addConstrs(((PpXVar[p] == 1) >> (EpVar[p - 1] == SpVar[p]) for p in P_range[1:]), name="constr_3_1")


model.addConstr(maxEp == max_([EpVar[p] for p in P_range]), name="constr_4_2")
#model.addConstrs((maxEp >= EpVar[p] for p in P_range), name="constr_4_2")

model.addConstr(len(self.LAYERS) == maxEp ,name = "const_4_3")


#model.addConstr(minSp == min_([SpVar[p] for p in P_range]), name="constr_5_2")
model.addConstr(0 == SpVar[P_range[0]], name="const_5_1")

model.addConstr((PpXVar[P_range[0]] == 1 ), name="constr_5_2")


model.addConstrs((PpYVar[p] == PpY[p - 1] for p in P_range), name="constr_6_0")
model.addConstrs((PpXVar[p - 1] >= PpXVar[p]  for p in P_range[1:]), name="constr_6_1")
model.addConstrs((PpXVar[p] <= 1 for p in P_range), name="constr_6_2")
model.addConstrs((PpYVar[p] == 1 for p in P_range), name="constr_6_3")


model.addConstr(expr_allP >= 1, name = "const_7")

model.addConstrs((TPpYVar[p] == TPpY[p - 1] for p in P_range), name="constr_8_0")
model.addConstrs((PpXVar[p] == TPpYVar[p] for p in P_range), name="constr_8_1")

model.addConstrs((CpVar[p] == Cp[p - 1] for p in P_range), name="const_9_1")
model.addConstr(maxCp == max_([CpVar[p] for p in P_range]), name="const_9_2")

model.addConstr(self.X == maxCp, name="const_9_3")

model.addConstrs((RpVar[p] == Rp[p - 1] for p in P_range), name="const_9_3")
model.addConstr(maxRp == max_([RpVar[p] for p in P_range]), name="const_9_4")
for S in S_range:
    for E in E_range[S:]:
        for W in W_range:
            for H in H_range:
                expr_temp = grb.QuadExpr()
                for P in P_range:
                    for D in D_range:
                        expr_temp += X[S][P,E] * Y[P, D, W, H]
                model.addConstr(Z[S][E, W, H] == expr_temp, name=f"constr_10_1_{S, E, W, H}")

model.addConstrs((expr_allP*Z[S][E, W, H]*self.Latency_Cache[S][E][W][H]<=self.max_latency for S in S_range
                  for E in E_range[S:] for W in W_range for H in H_range),name = "constr_11")
model.update()

model.addConstrs((AUX_OBJ>=Z[S][E, W, H]*self.Latency_Cache[S][E][W][H] for S in S_range
                  for E in E_range[S:] for W in W_range for H in H_range),name = "constr_obj")
model.setObjective(AUX_OBJ,sense=grb.GRB.MINIMIZE)
model.update()
model.optimize()