## METEORS input for the biphase mark protocol
## Bound information and event orders to be excluded.
## Written by Shinya Umeno


from METEORS_0_4 import *



#### Upper Bounds #######################
ubMark1 = ActionBound('Edge1S', ['Edge1T'], 'M1')
ubCell = ActionBound('Edge0S', ['Edge0S','Edge1S'], 'C')
ubCell2 = ActionBound('Edge1S', ['Edge0S','Edge1S'], 'C')
ubSettle0S = ActionBound('Edge0S', ['WireSettled'], 'H')
ubSettle1S = ActionBound('Edge1S', ['WireSettled'], 'H')
ubSettle1T = ActionBound('Edge1T', ['WireSettled'], 'H')
ubDetect  = ActionBound('bot', ['DetectT', 'DetectF'], 'D')
ubDetect2 = ActionBound('DetectF', ['DetectT', 'DetectF'], 'D')
ubDetect3 = ActionBound('Decode', ['DetectT', 'DetectF'], 'D')
ubDecode = ActionBound('DetectT', ['Decode'], 'T')

Bipahse_ubSet = [ubMark1, ubCell, ubCell2, ubSettle0S, ubSettle1S, ubSettle1T,
                 ubDetect, ubDetect2, ubDetect3, ubDecode]

#### Lower Bounds #######################
lbMark1 = ActionBound('Edge1S', ['Edge1T'], 'm1')
#lbMark2 = ActionBound('Edge1T', ['Edge0S','Edge1S'], 'm2')
lbCell = ActionBound('Edge0S', ['Edge0S','Edge1S'], 'c')
lbCell2 = ActionBound('Edge1S', ['Edge0S','Edge1S'], 'c')
lbSettle0S = ActionBound('Edge0S', ['WireSettled'], 'h')
lbSettle1S = ActionBound('Edge1S', ['WireSettled'], 'h')
lbSettle1T = ActionBound('Edge1T', ['WireSettled'], 'h')
lbDetect  = ActionBound('bot', ['DetectT', 'DetectF'], 'd')
lbDetect2 = ActionBound('DetectF', ['DetectT', 'DetectF'], 'd')
lbDetect3 = ActionBound('Decode', ['DetectT', 'DetectF'], 'd')
lbDecode = ActionBound('DetectT', ['Decode'], 't')

Bipahse_lbSet = [lbMark1, lbCell, lbCell2, lbSettle0S, lbSettle1S, lbSettle1T,
                 lbDetect, lbDetect2, lbDetect3, lbDecode]


#### Assumption for UB >= LB #######################
Biphase_bounds_order = [['m1','M1'], ['c','C'], ['h','H'], ['d','D'], ['t','T']]



#### METEORS system object
Biphase_sys = EOAsystem(Bipahse_ubSet, Bipahse_lbSet, Biphase_bounds_order, [[['C'],['m1']]])



#############################################################
######## Specification of bad event orders ##################
#############################################################

B1_0_0 = ['Edge0S', 'Edge0S']
B1_0_1 = ['Edge0S', 'Edge1S']
B1_1 =   ['Edge1S', 'Edge1T']



## Decode(\bot)-(Detect(false))*-Edge0S-(Detect(false))*-WireSettled-Edge0/1S

B2_0 =   ['bot','Edge0S','WireSettled','Edge0S'] ## decompose {DetectF} in [0,2]
B2_1 =   ['bot','Edge0S','WireSettled','Edge1S'] ## decompose {DetectF} in [0,2]

B2d_0 = ['Decode','Edge0S','WireSettled','Edge0S'] ## decompose {DetectF} in [0,2]
B2d_1 = ['Decode','Edge0S','WireSettled','Edge1S'] ## decompose {DetectF} in [0,2]

## Decode(\bot)-(Detect(false))*-Edge1S-(Detect(false))*-WireSettled-Edge1T

B2_1S = ['bot','Edge1S','WireSettled','Edge1T'] ## decompose {DetectF} in [0,2]
B2d_1S = ['Decode','Edge1S','WireSettled','Edge1T'] ## decompose {DetectF} in [0,2]

## Decode(\bot)-Edge0S-WireSettled_Detect(true)-Edge0/1S: insert {Detect(false)} in [1,3]
B6_0 =   ['bot','Edge0S','WireSettled','DetectT','Edge0S']  ## decompose {DetectF} in [0,2]
B6_1 =   ['bot','Edge0S','WireSettled','DetectT','Edge1S']  ## decompose {DetectF} in [0,2]

