def test_realistic(self):
real_nets = {
'Net1': [('R1', 1), ('R2', 1)],
'Net2': [('R1', 2)],
'Net3': [('R3', 1)],
'Net4': [('R2', 2), ('R3', 2)]
}
worker = CurrentFlow()
self.assertEqual(
list(map(sorted, worker.do(real_nets))),
[['Net1', 'Net2', 'Net3', 'Net4']]
)
def test_strip(self):
flow = CurrentFlow()
net_dict = {
'Net1': [('R1', '1'), ('C2', '1'), ('M1', '1')],
'Net2': [('R1', '2'), ('R2', '2'), ('NT3', '1'), ('M2', '2')],
}
self.assertEqual(
flow.strip(net_dict),
{
'Net1': ['R1', 'C2'],
'Net2': ['R1', 'R2', 'NT3'],
}
)
def test_net_hop_with_real_netlist(self):
reader = PcadReader('./comet_db.sample.net')
nethopper = CurrentFlow(passable=[r'^W\d+'])
result = reader.read(nethopper=nethopper)
self.assertEqual(result['NetD1_1'], result['DIFF_TERM_STV'])
self.assertEqual(result['NetD1_1'], result['NetD2_1'])
self.assertEqual(result['NetD1_1'], result['J1_LOC_TERM'])
self.assertEqual(result['NetD1_1'], result['J2_LOC_TERM'])
def test_compnents_appear_more_than_twice(self):
net_to_comp = {
'Net1': ['CxRB_320', 'CxRB_320', 'CxRB_320', 'R2'],
'Net2': ['CxRB_320', 'CxRB_320', 'CxRB_320'],
}
comp_to_net = CurrentFlow.swap_key_to_value(net_to_comp)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net1', net_to_comp, comp_to_net)),
['Net1', 'Net2', ]
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net2', net_to_comp, comp_to_net)),
['Net1', 'Net2', ]
)
def test_find_all_flows_case1(self):
net_to_comp = {
'Net1': ['R1', 'R2'],
'Net2': ['R1'],
'Net3': ['R2']
}
comp_to_net = CurrentFlow.swap_key_to_value(net_to_comp)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net1', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3']
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net2', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3']
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net3', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3']
)
def test_swap_key_to_value(self):
net_to_comp = {
'Net1': ['R1', 'R2'],
'Net2': ['R1'],
'Net3': ['R2']
}
self.assertEqual(
dict(CurrentFlow.swap_key_to_value(net_to_comp)),
{
'R1': ['Net1', 'Net2'],
'R2': ['Net1', 'Net3']
}
)
def test_find_all_flows_case2(self):
net_to_comp = {
'Net1': ['R1', 'R2'],
'Net2': ['R1'],
'Net3': ['R3'],
'Net4': ['R2', 'R3', 'R4'],
'Net5': ['R4', 'R5', 'R6', 'R7', 'R8'],
'Net6': ['R5'],
'Net7': ['R6']
}
comp_to_net = CurrentFlow.swap_key_to_value(net_to_comp)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net1', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3', 'Net4', 'Net5', 'Net6', 'Net7']
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net2', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3', 'Net4', 'Net5', 'Net6', 'Net7']
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net3', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3', 'Net4', 'Net5', 'Net6', 'Net7']
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net4', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3', 'Net4', 'Net5', 'Net6', 'Net7']
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net5', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3', 'Net4', 'Net5', 'Net6', 'Net7']
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net6', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3', 'Net4', 'Net5', 'Net6', 'Net7']
)
self.assertEqual(
sorted(
CurrentFlow.find_all_flows('Net7', net_to_comp, comp_to_net)),
['Net1', 'Net2', 'Net3', 'Net4', 'Net5', 'Net6', 'Net7']
)
from UT_Aux_mapping.helpers import filter_comp
from UT_Aux_mapping.helpers import post_filter_any
from UT_Aux_mapping.helpers import make_comp_netname_dict
from UT_Aux_mapping.helpers import gen_filename
mirror_bp_netlist = input_dir / Path("mirror_backplane.net")
mirror_custom_bb_netlist = input_dir / Path("mirror_custom_telemetry_bb.net")
mirror_bb_to_bp_mapping_filename = output_dir / Path(gen_filename(__file__))
#####################
# Read all netlists #
#####################
# Default net hopping should work for Custom BB.
NetHopper = CurrentFlow()
MirrorCustomBBReader = PcadReader(mirror_custom_bb_netlist)
mirror_custom_bb_descr = MirrorCustomBBReader.read(NetHopper)
MirrorBPReader = PcadNaiveReader(mirror_bp_netlist)
mirror_bp_descr = MirrorBPReader.read()
# MirrorBPHopper = CurrentFlow([PLACE COMPONENTS TO TREAT AS COPPER HERE])
MirrorBPHopper = CurrentFlow([r"^R\d", r"^RT\d", r"^C\d"])
PcadReader.make_equivalent_nets_identical(
mirror_bp_descr, MirrorBPHopper.do(mirror_bp_descr)
)
RuleNetlist_DepopDiffElksGamma(all_diff_nets),
RuleNetlist_DepopDiffElksBeta(all_diff_nets),
RuleNetlist_RBSPMislabelledAsRB(),
RuleNetlist_RBMislabelledAsR(),
RuleNetlist_NeverUsedFROElks(),
RuleNetlist_Default()
]
RawNetChecker = SelectorNet(netlist_dict, raw_net_rules)
result_check_raw_net = RawNetChecker.do()
#####################################
# Do net hopping on the raw netlist #
#####################################
NetHopper = CurrentFlow(
[r'^R\d+', r'^C\d+', r'^NT\d+', r'^CXRB_\d+', r'^RB_\d+|^RBSP\d+'])
PcadReader.make_equivalent_nets_identical(netlist_dict,
NetHopper.do(netlist_dict))
#################################
# Rules to check hopped netlist #
#################################
class RuleNetlistHopped_SingleToDiffN(RuleNetlist):
def match(self, netname, components):
return bool(
re.match(
r'JD\d_JP\d_EC_(RESET_GPIO|HYB_i2C_SDA|HYB_i2C_SCL)_\d_N$',
netname))
true_bp_netlist = input_dir / Path("mirror_backplane.net")
###########
# Helpers #
###########
def filter_netname(nets, name):
for n in nets:
if re.search(name, n):
return True
return False
def netname_printout(nets, name):
for n in nets:
if re.search(name, n):
print(n)
#################
# True BP debug #
#################
TrueBPReader = PcadNaiveReader(true_bp_netlist)
true_bp_descr = TrueBPReader.read()
TrueBPHopper = CurrentFlow([r'^R\d+', r'^RSP_\d+'])
true_nets_hopped = TrueBPHopper.do(true_bp_descr)
debug_comet_mapping_filename = output_dir / Path('DebugCometMapping.csv')
debug_dcb_path_finder_mapping_filename = output_dir / Path(
'DebugDcbPathFinderMapping.csv')
comet_dcb_full_mapping_filename = output_dir / Path('CometDcbFullMapping.csv')
comet_dcb_short_mapping_filename = output_dir / Path(
'CometDcbShortMapping.csv')
#####################
# Read all netlists #
#####################
# NOTE: Net hopping won't work for COMET, nor COMET DB, because of the special
# resistors RNXX that have 8 legs, instead of 2.
CometHopper = CurrentFlow([r'^R\d+', r'^NT\d+', r'^RN\d+_\d[ABCD]', r'^C\d+'])
CometDBHopper = CurrentFlow([r'^R\d+', r'^NT\d+', r'^RN\d+[ABCD]'])
CometReader = PcadNaiveReader(comet_netlist)
CometDBReader = PcadNaiveReader(comet_db_netlist)
comet_descr = split_rn(CometReader.read())
comet_db_descr = split_rn(
CometDBReader.read(),
regexp=r'^RN((?!5$|6$|9$|12$|15$|18$|21$|24$|27$|39$|30$|33$|36$)\d+)$')
# Manually do net hopping for COMET and COMET DB.
PcadReader.make_equivalent_nets_identical(comet_descr,
CometHopper.do(comet_descr))
PcadReader.make_equivalent_nets_identical(comet_db_descr,
CometDBHopper.do(comet_db_descr))
def test_diff_case2(self):
self.assertEqual(
CurrentFlow.diff(['R1', 'C2'], ['C1', 'C2']),
['R1']
)