def test():
"""Tests the product function in the product class
Write here all test you want to do.
REMEMBER to test your programm you can't use __init__ function
"""
assert product.check_PC("localhost",
1) == True, "Checker PC fails (personal_code: 1)"
assert product.check_PC("localhost",
2) == True, "Checker PC fails (personal_code: 1)"
assert product.check_PC("localhost",
10) == True, "Checker PC fails (personal_code: 1)"
assert product.make_csv_standard(
"'test','test'\n'example value','example value 2'\n'example value','example value 2'\n'example value','example value 2'"
) == "'test','test'\n'example value','example value 2'\n'example value','example value 2'\n'example value','example value 2'", "Maker CSV standard fails (personal_code: 2)"
assert product.csv2array(
"'test','test'\n'example value','example value 2'\n'example value','example value 2'\n'example value','example value 2'"
) == [["'test'", "'test'"], ["'example value'", "'example value 2'"],
["'example value'", "'example value 2'"],
["'example value'",
"'example value 2'"]], "CSV2Array fails (personal_code: 3a)"
assert product.array2csv(
[["test", "test"], ["example value", "example value 2"],
["example value", "example value 2"],
["example value", "example value 2"]]
) == '"test","test"\n"example value","example value 2"\n"example value","example value 2"\n"example value","example value 2"\n', "Array2CSV fails (personal_code: 3b)"
assert product(), "test failed (personal_code: 0)" # check all code
def handle_send_button(self):
prod = product()
prod.prodInsert(
self.inpName, self.inpType, self.inpBrand, self.inpFormat, self.inpStock, self.inpMstock, self.inpRate
)
self.del_widgets()
self.addProduct()
def decrypt(prefix):
res = []
for suffix in product(letters, repeat=5 - len(prefix)):
passwd = np.concatenate([prefix, suffix])
text = decode(ciphertext, passwd)
if isgood(text):
passwd = "".join(map(chr, passwd))
res.append((passwd, text))
return res
def startElement(self, name, attr):
if name == "Family":
self.family = family()
self.family.name = attr.getValue("Name")
if name == "Product":
attributes = attr.getNames()
prod = product()
prod.name = attr.getValue("Name")
if "DisplayMode" in attributes:
prod.displayMode = attr.getValue("DisplayMode")
else:
prod.displayMode = "Visible"
self.family.products.append(prod)
def ajouter(produts):
print(colored("\n\n\nVous etes entrain d'ajouter un produit",color="blue"))
try:
nom = str(input(colored("\nEntrer le nom du produit : ",color="yellow")))
prix = int(input(colored("\nS'il vous plait son prix : ",color="yellow")))
description = str(
input(colored("\nEt enfin sa description : ",color="yellow")))
except ValueError:
print(colored("\nEntrer un bonne element",color="red"))
ajouter(produts)
produts.append(product(nom, prix, description))
repeat(
"\nAimeriez vous ajouter un produit [Oui | Non => autres] ? ", ajouter, produts)
def createNewproduct(self, wherex, wherey, screenCoordinates=1):
self.fromClass = None
self.toClass = None
# try the global constraints...
res = self.ASGroot.preCondition(ASG.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
new_semantic_obj = product(self)
res = new_semantic_obj.preCondition(ASGNode.CREATE)
if res: return self.constraintViolation(res)
new_semantic_obj.preAction(ASGNode.CREATE)
ne = len(self.ASGroot.listNodes["product"])
if new_semantic_obj.keyword_:
new_semantic_obj.keyword_.setValue(
new_semantic_obj.keyword_.toString() + str(ne))
if screenCoordinates:
new_obj = graph_product(self.UMLmodel.canvasx(wherex),
self.UMLmodel.canvasy(wherey),
new_semantic_obj)
else: # already in canvas coordinates
new_obj = graph_product(wherex, wherey, new_semantic_obj)
new_obj.DrawObject(self.UMLmodel, self.editGGLabel)
self.UMLmodel.addtag_withtag("product", new_obj.tag)
new_semantic_obj.graphObject_ = new_obj
self.ASGroot.addNode(new_semantic_obj)
res = self.ASGroot.postCondition(ASG.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
res = new_semantic_obj.postCondition(ASGNode.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
new_semantic_obj.postAction(ASGNode.CREATE)
self.mode = self.IDLEMODE
if self.editGGLabel:
self.statusbar.event(StatusBar.TRANSFORMATION, StatusBar.CREATE)
else:
self.statusbar.event(StatusBar.MODEL, StatusBar.CREATE)
return new_semantic_obj
session.set_keyspace('adv')
rows2 = session.execute('
select t.range, count(*) as num
from
(select case
when price_product < 50 then '0 - 50'
when price_product >= 50 and price_product < 500 then '50 - 500'
when price_product >= 500 then 'more 500'
end
as range,
price_product
from product)
as t
group by range
')
INSERT INTO product (name_adv, name_product)
VALUES (123, 22, "USA")
CONSISTENCY [ TWO ]
session.set_keyspace('product')
rows3 = session.execute('
SELECT DISTINCT name_product, id_product, name_provider, name_adv, price_product, count_product, factory
FROM product, provider
WHERE name_product_p.product = name_product.provider, name_provider.product=name_provider_p.provider;
')
INSERT INTO provider (name_product, id_product, name_provider, name_adv, price_product, count_product, factory )
VALUES ('laundry soap', 221, 'PandG', 'laundry soap adv', 99, 23, ['Kyiv factory', 'Kharkiv factory' ])
CONSISTENCY [ THREE ]
session.set_keyspace('provider')
rows4 = session.execute('
42: assert is_consonant('a') == False
43: assert is_consonant('c') == True
44:
45: from function_exercises import is_consonant as is_this_a_consonant
46:
47: assert is_this_a_consonant('a') == False
48: assert is_this_a_consonant('c') == True
49:
50: # 2. For the following exercises, read about and use the itertools module from the standard library to help you solve the problem.
51:
52: # How many different ways can you combine the letters from "abc" with the numbers 1, 2, and 3?
53: # How many different ways can you combine two of the letters from "abcd"?
54:
55: from itertools import product
56:
57: product_list = list(product('abd', [1,2,3]))
58: product_count = len(product_list)
59: print(product_count)
60:
61: from itertools import combinations_with_replacement
62:
63: combo_list = list(combinations_with_replacement('abcd', 2))
64: combo_count = len(combo_list)
65: print(combo_count)
66:
67: from itertools import combinations
68:
69: combonation_list = list(combinations('abcd', 2))
70: combonation_count = len(combonation_list)
71: print(combo_count)
72:
def handle_update_prod(self):
prod = product()
prod.prodUpdate(self.pname, self.entrline.get())
def __init__(self, parent):
GGrule.__init__(self, 13)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.RHS = ASG_pns(parent)
self.obj1670 = product(parent)
self.obj1670.preAction(self.RHS.CREATE)
self.obj1670.isGraphObjectVisual = True
if (hasattr(self.obj1670, '_setHierarchicalLink')):
self.obj1670._setHierarchicalLink(False)
# MaxFlow
self.obj1670.MaxFlow.setValue(999999)
# price
self.obj1670.price.setValue(0)
# Name
self.obj1670.Name.setValue('OAF')
# ReqFlow
self.obj1670.ReqFlow.setValue(0)
self.obj1670.GGLabel.setValue(1)
self.obj1670.graphClass_ = graph_product
if parent.genGraphics:
new_obj = graph_product(100.0, 80.0, self.obj1670)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1670.graphObject_ = new_obj
self.obj16700 = AttrCalc()
self.obj16700.Copy = ATOM3Boolean()
self.obj16700.Copy.setValue(('Copy from LHS', 1))
self.obj16700.Copy.config = 0
self.obj16700.Specify = ATOM3Constraint()
self.obj16700.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1670.GGset2Any['MaxFlow'] = self.obj16700
self.obj16701 = AttrCalc()
self.obj16701.Copy = ATOM3Boolean()
self.obj16701.Copy.setValue(('Copy from LHS', 0))
self.obj16701.Copy.config = 0
self.obj16701.Specify = ATOM3Constraint()
self.obj16701.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1670.GGset2Any['Name'] = self.obj16701
self.obj16702 = AttrCalc()
self.obj16702.Copy = ATOM3Boolean()
self.obj16702.Copy.setValue(('Copy from LHS', 1))
self.obj16702.Copy.config = 0
self.obj16702.Specify = ATOM3Constraint()
self.obj16702.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1670.GGset2Any['ReqFlow'] = self.obj16702
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1670)
self.obj1670.postAction(self.RHS.CREATE)
def __init__(self, parent):
GGrule.__init__(self, 15)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.LHS.merge(ASG_GenericGraph(parent))
self.obj1677 = product(parent)
self.obj1677.preAction(self.LHS.CREATE)
self.obj1677.isGraphObjectVisual = True
if (hasattr(self.obj1677, '_setHierarchicalLink')):
self.obj1677._setHierarchicalLink(False)
# MaxFlow
self.obj1677.MaxFlow.setNone()
# price
self.obj1677.price.setValue(0)
# Name
self.obj1677.Name.setValue('')
self.obj1677.Name.setNone()
# ReqFlow
self.obj1677.ReqFlow.setNone()
self.obj1677.GGLabel.setValue(5)
self.obj1677.graphClass_ = graph_product
if parent.genGraphics:
new_obj = graph_product(280.0, 220.0, self.obj1677)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1677.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1677)
self.obj1677.postAction(self.LHS.CREATE)
self.obj1678 = metarial(parent)
self.obj1678.preAction(self.LHS.CREATE)
self.obj1678.isGraphObjectVisual = True
if (hasattr(self.obj1678, '_setHierarchicalLink')):
self.obj1678._setHierarchicalLink(False)
# MaxFlow
self.obj1678.MaxFlow.setNone()
# price
self.obj1678.price.setValue(0)
# Name
self.obj1678.Name.setValue('')
self.obj1678.Name.setNone()
# ReqFlow
self.obj1678.ReqFlow.setNone()
self.obj1678.GGLabel.setValue(3)
self.obj1678.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(320.0, 40.0, self.obj1678)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1678.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1678)
self.obj1678.postAction(self.LHS.CREATE)
self.obj1679 = Goal(parent)
self.obj1679.preAction(self.LHS.CREATE)
self.obj1679.isGraphObjectVisual = True
if (hasattr(self.obj1679, '_setHierarchicalLink')):
self.obj1679._setHierarchicalLink(False)
# name
self.obj1679.name.setValue('')
self.obj1679.name.setNone()
self.obj1679.GGLabel.setValue(2)
self.obj1679.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(180.0, 60.0, self.obj1679)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1679.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1679)
self.obj1679.postAction(self.LHS.CREATE)
self.obj1680 = GenericGraphEdge(parent)
self.obj1680.preAction(self.LHS.CREATE)
self.obj1680.isGraphObjectVisual = True
if (hasattr(self.obj1680, '_setHierarchicalLink')):
self.obj1680._setHierarchicalLink(False)
self.obj1680.GGLabel.setValue(4)
self.obj1680.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(264.5, 71.5, self.obj1680)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1680.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1680)
self.obj1680.postAction(self.LHS.CREATE)
self.obj1679.out_connections_.append(self.obj1680)
self.obj1680.in_connections_.append(self.obj1679)
self.obj1679.graphObject_.pendingConnections.append(
(self.obj1679.graphObject_.tag, self.obj1680.graphObject_.tag,
[203.0, 61.0, 264.5, 71.5], 0, True))
self.obj1680.out_connections_.append(self.obj1678)
self.obj1678.in_connections_.append(self.obj1680)
self.obj1680.graphObject_.pendingConnections.append(
(self.obj1680.graphObject_.tag, self.obj1678.graphObject_.tag,
[326.0, 82.0, 264.5, 71.5], 0, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1684 = product(parent)
self.obj1684.preAction(self.RHS.CREATE)
self.obj1684.isGraphObjectVisual = True
if (hasattr(self.obj1684, '_setHierarchicalLink')):
self.obj1684._setHierarchicalLink(False)
# MaxFlow
self.obj1684.MaxFlow.setNone()
# price
self.obj1684.price.setValue(0)
# Name
self.obj1684.Name.setValue('')
self.obj1684.Name.setNone()
# ReqFlow
self.obj1684.ReqFlow.setNone()
self.obj1684.GGLabel.setValue(5)
self.obj1684.graphClass_ = graph_product
if parent.genGraphics:
new_obj = graph_product(280.0, 220.0, self.obj1684)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1684.graphObject_ = new_obj
self.obj16840 = AttrCalc()
self.obj16840.Copy = ATOM3Boolean()
self.obj16840.Copy.setValue(('Copy from LHS', 1))
self.obj16840.Copy.config = 0
self.obj16840.Specify = ATOM3Constraint()
self.obj16840.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1684.GGset2Any['MaxFlow'] = self.obj16840
self.obj16841 = AttrCalc()
self.obj16841.Copy = ATOM3Boolean()
self.obj16841.Copy.setValue(('Copy from LHS', 1))
self.obj16841.Copy.config = 0
self.obj16841.Specify = ATOM3Constraint()
self.obj16841.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1684.GGset2Any['Name'] = self.obj16841
self.obj16842 = AttrCalc()
self.obj16842.Copy = ATOM3Boolean()
self.obj16842.Copy.setValue(('Copy from LHS', 1))
self.obj16842.Copy.config = 0
self.obj16842.Specify = ATOM3Constraint()
self.obj16842.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1684.GGset2Any['ReqFlow'] = self.obj16842
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1684)
self.obj1684.postAction(self.RHS.CREATE)
self.obj1685 = metarial(parent)
self.obj1685.preAction(self.RHS.CREATE)
self.obj1685.isGraphObjectVisual = True
if (hasattr(self.obj1685, '_setHierarchicalLink')):
self.obj1685._setHierarchicalLink(False)
# MaxFlow
self.obj1685.MaxFlow.setNone()
# price
self.obj1685.price.setValue(0)
# Name
self.obj1685.Name.setValue('')
self.obj1685.Name.setNone()
# ReqFlow
self.obj1685.ReqFlow.setNone()
self.obj1685.GGLabel.setValue(3)
self.obj1685.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(320.0, 40.0, self.obj1685)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1685.graphObject_ = new_obj
self.obj16850 = AttrCalc()
self.obj16850.Copy = ATOM3Boolean()
self.obj16850.Copy.setValue(('Copy from LHS', 1))
self.obj16850.Copy.config = 0
self.obj16850.Specify = ATOM3Constraint()
self.obj16850.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1685.GGset2Any['MaxFlow'] = self.obj16850
self.obj16851 = AttrCalc()
self.obj16851.Copy = ATOM3Boolean()
self.obj16851.Copy.setValue(('Copy from LHS', 1))
self.obj16851.Copy.config = 0
self.obj16851.Specify = ATOM3Constraint()
self.obj16851.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1685.GGset2Any['Name'] = self.obj16851
self.obj16852 = AttrCalc()
self.obj16852.Copy = ATOM3Boolean()
self.obj16852.Copy.setValue(('Copy from LHS', 1))
self.obj16852.Copy.config = 0
self.obj16852.Specify = ATOM3Constraint()
self.obj16852.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1685.GGset2Any['ReqFlow'] = self.obj16852
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1685)
self.obj1685.postAction(self.RHS.CREATE)
self.obj1686 = operatingUnit(parent)
self.obj1686.preAction(self.RHS.CREATE)
self.obj1686.isGraphObjectVisual = True
if (hasattr(self.obj1686, '_setHierarchicalLink')):
self.obj1686._setHierarchicalLink(False)
# OperCostProp
self.obj1686.OperCostProp.setValue(1.0)
# name
self.obj1686.name.setValue('')
self.obj1686.name.setNone()
# OperCostFix
self.obj1686.OperCostFix.setValue(2.0)
self.obj1686.GGLabel.setValue(7)
self.obj1686.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(320.0, 140.0, self.obj1686)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1686.graphObject_ = new_obj
self.obj16860 = AttrCalc()
self.obj16860.Copy = ATOM3Boolean()
self.obj16860.Copy.setValue(('Copy from LHS', 0))
self.obj16860.Copy.config = 0
self.obj16860.Specify = ATOM3Constraint()
self.obj16860.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1686.GGset2Any['OperCostProp'] = self.obj16860
self.obj16861 = AttrCalc()
self.obj16861.Copy = ATOM3Boolean()
self.obj16861.Copy.setValue(('Copy from LHS', 0))
self.obj16861.Copy.config = 0
self.obj16861.Specify = ATOM3Constraint()
self.obj16861.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
'return self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' OAF\'\n'
))
self.obj1686.GGset2Any['name'] = self.obj16861
self.obj16862 = AttrCalc()
self.obj16862.Copy = ATOM3Boolean()
self.obj16862.Copy.setValue(('Copy from LHS', 0))
self.obj16862.Copy.config = 0
self.obj16862.Specify = ATOM3Constraint()
self.obj16862.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1686.GGset2Any['OperCostFix'] = self.obj16862
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1686)
self.obj1686.postAction(self.RHS.CREATE)
self.obj1687 = intoProduct(parent)
self.obj1687.preAction(self.RHS.CREATE)
self.obj1687.isGraphObjectVisual = True
if (hasattr(self.obj1687, '_setHierarchicalLink')):
self.obj1687._setHierarchicalLink(False)
# rate
self.obj1687.rate.setValue(1.0)
self.obj1687.GGLabel.setValue(9)
self.obj1687.graphClass_ = graph_intoProduct
if parent.genGraphics:
new_obj = graph_intoProduct(322.0, 179.0, self.obj1687)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1687.graphObject_ = new_obj
self.obj16870 = AttrCalc()
self.obj16870.Copy = ATOM3Boolean()
self.obj16870.Copy.setValue(('Copy from LHS', 0))
self.obj16870.Copy.config = 0
self.obj16870.Specify = ATOM3Constraint()
self.obj16870.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1687.GGset2Any['rate'] = self.obj16870
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1687)
self.obj1687.postAction(self.RHS.CREATE)
self.obj1688 = fromMaterial(parent)
self.obj1688.preAction(self.RHS.CREATE)
self.obj1688.isGraphObjectVisual = True
if (hasattr(self.obj1688, '_setHierarchicalLink')):
self.obj1688._setHierarchicalLink(False)
# rate
self.obj1688.rate.setValue(1.0)
self.obj1688.GGLabel.setValue(8)
self.obj1688.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(342.0, 110.0, self.obj1688)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1688.graphObject_ = new_obj
self.obj16880 = AttrCalc()
self.obj16880.Copy = ATOM3Boolean()
self.obj16880.Copy.setValue(('Copy from LHS', 0))
self.obj16880.Copy.config = 0
self.obj16880.Specify = ATOM3Constraint()
self.obj16880.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1688.GGset2Any['rate'] = self.obj16880
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1688)
self.obj1688.postAction(self.RHS.CREATE)
self.obj1689 = Goal(parent)
self.obj1689.preAction(self.RHS.CREATE)
self.obj1689.isGraphObjectVisual = True
if (hasattr(self.obj1689, '_setHierarchicalLink')):
self.obj1689._setHierarchicalLink(False)
# name
self.obj1689.name.setValue('')
self.obj1689.name.setNone()
self.obj1689.GGLabel.setValue(2)
self.obj1689.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(180.0, 60.0, self.obj1689)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1689.graphObject_ = new_obj
self.obj16890 = AttrCalc()
self.obj16890.Copy = ATOM3Boolean()
self.obj16890.Copy.setValue(('Copy from LHS', 1))
self.obj16890.Copy.config = 0
self.obj16890.Specify = ATOM3Constraint()
self.obj16890.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1689.GGset2Any['name'] = self.obj16890
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1689)
self.obj1689.postAction(self.RHS.CREATE)
self.obj1690 = GenericGraphEdge(parent)
self.obj1690.preAction(self.RHS.CREATE)
self.obj1690.isGraphObjectVisual = True
if (hasattr(self.obj1690, '_setHierarchicalLink')):
self.obj1690._setHierarchicalLink(False)
self.obj1690.GGLabel.setValue(4)
self.obj1690.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(264.5, 71.5, self.obj1690)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1690.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1690)
self.obj1690.postAction(self.RHS.CREATE)
self.obj1685.out_connections_.append(self.obj1688)
self.obj1688.in_connections_.append(self.obj1685)
self.obj1685.graphObject_.pendingConnections.append(
(self.obj1685.graphObject_.tag, self.obj1688.graphObject_.tag,
[244.0, 89.0, 342.0, 110.0], 0, True))
self.obj1686.out_connections_.append(self.obj1687)
self.obj1687.in_connections_.append(self.obj1686)
self.obj1686.graphObject_.pendingConnections.append(
(self.obj1686.graphObject_.tag, self.obj1687.graphObject_.tag,
[339.0, 158.0, 322.0, 179.0], 0, True))
self.obj1687.out_connections_.append(self.obj1684)
self.obj1684.in_connections_.append(self.obj1687)
self.obj1687.graphObject_.pendingConnections.append(
(self.obj1687.graphObject_.tag, self.obj1684.graphObject_.tag,
[305.0, 220.0, 322.0, 179.0], 0, True))
self.obj1688.out_connections_.append(self.obj1686)
self.obj1686.in_connections_.append(self.obj1688)
self.obj1688.graphObject_.pendingConnections.append(
(self.obj1688.graphObject_.tag, self.obj1686.graphObject_.tag,
[340.0, 151.0, 342.0, 110.0], 0, True))
self.obj1689.out_connections_.append(self.obj1690)
self.obj1690.in_connections_.append(self.obj1689)
self.obj1689.graphObject_.pendingConnections.append(
(self.obj1689.graphObject_.tag, self.obj1690.graphObject_.tag,
[93.0, 61.0, 264.5, 71.5], 2, 0))
self.obj1690.out_connections_.append(self.obj1685)
self.obj1685.in_connections_.append(self.obj1690)
self.obj1690.graphObject_.pendingConnections.append(
(self.obj1690.graphObject_.tag, self.obj1685.graphObject_.tag,
[226.0, 82.0, 264.5, 71.5], 2, 0))
def pnsEx2_MDL(self, rootNode, pnsRootNode=None):
# --- Generating attributes code for ASG pns ---
if (pnsRootNode):
# author
pnsRootNode.author.setValue('Annonymous')
# description
pnsRootNode.description.setValue('\n')
pnsRootNode.description.setHeight(15)
# name
pnsRootNode.name.setValue('')
pnsRootNode.name.setNone()
# --- ASG attributes over ---
self.obj2050 = rawMaterial(self)
self.obj2050.isGraphObjectVisual = True
if (hasattr(self.obj2050, '_setHierarchicalLink')):
self.obj2050._setHierarchicalLink(False)
# MaxFlow
self.obj2050.MaxFlow.setValue(999999)
# price
self.obj2050.price.setValue(5)
# Name
self.obj2050.Name.setValue('A1')
# ReqFlow
self.obj2050.ReqFlow.setValue(0)
self.obj2050.graphClass_ = graph_rawMaterial
if self.genGraphics:
new_obj = graph_rawMaterial(412, 0, self.obj2050)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("rawMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2050.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2050)
self.globalAndLocalPostcondition(self.obj2050, rootNode)
self.obj2050.postAction(rootNode.CREATE)
self.obj2051 = rawMaterial(self)
self.obj2051.isGraphObjectVisual = True
if (hasattr(self.obj2051, '_setHierarchicalLink')):
self.obj2051._setHierarchicalLink(False)
# MaxFlow
self.obj2051.MaxFlow.setValue(999999)
# price
self.obj2051.price.setValue(5)
# Name
self.obj2051.Name.setValue('A2')
# ReqFlow
self.obj2051.ReqFlow.setValue(0)
self.obj2051.graphClass_ = graph_rawMaterial
if self.genGraphics:
new_obj = graph_rawMaterial(0, 0, self.obj2051)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("rawMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2051.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2051)
self.globalAndLocalPostcondition(self.obj2051, rootNode)
self.obj2051.postAction(rootNode.CREATE)
self.obj2052 = operatingUnit(self)
self.obj2052.isGraphObjectVisual = True
if (hasattr(self.obj2052, '_setHierarchicalLink')):
self.obj2052._setHierarchicalLink(False)
# OperCostProp
self.obj2052.OperCostProp.setValue(0.5)
# name
self.obj2052.name.setValue('A1 R1')
# OperCostFix
self.obj2052.OperCostFix.setValue(0.0)
self.obj2052.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(412, 108, self.obj2052)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2052.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2052)
self.globalAndLocalPostcondition(self.obj2052, rootNode)
self.obj2052.postAction(rootNode.CREATE)
self.obj2053 = operatingUnit(self)
self.obj2053.isGraphObjectVisual = True
if (hasattr(self.obj2053, '_setHierarchicalLink')):
self.obj2053._setHierarchicalLink(False)
# OperCostProp
self.obj2053.OperCostProp.setValue(0.25)
# name
self.obj2053.name.setValue('A2 R2')
# OperCostFix
self.obj2053.OperCostFix.setValue(0.0)
self.obj2053.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(0, 108, self.obj2053)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2053.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2053)
self.globalAndLocalPostcondition(self.obj2053, rootNode)
self.obj2053.postAction(rootNode.CREATE)
self.obj2054 = operatingUnit(self)
self.obj2054.isGraphObjectVisual = True
if (hasattr(self.obj2054, '_setHierarchicalLink')):
self.obj2054._setHierarchicalLink(False)
# OperCostProp
self.obj2054.OperCostProp.setValue(1.0)
# name
self.obj2054.name.setValue('G1 OAF')
# OperCostFix
self.obj2054.OperCostFix.setValue(2.0)
self.obj2054.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(412, 450, self.obj2054)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2054.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2054)
self.globalAndLocalPostcondition(self.obj2054, rootNode)
self.obj2054.postAction(rootNode.CREATE)
self.obj2055 = operatingUnit(self)
self.obj2055.isGraphObjectVisual = True
if (hasattr(self.obj2055, '_setHierarchicalLink')):
self.obj2055._setHierarchicalLink(False)
# OperCostProp
self.obj2055.OperCostProp.setValue(1.0)
# name
self.obj2055.name.setValue('G2 OAF')
# OperCostFix
self.obj2055.OperCostFix.setValue(2.0)
self.obj2055.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(206, 450, self.obj2055)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2055.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2055)
self.globalAndLocalPostcondition(self.obj2055, rootNode)
self.obj2055.postAction(rootNode.CREATE)
self.obj2056 = operatingUnit(self)
self.obj2056.isGraphObjectVisual = True
if (hasattr(self.obj2056, '_setHierarchicalLink')):
self.obj2056._setHierarchicalLink(False)
# OperCostProp
self.obj2056.OperCostProp.setValue(0.11)
# name
self.obj2056.name.setValue('A1 R1 G1')
# OperCostFix
self.obj2056.OperCostFix.setValue(2.0)
self.obj2056.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(412, 279, self.obj2056)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2056.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2056)
self.globalAndLocalPostcondition(self.obj2056, rootNode)
self.obj2056.postAction(rootNode.CREATE)
self.obj2057 = operatingUnit(self)
self.obj2057.isGraphObjectVisual = True
if (hasattr(self.obj2057, '_setHierarchicalLink')):
self.obj2057._setHierarchicalLink(False)
# OperCostProp
self.obj2057.OperCostProp.setValue(0.12)
# name
self.obj2057.name.setValue('A1 R1 G2')
# OperCostFix
self.obj2057.OperCostFix.setValue(2.0)
self.obj2057.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(206, 279, self.obj2057)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2057.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2057)
self.globalAndLocalPostcondition(self.obj2057, rootNode)
self.obj2057.postAction(rootNode.CREATE)
self.obj2058 = operatingUnit(self)
self.obj2058.isGraphObjectVisual = True
if (hasattr(self.obj2058, '_setHierarchicalLink')):
self.obj2058._setHierarchicalLink(False)
# OperCostProp
self.obj2058.OperCostProp.setValue(0.22)
# name
self.obj2058.name.setValue('A2 R2 G2')
# OperCostFix
self.obj2058.OperCostFix.setValue(2.0)
self.obj2058.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(0, 279, self.obj2058)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2058.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2058)
self.globalAndLocalPostcondition(self.obj2058, rootNode)
self.obj2058.postAction(rootNode.CREATE)
self.obj2059 = metarial(self)
self.obj2059.isGraphObjectVisual = True
if (hasattr(self.obj2059, '_setHierarchicalLink')):
self.obj2059._setHierarchicalLink(False)
# MaxFlow
self.obj2059.MaxFlow.setValue(999999)
# price
self.obj2059.price.setValue(0)
# Name
self.obj2059.Name.setValue('G1')
# ReqFlow
self.obj2059.ReqFlow.setValue(0)
self.obj2059.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(412, 350, self.obj2059)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2059.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2059)
self.globalAndLocalPostcondition(self.obj2059, rootNode)
self.obj2059.postAction(rootNode.CREATE)
self.obj2060 = metarial(self)
self.obj2060.isGraphObjectVisual = True
if (hasattr(self.obj2060, '_setHierarchicalLink')):
self.obj2060._setHierarchicalLink(False)
# MaxFlow
self.obj2060.MaxFlow.setValue(999999)
# price
self.obj2060.price.setValue(0)
# Name
self.obj2060.Name.setValue('G2')
# ReqFlow
self.obj2060.ReqFlow.setValue(0)
self.obj2060.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(206, 350, self.obj2060)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2060.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2060)
self.globalAndLocalPostcondition(self.obj2060, rootNode)
self.obj2060.postAction(rootNode.CREATE)
self.obj2061 = metarial(self)
self.obj2061.isGraphObjectVisual = True
if (hasattr(self.obj2061, '_setHierarchicalLink')):
self.obj2061._setHierarchicalLink(False)
# MaxFlow
self.obj2061.MaxFlow.setValue(999999)
# price
self.obj2061.price.setValue(0)
# Name
self.obj2061.Name.setValue('A1 R1 G1')
# ReqFlow
self.obj2061.ReqFlow.setValue(0)
self.obj2061.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(412, 179, self.obj2061)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2061.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2061)
self.globalAndLocalPostcondition(self.obj2061, rootNode)
self.obj2061.postAction(rootNode.CREATE)
self.obj2062 = metarial(self)
self.obj2062.isGraphObjectVisual = True
if (hasattr(self.obj2062, '_setHierarchicalLink')):
self.obj2062._setHierarchicalLink(False)
# MaxFlow
self.obj2062.MaxFlow.setValue(999999)
# price
self.obj2062.price.setValue(0)
# Name
self.obj2062.Name.setValue('A1 R1 G2')
# ReqFlow
self.obj2062.ReqFlow.setValue(0)
self.obj2062.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(206, 179, self.obj2062)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2062.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2062)
self.globalAndLocalPostcondition(self.obj2062, rootNode)
self.obj2062.postAction(rootNode.CREATE)
self.obj2063 = metarial(self)
self.obj2063.isGraphObjectVisual = True
if (hasattr(self.obj2063, '_setHierarchicalLink')):
self.obj2063._setHierarchicalLink(False)
# MaxFlow
self.obj2063.MaxFlow.setValue(999999)
# price
self.obj2063.price.setValue(0)
# Name
self.obj2063.Name.setValue('A2 R2 G2')
# ReqFlow
self.obj2063.ReqFlow.setValue(0)
self.obj2063.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(0, 179, self.obj2063)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2063.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2063)
self.globalAndLocalPostcondition(self.obj2063, rootNode)
self.obj2063.postAction(rootNode.CREATE)
self.obj2064 = product(self)
self.obj2064.isGraphObjectVisual = True
if (hasattr(self.obj2064, '_setHierarchicalLink')):
self.obj2064._setHierarchicalLink(False)
# MaxFlow
self.obj2064.MaxFlow.setValue(999999)
# price
self.obj2064.price.setValue(0)
# Name
self.obj2064.Name.setValue('OAF')
# ReqFlow
self.obj2064.ReqFlow.setValue(0)
self.obj2064.graphClass_ = graph_product
if self.genGraphics:
new_obj = graph_product(412, 521, self.obj2064)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("product", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2064.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2064)
self.globalAndLocalPostcondition(self.obj2064, rootNode)
self.obj2064.postAction(rootNode.CREATE)
self.obj2065 = fromMaterial(self)
self.obj2065.isGraphObjectVisual = True
if (hasattr(self.obj2065, '_setHierarchicalLink')):
self.obj2065._setHierarchicalLink(False)
# rate
self.obj2065.rate.setValue(1.0)
self.obj2065.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(443.97925309, 430.64382278, self.obj2065)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2065.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2065)
self.globalAndLocalPostcondition(self.obj2065, rootNode)
self.obj2065.postAction(rootNode.CREATE)
self.obj2066 = fromMaterial(self)
self.obj2066.isGraphObjectVisual = True
if (hasattr(self.obj2066, '_setHierarchicalLink')):
self.obj2066._setHierarchicalLink(False)
# rate
self.obj2066.rate.setValue(1.0)
self.obj2066.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(237.97925309, 430.64382278, self.obj2066)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2066.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2066)
self.globalAndLocalPostcondition(self.obj2066, rootNode)
self.obj2066.postAction(rootNode.CREATE)
self.obj2067 = fromMaterial(self)
self.obj2067.isGraphObjectVisual = True
if (hasattr(self.obj2067, '_setHierarchicalLink')):
self.obj2067._setHierarchicalLink(False)
# rate
self.obj2067.rate.setValue(1.0)
self.obj2067.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(463.682773237, 256.50121981, self.obj2067)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2067.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2067)
self.globalAndLocalPostcondition(self.obj2067, rootNode)
self.obj2067.postAction(rootNode.CREATE)
self.obj2068 = fromMaterial(self)
self.obj2068.isGraphObjectVisual = True
if (hasattr(self.obj2068, '_setHierarchicalLink')):
self.obj2068._setHierarchicalLink(False)
# rate
self.obj2068.rate.setValue(1.0)
self.obj2068.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(257.682773237, 256.50121981, self.obj2068)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2068.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2068)
self.globalAndLocalPostcondition(self.obj2068, rootNode)
self.obj2068.postAction(rootNode.CREATE)
self.obj2069 = fromMaterial(self)
self.obj2069.isGraphObjectVisual = True
if (hasattr(self.obj2069, '_setHierarchicalLink')):
self.obj2069._setHierarchicalLink(False)
# rate
self.obj2069.rate.setValue(1.0)
self.obj2069.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(51.6827732371, 256.50121981, self.obj2069)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2069.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2069)
self.globalAndLocalPostcondition(self.obj2069, rootNode)
self.obj2069.postAction(rootNode.CREATE)
self.obj2070 = intoProduct(self)
self.obj2070.isGraphObjectVisual = True
if (hasattr(self.obj2070, '_setHierarchicalLink')):
self.obj2070._setHierarchicalLink(False)
# rate
self.obj2070.rate.setValue(1.0)
self.obj2070.graphClass_ = graph_intoProduct
if self.genGraphics:
new_obj = graph_intoProduct(443.936529683, 493.375109847, self.obj2070)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoProduct", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2070.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2070)
self.globalAndLocalPostcondition(self.obj2070, rootNode)
self.obj2070.postAction(rootNode.CREATE)
self.obj2071 = intoProduct(self)
self.obj2071.isGraphObjectVisual = True
if (hasattr(self.obj2071, '_setHierarchicalLink')):
self.obj2071._setHierarchicalLink(False)
# rate
self.obj2071.rate.setValue(1.0)
self.obj2071.graphClass_ = graph_intoProduct
if self.genGraphics:
new_obj = graph_intoProduct(350.853713603, 484.915829787, self.obj2071)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoProduct", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2071.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2071)
self.globalAndLocalPostcondition(self.obj2071, rootNode)
self.obj2071.postAction(rootNode.CREATE)
self.obj2072 = fromRaw(self)
self.obj2072.isGraphObjectVisual = True
if (hasattr(self.obj2072, '_setHierarchicalLink')):
self.obj2072._setHierarchicalLink(False)
# rate
self.obj2072.rate.setValue(1.0)
self.obj2072.graphClass_ = graph_fromRaw
if self.genGraphics:
new_obj = graph_fromRaw(443.979904526, 88.1336447318, self.obj2072)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromRaw", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2072.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2072)
self.globalAndLocalPostcondition(self.obj2072, rootNode)
self.obj2072.postAction(rootNode.CREATE)
self.obj2073 = fromRaw(self)
self.obj2073.isGraphObjectVisual = True
if (hasattr(self.obj2073, '_setHierarchicalLink')):
self.obj2073._setHierarchicalLink(False)
# rate
self.obj2073.rate.setValue(1.0)
self.obj2073.graphClass_ = graph_fromRaw
if self.genGraphics:
new_obj = graph_fromRaw(31.9799045263, 88.1336447318, self.obj2073)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromRaw", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2073.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2073)
self.globalAndLocalPostcondition(self.obj2073, rootNode)
self.obj2073.postAction(rootNode.CREATE)
self.obj2074 = intoMaterial(self)
self.obj2074.isGraphObjectVisual = True
if (hasattr(self.obj2074, '_setHierarchicalLink')):
self.obj2074._setHierarchicalLink(False)
# rate
self.obj2074.rate.setValue(0.11)
self.obj2074.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(444.407115796, 321.140199793,
self.obj2074)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2074.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2074)
self.globalAndLocalPostcondition(self.obj2074, rootNode)
self.obj2074.postAction(rootNode.CREATE)
self.obj2075 = intoMaterial(self)
self.obj2075.isGraphObjectVisual = True
if (hasattr(self.obj2075, '_setHierarchicalLink')):
self.obj2075._setHierarchicalLink(False)
# rate
self.obj2075.rate.setValue(0.12)
self.obj2075.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(238.407115796, 321.140199793,
self.obj2075)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2075.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2075)
self.globalAndLocalPostcondition(self.obj2075, rootNode)
self.obj2075.postAction(rootNode.CREATE)
self.obj2076 = intoMaterial(self)
self.obj2076.isGraphObjectVisual = True
if (hasattr(self.obj2076, '_setHierarchicalLink')):
self.obj2076._setHierarchicalLink(False)
# rate
self.obj2076.rate.setValue(0.22)
self.obj2076.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(137.852377142, 316.57866424, self.obj2076)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2076.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2076)
self.globalAndLocalPostcondition(self.obj2076, rootNode)
self.obj2076.postAction(rootNode.CREATE)
self.obj2077 = intoMaterial(self)
self.obj2077.isGraphObjectVisual = True
if (hasattr(self.obj2077, '_setHierarchicalLink')):
self.obj2077._setHierarchicalLink(False)
# rate
self.obj2077.rate.setValue(0.5)
self.obj2077.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(448.986832981, 148.33772234, self.obj2077)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2077.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2077)
self.globalAndLocalPostcondition(self.obj2077, rootNode)
self.obj2077.postAction(rootNode.CREATE)
self.obj2078 = intoMaterial(self)
self.obj2078.isGraphObjectVisual = True
if (hasattr(self.obj2078, '_setHierarchicalLink')):
self.obj2078._setHierarchicalLink(False)
# rate
self.obj2078.rate.setValue(0.5)
self.obj2078.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(349.992999454, 166.870109648,
self.obj2078)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2078.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2078)
self.globalAndLocalPostcondition(self.obj2078, rootNode)
self.obj2078.postAction(rootNode.CREATE)
self.obj2079 = intoMaterial(self)
self.obj2079.isGraphObjectVisual = True
if (hasattr(self.obj2079, '_setHierarchicalLink')):
self.obj2079._setHierarchicalLink(False)
# rate
self.obj2079.rate.setValue(0.25)
self.obj2079.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(36.9868329805, 148.33772234, self.obj2079)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj2079.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj2079)
self.globalAndLocalPostcondition(self.obj2079, rootNode)
self.obj2079.postAction(rootNode.CREATE)
# Connections for obj2050 (graphObject_: Obj1645) of type rawMaterial
self.drawConnections((self.obj2050, self.obj2072, [
436.0, 56.0, 444.9799045262882, 72.38364473182781, 443.9799045262882,
88.13364473182781
], "true", 3))
# Connections for obj2051 (graphObject_: Obj1646) of type rawMaterial
self.drawConnections((self.obj2051, self.obj2073, [
24.0, 56.0, 32.97990452628816, 72.38364473182781, 31.97990452628816,
88.13364473182781
], "true", 3))
# Connections for obj2052 (graphObject_: Obj1647) named A1 R1
self.drawConnections((self.obj2052, self.obj2077, [
431.0, 126.0, 444.73683298050514, 135.58772233983163,
448.98683298050514, 148.33772233983163
], "true", 3), (self.obj2052, self.obj2078, [
431.0, 126.0, 392.2429994544884, 151.1201096477546, 349.9929994544884,
166.8701096477546
], "true", 3))
# Connections for obj2053 (graphObject_: Obj1648) named A2 R2
self.drawConnections((self.obj2053, self.obj2079, [
19.0, 126.0, 32.73683298050514, 135.58772233983163, 36.98683298050514,
148.33772233983163
], "true", 3))
# Connections for obj2054 (graphObject_: Obj1649) named G1 OAF
self.drawConnections((self.obj2054, self.obj2070, [
431.0, 468.0, 442.43652968314956, 480.12510984719063,
443.93652968314956, 493.37510984719063
], "true", 3))
# Connections for obj2055 (graphObject_: Obj1650) named G2 OAF
self.drawConnections((self.obj2055, self.obj2071, [
259.0, 468.0, 306.353713602772, 471.6658297869167, 350.853713602772,
484.9158297869167
], "true", 3))
# Connections for obj2056 (graphObject_: Obj1651) named A1 R1 G1
self.drawConnections((self.obj2056, self.obj2074, [
431.0, 297.0, 442.6571157960441, 308.39019979269983, 444.4071157960441,
321.14019979269983
], "true", 3))
# Connections for obj2057 (graphObject_: Obj1652) named A1 R1 G2
self.drawConnections((self.obj2057, self.obj2075, [
225.0, 297.0, 236.65711579604408, 308.39019979269983,
238.40711579604408, 321.14019979269983
], "true", 3))
# Connections for obj2058 (graphObject_: Obj1653) named A2 R2 G2
self.drawConnections((self.obj2058, self.obj2076, [
53.0, 297.0, 97.10237714155916, 302.078664240101, 137.85237714155915,
316.578664240101
], "true", 3))
# Connections for obj2059 (graphObject_: Obj1654) of type metarial
self.drawConnections((self.obj2059, self.obj2065, [
436.0, 399.0, 444.97925308968456, 415.14382277997964,
443.97925308968456, 430.64382277997964
], "true", 3))
# Connections for obj2060 (graphObject_: Obj1655) of type metarial
self.drawConnections((self.obj2060, self.obj2066, [
230.0, 399.0, 238.9792530896846, 415.14382277997964, 237.9792530896846,
430.64382277997964
], "true", 3))
# Connections for obj2061 (graphObject_: Obj1656) of type metarial
self.drawConnections((self.obj2061, self.obj2067, [
446.0, 228.0, 459.68277323709356, 241.0012198097823,
463.68277323709356, 256.5012198097823
], "true", 3))
# Connections for obj2062 (graphObject_: Obj1657) of type metarial
self.drawConnections((self.obj2062, self.obj2068, [
240.0, 228.0, 253.68277323709358, 241.0012198097823,
257.68277323709356, 256.5012198097823
], "true", 3))
# Connections for obj2063 (graphObject_: Obj1658) of type metarial
self.drawConnections((self.obj2063, self.obj2069, [
34.0, 228.0, 47.68277323709358, 241.0012198097823, 51.68277323709358,
256.5012198097823
], "true", 3))
# Connections for obj2064 (graphObject_: Obj1659) of type product
self.drawConnections()
# Connections for obj2065 (graphObject_: Obj1660) of type fromMaterial
self.drawConnections((self.obj2065, self.obj2054, [
443.97925308968456, 430.64382277997964, 442.97925308968456,
446.14382277997964, 432.0, 461.0
], "true", 3))
# Connections for obj2066 (graphObject_: Obj1662) of type fromMaterial
self.drawConnections((self.obj2066, self.obj2055, [
237.9792530896846, 430.64382277997964, 236.9792530896846,
446.14382277997964, 226.0, 461.0
], "true", 3))
# Connections for obj2067 (graphObject_: Obj1664) of type fromMaterial
self.drawConnections((self.obj2067, self.obj2056, [
463.68277323709356, 256.5012198097823, 467.68277323709356,
272.0012198097823, 462.0, 290.0
], "true", 3))
# Connections for obj2068 (graphObject_: Obj1666) of type fromMaterial
self.drawConnections((self.obj2068, self.obj2057, [
257.68277323709356, 256.5012198097823, 261.68277323709356,
272.0012198097823, 256.0, 290.0
], "true", 3))
# Connections for obj2069 (graphObject_: Obj1668) of type fromMaterial
self.drawConnections((self.obj2069, self.obj2058, [
51.68277323709358, 256.5012198097823, 55.68277323709358,
272.0012198097823, 50.0, 290.0
], "true", 3))
# Connections for obj2070 (graphObject_: Obj1670) of type intoProduct
self.drawConnections((self.obj2070, self.obj2064, [
443.93652968314956, 493.37510984719063, 445.43652968314956,
506.62510984719063, 437.0, 521.0
], "true", 3))
# Connections for obj2071 (graphObject_: Obj1672) of type intoProduct
self.drawConnections((self.obj2071, self.obj2064, [
350.853713602772, 484.9158297869167, 395.353713602772,
498.1658297869167, 437.0, 521.0
], "true", 3))
# Connections for obj2072 (graphObject_: Obj1674) of type fromRaw
self.drawConnections((self.obj2072, self.obj2052, [
443.9799045262882, 88.13364473182781, 442.9799045262882,
103.88364473182781, 432.0, 119.0
], "true", 3))
# Connections for obj2073 (graphObject_: Obj1676) of type fromRaw
self.drawConnections((self.obj2073, self.obj2053, [
31.97990452628816, 88.13364473182781, 30.97990452628816,
103.88364473182781, 20.0, 119.0
], "true", 3))
# Connections for obj2074 (graphObject_: Obj1678) of type intoMaterial
self.drawConnections((self.obj2074, self.obj2059, [
444.4071157960441, 321.14019979269983, 446.1571157960441,
333.89019979269983, 438.0, 348.0
], "true", 3))
# Connections for obj2075 (graphObject_: Obj1680) of type intoMaterial
self.drawConnections((self.obj2075, self.obj2060, [
238.40711579604408, 321.14019979269983, 240.15711579604408,
333.89019979269983, 232.0, 348.0
], "true", 3))
# Connections for obj2076 (graphObject_: Obj1682) of type intoMaterial
self.drawConnections((self.obj2076, self.obj2060, [
137.85237714155915, 316.578664240101, 178.60237714155915,
331.078664240101, 216.0, 355.0
], "true", 3))
# Connections for obj2077 (graphObject_: Obj1684) of type intoMaterial
self.drawConnections((self.obj2077, self.obj2061, [
448.98683298050514, 148.33772233983163, 453.23683298050514,
161.08772233983163, 448.0, 177.0
], "true", 3))
# Connections for obj2078 (graphObject_: Obj1686) of type intoMaterial
self.drawConnections((self.obj2078, self.obj2062, [
349.9929994544884, 166.8701096477546, 307.7429994544884,
182.6201096477546, 262.0, 189.0
], "true", 3))
# Connections for obj2079 (graphObject_: Obj1688) of type intoMaterial
self.drawConnections((self.obj2079, self.obj2063, [
36.98683298050514, 148.33772233983163, 41.23683298050514,
161.08772233983163, 36.0, 177.0
], "true", 3))
def neighbors(coord):
return {coord + Coord(*xy) for xy in product([-1, 0, 1], repeat=2)}
def pnsEx1_MDL(self, rootNode, pnsRootNode=None):
# --- Generating attributes code for ASG pns ---
if (pnsRootNode):
# author
pnsRootNode.author.setValue('Annonymous')
# description
pnsRootNode.description.setValue('\n')
pnsRootNode.description.setHeight(15)
# name
pnsRootNode.name.setValue('')
pnsRootNode.name.setNone()
# --- ASG attributes over ---
self.obj1028 = rawMaterial(self)
self.obj1028.isGraphObjectVisual = True
if (hasattr(self.obj1028, '_setHierarchicalLink')):
self.obj1028._setHierarchicalLink(False)
# MaxFlow
self.obj1028.MaxFlow.setValue(999999)
# price
self.obj1028.price.setValue(5)
# Name
self.obj1028.Name.setValue('A1')
# ReqFlow
self.obj1028.ReqFlow.setValue(0)
self.obj1028.graphClass_ = graph_rawMaterial
if self.genGraphics:
new_obj = graph_rawMaterial(206, 0, self.obj1028)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("rawMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1028.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1028)
self.globalAndLocalPostcondition(self.obj1028, rootNode)
self.obj1028.postAction(rootNode.CREATE)
self.obj1029 = operatingUnit(self)
self.obj1029.isGraphObjectVisual = True
if (hasattr(self.obj1029, '_setHierarchicalLink')):
self.obj1029._setHierarchicalLink(False)
# OperCostProp
self.obj1029.OperCostProp.setValue(0.5)
# name
self.obj1029.name.setValue('A1 R1')
# OperCostFix
self.obj1029.OperCostFix.setValue(0.0)
self.obj1029.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(206, 108, self.obj1029)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1029.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1029)
self.globalAndLocalPostcondition(self.obj1029, rootNode)
self.obj1029.postAction(rootNode.CREATE)
self.obj1030 = operatingUnit(self)
self.obj1030.isGraphObjectVisual = True
if (hasattr(self.obj1030, '_setHierarchicalLink')):
self.obj1030._setHierarchicalLink(False)
# OperCostProp
self.obj1030.OperCostProp.setValue(1.0)
# name
self.obj1030.name.setValue('G1 OAF')
# OperCostFix
self.obj1030.OperCostFix.setValue(2.0)
self.obj1030.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(0, 450, self.obj1030)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1030.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1030)
self.globalAndLocalPostcondition(self.obj1030, rootNode)
self.obj1030.postAction(rootNode.CREATE)
self.obj1031 = operatingUnit(self)
self.obj1031.isGraphObjectVisual = True
if (hasattr(self.obj1031, '_setHierarchicalLink')):
self.obj1031._setHierarchicalLink(False)
# OperCostProp
self.obj1031.OperCostProp.setValue(1.0)
# name
self.obj1031.name.setValue('G2 OAF')
# OperCostFix
self.obj1031.OperCostFix.setValue(2.0)
self.obj1031.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(206, 450, self.obj1031)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1031.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1031)
self.globalAndLocalPostcondition(self.obj1031, rootNode)
self.obj1031.postAction(rootNode.CREATE)
self.obj1032 = operatingUnit(self)
self.obj1032.isGraphObjectVisual = True
if (hasattr(self.obj1032, '_setHierarchicalLink')):
self.obj1032._setHierarchicalLink(False)
# OperCostProp
self.obj1032.OperCostProp.setValue(0.11)
# name
self.obj1032.name.setValue('A1 R1 G1')
# OperCostFix
self.obj1032.OperCostFix.setValue(2.0)
self.obj1032.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(0, 279, self.obj1032)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1032.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1032)
self.globalAndLocalPostcondition(self.obj1032, rootNode)
self.obj1032.postAction(rootNode.CREATE)
self.obj1033 = operatingUnit(self)
self.obj1033.isGraphObjectVisual = True
if (hasattr(self.obj1033, '_setHierarchicalLink')):
self.obj1033._setHierarchicalLink(False)
# OperCostProp
self.obj1033.OperCostProp.setValue(0.12)
# name
self.obj1033.name.setValue('A1 R1 G2')
# OperCostFix
self.obj1033.OperCostFix.setValue(2.0)
self.obj1033.graphClass_ = graph_operatingUnit
if self.genGraphics:
new_obj = graph_operatingUnit(206, 279, self.obj1033)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1033.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1033)
self.globalAndLocalPostcondition(self.obj1033, rootNode)
self.obj1033.postAction(rootNode.CREATE)
self.obj1034 = metarial(self)
self.obj1034.isGraphObjectVisual = True
if (hasattr(self.obj1034, '_setHierarchicalLink')):
self.obj1034._setHierarchicalLink(False)
# MaxFlow
self.obj1034.MaxFlow.setValue(999999)
# price
self.obj1034.price.setValue(0)
# Name
self.obj1034.Name.setValue('G1')
# ReqFlow
self.obj1034.ReqFlow.setValue(0)
self.obj1034.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(0, 350, self.obj1034)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1034.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1034)
self.globalAndLocalPostcondition(self.obj1034, rootNode)
self.obj1034.postAction(rootNode.CREATE)
self.obj1035 = metarial(self)
self.obj1035.isGraphObjectVisual = True
if (hasattr(self.obj1035, '_setHierarchicalLink')):
self.obj1035._setHierarchicalLink(False)
# MaxFlow
self.obj1035.MaxFlow.setValue(999999)
# price
self.obj1035.price.setValue(0)
# Name
self.obj1035.Name.setValue('G2')
# ReqFlow
self.obj1035.ReqFlow.setValue(0)
self.obj1035.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(206, 350, self.obj1035)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1035.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1035)
self.globalAndLocalPostcondition(self.obj1035, rootNode)
self.obj1035.postAction(rootNode.CREATE)
self.obj1036 = metarial(self)
self.obj1036.isGraphObjectVisual = True
if (hasattr(self.obj1036, '_setHierarchicalLink')):
self.obj1036._setHierarchicalLink(False)
# MaxFlow
self.obj1036.MaxFlow.setValue(999999)
# price
self.obj1036.price.setValue(0)
# Name
self.obj1036.Name.setValue('A1 R1 G1')
# ReqFlow
self.obj1036.ReqFlow.setValue(0)
self.obj1036.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(0, 179, self.obj1036)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1036.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1036)
self.globalAndLocalPostcondition(self.obj1036, rootNode)
self.obj1036.postAction(rootNode.CREATE)
self.obj1037 = metarial(self)
self.obj1037.isGraphObjectVisual = True
if (hasattr(self.obj1037, '_setHierarchicalLink')):
self.obj1037._setHierarchicalLink(False)
# MaxFlow
self.obj1037.MaxFlow.setValue(999999)
# price
self.obj1037.price.setValue(0)
# Name
self.obj1037.Name.setValue('A1 R1 G2')
# ReqFlow
self.obj1037.ReqFlow.setValue(0)
self.obj1037.graphClass_ = graph_metarial
if self.genGraphics:
new_obj = graph_metarial(206, 179, self.obj1037)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("metarial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1037.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1037)
self.globalAndLocalPostcondition(self.obj1037, rootNode)
self.obj1037.postAction(rootNode.CREATE)
self.obj1038 = product(self)
self.obj1038.isGraphObjectVisual = True
if (hasattr(self.obj1038, '_setHierarchicalLink')):
self.obj1038._setHierarchicalLink(False)
# MaxFlow
self.obj1038.MaxFlow.setValue(999999)
# price
self.obj1038.price.setValue(0)
# Name
self.obj1038.Name.setValue('OAF')
# ReqFlow
self.obj1038.ReqFlow.setValue(0)
self.obj1038.graphClass_ = graph_product
if self.genGraphics:
new_obj = graph_product(206, 521, self.obj1038)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("product", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1038.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1038)
self.globalAndLocalPostcondition(self.obj1038, rootNode)
self.obj1038.postAction(rootNode.CREATE)
self.obj1039 = fromMaterial(self)
self.obj1039.isGraphObjectVisual = True
if (hasattr(self.obj1039, '_setHierarchicalLink')):
self.obj1039._setHierarchicalLink(False)
# rate
self.obj1039.rate.setValue(1.0)
self.obj1039.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(32.005065672, 430.467211341, self.obj1039)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1039.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1039)
self.globalAndLocalPostcondition(self.obj1039, rootNode)
self.obj1039.postAction(rootNode.CREATE)
self.obj1040 = fromMaterial(self)
self.obj1040.isGraphObjectVisual = True
if (hasattr(self.obj1040, '_setHierarchicalLink')):
self.obj1040._setHierarchicalLink(False)
# rate
self.obj1040.rate.setValue(1.0)
self.obj1040.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(238.207284862, 430.669455243,
self.obj1040)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1040.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1040)
self.globalAndLocalPostcondition(self.obj1040, rootNode)
self.obj1040.postAction(rootNode.CREATE)
self.obj1041 = fromMaterial(self)
self.obj1041.isGraphObjectVisual = True
if (hasattr(self.obj1041, '_setHierarchicalLink')):
self.obj1041._setHierarchicalLink(False)
# rate
self.obj1041.rate.setValue(1.0)
self.obj1041.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(51.4550432196, 256.476547823,
self.obj1041)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1041.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1041)
self.globalAndLocalPostcondition(self.obj1041, rootNode)
self.obj1041.postAction(rootNode.CREATE)
self.obj1042 = fromMaterial(self)
self.obj1042.isGraphObjectVisual = True
if (hasattr(self.obj1042, '_setHierarchicalLink')):
self.obj1042._setHierarchicalLink(False)
# rate
self.obj1042.rate.setValue(1.0)
self.obj1042.graphClass_ = graph_fromMaterial
if self.genGraphics:
new_obj = graph_fromMaterial(257.45504322, 256.476547823, self.obj1042)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1042.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1042)
self.globalAndLocalPostcondition(self.obj1042, rootNode)
self.obj1042.postAction(rootNode.CREATE)
self.obj1043 = intoProduct(self)
self.obj1043.isGraphObjectVisual = True
if (hasattr(self.obj1043, '_setHierarchicalLink')):
self.obj1043._setHierarchicalLink(False)
# rate
self.obj1043.rate.setValue(1.0)
self.obj1043.graphClass_ = graph_intoProduct
if self.genGraphics:
new_obj = graph_intoProduct(144.868478175, 484.858273262, self.obj1043)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoProduct", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1043.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1043)
self.globalAndLocalPostcondition(self.obj1043, rootNode)
self.obj1043.postAction(rootNode.CREATE)
self.obj1044 = intoProduct(self)
self.obj1044.isGraphObjectVisual = True
if (hasattr(self.obj1044, '_setHierarchicalLink')):
self.obj1044._setHierarchicalLink(False)
# rate
self.obj1044.rate.setValue(1.0)
self.obj1044.graphClass_ = graph_intoProduct
if self.genGraphics:
new_obj = graph_intoProduct(238.187112626, 493.499100791, self.obj1044)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoProduct", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1044.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1044)
self.globalAndLocalPostcondition(self.obj1044, rootNode)
self.obj1044.postAction(rootNode.CREATE)
self.obj1045 = fromRaw(self)
self.obj1045.isGraphObjectVisual = True
if (hasattr(self.obj1045, '_setHierarchicalLink')):
self.obj1045._setHierarchicalLink(False)
# rate
self.obj1045.rate.setValue(1.0)
self.obj1045.graphClass_ = graph_fromRaw
if self.genGraphics:
new_obj = graph_fromRaw(237.772666213, 87.9637186904, self.obj1045)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("fromRaw", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1045.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1045)
self.globalAndLocalPostcondition(self.obj1045, rootNode)
self.obj1045.postAction(rootNode.CREATE)
self.obj1046 = intoMaterial(self)
self.obj1046.isGraphObjectVisual = True
if (hasattr(self.obj1046, '_setHierarchicalLink')):
self.obj1046._setHierarchicalLink(False)
# rate
self.obj1046.rate.setValue(0.11)
self.obj1046.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(32.4226168069, 321.008573698,
self.obj1046)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1046.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1046)
self.globalAndLocalPostcondition(self.obj1046, rootNode)
self.obj1046.postAction(rootNode.CREATE)
self.obj1047 = intoMaterial(self)
self.obj1047.isGraphObjectVisual = True
if (hasattr(self.obj1047, '_setHierarchicalLink')):
self.obj1047._setHierarchicalLink(False)
# rate
self.obj1047.rate.setValue(0.12)
self.obj1047.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(238.390600655, 321.222839546,
self.obj1047)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1047.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1047)
self.globalAndLocalPostcondition(self.obj1047, rootNode)
self.obj1047.postAction(rootNode.CREATE)
self.obj1048 = intoMaterial(self)
self.obj1048.isGraphObjectVisual = True
if (hasattr(self.obj1048, '_setHierarchicalLink')):
self.obj1048._setHierarchicalLink(False)
# rate
self.obj1048.rate.setValue(0.5)
self.obj1048.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(143.686831985, 166.822062776,
self.obj1048)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1048.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1048)
self.globalAndLocalPostcondition(self.obj1048, rootNode)
self.obj1048.postAction(rootNode.CREATE)
self.obj1049 = intoMaterial(self)
self.obj1049.isGraphObjectVisual = True
if (hasattr(self.obj1049, '_setHierarchicalLink')):
self.obj1049._setHierarchicalLink(False)
# rate
self.obj1049.rate.setValue(0.5)
self.obj1049.graphClass_ = graph_intoMaterial
if self.genGraphics:
new_obj = graph_intoMaterial(242.68883419, 148.342483174, self.obj1049)
new_obj.DrawObject(self.UMLmodel)
self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1049.graphObject_ = new_obj
# Add node to the root: rootNode
rootNode.addNode(self.obj1049)
self.globalAndLocalPostcondition(self.obj1049, rootNode)
self.obj1049.postAction(rootNode.CREATE)
# Connections for obj1028 (graphObject_: Obj713) of type rawMaterial
self.drawConnections((self.obj1028, self.obj1045, [
229.7927616866, 55.830073958000014, 238.77266621273276,
72.21371869016248, 237.77266621258278, 87.96371869041248
], "true", 3))
# Connections for obj1029 (graphObject_: Obj714) named A1 R1
self.drawConnections((self.obj1029, self.obj1048, [
224.792761686, 125.830073959, 185.99042726423008, 151.00958126939372,
143.68683198473008, 166.82206277614372
], "true", 3), (self.obj1029, self.obj1049, [
224.792761686, 125.830073959, 238.49242946992584, 135.53000166744766,
242.68883419042584, 148.34248317419767
], "true", 3))
# Connections for obj1030 (graphObject_: Obj715) named G1 OAF
self.drawConnections((self.obj1030, self.obj1043, [
53.0172746084, 467.88123386200004, 100.37279682732834,
471.57858172741805, 144.86847817522835, 484.85827326191804
], "true", 3))
# Connections for obj1031 (graphObject_: Obj716) named G2 OAF
self.drawConnections((self.obj1031, self.obj1044, [
225.482036654, 468.072046504, 236.80762178979543, 480.2671124172909,
238.18711262629543, 493.49910079129086
], "true", 3))
# Connections for obj1032 (graphObject_: Obj717) named A1 R1 G1
self.drawConnections((self.obj1032, self.obj1046, [
19.0, 297.0, 30.663979502928797, 308.3179567678522, 32.422616806928794,
321.00857369835217
], "true", 3))
# Connections for obj1033 (graphObject_: Obj718) named A1 R1 G2
self.drawConnections((self.obj1033, self.obj1047, [
225.0, 297.0, 236.6495823288382, 308.4368162949629, 238.39060065533818,
321.2228395464629
], "true", 3))
# Connections for obj1034 (graphObject_: Obj719) of type metarial
self.drawConnections((self.obj1034, self.obj1039, [
24.034549215999988, 398.7624677220001, 33.009384323918454,
414.9375198057641, 32.00506567201846, 430.4672113407641
], "true", 3))
# Connections for obj1035 (graphObject_: Obj720) of type metarial
self.drawConnections((self.obj1035, self.obj1040, [
229.964073306, 399.14409300600005, 239.07779402486605,
415.18746686842474, 238.20728486186607, 430.6694552429247
], "true", 3))
# Connections for obj1036 (graphObject_: Obj721) of type metarial
self.drawConnections((self.obj1036, self.obj1041, [
33.578380568, 228.07999998599996, 47.34963836160739, 240.9965478196302,
51.45504321960739, 256.4765478231302
], "true", 3))
# Connections for obj1037 (graphObject_: Obj722) of type metarial
self.drawConnections((self.obj1037, self.obj1042, [
239.578380568, 228.07999998600008, 253.34963836160736,
240.99654781963028, 257.4550432196074, 256.47654782313026
], "true", 3))
# Connections for obj1038 (graphObject_: Obj723) of type product
self.drawConnections()
# Connections for obj1039 (graphObject_: Obj724) of type fromMaterial
self.drawConnections((self.obj1039, self.obj1030, [
32.00506567201846, 430.4672113407641, 31.00074702011846,
445.9969028757641, 20.0172746084, 460.88123386200004
], "true", 3))
# Connections for obj1040 (graphObject_: Obj726) of type fromMaterial
self.drawConnections((self.obj1040, self.obj1031, [
238.20728486186607, 430.6694552429247, 237.3367756988661,
446.15144361742466, 226.482036654, 461.072046504
], "true", 3))
# Connections for obj1041 (graphObject_: Obj728) of type fromMaterial
self.drawConnections((self.obj1041, self.obj1032, [
51.45504321960739, 256.4765478231302, 55.56044807760739,
271.95654782663024, 50.0, 290.0
], "true", 3))
# Connections for obj1042 (graphObject_: Obj730) of type fromMaterial
self.drawConnections((self.obj1042, self.obj1033, [
257.4550432196074, 256.47654782313026, 261.5604480776074,
271.95654782663024, 256.0, 290.0
], "true", 3))
# Connections for obj1043 (graphObject_: Obj732) of type intoProduct
self.drawConnections((self.obj1043, self.obj1038, [
144.86847817522835, 484.85827326191804, 189.3641595231283,
498.13796479641803, 231.0, 521.0
], "true", 3))
# Connections for obj1044 (graphObject_: Obj734) of type intoProduct
self.drawConnections((self.obj1044, self.obj1038, [
238.18711262629543, 493.49910079129086, 239.56660346279543,
506.7310891652908, 231.0, 521.0
], "true", 3))
# Connections for obj1045 (graphObject_: Obj736) of type fromRaw
self.drawConnections((self.obj1045, self.obj1029, [
237.77266621258278, 87.96371869041248, 236.7726662124328,
103.71371869066247, 225.792761686, 118.830073959
], "true", 3))
# Connections for obj1046 (graphObject_: Obj738) of type intoMaterial
self.drawConnections((self.obj1046, self.obj1034, [
32.422616806928794, 321.00857369835217, 34.18125411092879,
333.69919062885214, 26.034549215999988, 347.762467722
], "true", 3))
# Connections for obj1047 (graphObject_: Obj740) of type intoMaterial
self.drawConnections((self.obj1047, self.obj1035, [
238.39060065533818, 321.2228395464629, 240.13161898183816,
334.00886279796293, 231.964073306, 348.14409300600005
], "true", 3))
# Connections for obj1048 (graphObject_: Obj742) of type intoMaterial
self.drawConnections((self.obj1048, self.obj1036, [
143.68683198473008, 166.82206277614372, 101.38323670523008,
182.63454428289373, 55.57838056800006, 189.07999998599996
], "true", 3))
# Connections for obj1049 (graphObject_: Obj744) of type intoMaterial
self.drawConnections((self.obj1049, self.obj1037, [
242.68883419042584, 148.34248317419767, 246.88523891092584,
161.15496468094767, 241.578380568, 177.07999998600002
], "true", 3))
def __init__(self, parent):
GGrule.__init__(self, 6)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.obj965 = product(parent)
self.obj965.preAction(self.LHS.CREATE)
self.obj965.isGraphObjectVisual = True
if (hasattr(self.obj965, '_setHierarchicalLink')):
self.obj965._setHierarchicalLink(False)
# MaxFlow
self.obj965.MaxFlow.setNone()
# price
self.obj965.price.setNone()
# Name
self.obj965.Name.setValue('')
self.obj965.Name.setNone()
# ReqFlow
self.obj965.ReqFlow.setNone()
self.obj965.GGLabel.setValue(2)
self.obj965.graphClass_ = graph_product
if parent.genGraphics:
new_obj = graph_product(220.0, 140.0, self.obj965)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj965.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj965)
self.obj965.postAction(self.LHS.CREATE)
self.obj966 = operatingUnit(parent)
self.obj966.preAction(self.LHS.CREATE)
self.obj966.isGraphObjectVisual = True
if (hasattr(self.obj966, '_setHierarchicalLink')):
self.obj966._setHierarchicalLink(False)
# OperCostProp
self.obj966.OperCostProp.setNone()
# name
self.obj966.name.setValue('')
self.obj966.name.setNone()
# OperCostFix
self.obj966.OperCostFix.setNone()
self.obj966.GGLabel.setValue(1)
self.obj966.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(180.0, 20.0, self.obj966)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj966.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj966)
self.obj966.postAction(self.LHS.CREATE)
self.obj967 = intoProduct(parent)
self.obj967.preAction(self.LHS.CREATE)
self.obj967.isGraphObjectVisual = True
if (hasattr(self.obj967, '_setHierarchicalLink')):
self.obj967._setHierarchicalLink(False)
# rate
self.obj967.rate.setNone()
self.obj967.GGLabel.setValue(3)
self.obj967.graphClass_ = graph_intoProduct
if parent.genGraphics:
new_obj = graph_intoProduct(239.0, 89.0, self.obj967)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj967.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj967)
self.obj967.postAction(self.LHS.CREATE)
self.obj966.out_connections_.append(self.obj967)
self.obj967.in_connections_.append(self.obj966)
self.obj966.graphObject_.pendingConnections.append(
(self.obj966.graphObject_.tag, self.obj967.graphObject_.tag,
[233.0, 38.0, 239.0, 89.0], 0, True))
self.obj967.out_connections_.append(self.obj965)
self.obj965.in_connections_.append(self.obj967)
self.obj967.graphObject_.pendingConnections.append(
(self.obj967.graphObject_.tag, self.obj965.graphObject_.tag,
[245.0, 140.0, 239.0, 89.0], 0, True))
self.RHS = ASG_pns(parent)
self.obj969 = product(parent)
self.obj969.preAction(self.RHS.CREATE)
self.obj969.isGraphObjectVisual = True
if (hasattr(self.obj969, '_setHierarchicalLink')):
self.obj969._setHierarchicalLink(False)
# MaxFlow
self.obj969.MaxFlow.setNone()
# price
self.obj969.price.setNone()
# Name
self.obj969.Name.setValue('')
self.obj969.Name.setNone()
# ReqFlow
self.obj969.ReqFlow.setNone()
self.obj969.GGLabel.setValue(2)
self.obj969.graphClass_ = graph_product
if parent.genGraphics:
new_obj = graph_product(220.0, 140.0, self.obj969)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj969.graphObject_ = new_obj
self.obj9690 = AttrCalc()
self.obj9690.Copy = ATOM3Boolean()
self.obj9690.Copy.setValue(('Copy from LHS', 1))
self.obj9690.Copy.config = 0
self.obj9690.Specify = ATOM3Constraint()
self.obj9690.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj969.GGset2Any['MaxFlow'] = self.obj9690
self.obj9691 = AttrCalc()
self.obj9691.Copy = ATOM3Boolean()
self.obj9691.Copy.setValue(('Copy from LHS', 1))
self.obj9691.Copy.config = 0
self.obj9691.Specify = ATOM3Constraint()
self.obj9691.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj969.GGset2Any['price'] = self.obj9691
self.obj9692 = AttrCalc()
self.obj9692.Copy = ATOM3Boolean()
self.obj9692.Copy.setValue(('Copy from LHS', 1))
self.obj9692.Copy.config = 0
self.obj9692.Specify = ATOM3Constraint()
self.obj9692.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj969.GGset2Any['Name'] = self.obj9692
self.obj9693 = AttrCalc()
self.obj9693.Copy = ATOM3Boolean()
self.obj9693.Copy.setValue(('Copy from LHS', 1))
self.obj9693.Copy.config = 0
self.obj9693.Specify = ATOM3Constraint()
self.obj9693.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj969.GGset2Any['ReqFlow'] = self.obj9693
# Add node to the root: self.RHS
self.RHS.addNode(self.obj969)
self.obj969.postAction(self.RHS.CREATE)
self.obj970 = operatingUnit(parent)
self.obj970.preAction(self.RHS.CREATE)
self.obj970.isGraphObjectVisual = True
if (hasattr(self.obj970, '_setHierarchicalLink')):
self.obj970._setHierarchicalLink(False)
# OperCostProp
self.obj970.OperCostProp.setNone()
# name
self.obj970.name.setValue('')
self.obj970.name.setNone()
# OperCostFix
self.obj970.OperCostFix.setNone()
self.obj970.GGLabel.setValue(1)
self.obj970.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(180.0, 20.0, self.obj970)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj970.graphObject_ = new_obj
self.obj9700 = AttrCalc()
self.obj9700.Copy = ATOM3Boolean()
self.obj9700.Copy.setValue(('Copy from LHS', 1))
self.obj9700.Copy.config = 0
self.obj9700.Specify = ATOM3Constraint()
self.obj9700.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj970.GGset2Any['OperCostProp'] = self.obj9700
self.obj9701 = AttrCalc()
self.obj9701.Copy = ATOM3Boolean()
self.obj9701.Copy.setValue(('Copy from LHS', 1))
self.obj9701.Copy.config = 0
self.obj9701.Specify = ATOM3Constraint()
self.obj9701.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj970.GGset2Any['name'] = self.obj9701
self.obj9702 = AttrCalc()
self.obj9702.Copy = ATOM3Boolean()
self.obj9702.Copy.setValue(('Copy from LHS', 1))
self.obj9702.Copy.config = 0
self.obj9702.Specify = ATOM3Constraint()
self.obj9702.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj970.GGset2Any['OperCostFix'] = self.obj9702
# Add node to the root: self.RHS
self.RHS.addNode(self.obj970)
self.obj970.postAction(self.RHS.CREATE)
self.obj971 = intoProduct(parent)
self.obj971.preAction(self.RHS.CREATE)
self.obj971.isGraphObjectVisual = True
if (hasattr(self.obj971, '_setHierarchicalLink')):
self.obj971._setHierarchicalLink(False)
# rate
self.obj971.rate.setNone()
self.obj971.GGLabel.setValue(3)
self.obj971.graphClass_ = graph_intoProduct
if parent.genGraphics:
new_obj = graph_intoProduct(239.0, 89.0, self.obj971)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj971.graphObject_ = new_obj
self.obj9710 = AttrCalc()
self.obj9710.Copy = ATOM3Boolean()
self.obj9710.Copy.setValue(('Copy from LHS', 1))
self.obj9710.Copy.config = 0
self.obj9710.Specify = ATOM3Constraint()
self.obj9710.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj971.GGset2Any['rate'] = self.obj9710
# Add node to the root: self.RHS
self.RHS.addNode(self.obj971)
self.obj971.postAction(self.RHS.CREATE)
self.obj970.out_connections_.append(self.obj971)
self.obj971.in_connections_.append(self.obj970)
self.obj970.graphObject_.pendingConnections.append(
(self.obj970.graphObject_.tag, self.obj971.graphObject_.tag,
[233.0, 28.0, 239.0, 89.0], 2, 0))
self.obj971.out_connections_.append(self.obj969)
self.obj969.in_connections_.append(self.obj971)
self.obj971.graphObject_.pendingConnections.append(
(self.obj971.graphObject_.tag, self.obj969.graphObject_.tag,
[245.0, 140.0, 239.0, 89.0], 2, 0))
import sums
import diff
import product
import division
print("Select operation.")
print("1.Add")
print("2.Subtract")
print("3.Multiply")
print("4.Divide")
# Take input from the user
choice = input("Enter choice(1/2/3/4): ")
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
if choice == '1':
print(num1, "+", num2, "=", sums(num1, num2))
elif choice == '2':
print(num1, "-", num2, "=", diff(num1, num2))
elif choice == '3':
print(num1, "*", num2, "=", product(num1, num2))
elif choice == '4':
print(num1, "/", num2, "=", division(num1, num2))
else:
print("Invalid input")