B6d_0 =   ['Decode','Edge0S','WireSettled','DetectT','Edge0S'] ## decompose {DetectF} in [0,2]
B6d_1 =   ['Decode','Edge0S','WireSettled','DetectT','Edge1S'] ## decompose {DetectF} in [0,2]

## Decode(\bot)-Edge1S-WireSettled-Detect(true)-Edge1T-Edge0/1S: 
##               insert {Detect(false)} in [1,3]; {WireSettled} in [5,6]
B6_2_0 =   ['bot','Edge1S','WireSettled','DetectT','Edge1T','Edge0S'] ## decompose {DetectF} in [0, 2]; insert {WireSettled} in [4,5]
B6_2_1 =   ['bot','Edge1S','WireSettled','DetectT','Edge1T','Edge1S'] ## decompose {DetectF} in [0, 2]; insert {WireSettled} in [4,5]

B6_2d_0 =   ['Decode','Edge1S','WireSettled','DetectT','Edge1T','Edge0S'] ## decompose {DetectF} in [0, 2]; insert {WireSettled} in [4,5]
B6_2d_1 =   ['Decode','Edge1S','WireSettled','DetectT','Edge1T','Edge1S'] ## decompose {DetectF} in [0, 2]; insert {WireSettled} in [4,5]

ignoreWS45 = [IgnoredEventSet(['WireSettled'], 4, 5)]

## Edge1S-Detect(true)-Edge1T-Decode: insert {Detect(false)} to [1,2], {WireSettled} to [1,3]
B3 = ['Edge1S','DetectT','Edge1T','Decode'] ## decompose {Detect(false)} to [0,1]; insert {WireSettled} to [0,2]

## Edge1S-Detect(true)-Decode: insert {Detect} in [1,2], {WireSettled} in [1,3]
B4 = ['Edge1S','DetectT','Decode'] ## decompose {Detect(false)} to [0,1]; insert {WireSettled} to [0,2]

#ignoreDF01_12 = [IgnoredEventSet(['DetectF'], 0, 1),IgnoredEventSet(['DetectF'], 1, 2)]
ignoreDF01 = [IgnoredEventSet(['DetectF'], 0, 1)]
ignoreDF02 = [IgnoredEventSet(['DetectF'], 0, 2)]
ignoreWS02 = [IgnoredEventSet(['WireSettled'], 0, 2)]
ignoreDF01_WS02 = [IgnoredEventSet(['DetectF'], 0, 1), IgnoredEventSet(['WireSettled'], 0, 2)]

## Edge0s-Detect(true)-Decode: insert {Detect(false)} in [1,2]
B5 = ['Edge0S','DetectT','Decode'] ## decompose {Detect(false)} to [0,1]

## Edge0s-Detect(true)-WireSettled-Edge0/1S: insert {Detect(false)} in [1,2]
B7_0 = ['Edge0S','DetectT','WireSettled','Edge0S'] ## decompose {Detect(false)} in [0,1]
B7_1 = ['Edge0S','DetectT','WireSettled','Edge1S'] ## decompose {Detect(false)} in [0,1]

## Edge1S-Detect(true)-WireSettled-Edge1T-Edge0/1S: insert {Detect(false)} to [1,2]; {WireSettled} to [4,5]
B7_2_0 = ['Edge1S','DetectT','WireSettled','Edge1T','Edge0S'] ## decompose {Detect(false)} in [0,1]; insert {WireSettled} to [3,4]
B7_2_1 = ['Edge1S','DetectT','WireSettled','Edge1T','Edge1S'] ## decompose {Detect(false)} to [0,1]; insert {WireSettled} to [3,4]

#ignoreDF01_WS34 = [IgnoredEventSet(['DetectF'], 0, 1), IgnoredEventSet(['WireSettled'], 3, 4)]
ignoreWS34 = [IgnoredEventSet(['WireSettled'], 3, 4)]

ignored0 = []

#####################################################################################

# Biphase_sys.printOn = True


# B1

Biphase_sys.addEventOrder(B1_0_0, ignored0)
Biphase_sys.addEventOrder(B1_0_1, ignored0)
Biphase_sys.addEventOrder(B1_1,   ignored0)

## B2 0

