public async Task <IActionResult> Edit(int id, [Bind("PowerID,PowerName")] PowerFactor powerFactor)
{
if (id != powerFactor.PowerID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(powerFactor);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PowerFactorExists(powerFactor.PowerID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(powerFactor));
}
public async Task <IActionResult> Create([Bind("PowerID,PowerName")] PowerFactor powerFactor)
{
if (ModelState.IsValid)
{
_context.Add(powerFactor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(powerFactor));
}
/// <summary>
/// 计算稳态子通道流量场，使用节点压力迭代，即用压力平衡思想考虑横向流动
/// </summary>
/// <param name="coolent">冷却剂</param>
/// <param name="channels">通道集合</param>
/// <param name="rods">燃料棒集合</param>
/// <param name="massFlow">质量流速对象</param>
/// <param name="Ni">通道数</param>
/// <param name="Nj">轴向分段数</param>
/// <param name="totalArea">总流通面积</param>
/// <param name="options">计算选项</param>
/// <returns></returns>
public List <ChannelFlow> Caculate_Channels_Steady_NodeIteration(
Fluid coolent,
List <Channel> channels,
List <Rod> rods,
MassFlow massFlow,
int Ni, int Nj,
double totalArea,
Options options)
{
///使用压力迭代方法确定不同子通道之间的流量，此计算方法使用压力迭代确定
///
Main.MsgCenter.ShowMessage("计算子通道数据,流量计算方式压力迭代：节点迭代...");
//初始化输出结果
List <ChannelFlow> channelsFlow = new List <ChannelFlow>();
for (int i = 0; i < Ni; i++)
{
ChannelFlow channelFlow = new ChannelFlow
{
//流动计算结果 编号与输入的子通道编号相对应
ChannelIndex = channels[i].Index,
FluidDatas = new List <FluidData>()
};
for (int j = 0; j < Nj + 1; j++)
{
channelFlow.FluidDatas.Add(new FluidData());
}
channelsFlow.Add(channelFlow);
}
//迭代的限制参数
Iteration iteration = options.Iteration;
//功率的乘子
PowerFactor powerFactor = options.PowerFactor;
//计算的准确度
Precision acc = options.Precision;
//CHF公式选取
CHF_Formula_Types chf_formula = options.DNBR_Formula;
//流动方向(-1~1)
double flow_direction = massFlow.Flow_Direction;
//质量流量迭代
var MassFlowRate = Matrix <double> .Build.Dense(Nj + 1, Ni, 0);
//每个子通道的分段压降,Ni行xNj列初值为0
var P_Local = Matrix <double> .Build.Dense(Nj + 1, Ni, 0);
//压降迭代因子
double Sigma = 0;
//质量流速迭代中间变量
double[] m = new double[Ni];
//质量流速迭代中间变量
double[] velocity = new double[Ni];
//质量流速迭代中间变量
double[] DeltaP = new double[Nj];
//遍历所有子通道
for (int i = 0; i < Ni; i++)
{
//初始化j=0入口节点
FluidData InitNode = SetInitNode(coolent, totalArea, channels[i], massFlow, acc);
//初始化子通道数据节点加入
channelsFlow[i].FluidDatas[0] = InitNode;
//局部压力场矩阵(Mpa)
P_Local[0, i] = InitNode.Pressure;
//质量流速kg/s 迭代用）
m[i] = InitNode.MassFlowRate;
//流速m/s（迭代用）
velocity[i] = InitNode.Velocity;
//质量流速矩阵（输出用）
MassFlowRate[0, i] = m[i];
}
//轴向迭代
for (int j = 1; j < Nj + 1; j++)
{
//迭代次数
int iteration_times = 0;
do
{
//计算所有燃料棒j段（J=1~Nj-1）
for (int i = 0; i < Ni; i++)
{
//计算当前段的长度j>=1
double Lj = rods[0].SubPowerCollection[j - 1].To - rods[0].SubPowerCollection[j - 1].From;
//前一个节点
FluidData pre = channelsFlow[i].FluidDatas[j - 1];
//当前子通道燃料棒功率输出
double SubPowerJ = 0;
//遍历所有燃料棒
foreach (Rod rod in rods)
{
//燃料棒所有接触的通道
foreach (var ContactedChannel in rod.ContactedChannel)
{
//如果与燃料棒接触的通道,如果是当前正在计算的通道
if (ContactedChannel.Index == channels[i].Index)
{
SubPowerJ += rod.SubPowerCollection[j - 1].Value * ContactedChannel.Angle / 360;
}
}
}
//乘以功率因子
SubPowerJ = SubPowerJ * powerFactor.Multiplier;
//计算新节点,NodeToNext计算子通道节点
FluidData next = NodeToNext(
coolent,
pre,
channels[i],
Lj,
SubPowerJ,
m[i],
acc,
out double DeltaPij,
chf_formula,
flow_direction);
//迭代中间变量赋值
DeltaP[i] = DeltaPij;
//存储计算结果
channelsFlow[i].FluidDatas[j] = next;
//i棒j段压降
P_Local[j, i] = next.Pressure;
//质量流速
MassFlowRate[j, i] = m[i];
}
//初始化迭代收敛因子
Sigma = 0;
//平均压降
double AvgPressure = 0;
for (int i = 0; i < Ni; i++)
{
AvgPressure += DeltaP[i];
}
//平均压降
AvgPressure = AvgPressure / Ni;
// 所有偏差之和
for (int i = 0; i < Ni; i++)
{
Sigma += Math.Abs(DeltaP[i] - AvgPressure);
}
//总质量流速
double TotalM = 0;
for (int i = 0; i < Ni; i++)
{
//子通道i压降和平均压降的比值
double Factor = (1 - DeltaP[i] / AvgPressure) * 0.1;
//重新分配压降
m[i] = m[i] + m[i] * Factor;
TotalM += m[i];
Debug.WriteLine(String.Format("因子{0}：", Factor));
}
//计算平衡后与平衡前的比值
double k = massFlow.MassVelocity / TotalM;
//保持总质量流速不变
for (int i = 0; i < Ni; i++)
{
//对质量流量进行修正
m[i] = k * m[i];
Debug.WriteLine(String.Format("通道{0}压降{1}Pa", i, DeltaP[i]));
}
Debug.WriteLine("=========================================");
//迭代压降
iteration_times += 1;
Main.MsgCenter.ShowMessage(String.Format("压力迭代次数：{0}", iteration_times));
if (iteration_times > iteration.MaxIteration)
{
Main.MsgCenter.ShowMessage(String.Format("超过最大迭代次数限制,最大迭代次数限制{0}", iteration.MaxIteration));
break;
}
}while (Sigma > iteration.Sigma);
//循环每个通道
Main.MsgCenter.ShowMessage(String.Format("Sigma->{0}", Sigma));
}
//信息输出
Main.MsgCenter.ShowMessage("--------压力场预览--------");
Main.MsgCenter.ShowMessage(P_Local.ToMatrixString(Nj + 1, Ni));
Main.MsgCenter.ShowMessage("--------流量场预览--------");
Main.MsgCenter.ShowMessage(MassFlowRate.ToMatrixString(Nj + 1, Ni));
return(channelsFlow);
}
/// <summary>
/// 计算稳态子通道流量场，使用进出口压力迭代，即不考虑横向流动
/// </summary>
/// <param name="coolent">冷却剂</param>
/// <param name="channels">通道集合</param>
/// <param name="rods">燃料棒集合</param>
/// <param name="massFlow">质量流速对象</param>
/// <param name="Ni">通道数</param>
/// <param name="Nj">轴向分段数</param>
/// <param name="totalArea">总流通面积</param>
/// <param name="options">计算选项</param>
/// <returns></returns>
public List <ChannelFlow> Caculate_Channels_Steady_IOIteration(
Fluid coolent,
List <Channel> channels,
List <Rod> rods,
MassFlow massFlow,
int Ni, int Nj,
double totalArea,
Options options)
{
///使用压力迭代方法确定稳态不同子通道之间的流量，此计算方法使用压力迭代确定
///一些局部变量
///
//初始化输出结果
List <ChannelFlow> channelsFlow = new List <ChannelFlow>();
for (int i = 0; i < Ni; i++)
{
ChannelFlow channelFlow = new ChannelFlow
{
//流动计算结果 编号与输入的子通道编号相对应
ChannelIndex = channels[i].Index,
FluidDatas = new List <FluidData>()
};
for (int j = 0; j < Nj + 1; j++)
{
channelFlow.FluidDatas.Add(new FluidData());
}
channelsFlow.Add(channelFlow);
}
//迭代的限制参数
Iteration iteration = options.Iteration;
//功率的乘子
PowerFactor powerFactor = options.PowerFactor;
//计算的准确度
Precision acc = options.Precision;
//CHF公式选取
CHF_Formula_Types chf_formula = options.DNBR_Formula;
//流动方向(-1~1)
double flow_direction = massFlow.Flow_Direction;
//压降迭代,每个子通道的压降
double[] DeltaP = new double[Ni];
//压降迭代,每个子通道的压降
double[] m = new double[Ni];
//每个子通道的分段压降,Ni行xNj列初值为0
Matrix <double> P_Local = Matrix <double> .Build.Dense(Nj + 1, Ni, 0);
//压降迭代收敛因子
double Sigma = 0;
//迭代次数统计
int iteration_times = 0;
//迭代压降
do
{
//遍历子通道
for (int i = 0; i < Ni; i++)
{
//初始化压降
DeltaP[i] = 0;
//初始化子通道入口数据节点
FluidData InitNode = SetInitNode(coolent, totalArea, channels[i], massFlow, acc);
//初始化子通道数据节点加入
channelsFlow[i].FluidDatas[0] = InitNode;
//局部压力场矩阵
P_Local[0, i] = InitNode.Pressure;
if (iteration_times <= 1)
{
//质量流速
m[i] = InitNode.MassFlowRate;
}
//每个通道数据节点（共Nj+1个,初始节点1个,循环Nj个）
for (int j = 1; j < Nj + 1; j++)
{
//计算当前段的长度j>=1
double Lj = rods[0].SubPowerCollection[j - 1].To - rods[0].SubPowerCollection[j - 1].From;
//前一个节点
FluidData pre = channelsFlow[i].FluidDatas[j - 1];
//当前子通道燃料棒功率输出
double SubPowerJ = 0;
//遍历所有燃料棒
foreach (Rod rod in rods)
{
//燃料棒所有接触的通道
foreach (var ContactedChannel in rod.ContactedChannel)
{
//如果与燃料棒接触的通道,如果是当前正在计算的通道
if (ContactedChannel.Index == channels[i].Index)
{
SubPowerJ += rod.SubPowerCollection[j - 1].Value * ContactedChannel.Angle / 360;
}
}
}
//乘以功率因子
SubPowerJ = SubPowerJ * powerFactor.Multiplier;
//计算新节点,NodeToNext计算子通道节点
FluidData next = NodeToNext(
coolent,
pre,
channels[i],
Lj,
SubPowerJ,
m[i],
acc,
out double DeltaPij,
chf_formula,
flow_direction);
//存储计算结果
channelsFlow[i].FluidDatas[j] = next;
//i棒j段压降
P_Local[j, i] = next.Pressure;
//压降用于迭代
DeltaP[i] += DeltaPij;
}
}
//初始化迭代收敛因子Sigma
Sigma = 0;
//平均压降
double AvgPressure = 0;
for (int i = 0; i < Ni; i++)
{
#if DEBUG
Main.MsgCenter.ShowMessage(String.Format("通道{0}压降:{1}", i, DeltaP[i]));
#endif
AvgPressure += DeltaP[i];
}
//平均压降
AvgPressure = AvgPressure / Ni;
//所有偏差之和
for (int i = 0; i < Ni; i++)
{
Sigma += Math.Abs(DeltaP[i] - AvgPressure);
}
double TotalM = 0;
for (int i = 0; i < Ni; i++)
{
//子通道i压降和平均压降的比值
double Factor = Math.Sqrt(AvgPressure / DeltaP[i]);
//重新分配压降
m[i] = Factor * m[i]; // 所有偏差之和
//计算平衡后的总质量流速
TotalM += m[i];
}
//计算平衡后与平衡前的比值
double k = massFlow.MassVelocity / TotalM;
//对质量流量进行修正,保持总质量流速不变
for (int i = 0; i < Ni; i++)
{
m[i] = k * m[i];
#if DEBUG
Main.MsgCenter.ShowMessage(String.Format("通道{0}质量流速:{1}", i, m[i]));
#endif
}
//输出迭代收敛因子
Main.MsgCenter.ShowMessage(String.Format("Sigma->{0}", Sigma));
//迭代次数+1
iteration_times += 1;
Main.MsgCenter.ShowMessage(String.Format("压力迭代次数：{0}", iteration_times));
if (iteration_times > iteration.MaxIteration)
{
Main.MsgCenter.ShowMessage(String.Format("超过最大迭代次数限制,最大迭代次数限制{0}", iteration.MaxIteration));
break;
}
}while (Sigma > iteration.Sigma);
// MyIOManager.OutputData.SteadyResult.ChannelsFlow = ChannelsFlow;
//信息输出
Main.MsgCenter.ShowMessage("--------压力场预览--------");
Main.MsgCenter.ShowMessage(P_Local.ToMatrixString(Nj + 1, Ni));
Main.MsgCenter.ShowMessage("--------流量场预览--------");
var MassFlowRate = Matrix <double> .Build.Dense(Nj + 1, Ni, (Mi, Mj) => m[Mj]);
Main.MsgCenter.ShowMessage(MassFlowRate.ToMatrixString(Nj + 1, Ni));
return(channelsFlow);
}
