def main():
"""
-----------------------------------------------------------------
--|-------------------------------------------------------------- | -----------------------------
| Initiator Process | | | Fabric |
| | | | |
| ------------------- ---------- | | |--------- ---------| -----------
| | Init. Procedure |---enqueue()--->| Queue |<---dequeue()------------ Socket |----- | Socket ---->| Target |
| | (BW Generator) | | (FIFO) | (implicit) | | |--------- | ---------| | Process |
| ------------------- ---------- | | | | | | -----------
| | | | ------------ |
| ------------------- ---------- | | |--------- | ARBITER | |
| | Init. Procedure |---enqueue()--->| Queue |<---dequeue()------------ Socket |---| | |
| | (BW Generator) | | (FIFO) | (implicit) | | |--------- | | |
| ------------------- ---------- | | | . | | |
| . . | | | . | | |
| . . | | | . ------------ |
| . . | | | . | | |
| ------------------- ---------- | | |--------- | ---------| -----------
| | Init. Procedure |---enqueue()--->| Queue |<---dequeue()------------ Socket |----- | Socket ---->| Target |
| | (BW Generator) | | (FIFO) | (implicit) | | |--------- ---------| | Process |
| ------------------- ---------- |-- | | -----------
----------------------------------------------------------------- -----------------------------
"""
env = simpy.Environment()
aux = Auxiliary(env, inc.global_params['DEBUG_LEVEL'])
tb = {'ENV': env, 'AUX': aux}
# ========================================================================================
aux.timestamp(__name__, "Initialization Phase started")
# Create Initiators:
tb['INITIATORS'] = {
'CPU': Initiator('CPU', inc.initiators_params['CPU'], tb),
'PCIE': Initiator('PCIE', inc.initiators_params['PCIE'], tb)
}
# ------------------------------------------------------
# Create Targets:
tb['TARGETS'] = {
'SRAM': Target('SRAM', inc.targets_params['SRAM'], tb),
'ROM': Target('ROM', inc.targets_params['ROM'], tb)
}
# ------------------------------------------------------
# Create Fabric:
tb['FABRIC'] = Fabric('DATA', inc.fabric_params, tb)
aux.timestamp(__name__, "Initialization Phase completed")
# ========================================================================================
aux.timestamp(__name__, "Run Phase started")
tb['ENV'].run(until=inc.global_params['SIMULATION_TIME_IN_CYCLES'])
aux.timestamp(__name__, "Run Phase completed")
def executeModelTop(showFlows):
##Auxiliaries
MultiplierSchedPressure = Auxiliary("MultiplierSchedPressure")
MultiplierWorkforce = Auxiliary("MultiplierWorkforce")
NominalErr = Auxiliary("NominalErr")
SWDevelopmentRate = Auxiliary("SWDevelopmentRate")
PotErrDetectRate = Auxiliary("PotErrDetectRate")
QARate = Auxiliary("QARate")
AvgErrPerTask = Auxiliary("AvgErrPerTask")
ActualReworkMP = Auxiliary("ActualReworkMP")
DailyMPRework = Auxiliary("DailyMPRework")
### Flows
ErrGenRate = Flow("ErrGenRate")
ErrDetRate = Flow("ErrDetRate")
ErrEscapeRate = Flow("ErrEscapeRate")
ReworkRate = Flow("ReworkRate")
## we need to fill up auxiliaries ...
auxDict = utility.createAuxiliaries_Top()
##States
curr = State("CurrentState", True)
prev = State("PrevState", True)
dt = 1
##output & test purpose
stockDict ={}
for key_,val_ in auxDict.items():
# current state's stocks are dependent on prev. state's flows
# some have in and out flows
curr.PotentiallyDetectableError_.setInput(dt * (prev.ErrGenRate_.curr - prev.ErrDetRate_.curr - prev.ErrEscapeRate_.curr ))
curr.DetectedError_.setInput( dt*( ErrDetRate.curr - ReworkRate.curr ))
# some only have in flows
curr.EscapedError_.setInput( dt*(ErrEscapeRate.curr))
curr.ReworkedError_.setInput(dt*(ReworkRate.curr))
print "{} ---> {}".format( key_, curr)
#setup output
stockDict[key_]=[curr.PotentiallyDetectableError_.curr, curr.DetectedError_.curr, curr.EscapedError_.curr, curr.ReworkedError_.curr]
print "---------------"
#setting up auxiliaries
MultiplierSchedPressure.setInput(val_[0])
MultiplierWorkforce.setInput(val_[1])
NominalErr.setInput(val_[2])
SWDevelopmentRate.setInput(val_[3])
PotErrDetectRate.setInput(val_[4])
AvgErrPerTask.setInput(val_[5])
QARate.setInput(val_[6])
ActualReworkMP.setInput(val_[7])
DailyMPRework.setInput(val_[8])
#filling flows
ErrGenRate.fillFlowsByAuxs(MultiplierSchedPressure, MultiplierWorkforce, NominalErr, SWDevelopmentRate)
ErrDetRate.fillFlowsByAuxs(PotErrDetectRate)
ErrEscapeRate.fillFlowsByAuxs(AvgErrPerTask, QARate)
ReworkRate.fillFlowsByAuxs(ActualReworkMP, DailyMPRework)
# updating current state's flows
curr.updateErrGenRate(ErrGenRate)
curr.updateErrDetRate(ErrDetRate)
curr.updateErrEscapeRate(ErrEscapeRate)
curr.updateReworkRate(ReworkRate)
if(showFlows):
print "{} ---> {}".format( key_, curr.getFlows())
print "---------------"
prev = curr.copyTop("Prev")
#print "Prev: ZZZ ",prev_
print "###################"
return stockDict
def executeModelBottom(showFlows):
## Eight Unique Auxiliaries
TimeToSmooth = Auxiliary("TimeToSmooth")
MultiplierToRegen = Auxiliary("MultiplierToRegen")
ActiveErrorDensity = Auxiliary("ActiveErrorDensity")
TestingRate = Auxiliary("TestingRate")
PassiveErrorDensity = Auxiliary("PassiveErrorDensity")
FractionEscapingErrors = Auxiliary("FractionEscapingErrors")
ActiveErrorsRetiringFraction = Auxiliary("ActiveErrorsRetiringFraction")
BadFixGenRate = Auxiliary("BadFixGenRate")
## Six Flows
ActiveErrorRegenRate = Flow("ActiveErrorRegenRate")
ActiveErrorDetectAndCorrectRate = Flow("ActiveErrorDetectAndCorrectRate")
ActiveErrorRetirementRate = Flow("ActiveErrorRetirementRate")
PassiveErrorDetectAndCorrectRate = Flow("PassiveErrorDetectAndCorrectRate")
PassiveErrorGenRate = Flow("PassiveErrorGenRate")
ActiveErrorGenRate = Flow("ActiveErrorGenRate")
auxDict = utility.createAuxiliaries_Bottom()
##States
curr = State("CurrentState", False)
prev = State("PrevState", False)
dt = 1
##output & test purpose
stockDict ={}
for key_, val_ in auxDict.items():
# Update stock from inflows and outflows
curr.UndetectedActiveErrors_.setInput(dt * (prev.ActiveErrorRegenRate_.curr + prev.ActiveErrorGenRate_.curr) - (prev.ActiveErrorRetirementRate_.curr + prev.ActiveErrorDetectAndCorrectRate_.curr) )
curr.UndetectedPassiveErrors_.setInput(dt * (prev.ActiveErrorRetirementRate_.curr + prev.PassiveErrorGenRate_.curr)- prev.PassiveErrorDetectAndCorrectRate_.curr)
print "{} ---> {}".format( key_, curr)
stockDict[key_]=[curr.UndetectedActiveErrors_.curr]
print "---------------"
#Setting up eight Auxiliaries
TimeToSmooth.setInput(val_[0])
MultiplierToRegen.setInput(val_[1])
ActiveErrorDensity.setInput(val_[2])
TestingRate.setInput(val_[3])
ActiveErrorsRetiringFraction.setInput(val_[4])
FractionEscapingErrors.setInput(val_[5])
BadFixGenRate.setInput(val_[6])
PassiveErrorDensity.setInput(val_[7] + curr.UndetectedPassiveErrors_.curr)
# Filling Flows : six flows
ActiveErrorRegenRate.fillFlowsByAuxs(TimeToSmooth, MultiplierToRegen, ActiveErrorDensity)
ActiveErrorDetectAndCorrectRate.fillFlowsByAuxs(ActiveErrorDensity)
ActiveErrorRetirementRate.fillFlowsByAuxs(TestingRate, ActiveErrorsRetiringFraction)
ActiveErrorGenRate.fillFlowsByAuxs(FractionEscapingErrors, BadFixGenRate)
PassiveErrorGenRate.fillFlowsByAuxs(BadFixGenRate, FractionEscapingErrors)
PassiveErrorDetectAndCorrectRate.fillFlowsByAuxs(PassiveErrorDensity, TestingRate)
# updating current state's flows: six flows
curr.updateActiveErrorRegenRate(ActiveErrorRegenRate)
curr.updateActiveErrorDetectAndCorrectRate(ActiveErrorDetectAndCorrectRate)
curr.updateActiveErrorRetirementRate(ActiveErrorRetirementRate)
curr.updateActiveErrorGenRate(ActiveErrorGenRate)
curr.updatePassiveErrorGenRate(PassiveErrorGenRate)
curr.updatePassiveErrorDetectAndCorrectRate(PassiveErrorDetectAndCorrectRate)
if(showFlows):
print "{} ---> {}".format( key_, curr.getFlows())
print "---------------"
prev = curr.copyBottom("Prev")
#print "Prev: ZZZ ",prev_
print "###################"
return stockDict
def executeModelForBaseline(auxListParam, currStateParam, prevStateParam, dt):
##Nine Unique Auxiliaries : Top
MultiplierSchedPressure = Auxiliary("MultiplierSchedPressure")
MultiplierWorkforce = Auxiliary("MultiplierWorkforce")
NominalErr = Auxiliary("NominalErr")
SWDevelopmentRate = Auxiliary("SWDevelopmentRate")
PotErrDetectRate = Auxiliary("PotErrDetectRate")
QARate = Auxiliary("QARate")
AvgErrPerTask = Auxiliary("AvgErrPerTask")
ActualReworkMP = Auxiliary("ActualReworkMP")
DailyMPRework = Auxiliary("DailyMPRework")
## Eight Unique Auxiliaries :Bottom
TimeToSmooth = Auxiliary("TimeToSmooth")
MultiplierToRegen = Auxiliary("MultiplierToRegen")
ActiveErrorDensity = Auxiliary("ActiveErrorDensity")
TestingRate = Auxiliary("TestingRate")
PassiveErrorDensity = Auxiliary("PassiveErrorDensity")
FractionEscapingErrors = Auxiliary("FractionEscapingErrors")
ActiveErrorsRetiringFraction = Auxiliary("ActiveErrorsRetiringFraction")
BadFixGenRate = Auxiliary("BadFixGenRate")
### Four Flows from Top
ErrGenRate = Flow("ErrGenRate")
ErrDetRate = Flow("ErrDetRate")
ErrEscapeRate = Flow("ErrEscapeRate")
ReworkRate = Flow("ReworkRate")
## Six Flows from Bottom
ActiveErrorRegenRate = Flow("ActiveErrorRegenRate")
ActiveErrorDetectAndCorrectRate = Flow("ActiveErrorDetectAndCorrectRate")
ActiveErrorRetirementRate = Flow("ActiveErrorRetirementRate")
PassiveErrorDetectAndCorrectRate = Flow("PassiveErrorDetectAndCorrectRate")
PassiveErrorGenRate = Flow("PassiveErrorGenRate")
ActiveErrorGenRate = Flow("ActiveErrorGenRate")
# current state's stocks are dependent on prev. state's flows
# some have in and out flows
currStateParam.PotentiallyDetectableError_.setInput(
dt *
(prevStateParam.ErrGenRate_.curr - prevStateParam.ErrDetRate_.curr -
prevStateParam.ErrEscapeRate_.curr))
currStateParam.DetectedError_.setInput(
dt *
(prevStateParam.ErrDetRate_.curr - prevStateParam.ReworkRate_.curr))
# some only have in flows from top
currStateParam.EscapedError_.setInput(dt *
(prevStateParam.ErrEscapeRate_.curr))
currStateParam.ReworkedError_.setInput(dt *
(prevStateParam.ReworkRate_.curr))
# Update stock from inflows and outflows from Bottom
currStateParam.UndetectedActiveErrors_.setInput(
dt * (prevStateParam.ActiveErrorRegenRate_.curr +
prevStateParam.ActiveErrorGenRate_.curr) -
(prevStateParam.ActiveErrorRetirementRate_.curr +
prevStateParam.ActiveErrorDetectAndCorrectRate_.curr))
currStateParam.UndetectedPassiveErrors_.setInput(
dt * (prevStateParam.ActiveErrorRetirementRate_.curr +
prevStateParam.PassiveErrorGenRate_.curr) -
prevStateParam.PassiveErrorDetectAndCorrectRate_.curr)
#setting up auxiliaries
MultiplierSchedPressure.setInput(auxListParam[0])
MultiplierWorkforce.setInput(auxListParam[1])
NominalErr.setInput(auxListParam[2])
SWDevelopmentRate.setInput(auxListParam[3])
PotErrDetectRate.setInput(auxListParam[4])
AvgErrPerTask.setInput(auxListParam[5])
QARate.setInput(auxListParam[6])
ActualReworkMP.setInput(auxListParam[7])
DailyMPRework.setInput(auxListParam[8])
#Setting up eight Auxiliaries from Bottom
TimeToSmooth.setInput(auxListParam[9])
MultiplierToRegen.setInput(auxListParam[10])
ActiveErrorDensity.setInput(auxListParam[11])
TestingRate.setInput(auxListParam[12])
ActiveErrorsRetiringFraction.setInput(auxListParam[13])
PassiveErrorDensity.setInput(auxListParam[16] +
currStateParam.UndetectedPassiveErrors_.curr)
#filling flows on the top
ErrGenRate.fillFlowsByAuxs(MultiplierSchedPressure, MultiplierWorkforce,
NominalErr, SWDevelopmentRate)
ErrDetRate.fillFlowsByAuxs(PotErrDetectRate)
ErrEscapeRate.fillFlowsByAuxs(AvgErrPerTask, QARate)
ReworkRate.fillFlowsByAuxs(ActualReworkMP, DailyMPRework)
# updating current state's flows
currStateParam.updateErrGenRate(ErrGenRate)
currStateParam.updateErrDetRate(ErrDetRate)
currStateParam.updateErrEscapeRate(ErrEscapeRate)
currStateParam.updateReworkRate(ReworkRate)
# Connecting top to the bottom
# Error Escape Rate -> Fraction Escaping Errors
# Rework Rate -> Bad Fix Generation Rate
FractionEscapingErrors.setInput(auxListParam[14] + ErrEscapeRate.curr)
BadFixGenRate.setInput(auxListParam[15] + ReworkRate.curr)
# Filling Flows : six flows from Bottom
ActiveErrorRegenRate.fillFlowsByAuxs(TimeToSmooth, MultiplierToRegen,
ActiveErrorDensity)
ActiveErrorDetectAndCorrectRate.fillFlowsByAuxs(ActiveErrorDensity)
ActiveErrorRetirementRate.fillFlowsByAuxs(TestingRate,
ActiveErrorsRetiringFraction)
ActiveErrorGenRate.fillFlowsByAuxs(FractionEscapingErrors, BadFixGenRate)
PassiveErrorGenRate.fillFlowsByAuxs(BadFixGenRate, FractionEscapingErrors)
PassiveErrorDetectAndCorrectRate.fillFlowsByAuxs(PassiveErrorDensity,
TestingRate)
# updating current state's flows: six flows from bottom
currStateParam.updateActiveErrorRegenRate(ActiveErrorRegenRate)
currStateParam.updateActiveErrorDetectAndCorrectRate(
ActiveErrorDetectAndCorrectRate)
currStateParam.updateActiveErrorRetirementRate(ActiveErrorRetirementRate)
currStateParam.updateActiveErrorGenRate(ActiveErrorGenRate)
currStateParam.updatePassiveErrorGenRate(PassiveErrorGenRate)
currStateParam.updatePassiveErrorDetectAndCorrectRate(
PassiveErrorDetectAndCorrectRate)
## copying current to prev.
prevStateParam = currStateParam.copyAll("prev")
return prevStateParam, currStateParam
def executeModelAll(showFlows):
##Nine Unique Auxiliaries : Top
MultiplierSchedPressure = Auxiliary("MultiplierSchedPressure")
MultiplierWorkforce = Auxiliary("MultiplierWorkforce")
NominalErr = Auxiliary("NominalErr")
SWDevelopmentRate = Auxiliary("SWDevelopmentRate")
PotErrDetectRate = Auxiliary("PotErrDetectRate")
QARate = Auxiliary("QARate")
AvgErrPerTask = Auxiliary("AvgErrPerTask")
ActualReworkMP = Auxiliary("ActualReworkMP")
DailyMPRework = Auxiliary("DailyMPRework")
## Eight Unique Auxiliaries :Bottom
TimeToSmooth = Auxiliary("TimeToSmooth")
MultiplierToRegen = Auxiliary("MultiplierToRegen")
ActiveErrorDensity = Auxiliary("ActiveErrorDensity")
TestingRate = Auxiliary("TestingRate")
PassiveErrorDensity = Auxiliary("PassiveErrorDensity")
FractionEscapingErrors = Auxiliary("FractionEscapingErrors")
ActiveErrorsRetiringFraction = Auxiliary("ActiveErrorsRetiringFraction")
BadFixGenRate = Auxiliary("BadFixGenRate")
### Four Flows from Top
ErrGenRate = Flow("ErrGenRate")
ErrDetRate = Flow("ErrDetRate")
ErrEscapeRate = Flow("ErrEscapeRate")
ReworkRate = Flow("ReworkRate")
## Six Flows from Bottom
ActiveErrorRegenRate = Flow("ActiveErrorRegenRate")
ActiveErrorDetectAndCorrectRate = Flow("ActiveErrorDetectAndCorrectRate")
ActiveErrorRetirementRate = Flow("ActiveErrorRetirementRate")
PassiveErrorDetectAndCorrectRate = Flow("PassiveErrorDetectAndCorrectRate")
PassiveErrorGenRate = Flow("PassiveErrorGenRate")
ActiveErrorGenRate = Flow("ActiveErrorGenRate")
## we need to fill up auxiliaries ...
auxDict = utility.createAuxiliaries_All()
##States
curr = StateAll("CurrentState")
prev = StateAll("PrevState")
dt = 1
##output & test purpose
stockDict = {}
for key_, val_ in auxDict.items():
# current state's stocks are dependent on prev. state's flows
# some have in and out flows
curr.PotentiallyDetectableError_.setInput(
dt * (prev.ErrGenRate_.curr - prev.ErrDetRate_.curr -
prev.ErrEscapeRate_.curr))
curr.DetectedError_.setInput(
dt * (prev.ErrDetRate_.curr - prev.ReworkRate_.curr))
# some only have in flows from top
curr.EscapedError_.setInput(dt * (prev.ErrEscapeRate_.curr))
curr.ReworkedError_.setInput(dt * (prev.ReworkRate_.curr))
# Update stock from inflows and outflows from Bottom
curr.UndetectedActiveErrors_.setInput(
dt *
(prev.ActiveErrorRegenRate_.curr + prev.ActiveErrorGenRate_.curr) -
(prev.ActiveErrorRetirementRate_.curr +
prev.ActiveErrorDetectAndCorrectRate_.curr))
curr.UndetectedPassiveErrors_.setInput(
dt * (prev.ActiveErrorRetirementRate_.curr +
prev.PassiveErrorGenRate_.curr) -
prev.PassiveErrorDetectAndCorrectRate_.curr)
print "{} ---> {}".format(key_, curr)
#setup output
stockDict[key_] = [
curr.PotentiallyDetectableError_.curr, curr.DetectedError_.curr,
curr.EscapedError_.curr, curr.ReworkedError_.curr,
curr.UndetectedActiveErrors_.curr,
curr.UndetectedPassiveErrors_.curr
]
print "---------------"
#setting up auxiliaries
MultiplierSchedPressure.setInput(val_[0])
MultiplierWorkforce.setInput(val_[1])
NominalErr.setInput(val_[2])
SWDevelopmentRate.setInput(val_[3])
PotErrDetectRate.setInput(val_[4])
AvgErrPerTask.setInput(val_[5])
QARate.setInput(val_[6])
ActualReworkMP.setInput(val_[7])
DailyMPRework.setInput(val_[8])
#Setting up eight Auxiliaries from Bottom
TimeToSmooth.setInput(val_[9])
MultiplierToRegen.setInput(val_[10])
ActiveErrorDensity.setInput(val_[11])
TestingRate.setInput(val_[12])
ActiveErrorsRetiringFraction.setInput(val_[13])
PassiveErrorDensity.setInput(val_[16] +
curr.UndetectedPassiveErrors_.curr)
#filling flows on the top
ErrGenRate.fillFlowsByAuxs(MultiplierSchedPressure,
MultiplierWorkforce, NominalErr,
SWDevelopmentRate)
ErrDetRate.fillFlowsByAuxs(PotErrDetectRate)
ErrEscapeRate.fillFlowsByAuxs(AvgErrPerTask, QARate)
ReworkRate.fillFlowsByAuxs(ActualReworkMP, DailyMPRework)
# updating current state's flows
curr.updateErrGenRate(ErrGenRate)
curr.updateErrDetRate(ErrDetRate)
curr.updateErrEscapeRate(ErrEscapeRate)
curr.updateReworkRate(ReworkRate)
# Connecting top to the bottom
# Error Escape Rate -> Fraction Escaping Errors
# Rework Rate -> Bad Fix Generation Rate
FractionEscapingErrors.setInput(val_[14] + ErrEscapeRate.curr)
BadFixGenRate.setInput(val_[15] + ReworkRate.curr)
# Filling Flows : six flows from Bottom
ActiveErrorRegenRate.fillFlowsByAuxs(TimeToSmooth, MultiplierToRegen,
ActiveErrorDensity)
ActiveErrorDetectAndCorrectRate.fillFlowsByAuxs(ActiveErrorDensity)
ActiveErrorRetirementRate.fillFlowsByAuxs(
TestingRate, ActiveErrorsRetiringFraction)
ActiveErrorGenRate.fillFlowsByAuxs(FractionEscapingErrors,
BadFixGenRate)
PassiveErrorGenRate.fillFlowsByAuxs(BadFixGenRate,
FractionEscapingErrors)
PassiveErrorDetectAndCorrectRate.fillFlowsByAuxs(
PassiveErrorDensity, TestingRate)
# updating current state's flows: six flows from bottom
curr.updateActiveErrorRegenRate(ActiveErrorRegenRate)
curr.updateActiveErrorDetectAndCorrectRate(
ActiveErrorDetectAndCorrectRate)
curr.updateActiveErrorRetirementRate(ActiveErrorRetirementRate)
curr.updateActiveErrorGenRate(ActiveErrorGenRate)
curr.updatePassiveErrorGenRate(PassiveErrorGenRate)
curr.updatePassiveErrorDetectAndCorrectRate(
PassiveErrorDetectAndCorrectRate)
if (showFlows):
print "Printing F-L-O-W-S !"
print "key, flow value ---> {}, {}".format(key_, curr.getFlows())
## copying current to prev.
prev = curr.copyAll("prev")
print "###################"
return stockDict
from Auxiliary import Auxiliary
import Statement
import datetime
aux = Auxiliary()
try:
fullpath, filename, file_extention = aux.getSourceStatementName()
print (filename)
except AttributeError:
exit(0)
acceptext = [".DBF", ".CSV"]
if file_extention not in acceptext:
exit(0)
elif file_extention == ".CSV":
statement = Statement.MarfinStatement()
elif file_extention == ".DBF":
statement = Statement.PivdennyStatement()
suffix = statement.createOutDbfName()
outputDbfName = fullpath +"\\"+suffix.upper() + ".DBF"
def executeModelForBaseline(auxListParam, currStateParam, prevStateParam, dt):
##Nine Unique Auxiliaries : Top
MultiplierSchedPressure = Auxiliary("MultiplierSchedPressure")
MultiplierWorkforce = Auxiliary("MultiplierWorkforce")
NominalErr = Auxiliary("NominalErr")
SWDevelopmentRate = Auxiliary("SWDevelopmentRate")
PotErrDetectRate = Auxiliary("PotErrDetectRate")
QARate = Auxiliary("QARate")
AvgErrPerTask = Auxiliary("AvgErrPerTask")
ActualReworkMP = Auxiliary("ActualReworkMP")
DailyMPRework = Auxiliary("DailyMPRework")
## Eight Unique Auxiliaries :Bottom
TimeToSmooth = Auxiliary("TimeToSmooth")
MultiplierToRegen = Auxiliary("MultiplierToRegen")
ActiveErrorDensity = Auxiliary("ActiveErrorDensity")
TestingRate = Auxiliary("TestingRate")
PassiveErrorDensity = Auxiliary("PassiveErrorDensity")
FractionEscapingErrors = Auxiliary("FractionEscapingErrors")
ActiveErrorsRetiringFraction = Auxiliary("ActiveErrorsRetiringFraction")
BadFixGenRate = Auxiliary("BadFixGenRate")
### Four Flows from Top
ErrGenRate = Flow("ErrGenRate")
ErrDetRate = Flow("ErrDetRate")
ErrEscapeRate = Flow("ErrEscapeRate")
ReworkRate = Flow("ReworkRate")
## Six Flows from Bottom
ActiveErrorRegenRate = Flow("ActiveErrorRegenRate")
ActiveErrorDetectAndCorrectRate = Flow("ActiveErrorDetectAndCorrectRate")
ActiveErrorRetirementRate = Flow("ActiveErrorRetirementRate")
PassiveErrorDetectAndCorrectRate = Flow("PassiveErrorDetectAndCorrectRate")
PassiveErrorGenRate = Flow("PassiveErrorGenRate")
ActiveErrorGenRate = Flow("ActiveErrorGenRate")
# current state's stocks are dependent on prev. state's flows
# some have in and out flows
currStateParam.PotentiallyDetectableError_.setInput(dt * (prevStateParam.ErrGenRate_.curr - prevStateParam.ErrDetRate_.curr - prevStateParam.ErrEscapeRate_.curr ))
currStateParam.DetectedError_.setInput( dt*( prevStateParam.ErrDetRate_.curr - prevStateParam.ReworkRate_.curr ))
# some only have in flows from top
currStateParam.EscapedError_.setInput( dt*(prevStateParam.ErrEscapeRate_.curr))
currStateParam.ReworkedError_.setInput(dt*(prevStateParam.ReworkRate_.curr))
# Update stock from inflows and outflows from Bottom
currStateParam.UndetectedActiveErrors_.setInput(dt * (prevStateParam.ActiveErrorRegenRate_.curr + prevStateParam.ActiveErrorGenRate_.curr) - (prevStateParam.ActiveErrorRetirementRate_.curr + prevStateParam.ActiveErrorDetectAndCorrectRate_.curr) )
currStateParam.UndetectedPassiveErrors_.setInput(dt * (prevStateParam.ActiveErrorRetirementRate_.curr + prevStateParam.PassiveErrorGenRate_.curr)- prevStateParam.PassiveErrorDetectAndCorrectRate_.curr)
#setting up auxiliaries
MultiplierSchedPressure.setInput(auxListParam[0])
MultiplierWorkforce.setInput(auxListParam[1])
NominalErr.setInput(auxListParam[2])
SWDevelopmentRate.setInput(auxListParam[3])
PotErrDetectRate.setInput(auxListParam[4])
AvgErrPerTask.setInput(auxListParam[5])
QARate.setInput(auxListParam[6])
ActualReworkMP.setInput(auxListParam[7])
DailyMPRework.setInput(auxListParam[8])
#Setting up eight Auxiliaries from Bottom
TimeToSmooth.setInput(auxListParam[9])
MultiplierToRegen.setInput(auxListParam[10])
ActiveErrorDensity.setInput(auxListParam[11])
TestingRate.setInput(auxListParam[12])
ActiveErrorsRetiringFraction.setInput(auxListParam[13])
PassiveErrorDensity.setInput(auxListParam[16] + currStateParam.UndetectedPassiveErrors_.curr)
#filling flows on the top
ErrGenRate.fillFlowsByAuxs(MultiplierSchedPressure, MultiplierWorkforce, NominalErr, SWDevelopmentRate)
ErrDetRate.fillFlowsByAuxs(PotErrDetectRate)
ErrEscapeRate.fillFlowsByAuxs(AvgErrPerTask, QARate)
ReworkRate.fillFlowsByAuxs(ActualReworkMP, DailyMPRework)
# updating current state's flows
currStateParam.updateErrGenRate(ErrGenRate)
currStateParam.updateErrDetRate(ErrDetRate)
currStateParam.updateErrEscapeRate(ErrEscapeRate)
currStateParam.updateReworkRate(ReworkRate)
# Connecting top to the bottom
# Error Escape Rate -> Fraction Escaping Errors
# Rework Rate -> Bad Fix Generation Rate
FractionEscapingErrors.setInput(auxListParam[14] + ErrEscapeRate.curr)
BadFixGenRate.setInput(auxListParam[15] + ReworkRate.curr)
# Filling Flows : six flows from Bottom
ActiveErrorRegenRate.fillFlowsByAuxs(TimeToSmooth, MultiplierToRegen, ActiveErrorDensity)
ActiveErrorDetectAndCorrectRate.fillFlowsByAuxs(ActiveErrorDensity)
ActiveErrorRetirementRate.fillFlowsByAuxs(TestingRate, ActiveErrorsRetiringFraction)
ActiveErrorGenRate.fillFlowsByAuxs(FractionEscapingErrors, BadFixGenRate)
PassiveErrorGenRate.fillFlowsByAuxs(BadFixGenRate, FractionEscapingErrors)
PassiveErrorDetectAndCorrectRate.fillFlowsByAuxs(PassiveErrorDensity, TestingRate)
# updating current state's flows: six flows from bottom
currStateParam.updateActiveErrorRegenRate(ActiveErrorRegenRate)
currStateParam.updateActiveErrorDetectAndCorrectRate(ActiveErrorDetectAndCorrectRate)
currStateParam.updateActiveErrorRetirementRate(ActiveErrorRetirementRate)
currStateParam.updateActiveErrorGenRate(ActiveErrorGenRate)
currStateParam.updatePassiveErrorGenRate(PassiveErrorGenRate)
currStateParam.updatePassiveErrorDetectAndCorrectRate(PassiveErrorDetectAndCorrectRate)
## copying current to prev.
prevStateParam = currStateParam.copyAll("prev")
return prevStateParam, currStateParam
def executeModelAll(showFlows):
##Nine Unique Auxiliaries : Top
MultiplierSchedPressure = Auxiliary("MultiplierSchedPressure")
MultiplierWorkforce = Auxiliary("MultiplierWorkforce")
NominalErr = Auxiliary("NominalErr")
SWDevelopmentRate = Auxiliary("SWDevelopmentRate")
PotErrDetectRate = Auxiliary("PotErrDetectRate")
QARate = Auxiliary("QARate")
AvgErrPerTask = Auxiliary("AvgErrPerTask")
ActualReworkMP = Auxiliary("ActualReworkMP")
DailyMPRework = Auxiliary("DailyMPRework")
## Eight Unique Auxiliaries :Bottom
TimeToSmooth = Auxiliary("TimeToSmooth")
MultiplierToRegen = Auxiliary("MultiplierToRegen")
ActiveErrorDensity = Auxiliary("ActiveErrorDensity")
TestingRate = Auxiliary("TestingRate")
PassiveErrorDensity = Auxiliary("PassiveErrorDensity")
FractionEscapingErrors = Auxiliary("FractionEscapingErrors")
ActiveErrorsRetiringFraction = Auxiliary("ActiveErrorsRetiringFraction")
BadFixGenRate = Auxiliary("BadFixGenRate")
### Four Flows from Top
ErrGenRate = Flow("ErrGenRate")
ErrDetRate = Flow("ErrDetRate")
ErrEscapeRate = Flow("ErrEscapeRate")
ReworkRate = Flow("ReworkRate")
## Six Flows from Bottom
ActiveErrorRegenRate = Flow("ActiveErrorRegenRate")
ActiveErrorDetectAndCorrectRate = Flow("ActiveErrorDetectAndCorrectRate")
ActiveErrorRetirementRate = Flow("ActiveErrorRetirementRate")
PassiveErrorDetectAndCorrectRate = Flow("PassiveErrorDetectAndCorrectRate")
PassiveErrorGenRate = Flow("PassiveErrorGenRate")
ActiveErrorGenRate = Flow("ActiveErrorGenRate")
## we need to fill up auxiliaries ...
auxDict = utility.createAuxiliaries_All()
##States
curr = StateAll("CurrentState")
prev = StateAll("PrevState")
dt = 1
##output & test purpose
stockDict ={}
for key_,val_ in auxDict.items():
# current state's stocks are dependent on prev. state's flows
# some have in and out flows
curr.PotentiallyDetectableError_.setInput(dt * (prev.ErrGenRate_.curr - prev.ErrDetRate_.curr - prev.ErrEscapeRate_.curr ))
curr.DetectedError_.setInput( dt*( prev.ErrDetRate_.curr - prev.ReworkRate_.curr ))
# some only have in flows from top
curr.EscapedError_.setInput( dt*(prev.ErrEscapeRate_.curr))
curr.ReworkedError_.setInput(dt*(prev.ReworkRate_.curr))
# Update stock from inflows and outflows from Bottom
curr.UndetectedActiveErrors_.setInput(dt * (prev.ActiveErrorRegenRate_.curr + prev.ActiveErrorGenRate_.curr) - (prev.ActiveErrorRetirementRate_.curr + prev.ActiveErrorDetectAndCorrectRate_.curr) )
curr.UndetectedPassiveErrors_.setInput(dt * (prev.ActiveErrorRetirementRate_.curr + prev.PassiveErrorGenRate_.curr)- prev.PassiveErrorDetectAndCorrectRate_.curr)
print "{} ---> {}".format( key_, curr)
#setup output
stockDict[key_]=[curr.PotentiallyDetectableError_.curr, curr.DetectedError_.curr, curr.EscapedError_.curr, curr.ReworkedError_.curr, curr.UndetectedActiveErrors_.curr,curr.UndetectedPassiveErrors_.curr]
print "---------------"
#setting up auxiliaries
MultiplierSchedPressure.setInput(val_[0])
MultiplierWorkforce.setInput(val_[1])
NominalErr.setInput(val_[2])
SWDevelopmentRate.setInput(val_[3])
PotErrDetectRate.setInput(val_[4])
AvgErrPerTask.setInput(val_[5])
QARate.setInput(val_[6])
ActualReworkMP.setInput(val_[7])
DailyMPRework.setInput(val_[8])
#Setting up eight Auxiliaries from Bottom
TimeToSmooth.setInput(val_[9])
MultiplierToRegen.setInput(val_[10])
ActiveErrorDensity.setInput(val_[11])
TestingRate.setInput(val_[12])
ActiveErrorsRetiringFraction.setInput(val_[13])
PassiveErrorDensity.setInput(val_[16] + curr.UndetectedPassiveErrors_.curr)
#filling flows on the top
ErrGenRate.fillFlowsByAuxs(MultiplierSchedPressure, MultiplierWorkforce, NominalErr, SWDevelopmentRate)
ErrDetRate.fillFlowsByAuxs(PotErrDetectRate)
ErrEscapeRate.fillFlowsByAuxs(AvgErrPerTask, QARate)
ReworkRate.fillFlowsByAuxs(ActualReworkMP, DailyMPRework)
# updating current state's flows
curr.updateErrGenRate(ErrGenRate)
curr.updateErrDetRate(ErrDetRate)
curr.updateErrEscapeRate(ErrEscapeRate)
curr.updateReworkRate(ReworkRate)
# Connecting top to the bottom
# Error Escape Rate -> Fraction Escaping Errors
# Rework Rate -> Bad Fix Generation Rate
FractionEscapingErrors.setInput(val_[14] + ErrEscapeRate.curr)
BadFixGenRate.setInput(val_[15] + ReworkRate.curr)
# Filling Flows : six flows from Bottom
ActiveErrorRegenRate.fillFlowsByAuxs(TimeToSmooth, MultiplierToRegen, ActiveErrorDensity)
ActiveErrorDetectAndCorrectRate.fillFlowsByAuxs(ActiveErrorDensity)
ActiveErrorRetirementRate.fillFlowsByAuxs(TestingRate, ActiveErrorsRetiringFraction)
ActiveErrorGenRate.fillFlowsByAuxs(FractionEscapingErrors, BadFixGenRate)
PassiveErrorGenRate.fillFlowsByAuxs(BadFixGenRate, FractionEscapingErrors)
PassiveErrorDetectAndCorrectRate.fillFlowsByAuxs(PassiveErrorDensity, TestingRate)
# updating current state's flows: six flows from bottom
curr.updateActiveErrorRegenRate(ActiveErrorRegenRate)
curr.updateActiveErrorDetectAndCorrectRate(ActiveErrorDetectAndCorrectRate)
curr.updateActiveErrorRetirementRate(ActiveErrorRetirementRate)
curr.updateActiveErrorGenRate(ActiveErrorGenRate)
curr.updatePassiveErrorGenRate(PassiveErrorGenRate)
curr.updatePassiveErrorDetectAndCorrectRate(PassiveErrorDetectAndCorrectRate)
if(showFlows):
print "Printing F-L-O-W-S !"
print "key, flow value ---> {}, {}".format(key_, curr.getFlows())
## copying current to prev.
prev = curr.copyAll("prev")
print "###################"
return stockDict
