/// <summary>
/// 普通导通测试支路
/// </summary>
public LogicNet[] Load24VBranches(int logicMaxNetNum)
{
AppProject pro = AppProject.GetInstance();
nets.Clear();
List <TNode> cfs = pro.GetCFNodes();
int Count = cfs.Count;
BranchNet[] _nets = new BranchNet[Count];
LogicNet[] pnets = new LogicNet[Count];
for (int i = 0; i < Count; i++)
{
BranchNet net = new BranchNet(MaxNetNum + 1);
this.nets.Add(net);
LogicNet pnet = new LogicNet(++logicMaxNetNum);
List <TestBranch> normbr = new List <TestBranch>();
TestBranch branch = new TestBranch();
branch.TryAddNode(cfs[i]);
normbr.Add(branch);
Get24VBranches(normbr, ref net, ref pnet);
_nets[i] = net;
pnets[i] = pnet;
}
pro.Nodes.ForEach(p => p.HasIncluded = false);
return(pnets);
}
/// <summary>
/// 获得与总负相连接的支路(递归广度)
/// </summary>
private void GetGndBranches(List <TestBranch> branches, ref BranchNet net)
{
AppProject pro = AppProject.GetInstance();
List <TestBranch> nextBranches = new List <TestBranch>();
foreach (var branch in branches)
{
TNode node = branch.LastNode;
foreach (var child in node.Nodes)
{
TestBranch cbranch = branch.Clone();
if (!child.HasIncluded)
{
if (child.PartType == "端子排" &&
child.TNType != TerminalType.Block &&
!(node.TNType == TerminalType.DiodePositive && child.TNType == TerminalType.DiodeNegative))
{
if (!pro.GndTbs.Contains(child, AppProject.cmpNode))
{
pro.GndTbs.Add(child);
}
if (cbranch.AllTB)
{
cbranch.Clear();
}
cbranch.TryAddNode(child);
nextBranches.Add(cbranch);
}
else if (child.TNType == TerminalType.RE)
{
if (!pro.GndTbs.Contains(child, AppProject.cmpNode))
{
pro.GndTbs.Add(child);
}
cbranch.TryAddNode(child);
nextBranches.Add(cbranch);
}
else if (child.PartType == "接口连接器")
{
if (!pro.GndTbs.Contains(child, AppProject.cmpNode))
{
pro.GndTbs.Add(child);
}
cbranch.TryAddNode(child);
net.Branches.Add(cbranch);
cbranch = new TestBranch();
cbranch.TryAddNode(child);
nextBranches.Add(cbranch);
}
}
}
node.HasIncluded = true;
}
if (nextBranches.Count != 0)
{
GetGndBranches(nextBranches, ref net);
}
}
/// <summary>
/// 浅度复制一个测试支路
/// </summary>
public TestBranch Clone()
{
TestBranch br = new TestBranch();
foreach (var node in branch)
{
br.TryAddNode(node);
}
return(br);
}
/// <summary>
/// 获得与总负相连接的支路
/// </summary>
public void LoadGndBranches()
{
AppProject pro = AppProject.GetInstance();
nets.Clear();
BranchNet net = new BranchNet(MaxNetNum + 1);
List <TNode> gndnd = pro.GetSetTerminal(p => p.Type == NamesManage.Negative);
List <TestBranch> gndbr = new List <TestBranch>();
gndnd.ForEach(p =>
{
TestBranch br = new TestBranch();
br.TryAddNode(p);
gndbr.Add(br);
});
GetGndBranches(gndbr, ref net);
//GetGndBranches(gndnd, ref net);
nets.Add(net);
pro.Nodes.ForEach(p => p.HasIncluded = false);
}
/// <summary>
/// 获得与CF点相连接、包含逻辑元件的回路
/// </summary>
private void GetLogicRelations(List <TestBranch> branches, ref BranchNet net)
{
AppProject pro = AppProject.GetInstance();
List <TestBranch> nextBranches = new List <TestBranch>();
foreach (var branch in branches)
{
TNode node = branch.LastNode;
foreach (var child in node.Nodes)
{
TestBranch cbranch = branch.Clone();
if (!child.HasIncluded)
{
if (child.TNType != TerminalType.Block &&
child.PartType != "设备连接器" &&
!pro.GndTbs.Contains(child, AppProject.cmpNode))
{
bool success = cbranch.TryAddNode(child);
if (success)
{
nextBranches.Add(cbranch);
}
}
else if (pro.GndTbs.Contains(child, AppProject.cmpNode) && cbranch.HasLogicElement)
{
cbranch.TryAddNode(child);
bool condict = cbranch.BranchContradict();
if (!condict)
{
net.Branches.Add(cbranch);
}
}
}
}
node.HasIncluded = true;
}
if (nextBranches.Count != 0)
{
GetLogicRelations(nextBranches, ref net);
}
}
/// <summary>
/// 获得包含逻辑元件的回路
/// </summary>
public void LoadLogicLoops()
{
AppProject pro = AppProject.GetInstance();
nets.Clear();
/*获得与CF点相连接、包含逻辑元件的回路*/
var cfs = pro.Nodes.Where(p =>
p.PartType == "接口连接器" &&
p.TNType == TerminalType.Normal &&
!pro.GndTbs.Contains(p, AppProject.cmpNode)
).ToList();
int Count = cfs.Count;
for (int i = 0; i < Count; i++)
{
pro.Nodes.ForEach(p => p.HasIncluded = false);
int netnum = MaxNetNum;
BranchNet net = new BranchNet(++netnum);
nets.Add(net);
List <TestBranch> loopbr = new List <TestBranch>();
TestBranch branch = new TestBranch();
branch.TryAddNode(cfs[i]);
loopbr.Add(branch);
GetLogicRelations(loopbr, ref net);
}
/*获得与总正相连接、包含逻辑器件的回路*/
var vccs = pro.GetSetTerminal(p => p.Type == NamesManage.Positive);
pro.Nodes.ForEach(p => p.HasIncluded = false);
BranchNet vnet = new BranchNet(1 + MaxNetNum);
nets.Add(vnet);
for (int i = 0; i < vccs.Count; i++)
{
List <TestBranch> loopbr = new List <TestBranch>();
TestBranch branch = new TestBranch();
branch.TryAddNode(vccs[i]);
loopbr.Add(branch);
GetLogicRelations(loopbr, ref vnet);
}
}
/// <summary>
/// 获得与总正相连接的支路
/// </summary>
public LogicNet Load110VBranches(int logicMaxNetNum)
{
AppProject pro = AppProject.GetInstance();
nets.Clear();
BranchNet net = new BranchNet(MaxNetNum + 1);
nets.Add(net);
LogicNet pnet = new LogicNet(logicMaxNetNum + 1);
List <TNode> vccnd = pro.GetSetTerminal(p => p.Type == NamesManage.Positive);
List <TestBranch> vccbr = new List <TestBranch>();
vccnd.ForEach(p =>
{
TestBranch br = new TestBranch();
br.TryAddNode(p);
vccbr.Add(br);
});
Get110VBranches(vccbr, ref net, ref pnet);
pro.Nodes.ForEach(p => p.HasIncluded = false);
return(pnet);
}
/// <summary>
/// 获得与总负相连接的支路(Dijkstra)
/// </summary>
public void GetGndBranches(List <TNode> sources, ref BranchNet net)
{
AppProject pro = AppProject.GetInstance();
IReadOnlyCollection <TNode> cfs = pro.CFNodes;
foreach (var nd in sources)
{
Dijkstra dist = pro.getDijkstra(nd);
foreach (var cf in cfs)
{
if (dist.getRouteWeight(cf.index) == 0)
{
List <int> paths = dist.getPath(cf.index);
TestBranch cbranch = new TestBranch();
if (paths.Count > 0)
{
cbranch.TryAddNode(pro.Nodes[paths[paths.Count - 1]]);
}
net.Branches.Add(cbranch);
}
}
}
}
/// <summary>
/// 获得与总正相连接的支路(递归广度)
/// </summary>
private void Get110VBranches(List <TestBranch> branches, ref BranchNet net, ref LogicNet positiveNet)
{
AppProject pro = AppProject.GetInstance();
List <TestBranch> nextBranches = new List <TestBranch>();
foreach (var branch in branches)
{
TNode node = branch.LastNode;
if (node.HasIncluded)
{
continue;
}
foreach (var child in node.Nodes)
{
TestBranch cbranch = branch.Clone();
if (!child.HasIncluded)
{
if (child.PartType == "端子排" && child.TNType != TerminalType.Block)
{
if (cbranch.AllTB)
{
cbranch.Clear();
}
bool success = cbranch.TryAddNode(child);
if (success)
{
nextBranches.Add(cbranch);
}
}
else if (child.TNType == TerminalType.RE ||
child.TNType == TerminalType.BreakerContact ||
child.TNType == TerminalType.DiodePositive ||
child.TNType == TerminalType.DiodeNegative ||
child.TNType == TerminalType.Coil ||
child.TNType == TerminalType.ContactNormalClose ||
child.TNType == TerminalType.ContactNormalOpen ||
child.TNType == TerminalType.ContactCom ||
child.TNType == TerminalType.Switch ||
child.TNType == TerminalType.Indicator)
{
bool success = cbranch.TryAddNode(child);
if (success)
{
nextBranches.Add(cbranch);
}
}
else if (child.PartType == "接口连接器")
{
bool success = cbranch.TryAddNode(child);
/*是否含有逻辑元件*/
if (cbranch.HasLogicElement)
{
if (success)
{
positiveNet.Branches.Add(cbranch);
}
}
else
{
if (success)
{
net.Branches.Add(cbranch);
}
}
cbranch = new TestBranch();
success = cbranch.TryAddNode(child);
if (success)
{
nextBranches.Add(cbranch);
}
}
}
}
node.HasIncluded = true;
}
if (nextBranches.Count != 0)
{
Get110VBranches(nextBranches, ref net, ref positiveNet);
}
}
/// <summary>
/// 从条件支路中提取出，下一次要寻找的线圈、新增的屏蔽节点
/// </summary>
/// <param name="br">一条条件支路</param>
/// <param name="destCoils">存放下一次要寻找的线圈</param>
/// <param name="blockNodes">屏蔽节点的集合</param>
/// <returns>本条件支路中包含的线圈的名称</returns>
private IEnumerable <string> UpdateRelation(TestBranch br, List <string> destCoils, List <TNode> blockNodes)
{
AppProject pro = AppProject.GetInstance();
List <string> includedCoils = new List <string>();
foreach (var node in br.LogicNodes)
{
var another = node.GetAnother();
if (br.LogicNodes.Contains(another) && node.TNType == TerminalType.ContactNormalOpen)
{
/*常开触点的线圈作为寻找的目标*/
var query = pro.Nodes.Where(p =>
p.Part == node.Part && p.TNType == TerminalType.Coil);
foreach (var coil in query)
{
if (!destCoils.Contains(coil.Part))
{
destCoils.Add(coil.Part);
}
}
/*常开触点对应的常闭触点需要屏蔽*/
query = pro.Nodes.Where(p =>
p.Part == node.Part && p.TNType == TerminalType.ContactNormalClose);
foreach (var nc in query)
{
TNode athr = nc.GetAnother();
if (athr != null && !blockNodes.Contains(nc))
{
blockNodes.Add(nc);
blockNodes.Add(athr);
}
}
}
if (br.LogicNodes.Contains(another) && node.TNType == TerminalType.ContactNormalClose)
{
/*常闭触点的线圈需要屏蔽*/
var query = pro.Nodes.Where(p =>
p.Part == node.Part && p.TNType == TerminalType.Coil);
foreach (var coil in query)
{
blockNodes.Add(coil);
}
/*常闭触点对应的常开触点需要屏蔽*/
query = pro.Nodes.Where(p =>
p.Part == node.Part && p.TNType == TerminalType.ContactNormalOpen);
foreach (var no in query)
{
TNode athr = no.GetAnother();
if (athr != null && !blockNodes.Contains(no))
{
blockNodes.Add(no);
blockNodes.Add(athr);
}
}
}
if (node.TNType == TerminalType.Coil)
{
var coilpair = br.LogicNodes.Where(p => p.TNType == TerminalType.Coil && p.Part == node.Part).ToList();
if (coilpair.Count == 2)
{
foreach (var coil in coilpair)
{
if (!blockNodes.Contains(coil))
{
blockNodes.Add(coil);
}
if (!includedCoils.Contains(coil.Part))
{
includedCoils.Add(coil.Part);
}
}
var query = pro.Nodes.Where(p =>
p.Part == node.Part && p.TNType == TerminalType.ContactNormalClose);
foreach (var nd in query)
{
TNode ather = nd.GetAnother();
if (ather != null && !blockNodes.Contains(nd))
{
blockNodes.Add(nd);
blockNodes.Add(ather);
}
}
}
}
}
/*屏蔽不符合的支路*/
BlockBranches(blockNodes);
return(includedCoils);
}
/// <summary>
/// 逆推逻辑导通的条件
/// 这是深度递归函数
/// </summary>
/// <param name="branches">最后找到的条件支路</param>
/// <param name="destCoil">目的线圈的部件名称</param>
/// <param name="blockNodes">会产生矛盾，应该屏蔽的节点</param>
/// <param name="parentCoils">当前要寻找的线圈的祖先辈线圈</param>
/// <param name="includedCoils">已经找到的条件支路中所有的线圈</param>
/// <returns>是否搜索到合适导通条件</returns>
private bool GetConditions(List <TestBranch> branches, string destCoil, List <TNode> blockNodes, List <string> parentCoils)
{
AppProject pro = AppProject.GetInstance();
/*没有需要得电的线圈了就停止搜索*/
if (string.IsNullOrEmpty(destCoil))
{
return(true);
}
/*如果寻找的线圈不在父支路中但在已经搜索过的其他支路里
* 父支路已有的线圈如果再次出现就产生了矛盾
* 那么不用重复寻找
*/
if (!parentCoils.Contains(destCoil) && includedCoils.Contains(destCoil))
{
return(true);
}
else if (parentCoils.Contains(destCoil))
{
return(false);
}
/*遍历该网络中的每一条支路*/
TestBranch br = null;
if (pro.LoopNets.Nets.Count > 0)
{
foreach (var branch in pro.LoopNets.Nets[pro.LoopNets.Nets.Count - 1].Branches)
{
if (!branch.hasBlock)
{
int num = branch.LogicNodes.Count(p => p.Part == destCoil && p.TNType == TerminalType.Coil);
if (num == 2)
{
if (br == null)
{
br = branch;
}
else
{
int brNcNum = br.Branch.Count(p => p.TNType == TerminalType.ContactNormalClose);
int NcNum = branch.Branch.Count(p => p.TNType == TerminalType.ContactNormalClose);
if (brNcNum > NcNum)
{
br = branch;
}
}
}
}
}
}
if (br == null)
{
foreach (var net in pro.LoopNets.Nets)
{
foreach (var branch in net.Branches)
{
if (!branch.hasBlock)
{
int num = branch.LogicNodes.Count(p => p.Part == destCoil && p.TNType == TerminalType.Coil);
if (num == 2)
{
if (br == null)
{
br = branch;
}
else
{
int brNcNum = br.Branch.Count(p => p.TNType == TerminalType.ContactNormalClose);
int NcNum = branch.Branch.Count(p => p.TNType == TerminalType.ContactNormalClose);
if (brNcNum > NcNum)
{
br = branch;
}
}
}
}
}
}
}
else
{
}
/*找到就更新屏蔽的节点、查找下一步寻找的线圈*/
if (br != null)
{
List <string> destCoils = new List <string>();
IEnumerable <string> coils = UpdateRelation(br, destCoils, blockNodes);
if (!branches.Contains(br))
{
branches.Add(br);
}
foreach (var cl in coils)
{
parentCoils.Add(cl);
includedCoils.Add(cl);
}
foreach (var cl in destCoils)
{
List <string> parentcls = new List <string>();
parentCoils.ForEach(p => parentcls.Add(p));
bool success = GetConditions(branches, cl, blockNodes, parentcls);
if (!success)
{
return(false);
}
}
}
else
{
/*没有找到符合条件的支路*/
return(false);
}
return(true);
}