Biphase_sys.addEventOrderWithDecomposition(B2_0,  ignoreDF02[0],[])
Biphase_sys.addEventOrderWithDecomposition(B2_1,  ignoreDF02[0],[])
Biphase_sys.addEventOrderWithDecomposition(B2d_0, ignoreDF02[0],[])
Biphase_sys.addEventOrderWithDecomposition(B2d_1, ignoreDF02[0],[])

## B2 1S

Biphase_sys.addEventOrderWithDecomposition(B2_1S, ignoreDF02[0],[])
Biphase_sys.addEventOrderWithDecomposition(B2d_1S, ignoreDF02[0],[])

## B6 0/1S
Biphase_sys.addEventOrderWithDecomposition(B6_0, ignoreDF02[0],[])
Biphase_sys.addEventOrderWithDecomposition(B6_1, ignoreDF02[0],[])

Biphase_sys.addEventOrderWithDecomposition(B6d_0, ignoreDF02[0],[])
Biphase_sys.addEventOrderWithDecomposition(B6d_1, ignoreDF02[0],[])

## B6 2
Biphase_sys.addEventOrderWithDecomposition(B6_2_0, ignoreDF02[0], ignoreWS45)
Biphase_sys.addEventOrderWithDecomposition(B6_2_1, ignoreDF02[0], ignoreWS45)

Biphase_sys.addEventOrderWithDecomposition(B6_2d_0, ignoreDF02[0], ignoreWS45)
Biphase_sys.addEventOrderWithDecomposition(B6_2d_1, ignoreDF02[0], ignoreWS45)

## B3
Biphase_sys.addEventOrderWithDecomposition(B3, ignoreDF01[0], ignoreWS02)


## B4

Biphase_sys.addEventOrderWithDecomposition(B4, ignoreDF01[0], ignoreWS02)

## B5

Biphase_sys.addEventOrderWithDecomposition(B5, ignoreDF01[0], [])

## B7

Biphase_sys.addEventOrderWithDecomposition(B7_0, ignoreDF01[0], [])
Biphase_sys.addEventOrderWithDecomposition(B7_1, ignoreDF01[0], [])
Biphase_sys.addEventOrderWithDecomposition(B7_2_0, ignoreDF01[0], ignoreWS34)
Biphase_sys.addEventOrderWithDecomposition(B7_2_1, ignoreDF01[0], ignoreWS34)

print 'Apply simplications and display the resulting constraints:'
Biphase_sys.simplify()
Biphase_sys.printConstraintList()
print ''
print 'The list of constraints sufficient to exclude each bad event orders:'

## B1
print 'B1:' 
Biphase_sys.subsumedByDerivedConstraints(B1_0_0, ignored0)
Biphase_sys.subsumedByDerivedConstraints(B1_0_1, ignored0)
Biphase_sys.subsumedByDerivedConstraints(B1_1,   ignored0)

## B2 0
print 'B2 0:'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B2_0,  ignoreDF02[0],[])
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B2_1,  ignoreDF02[0],[])
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B2d_0, ignoreDF02[0],[])
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B2d_1, ignoreDF02[0],[])

## B2 1S
print 'B2 1S:'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B2_1S, ignoreDF02[0],[])
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B2d_1S, ignoreDF02[0],[])

## B3
print 'B3:'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B3, ignoreDF01[0], ignoreWS02)

## B4
print 'B4:'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B4, ignoreDF01[0], ignoreWS02)
    
## B5
print 'B5:'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B5, ignoreDF01[0], [])

## B6 0S
print 'B6 0S:'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B6_0, ignoreDF02[0],[])
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B6_1, ignoreDF02[0],[])

Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B6d_0, ignoreDF02[0],[])
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B6d_1, ignoreDF02[0],[])

## B6 1S
print 'B6 1S:'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B6_2_0, ignoreDF02[0], ignoreWS45)
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B6_2_1, ignoreDF02[0], ignoreWS45)

Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B6_2d_0, ignoreDF02[0], ignoreWS45)
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B6_2d_1, ignoreDF02[0], ignoreWS45)

## B7
print 'B7 0S'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B7_0, ignoreDF01[0], [])
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B7_1, ignoreDF01[0], [])
print 'B7 1S'
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B7_2_0, ignoreDF01[0], ignoreWS34)
Biphase_sys.subsumedByDerivedConstraintsForDecomposition(B7_2_1, ignoreDF01[0], ignoreWS34)
