def getEntity(self):
activeObject = self.getActiveObject()
activeEntity = Machine.getEntity(self) #run the default code
# read the processing time from the corresponding remainingRoute entry
processingTime = activeEntity.remainingRoute[0].get(
'processingTime', {})
processingTime = self.getOperationTime(processingTime)
self.rng = RandomNumberGenerator(self, processingTime)
self.procTime = self.rng.generateNumber()
# check if there is a need for manual processing
self.checkForManualOperation(type='Processing', entity=activeEntity)
# read the setup time from the corresponding remainingRoute entry
setupTime = activeEntity.remainingRoute[0].get('setupTime', {})
setupTime = self.getOperationTime(setupTime)
self.stpRng = RandomNumberGenerator(self, setupTime)
# check if there is a need for manual processing
self.checkForManualOperation(type='Setup', entity=activeEntity)
activeEntity.currentStep = activeEntity.remainingRoute.pop(
0) #remove data from the remaining route of the entity
if activeEntity.currentStep:
# update the task_id of the currentStep dict within the schedule
try:
activeEntity.schedule[-1][
"task_id"] = activeEntity.currentStep["task_id"]
# if there is currentOperator then update the taskId of corresponding step of their schedule according to the task_id of the currentStep
if self.currentOperator:
self.currentOperator.schedule[-1][
"task_id"] = activeEntity.currentStep["task_id"]
except KeyError:
pass
return activeEntity
def __init__(self, id='',name='',victim=None, distribution=None, index=0, repairman=None,**kw):
ObjectInterruption.__init__(self,id,name,victim=victim)
self.rngTTF=RandomNumberGenerator(self, distribution.get('TTF',{'Fixed':{'mean':100}}))
self.rngTTR=RandomNumberGenerator(self, distribution.get('TTR',{'Fixed':{'mean':10}}))
self.name="F"+str(index)
self.repairman=repairman # the resource that may be needed to fix the failure
# if now resource is needed this will be "None"
self.type="PeriodicMaintenance"
def calculateInitialOperationTimes(self):
# read the setup/processing time from the first entry of the full route
activeEntity = self.getActiveObjectQueue()[0]
#if the entity has its route defined in the BOM then remainingProcessing/SetupTime is provided
# XX consider moving setupUPtime update to checkForManualOperationTypes as Setup is performed before Processing
if activeEntity.routeInBOM:
processingTime = self.getOperationTime(
activeEntity.remainingProcessingTime)
setupTime = self.getOperationTime(activeEntity.remainingSetupTime)
else: # other wise these should be read from the route
processingTime = activeEntity.route[0].get('processingTime', {})
processingTime = self.getOperationTime(processingTime)
setupTime = activeEntity.route[0].get('setupTime', {})
setupTime = self.getOperationTime(setupTime)
self.rng = RandomNumberGenerator(self, processingTime)
self.stpRng = RandomNumberGenerator(self, setupTime)
def __init__(self, id, name, capacity=1, \
processingTime=None, repairman='None',\
scrapQuantity={},
operatorPool='None',operationType='None',\
setupTime=None, loadTime=None,
canDeliverOnInterruption=False,
**kw):
if not processingTime:
processingTime = {'distributionType': 'Fixed', 'mean': 1}
# initialize using the default method of the object
Machine.__init__(self,id=id,name=name,\
capacity=capacity,\
processingTime=processingTime,
repairman=repairman,
canDeliverOnInterruption=canDeliverOnInterruption,
operatorPool=operatorPool,operationType=operationType,\
setupTime=setupTime, loadTime=loadTime,
)
# set the attributes of the scrap quantity distribution
if not scrapQuantity:
scrapQuantity = {'Fixed': {'mean': 0}}
self.scrapRng = RandomNumberGenerator(self, scrapQuantity)
from Globals import G
G.BatchScrapMachineList.append(self)
def __init__(self,
id,
name,
numberOfSubBatches=1,
processingTime=None,
operator='None',
outputResults=False,
**kw):
CoreObject.__init__(self, id, name)
self.type = "BatchRassembly" #String that shows the type of object
if not processingTime:
processingTime = {'Fixed': {'mean': 0}}
if 'Normal' in processingTime.keys() and\
processingTime['Normal'].get('max', None) is None:
processingTime['Normal']['max'] = float(
processingTime['Normal']['mean']) + 5 * float(
processingTime['Normal']['stdev'])
# holds the capacity of the object
self.numberOfSubBatches = numberOfSubBatches
# sets the operator resource of the Machine
self.operator = operator
# Sets the attributes of the processing (and failure) time(s)
self.rng = RandomNumberGenerator(self, processingTime)
from Globals import G
G.BatchReassemblyList.append(self)
# flag to show if the objects outputs results
self.outputResults = bool(int(outputResults))
class Main:
generator = RandomNumberGenerator()
observer1 = DigitObserver()
observer2 = GraphObserver()
generator.addObserver(observer1)
generator.addObserver(observer2)
generator.execute()
def __init__(self,
id,
name,
interArrivalTime=None,
entity='Dream.Part',
**kw):
# Default values
if not interArrivalTime:
interArrivalTime = {'Fixed': {'mean': 1}}
if 'Normal' in interArrivalTime.keys() and\
interArrivalTime['Normal'].get('max', None) is None:
interArrivalTime['Normal']['max'] = interArrivalTime['Normal'][
'mean'] + 5 * interArrivalTime['Normal']['stdev']
CoreObject.__init__(self, id, name)
# properties used for statistics
self.totalinterArrivalTime = 0 # the total interarrival time
self.numberOfArrivals = 0 # the number of entities that were created
self.type = "Source" #String that shows the type of object
self.rng = RandomNumberGenerator(self, interArrivalTime)
self.item = Globals.getClassFromName(
entity) #the type of object that the Source will generate
self.scheduledEntities = [
] # list of creations that are scheduled. pattern is [timeOfCreation, EntityCounter]
from Globals import G
G.SourceList.append(self)
def __init__(self,
id,
name,
processingTime=None,
numberOfSubBatches=1,
operator='None',
**kw):
CoreObject.__init__(self, id, name)
self.type = "BatchDecomposition" #String that shows the type of object
if not processingTime:
processingTime = {'Fixed': {'mean': 0}}
if 'Normal' in processingTime.keys() and\
processingTime['Normal'].get('max', None) is None:
processingTime['Normal']['max'] = float(
processingTime['Normal']['mean']) + 5 * float(
processingTime['Normal']['stdev'])
# holds the capacity of the object
self.numberOfSubBatches = int(numberOfSubBatches)
# sets the operator resource of the Machine
self.operator = operator
# Sets the attributes of the processing (and failure) time(s)
self.rng = RandomNumberGenerator(self, processingTime)
from Globals import G
G.BatchDecompositionList.append(self)
def readLoadTime(self,callerObject=None):
assert callerObject!=None, 'the caller of readLoadTime cannot be None'
thecaller=callerObject
thecaller.sortEntities()
activeEntity=thecaller.Res.users[0]
# read the load time from the corresponding remainingRoute entry
loadTime=activeEntity.remainingRoute[0].get('loadTime',{})
loadTime=self.getOperationTime(loadTime)
self.loadRng=RandomNumberGenerator(self, loadTime)
def getEntity(self):
activeObject=self.getActiveObject()
activeEntity=Machine.getEntity(self) #run the default code
# read the processing time from the corresponding remainingRoute entry
processingTime=activeEntity.remainingRoute[0].get('processingTime',{})
processingTime=self.getOperationTime(processingTime)
self.rng=RandomNumberGenerator(self, processingTime)
self.procTime=self.rng.generateNumber()
# check if there is a need for manual processing
self.checkForManualOperation(type='Processing',entity=activeEntity)
# read the setup time from the corresponding remainingRoute entry
setupTime=activeEntity.remainingRoute[0].get('setupTime',{})
setupTime=self.getOperationTime(setupTime)
self.stpRng=RandomNumberGenerator(self, setupTime)
# check if there is a need for manual processing
self.checkForManualOperation(type='Setup',entity=activeEntity)
removedStep = activeEntity.remainingRoute.pop(0) #remove data from the remaining route of the entity
return activeEntity
def __generate_instance(self, seed):
RNG = RandomNumberGenerator(seed)
task_queue = []
for J in range(0, self.size):
task_queue.append({'j': J + 1})
for M in range(1, self.machines + 1):
task_queue[J].update({f'p{M}': RNG.nextInt(1, MAX_VALUE)})
task_queue[J].update({f'S{M}': 0})
task_queue[J].update({f'C{M}': 0})
return task_queue
def calculateProcessingTime(self):
# this is only for processing of the initial wip
if self.isProcessingInitialWIP:
activeEntity=self.getActiveObjectQueue()[0]
if activeEntity.remainingProcessingTime:
remainingProcessingTime=activeEntity.remainingProcessingTime
from RandomNumberGenerator import RandomNumberGenerator
initialWIPrng=RandomNumberGenerator(self, remainingProcessingTime)
return initialWIPrng.generateNumber()
return self.rng.generateNumber() # this is if we have a default processing time for all the entities
def instanceGenerator(Z, size):
generator = RandomNumberGenerator(Z)
d = [[0 for i in range(size)] for j in range(size)]
for i in range(size):
for j in range(size):
if (i > j):
d[i][j] = generator.nextInt(1, 50)
d[j][i] = generator.nextInt(1, 50)
return d
def defineScrapQuantities():
process = G.CMSDData.getElementsByTagName('Process')
#loop through the processes
for proc in process:
try:
#read the scrap quantity
Property = proc.getElementsByTagName('Property')
for prop in Property:
name = prop.getElementsByTagName('Name')
name = name[0].toxml().replace('<Name>',
'').replace('</Name>', '')
if name == 'ScrapQuantity':
scrap = Property[0].getElementsByTagName('Distribution')
scrapName = scrap[0].getElementsByTagName('Name')
scrapName = scrapName[0].toxml().replace('<Name>',
'').replace(
'</Name>', '')
distrParA = scrap[0].getElementsByTagName(
'DistributionParameterA')
parAName = distrParA[0].getElementsByTagName('Name')
parAName = parAName[0].toxml().replace('<Name>',
'').replace(
'</Name>', '')
parAValue = distrParA[0].getElementsByTagName('Value')
parAValue = parAValue[0].toxml().replace(
'<Value>', '').replace('</Value>', '')
else:
continue
#read the id of the station resource
ResourcesRequired = proc.getElementsByTagName(
'ResourcesRequired')
for res in ResourcesRequired:
Resource = res.getElementsByTagName('Resource')
ResourceIdentifier = Resource[0].getElementsByTagName(
'ResourceIdentifier')
ResourceIdentifier = ResourceIdentifier[0].toxml().replace(
'<ResourceIdentifier>',
'').replace('</ResourceIdentifier>', '')
#loop through the stations and for the one with the id set the scrap
distributionDict = {
str(scrapName): {
str(parAName): parAValue
}
}
for obj in G.ObjList:
if obj.id == ResourceIdentifier:
obj.rng = RandomNumberGenerator(obj, distributionDict)
except IndexError:
continue
def __init__(self, id='',name='',victim=None, distribution={}, index=0, repairman=None, offshift=False,
deteriorationType='constant',
waitOnTie=False,**kw):
ObjectInterruption.__init__(self,id,name,victim=victim)
self.rngTTF=RandomNumberGenerator(self, distribution.get('TTF',{'Fixed':{'mean':100}}))
self.rngTTR=RandomNumberGenerator(self, distribution.get('TTR',{'Fixed':{'mean':10}}))
self.name="F"+str(index)
self.repairman=repairman # the resource that may be needed to fix the failure
# if now resource is needed this will be "None"
self.type="Failure"
# shows how the time to failure is measured
# 'constant' means it counts not matter the state of the victim
# 'onShift' counts only if the victim is onShift
# 'working' counts only working time
self.deteriorationType=deteriorationType
# flag used to identify if the time between failures should be counted while the victim is off-shift
self.offshift=offshift
# flag to show if the failure will wait on tie with other events before interrupting the victim
self.waitOnTie=waitOnTie
def __init__(self,
id='',
name='',
victim=None,
distribution={},
endUnfinished=True,
offShiftAnticipation=0,
**kw):
ObjectInterruption.__init__(self, id, name, victim=victim)
self.rngTTB = RandomNumberGenerator(
self, distribution.get('TTB', {'Fixed': {
'mean': 100
}}))
self.rngTTR = RandomNumberGenerator(
self, distribution.get('TTR', {'Fixed': {
'mean': 10
}}))
self.type = "Break"
# end current wip before going to break
self.endUnfinished = endUnfinished
# if the break is close to end of shift below a limit it will be suspended
self.offShiftAnticipation = offShiftAnticipation
def defineProcessingTimes():
process = G.CMSDData.getElementsByTagName('Process')
#loop through the processes
for proc in process:
try:
#read the mean processing time a the unit
OperationTime = proc.getElementsByTagName('OperationTime')
distr = OperationTime[0].getElementsByTagName('Distribution')
distrName = distr[0].getElementsByTagName('Name')
distrName = distrName[0].toxml().replace('<Name>', '').replace(
'</Name>', '')
distrParA = distr[0].getElementsByTagName('DistributionParameterA')
parAName = distrParA[0].getElementsByTagName('Name')
parAName = parAName[0].toxml().replace('<Name>',
'').replace('</Name>', '')
parAValue = distrParA[0].getElementsByTagName('Value')
parAValue = parAValue[0].toxml().replace('<Value>', '').replace(
'</Value>', '')
distrParB = distr[0].getElementsByTagName('DistributionParameterB')
parBName = distrParB[0].getElementsByTagName('Name')
parBName = parBName[0].toxml().replace('<Name>',
'').replace('</Name>', '')
parBValue = distrParB[0].getElementsByTagName('Value')
parBValue = parBValue[0].toxml().replace('<Value>', '').replace(
'</Value>', '')
#read the id of the station resource
ResourcesRequired = proc.getElementsByTagName('ResourcesRequired')
for res in ResourcesRequired:
Resource = res.getElementsByTagName('Resource')
ResourceIdentifier = Resource[0].getElementsByTagName(
'ResourceIdentifier')
ResourceIdentifier = ResourceIdentifier[0].toxml().replace(
'<ResourceIdentifier>',
'').replace('</ResourceIdentifier>', '')
#loop through the stations and for the one with the id set the processing time
distributionDict = {
str(distrName): {
str(parAName): parAValue,
str(parBName): parBValue
}
}
for obj in G.ObjList:
if obj.id == ResourceIdentifier:
obj.rng = RandomNumberGenerator(obj, distributionDict)
except IndexError:
continue
def main():
seed = int(input("Wprowadź Z: "))
generator = RandomNumberGenerator(seed)
taskNumber = int(input("Wprowadź liczbę zadań: "))
tasks = range(1, taskNumber + 1)
machineNumber = int(input("Wprowadź liczbę maszyn: "))
machines = range(1, machineNumber + 1)
#lista wszystkich zadan na konkretnych maszynach
p_ij = []
# permutacja zadan
pi = []
# wyswietlenie rozwiazania po wykonaniu algorytmu optymalizacji
solution = []
#lista zadan przydzielonych do jednej maszyny
pj = []
for task in tasks:
for machine in machines:
pj.append(generator.nextInt(1, 29))
p_ij.append(pj.copy())
pj.clear()
pi.append(task)
print(p_ij)
print("Permutacj naturalna: ")
print("pi: ", pi)
Cj, Cmax = calculate(p_ij, taskNumber, machineNumber)
print("C:", Cj)
print("Cmax:", Cmax)
for task in tasks:
solution.append([pi[task - 1], p_ij[task - 1]])
pi = Johnson(tasks, p_ij.copy())
print("Johnson: ")
print("pi: ", pi)
sort = {x: i for i, x in enumerate(pi)}
solution.sort(key=lambda x: sort[x[0]])
Cj, Cmax = calculate([row[1] for row in solution], taskNumber,
machineNumber)
print("C", Cj)
print("Cmax:", Cmax)
def main():
seed = int(input("Wprowadź Z: "))
generator = RandomNumberGenerator(seed)
taskNumber = int(input("Wprowadź rozmiar problemu: "))
tasks = range(1, taskNumber + 1)
nr = []
pj = [] #czas wykonania
wj = [] #waga/współczynnik kary
dj = [] #żądany termin zakończenia
for task in tasks:
nr.append(task)
pj.append(generator.nextInt(1, 29))
A = 0
for number in pj:
A += number
for task in tasks:
wj.append(generator.nextInt(1, 9))
X = 29
#X=A
for task in tasks:
dj.append(generator.nextInt(1, X))
print("\nnr:", nr)
print("pj: ", pj)
print("wj ", wj)
print("dj", dj)
witi_start = target_fun(pj, wj, dj, taskNumber)
print(f'\nWiTi dla początkowego = {witi_start[0]}')
print(f'C: {witi_start[2]}')
print(f'T: {witi_start[1]}')
witi_greedy = greedy(pj, wj, dj, taskNumber)
print(f'\nWiTi dla Greedy algorithm = {witi_greedy[0]}')
print(f'C: {witi_greedy[2]}')
print(f'T: {witi_greedy[1]}')
witi_brute_force = brute_force(pj, wj, dj, taskNumber)
print(f'\nWiTi dla Brute Force = {witi_brute_force[0]}')
print(f'C: {witi_brute_force[2]}')
print(f'T: {witi_brute_force[1]}')
def __init__(self, size, seed):
self.size = size
self.last_permutation = []
RNG = RandomNumberGenerator(seed)
p_list = []
w_list = []
d_list = []
p_sum = 0
self.queue = []
for J in range(0, self.size):
p_list.append(RNG.nextInt(1, MAX_VALUE))
p_sum += p_list[-1]
for J in range(0, self.size):
w_list.append(RNG.nextInt(1, 9))
for J in range(0, self.size):
d_list.append(RNG.nextInt(1, MAX_D))
for J in range(0, self.size):
self.queue.append(task(J + 1, p_list[J], w_list[J], d_list[J]))
self.last_permutation.append(J + 1)
def __init__(self,
id='',
name='',
processingTime=None,
inputsDict=None,
**kw):
self.type = "Assembly" #String that shows the type of object
self.next = [] #list with the next objects in the flow
self.previous = [] #list with the previous objects in the flow
self.previousPart = [] #list with the previous objects that send parts
self.previousFrame = [
] #list with the previous objects that send frames
self.nextIds = [] #list with the ids of the next objects in the flow
self.previousIds = [
] #list with the ids of the previous objects in the flow
#lists to hold statistics of multiple runs
self.Waiting = []
self.Working = []
self.Blockage = []
if not processingTime:
processingTime = {'Fixed': {'mean': 0}}
if 'Normal' in processingTime.keys() and\
processingTime['Normal'].get('max', None) is None:
processingTime['Normal']['max'] = float(
processingTime['Normal']['mean']) + 5 * float(
processingTime['Normal']['stdev'])
CoreObject.__init__(self, id, name)
self.rng = RandomNumberGenerator(self, processingTime)
# ============================== variable that is used for the loading of machines =============
self.exitAssignedToReceiver = False # by default the objects are not blocked
# when the entities have to be loaded to operatedMachines
# then the giverObjects have to be blocked for the time
# that the machine is being loaded
from Globals import G
G.AssemblyList.append(self)
def simulatedAnnealing(tasks):
RNG = RandomNumberGenerator(123)
t = copy.deepcopy(tasks)
T = 1550.0 #temperatura zarzenia na bialo rozgrzanej stali :)
Tend = 1E-10 # cokolwiek większe od zera
it = 0
L = 10
pi = []
pi_new = []
pi_best = []
#natural perm
for perm in range(1, t.size + 1):
pi.append(perm)
pi_best.append(perm)
while T > Tend:
for k in range(L):
i = RNG.nextInt(0, t.size) - 1
j = RNG.nextInt(0, t.size) - 1
pi_new = copy.deepcopy(pi)
swap_value = pi_new[i]
pi_new[i] = pi_new[j]
pi_new[j] = swap_value
cmax_new = t.calculate_Cmax(pi_new)
cmax_old = t.calculate_Cmax(pi)
if cmax_new > cmax_old:
r = RNG.nextFloat(0, 1)
dCmax = cmax_old - cmax_new
if r >= math.exp(dCmax / T):
pi_new = copy.deepcopy(pi)
pi = copy.deepcopy(pi_new)
if t.calculate_Cmax(pi_best) > t.calculate_Cmax(pi):
pi_best = copy.deepcopy(pi)
it += 1
T = T / math.log(it + 1) #ln(it+1)
return pi_best
def parseInputs(self, inputsDict):
CoreObject.parseInputs(self, inputsDict)
processingTime = inputsDict.get('processingTime', {})
if not processingTime:
processingTime = {
'distributionType': 'Fixed',
'mean': 0,
'stdev': 0,
'min': 0,
}
if processingTime['distributionType'] == 'Normal' and\
processingTime.get('max', None) is None:
processingTime['max'] = float(
processingTime['mean']) + 5 * float(processingTime['stdev'])
self.rng = RandomNumberGenerator(self, **processingTime)
# ============================== variable that is used for the loading of machines =============
self.exitAssignedToReceiver = False # by default the objects are not blocked
# when the entities have to be loaded to operatedMachines
# then the giverObjects have to be blocked for the time
# that the machine is being loaded
from Globals import G
G.AssemblyList.append(self)
def main():
seed = int(input("Wprowadź Z: "))
generator = RandomNumberGenerator(seed)
taskNumber = int(input("Wprowadź liczbę zadań: "))
tasks = range(1, taskNumber + 1)
machineNumber = int(input("Wprowadź liczbę maszyn: "))
machines = range(1, machineNumber + 1)
Pi = [] #Permutacja po uszeregowaniu
P = [] # Macierz czas wykonania
Nr = [] # Lista zadań do wykonania
P_Copy = [] #Macierz czasów wykonania
Nr_Copy = [] # Lista zadań do wykonania
C = [] # Macierz czasów zakończenia zadań
S = [] # Macierz czasów trwania zadań
for i in range(1, taskNumber + 1):
Pi.append(i)
for i in range(0, taskNumber):
z = [None] * machineNumber
C.append(z)
for i in range(0, taskNumber):
x = [None] * machineNumber
S.append(x)
for i in range(0, taskNumber):
p = []
for j in range(0, machineNumber):
p.append(generator.nextInt(1, 29))
P.append(p)
P_Copy.append(p)
for i in range(1, taskNumber + 1):
Nr.append(i)
Nr_Copy.append(i)
print("\n")
print("Tabu Calculate:")
tabu_calculate(taskNumber, machineNumber, C, P, Pi, S)
print(f"Pi: {Pi}")
print(f"P: {P}")
print(f"C: {C}")
print(f"Cmax: {calculate_cmax(machineNumber,Pi,P)}")
tabu_time_start = datetime.datetime.now()
newPi = tabuSearch(taskNumber, machineNumber, P, Pi)
tabu_time_end = datetime.datetime.now() - tabu_time_start
newP = []
for i in range(0, taskNumber):
newP.append(P[newPi[i] - 1])
tabu_calculate(taskNumber, machineNumber, C, newP, newPi, S)
C, Cmax = calculate_neh(newP, taskNumber, machineNumber)
print(f"Tabu search czas: {tabu_time_end}")
print(f"Tabu search po sortowaniu: ")
print(f"Pi: {newPi}")
print(f"C: {C}")
print(f"Cmax: {Cmax}")
#lista wszystkich zadan na konkretnych maszynach
p_ij_neh = P
# permutacja zadan
pi_neh = Nr
p_kj = []
print("\n")
print("NEH:")
print("p", p_ij_neh)
print("Permutacj naturalna: ")
print("pi: ", pi_neh)
Cj, Cmax = calculate_neh(p_ij_neh, taskNumber, machineNumber)
print("C:", Cj)
print("Cmax:", Cmax)
neh_time_start = datetime.datetime.now()
p_kj = NEH(p_ij_neh.copy(), taskNumber, machineNumber)
neh_time_end = datetime.datetime.now() - neh_time_start
print(f"NEH czas: {neh_time_end}")
print("NEH po sortowaniu: ")
print("pkj: ", p_kj)
Cj, Cmax = calculate_neh(p_kj, taskNumber, machineNumber)
print("C:", Cj)
print("Cmax:", Cmax)
#lista wszystkich zadan na konkretnych maszynach
p_ij_johnson = P
# permutacja zadan
pi_johnson = Nr
# wyswietlenie rozwiazania po wykonaniu algorytmu optymalizacji
solution = []
print("\n")
print("Johnson:")
print(p_ij_johnson)
print("Permutacj naturalna: ")
print("pi: ", pi_johnson)
Cj, Cmax = calculate_johnson(p_ij_johnson, taskNumber, machineNumber)
print("C:", Cj)
print("Cmax:", Cmax)
for task in tasks:
solution.append([pi_johnson[task - 1], p_ij_johnson[task - 1]])
johson_time_start = datetime.datetime.now()
pi = Johnson(tasks, p_ij_johnson.copy())
johson_time_end = datetime.datetime.now() - johson_time_start
print(f"Johson czas: {johson_time_end}")
print("Johnson po sortowaniu: ")
print("pi: ", pi)
sort = {x: i for i, x in enumerate(pi)}
solution.sort(key=lambda x: sort[x[0]])
Cj, Cmax = calculate_johnson([row[1] for row in solution], taskNumber,
machineNumber)
print("C", Cj)
print("Cmax:", Cmax)
def main():
seed = int(input("Wprowadź Z:"))
generator = RandomNumberGenerator(seed)
taskNumber = int(input("Wprtowadź liczbe zadań:"))
tasks = range(1, taskNumber + 1)
nr = [] #wektor kolejnych zadan
r = [] #czas przygotowania kolejnych zadań
p = [] #czas wykonania kolejnych zadan
q = [] #czas dostarczenia/stygnięcia kolejnych zadań
#generowanie danych do zadania
for task in tasks:
nr.append(task)
p.append(generator.nextInt(1, 29))
pi = nr.copy() #inicjalizacja permutacji zadań
A = 0
# X = 29
for number in p:
A += number
for task in tasks:
r.append(generator.nextInt(1, A))
for task in tasks:
q.append(generator.nextInt(1, 29))
print("\nnr:", nr)
print("r: ", r)
print("p: ", p)
print("q: ", q)
print("\n")
S, C, Cq, Cmax = calculate(r, p, q, taskNumber)
print(f'pi: {pi}')
print("S: ", S)
print("C: ", C)
print(f"Cq: {Cq}")
print("Cmax", Cmax)
print("\n")
#inicjalizacja permutacji zadań
# pi = nr.copy()
#strutktura skladajaca sie z
solution = []
for task in tasks:
solution.append([pi[task - 1], r[task - 1], p[task - 1], q[task - 1]])
#Schrage
print("Po sortowaniu:")
pi = schragePmtn(r, p, q, tasks)
sort = {x: i for i, x in enumerate(pi)}
solution.sort(key=lambda x: sort[x[0]])
rjSchrage = []
pjSchrage = []
qjSchrage = []
for task in tasks:
rjSchrage.append(solution[task - 1][1])
pjSchrage.append(solution[task - 1][2])
qjSchrage.append(solution[task - 1][3])
SSchrage, CSchrage, CqSchrage, CmaxSchrager = calculate(
rjSchrage, pjSchrage, qjSchrage, taskNumber)
print("pi:", pi)
print("S: ", SSchrage)
print("C: ", CSchrage)
print(f"Cq: {CqSchrage}")
print("Cmax", CmaxSchrager)
from RandomNumberGenerator import RandomNumberGenerator
from DigitObserver import DigitObserver
from GraphObserver import GraphObserver
if __name__ == '__main__':
generator = RandomNumberGenerator()
observer1 = DigitObserver()
observer2 = GraphObserver()
generator.addObserver(observer1)
generator.addObserver(observer2)
generator.execute()
def createMould(self, component):
#read attributes from the json or from the orderToBeDecomposed
id = component.get('id', 'not found')
name = component.get('name', 'not found')
try:
# dummy variable that holds the routes of the jobs the route from the JSON file is a sequence of dictionaries
JSONRoute = component.get('route', [])
# variable that holds the argument used in the Job initiation hold None for each entry in the 'route' list
route = [x for x in JSONRoute] # copy JSONRoute
# assert that the assembler is in the moulds route and update the initial step of the mould's route
firstStep = route.pop(0)
assert (self.id in firstStep.get('stationIdsList',[])),\
'the assembler must be in the mould-to-be-created route\' initial step'
# normal processing operation
processingTime = firstStep['processingTime']
processingTime = self.getOperationTime(processingTime)
self.rng = RandomNumberGenerator(self, processingTime)
self.procTime = self.rng.generateNumber()
# update the activeObject's processing time according to the readings in the mould's route
processDistType = processingTime.keys()[0]
procTime = float(processingTime[processDistType].get('mean', 0))
processOpType = firstStep.get('operationType', {}).get(
'Processing', 'not found') # can be manual/automatic
# task_id
task_id = firstStep.get('task_id', None)
# sequence
sequence = firstStep.get('sequence', None)
# operator
operator = firstStep.get('operator', {})
# technology
technology = firstStep.get('technology', None)
# quantity
quantity = firstStep.get('quantity', None)
# setup operation
setupTime = firstStep.get('setupTime', None)
if setupTime:
setupTime = self.getOperationTime(setupTime)
self.stpRng = RandomNumberGenerator(self, setupTime)
# update the activeObject's processing time according to the readings in the mould's route
setupDistType = setupTime.keys()[0]
setTime = float(setupTime[setupDistType].get('mean', 0))
setupOpType = firstStep.get('operationType', {}).get(
'Setup', 'not found') # can be manual/automatic
# update the first step of the route with the activeObjects id as sole element of the stationIdsList
route.insert(0, {'stationIdsList':[str(self.id)],
'processingTime':{str(processDistType):{'mean':str(procTime)}},\
'setupTime':{str(setupDistType):{'mean':str(setupTime)}},
'operationType':{'Processing':processOpType,'Setup':setupOpType}})
else:
# update the first step of the route with the activeObjects id as sole element of the stationIdsList
route.insert(
0, {
'stationIdsList': [str(self.id)],
'processingTime': {
str(processDistType): {
'mean': str(procTime)
}
},
'operationType': {
'Processing': processOpType
}
})
# if there is task_id then add it to the route
if task_id:
route[0]["task_id"] = task_id
# if there is sequence then add it to the route
if sequence:
route[0]["sequence"] = sequence
# if there is operator then add it to the route
if operator:
route[0]["operator"] = operator
# if there is technology then add it to the route
if technology:
route[0]["technology"] = technology
# if there is quantity then add it to the route
if quantity != None:
route[0]["quantity"] = quantity
#Below it is to assign an exit if it was not assigned in JSON
#have to talk about it with NEX
exitAssigned = False
for element in route:
elementIds = element.get('stationIdsList', [])
for obj in G.ObjList:
for elementId in elementIds:
if obj.id == elementId and obj.type == 'Exit':
exitAssigned = True
# assign an exit to the route of the mould
if not exitAssigned:
exitId = None
for obj in G.ObjList:
if obj.type == 'Exit':
exitId = obj.id
break
if exitId:
route.append({
'stationIdsList': [str(exitId)],
'processingTime': {}
})
# keep a reference of all extra properties passed to the job
extraPropertyDict = {}
for key, value in component.items():
if key not in ('_class', 'id'):
extraPropertyDict[key] = value
# create and initiate the OrderComponent
from Mould import Mould
M=Mould(id, name, route, \
priority=self.mouldParent.priority, \
order=self.mouldParent,\
dueDate=self.mouldParent.dueDate, \
orderDate=self.mouldParent.orderDate, \
extraPropertyDict=extraPropertyDict,\
isCritical=self.mouldParent.isCritical)
# update the mouldToBeCreated
self.mouldToBeCreated = M
G.JobList.append(M)
G.WipList.append(M)
G.EntityList.append(M)
G.MouldList.append(M)
#initialize the component
M.initialize()
except:
# added for testing
print 'the mould to be created', component.get(
'name', 'not found'), 'cannot be created', 'time', self.env.now
raise
key,
algorithm,
use_custom_rc4=USE_CUSTOM_RC4)
else:
print("Invalid parameters. \n" + help_message)
except Exception as e:
print(e)
print("Invalid parameters. \n" + help_message)
elif method_id == "2": # random number
key = sys.argv[0]
test_randomness = False
if nb_args == 3:
test_randomness = True if sys.argv[1] == "True" else False
rdm_generator = RandomNumberGenerator(key,
use_custom=USE_CUSTOM_RC4)
print(f"Your random number: {rdm_generator.generate()}")
if test_randomness:
rdm_generator.display_random_image()
rdm_generator.verify_randomness()
rdm_generator.plot_random_and_semi_random()
elif method_id == "3": # full cipher/decipher pipeline
filename = sys.argv[0]
algorithm = sys.argv[
1] if sys.argv[1] == "rc4" or sys.argv[1] == "rc5" else None
key = sys.argv[2]
WAV_file_demo = False
if nb_args == 5:
WAV_file_demo = True if sys.argv[3] == "True" else False
