def createNewoperatingUnit(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 = operatingUnit(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["operatingUnit"])
if new_semantic_obj.keyword_:
new_semantic_obj.keyword_.setValue(
new_semantic_obj.keyword_.toString() + str(ne))
if screenCoordinates:
new_obj = graph_operatingUnit(self.UMLmodel.canvasx(wherex),
self.UMLmodel.canvasy(wherey),
new_semantic_obj)
else: # already in canvas coordinates
new_obj = graph_operatingUnit(wherex, wherey, new_semantic_obj)
new_obj.DrawObject(self.UMLmodel, self.editGGLabel)
self.UMLmodel.addtag_withtag("operatingUnit", 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
def __init__(self, parent):
GGrule.__init__(self, 28)
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.obj1849 = metarial(parent)
self.obj1849.preAction(self.LHS.CREATE)
self.obj1849.isGraphObjectVisual = True
if (hasattr(self.obj1849, '_setHierarchicalLink')):
self.obj1849._setHierarchicalLink(False)
# MaxFlow
self.obj1849.MaxFlow.setNone()
# price
self.obj1849.price.setValue(0)
# Name
self.obj1849.Name.setValue('')
self.obj1849.Name.setNone()
# ReqFlow
self.obj1849.ReqFlow.setNone()
self.obj1849.GGLabel.setValue(2)
self.obj1849.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(280.0, 40.0, self.obj1849)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1849.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1849)
self.obj1849.postAction(self.LHS.CREATE)
self.obj1850 = operatingUnit(parent)
self.obj1850.preAction(self.LHS.CREATE)
self.obj1850.isGraphObjectVisual = True
if (hasattr(self.obj1850, '_setHierarchicalLink')):
self.obj1850._setHierarchicalLink(False)
# OperCostProp
self.obj1850.OperCostProp.setNone()
# name
self.obj1850.name.setValue('')
self.obj1850.name.setNone()
# OperCostFix
self.obj1850.OperCostFix.setNone()
self.obj1850.GGLabel.setValue(3)
self.obj1850.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(300.0, 140.0, self.obj1850)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1850.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1850)
self.obj1850.postAction(self.LHS.CREATE)
self.obj1851 = fromMaterial(parent)
self.obj1851.preAction(self.LHS.CREATE)
self.obj1851.isGraphObjectVisual = True
if (hasattr(self.obj1851, '_setHierarchicalLink')):
self.obj1851._setHierarchicalLink(False)
# rate
self.obj1851.rate.setNone()
self.obj1851.GGLabel.setValue(4)
self.obj1851.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(342.75, 113.75, self.obj1851)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1851.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1851)
self.obj1851.postAction(self.LHS.CREATE)
self.obj1852 = Role(parent)
self.obj1852.preAction(self.LHS.CREATE)
self.obj1852.isGraphObjectVisual = True
if (hasattr(self.obj1852, '_setHierarchicalLink')):
self.obj1852._setHierarchicalLink(False)
# name
self.obj1852.name.setValue('')
self.obj1852.name.setNone()
self.obj1852.GGLabel.setValue(1)
self.obj1852.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(80.0, 60.0, self.obj1852)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1852.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1852)
self.obj1852.postAction(self.LHS.CREATE)
self.obj1853 = GenericGraphEdge(parent)
self.obj1853.preAction(self.LHS.CREATE)
self.obj1853.isGraphObjectVisual = True
if (hasattr(self.obj1853, '_setHierarchicalLink')):
self.obj1853._setHierarchicalLink(False)
self.obj1853.GGLabel.setValue(5)
self.obj1853.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(195.0, 71.5, self.obj1853)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1853.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1853)
self.obj1853.postAction(self.LHS.CREATE)
self.obj1849.out_connections_.append(self.obj1851)
self.obj1851.in_connections_.append(self.obj1849)
self.obj1849.graphObject_.pendingConnections.append(
(self.obj1849.graphObject_.tag, self.obj1851.graphObject_.tag,
[321.0, 82.0, 335.5, 96.5, 342.75, 113.75], 2, True))
self.obj1851.out_connections_.append(self.obj1850)
self.obj1850.in_connections_.append(self.obj1851)
self.obj1851.graphObject_.pendingConnections.append(
(self.obj1851.graphObject_.tag, self.obj1850.graphObject_.tag,
[350.0, 151.0, 350.0, 131.0, 342.75, 113.75], 2, True))
self.obj1852.out_connections_.append(self.obj1853)
self.obj1853.in_connections_.append(self.obj1852)
self.obj1852.graphObject_.pendingConnections.append(
(self.obj1852.graphObject_.tag, self.obj1853.graphObject_.tag,
[104.0, 61.0, 195.0, 71.5], 0, True))
self.obj1853.out_connections_.append(self.obj1849)
self.obj1849.in_connections_.append(self.obj1853)
self.obj1853.graphObject_.pendingConnections.append(
(self.obj1853.graphObject_.tag, self.obj1849.graphObject_.tag,
[286.0, 82.0, 195.0, 71.5], 0, True))
self.RHS = ASG_pns(parent)
self.obj1855 = metarial(parent)
self.obj1855.preAction(self.RHS.CREATE)
self.obj1855.isGraphObjectVisual = True
if (hasattr(self.obj1855, '_setHierarchicalLink')):
self.obj1855._setHierarchicalLink(False)
# MaxFlow
self.obj1855.MaxFlow.setValue(999999)
# price
self.obj1855.price.setValue(0)
# Name
self.obj1855.Name.setValue('')
self.obj1855.Name.setNone()
# ReqFlow
self.obj1855.ReqFlow.setValue(0)
self.obj1855.GGLabel.setValue(2)
self.obj1855.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(160.0, 40.0, self.obj1855)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1855.graphObject_ = new_obj
self.obj18550 = AttrCalc()
self.obj18550.Copy = ATOM3Boolean()
self.obj18550.Copy.setValue(('Copy from LHS', 1))
self.obj18550.Copy.config = 0
self.obj18550.Specify = ATOM3Constraint()
self.obj18550.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.obj1855.GGset2Any['MaxFlow'] = self.obj18550
self.obj18551 = AttrCalc()
self.obj18551.Copy = ATOM3Boolean()
self.obj18551.Copy.setValue(('Copy from LHS', 1))
self.obj18551.Copy.config = 0
self.obj18551.Specify = ATOM3Constraint()
self.obj18551.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.obj1855.GGset2Any['Name'] = self.obj18551
self.obj18552 = AttrCalc()
self.obj18552.Copy = ATOM3Boolean()
self.obj18552.Copy.setValue(('Copy from LHS', 1))
self.obj18552.Copy.config = 0
self.obj18552.Specify = ATOM3Constraint()
self.obj18552.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.obj1855.GGset2Any['ReqFlow'] = self.obj18552
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1855)
self.obj1855.postAction(self.RHS.CREATE)
self.obj1856 = operatingUnit(parent)
self.obj1856.preAction(self.RHS.CREATE)
self.obj1856.isGraphObjectVisual = True
if (hasattr(self.obj1856, '_setHierarchicalLink')):
self.obj1856._setHierarchicalLink(False)
# OperCostProp
self.obj1856.OperCostProp.setValue(0.0)
# name
self.obj1856.name.setValue('')
self.obj1856.name.setNone()
# OperCostFix
self.obj1856.OperCostFix.setValue(0.0)
self.obj1856.GGLabel.setValue(3)
self.obj1856.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(200.0, 140.0, self.obj1856)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1856.graphObject_ = new_obj
self.obj18560 = AttrCalc()
self.obj18560.Copy = ATOM3Boolean()
self.obj18560.Copy.setValue(('Copy from LHS', 1))
self.obj18560.Copy.config = 0
self.obj18560.Specify = ATOM3Constraint()
self.obj18560.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.obj1856.GGset2Any['OperCostProp'] = self.obj18560
self.obj18561 = AttrCalc()
self.obj18561.Copy = ATOM3Boolean()
self.obj18561.Copy.setValue(('Copy from LHS', 1))
self.obj18561.Copy.config = 0
self.obj18561.Specify = ATOM3Constraint()
self.obj18561.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.obj1856.GGset2Any['name'] = self.obj18561
self.obj18562 = AttrCalc()
self.obj18562.Copy = ATOM3Boolean()
self.obj18562.Copy.setValue(('Copy from LHS', 1))
self.obj18562.Copy.config = 0
self.obj18562.Specify = ATOM3Constraint()
self.obj18562.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.obj1856.GGset2Any['OperCostFix'] = self.obj18562
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1856)
self.obj1856.postAction(self.RHS.CREATE)
self.obj1857 = fromMaterial(parent)
self.obj1857.preAction(self.RHS.CREATE)
self.obj1857.isGraphObjectVisual = True
if (hasattr(self.obj1857, '_setHierarchicalLink')):
self.obj1857._setHierarchicalLink(False)
# rate
self.obj1857.rate.setValue(0.0)
self.obj1857.GGLabel.setValue(4)
self.obj1857.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(238.75, 106.25, self.obj1857)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1857.graphObject_ = new_obj
self.obj18570 = AttrCalc()
self.obj18570.Copy = ATOM3Boolean()
self.obj18570.Copy.setValue(('Copy from LHS', 1))
self.obj18570.Copy.config = 0
self.obj18570.Specify = ATOM3Constraint()
self.obj18570.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.obj1857.GGset2Any['rate'] = self.obj18570
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1857)
self.obj1857.postAction(self.RHS.CREATE)
self.obj1855.out_connections_.append(self.obj1857)
self.obj1857.in_connections_.append(self.obj1855)
self.obj1855.graphObject_.pendingConnections.append(
(self.obj1855.graphObject_.tag, self.obj1857.graphObject_.tag,
[201.0, 82.0, 226.5, 89.0, 238.75, 106.25], 2, True))
self.obj1857.out_connections_.append(self.obj1856)
self.obj1856.in_connections_.append(self.obj1857)
self.obj1857.graphObject_.pendingConnections.append(
(self.obj1857.graphObject_.tag, self.obj1856.graphObject_.tag,
[250.0, 151.0, 251.0, 123.5, 238.75, 106.25], 2, True))
def __init__(self, parent):
GGrule.__init__(self, 8)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.obj987=metarial(parent)
self.obj987.preAction( self.LHS.CREATE )
self.obj987.isGraphObjectVisual = True
if(hasattr(self.obj987, '_setHierarchicalLink')):
self.obj987._setHierarchicalLink(False)
# MaxFlow
self.obj987.MaxFlow.setNone()
# price
self.obj987.price.setNone()
# Name
self.obj987.Name.setValue('')
self.obj987.Name.setNone()
# ReqFlow
self.obj987.ReqFlow.setNone()
self.obj987.GGLabel.setValue(2)
self.obj987.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(240.0,140.0,self.obj987)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj987.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj987)
self.obj987.postAction( self.LHS.CREATE )
self.obj988=operatingUnit(parent)
self.obj988.preAction( self.LHS.CREATE )
self.obj988.isGraphObjectVisual = True
if(hasattr(self.obj988, '_setHierarchicalLink')):
self.obj988._setHierarchicalLink(False)
# OperCostProp
self.obj988.OperCostProp.setNone()
# name
self.obj988.name.setValue('')
self.obj988.name.setNone()
# OperCostFix
self.obj988.OperCostFix.setNone()
self.obj988.GGLabel.setValue(1)
self.obj988.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(220.0,20.0,self.obj988)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj988.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj988)
self.obj988.postAction( self.LHS.CREATE )
self.obj989=intoMaterial(parent)
self.obj989.preAction( self.LHS.CREATE )
self.obj989.isGraphObjectVisual = True
if(hasattr(self.obj989, '_setHierarchicalLink')):
self.obj989._setHierarchicalLink(False)
# rate
self.obj989.rate.setNone()
self.obj989.GGLabel.setValue(3)
self.obj989.graphClass_= graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(269.5,88.0,self.obj989)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj989.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj989)
self.obj989.postAction( self.LHS.CREATE )
self.obj988.out_connections_.append(self.obj989)
self.obj989.in_connections_.append(self.obj988)
self.obj988.graphObject_.pendingConnections.append((self.obj988.graphObject_.tag, self.obj989.graphObject_.tag, [273.0, 38.0, 269.5, 88.0], 0, True))
self.obj989.out_connections_.append(self.obj987)
self.obj987.in_connections_.append(self.obj989)
self.obj989.graphObject_.pendingConnections.append((self.obj989.graphObject_.tag, self.obj987.graphObject_.tag, [266.0, 138.0, 269.5, 88.0], 0, True))
self.RHS = ASG_pns(parent)
self.obj991=metarial(parent)
self.obj991.preAction( self.RHS.CREATE )
self.obj991.isGraphObjectVisual = True
if(hasattr(self.obj991, '_setHierarchicalLink')):
self.obj991._setHierarchicalLink(False)
# MaxFlow
self.obj991.MaxFlow.setNone()
# price
self.obj991.price.setNone()
# Name
self.obj991.Name.setValue('')
self.obj991.Name.setNone()
# ReqFlow
self.obj991.ReqFlow.setNone()
self.obj991.GGLabel.setValue(2)
self.obj991.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(240.0,140.0,self.obj991)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj991.graphObject_ = new_obj
self.obj9910= AttrCalc()
self.obj9910.Copy=ATOM3Boolean()
self.obj9910.Copy.setValue(('Copy from LHS', 1))
self.obj9910.Copy.config = 0
self.obj9910.Specify=ATOM3Constraint()
self.obj9910.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.obj991.GGset2Any['MaxFlow']= self.obj9910
self.obj9911= AttrCalc()
self.obj9911.Copy=ATOM3Boolean()
self.obj9911.Copy.setValue(('Copy from LHS', 1))
self.obj9911.Copy.config = 0
self.obj9911.Specify=ATOM3Constraint()
self.obj9911.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.obj991.GGset2Any['price']= self.obj9911
self.obj9912= AttrCalc()
self.obj9912.Copy=ATOM3Boolean()
self.obj9912.Copy.setValue(('Copy from LHS', 1))
self.obj9912.Copy.config = 0
self.obj9912.Specify=ATOM3Constraint()
self.obj9912.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.obj991.GGset2Any['Name']= self.obj9912
self.obj9913= AttrCalc()
self.obj9913.Copy=ATOM3Boolean()
self.obj9913.Copy.setValue(('Copy from LHS', 1))
self.obj9913.Copy.config = 0
self.obj9913.Specify=ATOM3Constraint()
self.obj9913.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.obj991.GGset2Any['ReqFlow']= self.obj9913
# Add node to the root: self.RHS
self.RHS.addNode(self.obj991)
self.obj991.postAction( self.RHS.CREATE )
self.obj992=operatingUnit(parent)
self.obj992.preAction( self.RHS.CREATE )
self.obj992.isGraphObjectVisual = True
if(hasattr(self.obj992, '_setHierarchicalLink')):
self.obj992._setHierarchicalLink(False)
# OperCostProp
self.obj992.OperCostProp.setNone()
# name
self.obj992.name.setValue('')
self.obj992.name.setNone()
# OperCostFix
self.obj992.OperCostFix.setNone()
self.obj992.GGLabel.setValue(1)
self.obj992.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(220.0,20.0,self.obj992)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj992.graphObject_ = new_obj
self.obj9920= AttrCalc()
self.obj9920.Copy=ATOM3Boolean()
self.obj9920.Copy.setValue(('Copy from LHS', 1))
self.obj9920.Copy.config = 0
self.obj9920.Specify=ATOM3Constraint()
self.obj9920.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.obj992.GGset2Any['OperCostProp']= self.obj9920
self.obj9921= AttrCalc()
self.obj9921.Copy=ATOM3Boolean()
self.obj9921.Copy.setValue(('Copy from LHS', 1))
self.obj9921.Copy.config = 0
self.obj9921.Specify=ATOM3Constraint()
self.obj9921.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.obj992.GGset2Any['name']= self.obj9921
self.obj9922= AttrCalc()
self.obj9922.Copy=ATOM3Boolean()
self.obj9922.Copy.setValue(('Copy from LHS', 1))
self.obj9922.Copy.config = 0
self.obj9922.Specify=ATOM3Constraint()
self.obj9922.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.obj992.GGset2Any['OperCostFix']= self.obj9922
# Add node to the root: self.RHS
self.RHS.addNode(self.obj992)
self.obj992.postAction( self.RHS.CREATE )
self.obj993=intoMaterial(parent)
self.obj993.preAction( self.RHS.CREATE )
self.obj993.isGraphObjectVisual = True
if(hasattr(self.obj993, '_setHierarchicalLink')):
self.obj993._setHierarchicalLink(False)
# rate
self.obj993.rate.setNone()
self.obj993.GGLabel.setValue(3)
self.obj993.graphClass_= graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(269.5,88.0,self.obj993)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj993.graphObject_ = new_obj
self.obj9930= AttrCalc()
self.obj9930.Copy=ATOM3Boolean()
self.obj9930.Copy.setValue(('Copy from LHS', 1))
self.obj9930.Copy.config = 0
self.obj9930.Specify=ATOM3Constraint()
self.obj9930.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.obj993.GGset2Any['rate']= self.obj9930
# Add node to the root: self.RHS
self.RHS.addNode(self.obj993)
self.obj993.postAction( self.RHS.CREATE )
self.obj992.out_connections_.append(self.obj993)
self.obj993.in_connections_.append(self.obj992)
self.obj992.graphObject_.pendingConnections.append((self.obj992.graphObject_.tag, self.obj993.graphObject_.tag, [273.0, 28.0, 269.5, 88.0], 2, 0))
self.obj993.out_connections_.append(self.obj991)
self.obj991.in_connections_.append(self.obj993)
self.obj993.graphObject_.pendingConnections.append((self.obj993.graphObject_.tag, self.obj991.graphObject_.tag, [286.0, 150.0, 269.5, 88.0], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 5)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.obj954 = rawMaterial(parent)
self.obj954.preAction(self.LHS.CREATE)
self.obj954.isGraphObjectVisual = True
if (hasattr(self.obj954, '_setHierarchicalLink')):
self.obj954._setHierarchicalLink(False)
# MaxFlow
self.obj954.MaxFlow.setNone()
# price
self.obj954.price.setNone()
# Name
self.obj954.Name.setValue('')
self.obj954.Name.setNone()
# ReqFlow
self.obj954.ReqFlow.setNone()
self.obj954.GGLabel.setValue(1)
self.obj954.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(200.0, 20.0, self.obj954)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj954.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj954)
self.obj954.postAction(self.LHS.CREATE)
self.obj955 = operatingUnit(parent)
self.obj955.preAction(self.LHS.CREATE)
self.obj955.isGraphObjectVisual = True
if (hasattr(self.obj955, '_setHierarchicalLink')):
self.obj955._setHierarchicalLink(False)
# OperCostProp
self.obj955.OperCostProp.setNone()
# name
self.obj955.name.setValue('')
self.obj955.name.setNone()
# OperCostFix
self.obj955.OperCostFix.setNone()
self.obj955.GGLabel.setValue(2)
self.obj955.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(200.0, 160.0, self.obj955)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj955.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj955)
self.obj955.postAction(self.LHS.CREATE)
self.obj956 = fromRaw(parent)
self.obj956.preAction(self.LHS.CREATE)
self.obj956.isGraphObjectVisual = True
if (hasattr(self.obj956, '_setHierarchicalLink')):
self.obj956._setHierarchicalLink(False)
# rate
self.obj956.rate.setNone()
self.obj956.GGLabel.setValue(3)
self.obj956.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(222.0, 123.5, self.obj956)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj956.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj956)
self.obj956.postAction(self.LHS.CREATE)
self.obj954.out_connections_.append(self.obj956)
self.obj956.in_connections_.append(self.obj954)
self.obj954.graphObject_.pendingConnections.append(
(self.obj954.graphObject_.tag, self.obj956.graphObject_.tag,
[224.0, 76.0, 222.0, 123.5], 0, True))
self.obj956.out_connections_.append(self.obj955)
self.obj955.in_connections_.append(self.obj956)
self.obj956.graphObject_.pendingConnections.append(
(self.obj956.graphObject_.tag, self.obj955.graphObject_.tag,
[220.0, 171.0, 222.0, 123.5], 0, True))
self.RHS = ASG_pns(parent)
self.obj958 = rawMaterial(parent)
self.obj958.preAction(self.RHS.CREATE)
self.obj958.isGraphObjectVisual = True
if (hasattr(self.obj958, '_setHierarchicalLink')):
self.obj958._setHierarchicalLink(False)
# MaxFlow
self.obj958.MaxFlow.setNone()
# price
self.obj958.price.setNone()
# Name
self.obj958.Name.setValue('')
self.obj958.Name.setNone()
# ReqFlow
self.obj958.ReqFlow.setNone()
self.obj958.GGLabel.setValue(1)
self.obj958.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(200.0, 20.0, self.obj958)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj958.graphObject_ = new_obj
self.obj9580 = AttrCalc()
self.obj9580.Copy = ATOM3Boolean()
self.obj9580.Copy.setValue(('Copy from LHS', 1))
self.obj9580.Copy.config = 0
self.obj9580.Specify = ATOM3Constraint()
self.obj9580.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.obj958.GGset2Any['MaxFlow'] = self.obj9580
self.obj9581 = AttrCalc()
self.obj9581.Copy = ATOM3Boolean()
self.obj9581.Copy.setValue(('Copy from LHS', 1))
self.obj9581.Copy.config = 0
self.obj9581.Specify = ATOM3Constraint()
self.obj9581.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.obj958.GGset2Any['price'] = self.obj9581
self.obj9582 = AttrCalc()
self.obj9582.Copy = ATOM3Boolean()
self.obj9582.Copy.setValue(('Copy from LHS', 1))
self.obj9582.Copy.config = 0
self.obj9582.Specify = ATOM3Constraint()
self.obj9582.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.obj958.GGset2Any['Name'] = self.obj9582
self.obj9583 = AttrCalc()
self.obj9583.Copy = ATOM3Boolean()
self.obj9583.Copy.setValue(('Copy from LHS', 1))
self.obj9583.Copy.config = 0
self.obj9583.Specify = ATOM3Constraint()
self.obj9583.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.obj958.GGset2Any['ReqFlow'] = self.obj9583
# Add node to the root: self.RHS
self.RHS.addNode(self.obj958)
self.obj958.postAction(self.RHS.CREATE)
self.obj959 = operatingUnit(parent)
self.obj959.preAction(self.RHS.CREATE)
self.obj959.isGraphObjectVisual = True
if (hasattr(self.obj959, '_setHierarchicalLink')):
self.obj959._setHierarchicalLink(False)
# OperCostProp
self.obj959.OperCostProp.setNone()
# name
self.obj959.name.setValue('')
self.obj959.name.setNone()
# OperCostFix
self.obj959.OperCostFix.setNone()
self.obj959.GGLabel.setValue(2)
self.obj959.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(200.0, 160.0, self.obj959)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj959.graphObject_ = new_obj
self.obj9590 = AttrCalc()
self.obj9590.Copy = ATOM3Boolean()
self.obj9590.Copy.setValue(('Copy from LHS', 1))
self.obj9590.Copy.config = 0
self.obj9590.Specify = ATOM3Constraint()
self.obj9590.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.obj959.GGset2Any['OperCostProp'] = self.obj9590
self.obj9591 = AttrCalc()
self.obj9591.Copy = ATOM3Boolean()
self.obj9591.Copy.setValue(('Copy from LHS', 1))
self.obj9591.Copy.config = 0
self.obj9591.Specify = ATOM3Constraint()
self.obj9591.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.obj959.GGset2Any['name'] = self.obj9591
self.obj9592 = AttrCalc()
self.obj9592.Copy = ATOM3Boolean()
self.obj9592.Copy.setValue(('Copy from LHS', 1))
self.obj9592.Copy.config = 0
self.obj9592.Specify = ATOM3Constraint()
self.obj9592.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.obj959.GGset2Any['OperCostFix'] = self.obj9592
# Add node to the root: self.RHS
self.RHS.addNode(self.obj959)
self.obj959.postAction(self.RHS.CREATE)
self.obj960 = fromRaw(parent)
self.obj960.preAction(self.RHS.CREATE)
self.obj960.isGraphObjectVisual = True
if (hasattr(self.obj960, '_setHierarchicalLink')):
self.obj960._setHierarchicalLink(False)
# rate
self.obj960.rate.setNone()
self.obj960.GGLabel.setValue(3)
self.obj960.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(222.0, 123.5, self.obj960)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj960.graphObject_ = new_obj
self.obj9600 = AttrCalc()
self.obj9600.Copy = ATOM3Boolean()
self.obj9600.Copy.setValue(('Copy from LHS', 1))
self.obj9600.Copy.config = 0
self.obj9600.Specify = ATOM3Constraint()
self.obj9600.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.obj960.GGset2Any['rate'] = self.obj9600
# Add node to the root: self.RHS
self.RHS.addNode(self.obj960)
self.obj960.postAction(self.RHS.CREATE)
self.obj958.out_connections_.append(self.obj960)
self.obj960.in_connections_.append(self.obj958)
self.obj958.graphObject_.pendingConnections.append(
(self.obj958.graphObject_.tag, self.obj960.graphObject_.tag,
[224.0, 70.0, 222.0, 123.5], 2, 0))
self.obj960.out_connections_.append(self.obj959)
self.obj959.in_connections_.append(self.obj960)
self.obj960.graphObject_.pendingConnections.append(
(self.obj960.graphObject_.tag, self.obj959.graphObject_.tag,
[250.0, 161.0, 222.0, 123.5], 2, 0))
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 __init__(self, parent):
GGrule.__init__(self, 1)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.obj91 = rawMaterial(parent)
self.obj91.preAction(self.LHS.CREATE)
self.obj91.isGraphObjectVisual = True
if (hasattr(self.obj91, '_setHierarchicalLink')):
self.obj91._setHierarchicalLink(False)
# MaxFlow
self.obj91.MaxFlow.setNone()
# price
self.obj91.price.setNone()
# Name
self.obj91.Name.setValue('')
self.obj91.Name.setNone()
# ReqFlow
self.obj91.ReqFlow.setNone()
self.obj91.GGLabel.setValue(1)
self.obj91.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(60.0, 20.0, self.obj91)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj91.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj91)
self.obj91.postAction(self.LHS.CREATE)
self.obj92 = metarial(parent)
self.obj92.preAction(self.LHS.CREATE)
self.obj92.isGraphObjectVisual = True
if (hasattr(self.obj92, '_setHierarchicalLink')):
self.obj92._setHierarchicalLink(False)
# MaxFlow
self.obj92.MaxFlow.setNone()
# price
self.obj92.price.setNone()
# Name
self.obj92.Name.setValue('')
self.obj92.Name.setNone()
# ReqFlow
self.obj92.ReqFlow.setNone()
self.obj92.GGLabel.setValue(4)
self.obj92.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(360.0, 160.0, self.obj92)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj92.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj92)
self.obj92.postAction(self.LHS.CREATE)
self.obj93 = operatingUnit(parent)
self.obj93.preAction(self.LHS.CREATE)
self.obj93.isGraphObjectVisual = True
if (hasattr(self.obj93, '_setHierarchicalLink')):
self.obj93._setHierarchicalLink(False)
# OperCostProp
self.obj93.OperCostProp.setNone()
# name
self.obj93.name.setValue('')
self.obj93.name.setNone()
# OperCostFix
self.obj93.OperCostFix.setNone()
self.obj93.GGLabel.setValue(2)
self.obj93.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(160.0, 100.0, self.obj93)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj93.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj93)
self.obj93.postAction(self.LHS.CREATE)
self.obj94 = fromRaw(parent)
self.obj94.preAction(self.LHS.CREATE)
self.obj94.isGraphObjectVisual = True
if (hasattr(self.obj94, '_setHierarchicalLink')):
self.obj94._setHierarchicalLink(False)
# rate
self.obj94.rate.setNone()
self.obj94.GGLabel.setValue(3)
self.obj94.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(135.5, 78.0, self.obj94)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj94.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj94)
self.obj94.postAction(self.LHS.CREATE)
self.obj95 = intoMaterial(parent)
self.obj95.preAction(self.LHS.CREATE)
self.obj95.isGraphObjectVisual = True
if (hasattr(self.obj95, '_setHierarchicalLink')):
self.obj95._setHierarchicalLink(False)
# rate
self.obj95.rate.setNone()
self.obj95.GGLabel.setValue(5)
self.obj95.graphClass_ = graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(291.5, 140.5, self.obj95)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj95.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj95)
self.obj95.postAction(self.LHS.CREATE)
self.obj91.out_connections_.append(self.obj94)
self.obj94.in_connections_.append(self.obj91)
self.obj91.graphObject_.pendingConnections.append(
(self.obj91.graphObject_.tag, self.obj94.graphObject_.tag,
[84.0, 76.0, 84.0, 118.0, 135.5, 78.0], 2, True))
self.obj93.out_connections_.append(self.obj95)
self.obj95.in_connections_.append(self.obj93)
self.obj93.graphObject_.pendingConnections.append(
(self.obj93.graphObject_.tag, self.obj95.graphObject_.tag,
[213.0, 118.0, 212.0, 177.0, 291.5, 140.5], 2, True))
self.obj94.out_connections_.append(self.obj93)
self.obj93.in_connections_.append(self.obj94)
self.obj94.graphObject_.pendingConnections.append(
(self.obj94.graphObject_.tag, self.obj93.graphObject_.tag,
[180.0, 111.0, 187.0, 38.0, 135.5, 78.0], 2, True))
self.obj95.out_connections_.append(self.obj92)
self.obj92.in_connections_.append(self.obj95)
self.obj95.graphObject_.pendingConnections.append(
(self.obj95.graphObject_.tag, self.obj92.graphObject_.tag,
[386.0, 158.0, 371.0, 104.0, 291.5, 140.5], 2, True))
self.RHS = ASG_pns(parent)
self.obj97 = rawMaterial(parent)
self.obj97.preAction(self.RHS.CREATE)
self.obj97.isGraphObjectVisual = True
if (hasattr(self.obj97, '_setHierarchicalLink')):
self.obj97._setHierarchicalLink(False)
# MaxFlow
self.obj97.MaxFlow.setNone()
# price
self.obj97.price.setNone()
# Name
self.obj97.Name.setValue('')
self.obj97.Name.setNone()
# ReqFlow
self.obj97.ReqFlow.setNone()
self.obj97.GGLabel.setValue(1)
self.obj97.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(60.0, 20.0, self.obj97)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj97.graphObject_ = new_obj
self.obj970 = AttrCalc()
self.obj970.Copy = ATOM3Boolean()
self.obj970.Copy.setValue(('Copy from LHS', 1))
self.obj970.Copy.config = 0
self.obj970.Specify = ATOM3Constraint()
self.obj970.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.obj97.GGset2Any['MaxFlow'] = self.obj970
self.obj971 = AttrCalc()
self.obj971.Copy = ATOM3Boolean()
self.obj971.Copy.setValue(('Copy from LHS', 1))
self.obj971.Copy.config = 0
self.obj971.Specify = ATOM3Constraint()
self.obj971.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.obj97.GGset2Any['price'] = self.obj971
self.obj972 = AttrCalc()
self.obj972.Copy = ATOM3Boolean()
self.obj972.Copy.setValue(('Copy from LHS', 1))
self.obj972.Copy.config = 0
self.obj972.Specify = ATOM3Constraint()
self.obj972.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.obj97.GGset2Any['Name'] = self.obj972
self.obj973 = AttrCalc()
self.obj973.Copy = ATOM3Boolean()
self.obj973.Copy.setValue(('Copy from LHS', 1))
self.obj973.Copy.config = 0
self.obj973.Specify = ATOM3Constraint()
self.obj973.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.obj97.GGset2Any['ReqFlow'] = self.obj973
# Add node to the root: self.RHS
self.RHS.addNode(self.obj97)
self.obj97.postAction(self.RHS.CREATE)
self.obj98 = metarial(parent)
self.obj98.preAction(self.RHS.CREATE)
self.obj98.isGraphObjectVisual = True
if (hasattr(self.obj98, '_setHierarchicalLink')):
self.obj98._setHierarchicalLink(False)
# MaxFlow
self.obj98.MaxFlow.setNone()
# price
self.obj98.price.setNone()
# Name
self.obj98.Name.setValue('')
self.obj98.Name.setNone()
# ReqFlow
self.obj98.ReqFlow.setNone()
self.obj98.GGLabel.setValue(4)
self.obj98.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(360.0, 160.0, self.obj98)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj98.graphObject_ = new_obj
self.obj980 = AttrCalc()
self.obj980.Copy = ATOM3Boolean()
self.obj980.Copy.setValue(('Copy from LHS', 1))
self.obj980.Copy.config = 0
self.obj980.Specify = ATOM3Constraint()
self.obj980.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.obj98.GGset2Any['MaxFlow'] = self.obj980
self.obj981 = AttrCalc()
self.obj981.Copy = ATOM3Boolean()
self.obj981.Copy.setValue(('Copy from LHS', 1))
self.obj981.Copy.config = 0
self.obj981.Specify = ATOM3Constraint()
self.obj981.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.obj98.GGset2Any['price'] = self.obj981
self.obj982 = AttrCalc()
self.obj982.Copy = ATOM3Boolean()
self.obj982.Copy.setValue(('Copy from LHS', 1))
self.obj982.Copy.config = 0
self.obj982.Specify = ATOM3Constraint()
self.obj982.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.obj98.GGset2Any['Name'] = self.obj982
self.obj983 = AttrCalc()
self.obj983.Copy = ATOM3Boolean()
self.obj983.Copy.setValue(('Copy from LHS', 1))
self.obj983.Copy.config = 0
self.obj983.Specify = ATOM3Constraint()
self.obj983.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.obj98.GGset2Any['ReqFlow'] = self.obj983
# Add node to the root: self.RHS
self.RHS.addNode(self.obj98)
self.obj98.postAction(self.RHS.CREATE)
self.obj99 = operatingUnit(parent)
self.obj99.preAction(self.RHS.CREATE)
self.obj99.isGraphObjectVisual = True
if (hasattr(self.obj99, '_setHierarchicalLink')):
self.obj99._setHierarchicalLink(False)
# OperCostProp
self.obj99.OperCostProp.setNone()
# name
self.obj99.name.setValue('')
self.obj99.name.setNone()
# OperCostFix
self.obj99.OperCostFix.setNone()
self.obj99.GGLabel.setValue(2)
self.obj99.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(160.0, 100.0, self.obj99)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj99.graphObject_ = new_obj
self.obj990 = AttrCalc()
self.obj990.Copy = ATOM3Boolean()
self.obj990.Copy.setValue(('Copy from LHS', 1))
self.obj990.Copy.config = 0
self.obj990.Specify = ATOM3Constraint()
self.obj990.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.obj99.GGset2Any['OperCostProp'] = self.obj990
self.obj991 = AttrCalc()
self.obj991.Copy = ATOM3Boolean()
self.obj991.Copy.setValue(('Copy from LHS', 1))
self.obj991.Copy.config = 0
self.obj991.Specify = ATOM3Constraint()
self.obj991.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.obj99.GGset2Any['name'] = self.obj991
self.obj992 = AttrCalc()
self.obj992.Copy = ATOM3Boolean()
self.obj992.Copy.setValue(('Copy from LHS', 1))
self.obj992.Copy.config = 0
self.obj992.Specify = ATOM3Constraint()
self.obj992.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.obj99.GGset2Any['OperCostFix'] = self.obj992
# Add node to the root: self.RHS
self.RHS.addNode(self.obj99)
self.obj99.postAction(self.RHS.CREATE)
self.obj100 = fromRaw(parent)
self.obj100.preAction(self.RHS.CREATE)
self.obj100.isGraphObjectVisual = True
if (hasattr(self.obj100, '_setHierarchicalLink')):
self.obj100._setHierarchicalLink(False)
# rate
self.obj100.rate.setNone()
self.obj100.GGLabel.setValue(3)
self.obj100.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(135.5, 78.0, self.obj100)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj100.graphObject_ = new_obj
self.obj1000 = AttrCalc()
self.obj1000.Copy = ATOM3Boolean()
self.obj1000.Copy.setValue(('Copy from LHS', 1))
self.obj1000.Copy.config = 0
self.obj1000.Specify = ATOM3Constraint()
self.obj1000.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.obj100.GGset2Any['rate'] = self.obj1000
# Add node to the root: self.RHS
self.RHS.addNode(self.obj100)
self.obj100.postAction(self.RHS.CREATE)
self.obj101 = intoMaterial(parent)
self.obj101.preAction(self.RHS.CREATE)
self.obj101.isGraphObjectVisual = True
if (hasattr(self.obj101, '_setHierarchicalLink')):
self.obj101._setHierarchicalLink(False)
# rate
self.obj101.rate.setNone()
self.obj101.GGLabel.setValue(5)
self.obj101.graphClass_ = graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(291.5, 140.5, self.obj101)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj101.graphObject_ = new_obj
self.obj1010 = AttrCalc()
self.obj1010.Copy = ATOM3Boolean()
self.obj1010.Copy.setValue(('Copy from LHS', 1))
self.obj1010.Copy.config = 0
self.obj1010.Specify = ATOM3Constraint()
self.obj1010.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.obj101.GGset2Any['rate'] = self.obj1010
# Add node to the root: self.RHS
self.RHS.addNode(self.obj101)
self.obj101.postAction(self.RHS.CREATE)
self.obj97.out_connections_.append(self.obj100)
self.obj100.in_connections_.append(self.obj97)
self.obj97.graphObject_.pendingConnections.append(
(self.obj97.graphObject_.tag, self.obj100.graphObject_.tag,
[84.0, 70.0, 135.5, 78.0], 2, 0))
self.obj99.out_connections_.append(self.obj101)
self.obj101.in_connections_.append(self.obj99)
self.obj99.graphObject_.pendingConnections.append(
(self.obj99.graphObject_.tag, self.obj101.graphObject_.tag,
[213.0, 108.0, 291.5, 140.5], 2, 0))
self.obj100.out_connections_.append(self.obj99)
self.obj99.in_connections_.append(self.obj100)
self.obj100.graphObject_.pendingConnections.append(
(self.obj100.graphObject_.tag, self.obj99.graphObject_.tag,
[210.0, 101.0, 135.5, 78.0], 2, 0))
self.obj101.out_connections_.append(self.obj98)
self.obj98.in_connections_.append(self.obj101)
self.obj101.graphObject_.pendingConnections.append(
(self.obj101.graphObject_.tag, self.obj98.graphObject_.tag,
[370.0, 165.0, 291.5, 140.5], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 5)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.obj142=metarial(parent)
self.obj142.preAction( self.LHS.CREATE )
self.obj142.isGraphObjectVisual = True
if(hasattr(self.obj142, '_setHierarchicalLink')):
self.obj142._setHierarchicalLink(False)
# MaxFlow
self.obj142.MaxFlow.setNone()
# price
self.obj142.price.setNone()
# Name
self.obj142.Name.setValue('')
self.obj142.Name.setNone()
# ReqFlow
self.obj142.ReqFlow.setNone()
self.obj142.GGLabel.setValue(1)
self.obj142.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(40.0,40.0,self.obj142)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj142.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj142)
self.obj142.postAction( self.LHS.CREATE )
self.obj143=metarial(parent)
self.obj143.preAction( self.LHS.CREATE )
self.obj143.isGraphObjectVisual = True
if(hasattr(self.obj143, '_setHierarchicalLink')):
self.obj143._setHierarchicalLink(False)
# MaxFlow
self.obj143.MaxFlow.setNone()
# price
self.obj143.price.setNone()
# Name
self.obj143.Name.setValue('')
self.obj143.Name.setNone()
# ReqFlow
self.obj143.ReqFlow.setNone()
self.obj143.GGLabel.setValue(3)
self.obj143.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(360.0,160.0,self.obj143)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj143.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj143)
self.obj143.postAction( self.LHS.CREATE )
self.obj144=operatingUnit(parent)
self.obj144.preAction( self.LHS.CREATE )
self.obj144.isGraphObjectVisual = True
if(hasattr(self.obj144, '_setHierarchicalLink')):
self.obj144._setHierarchicalLink(False)
# OperCostProp
self.obj144.OperCostProp.setNone()
# name
self.obj144.name.setValue('')
self.obj144.name.setNone()
# OperCostFix
self.obj144.OperCostFix.setNone()
self.obj144.GGLabel.setValue(2)
self.obj144.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(180.0,100.0,self.obj144)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj144.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj144)
self.obj144.postAction( self.LHS.CREATE )
self.obj145=intoMaterial(parent)
self.obj145.preAction( self.LHS.CREATE )
self.obj145.isGraphObjectVisual = True
if(hasattr(self.obj145, '_setHierarchicalLink')):
self.obj145._setHierarchicalLink(False)
# rate
self.obj145.rate.setNone()
self.obj145.GGLabel.setValue(5)
self.obj145.graphClass_= graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(248.75,168.5,self.obj145)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj145.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj145)
self.obj145.postAction( self.LHS.CREATE )
self.obj146=fromMaterial(parent)
self.obj146.preAction( self.LHS.CREATE )
self.obj146.isGraphObjectVisual = True
if(hasattr(self.obj146, '_setHierarchicalLink')):
self.obj146._setHierarchicalLink(False)
# rate
self.obj146.rate.setNone()
self.obj146.GGLabel.setValue(4)
self.obj146.graphClass_= graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(175.0,68.75,self.obj146)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj146.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj146)
self.obj146.postAction( self.LHS.CREATE )
self.obj142.out_connections_.append(self.obj146)
self.obj146.in_connections_.append(self.obj142)
self.obj142.graphObject_.pendingConnections.append((self.obj142.graphObject_.tag, self.obj146.graphObject_.tag, [86.0, 50.0, 146.5, 53.5, 175.0, 68.75], 2, True))
self.obj144.out_connections_.append(self.obj145)
self.obj145.in_connections_.append(self.obj144)
self.obj144.graphObject_.pendingConnections.append((self.obj144.graphObject_.tag, self.obj145.graphObject_.tag, [199.0, 118.0, 207.0, 147.5, 248.75, 168.5], 2, True))
self.obj145.out_connections_.append(self.obj143)
self.obj143.in_connections_.append(self.obj145)
self.obj145.graphObject_.pendingConnections.append((self.obj145.graphObject_.tag, self.obj143.graphObject_.tag, [366.0, 202.0, 290.5, 189.5, 248.75, 168.5], 2, True))
self.obj146.out_connections_.append(self.obj144)
self.obj144.in_connections_.append(self.obj146)
self.obj146.graphObject_.pendingConnections.append((self.obj146.graphObject_.tag, self.obj144.graphObject_.tag, [200.0, 111.0, 203.5, 84.0, 175.0, 68.75], 2, True))
self.RHS = ASG_pns(parent)
self.obj148=metarial(parent)
self.obj148.preAction( self.RHS.CREATE )
self.obj148.isGraphObjectVisual = True
if(hasattr(self.obj148, '_setHierarchicalLink')):
self.obj148._setHierarchicalLink(False)
# MaxFlow
self.obj148.MaxFlow.setNone()
# price
self.obj148.price.setNone()
# Name
self.obj148.Name.setValue('')
self.obj148.Name.setNone()
# ReqFlow
self.obj148.ReqFlow.setNone()
self.obj148.GGLabel.setValue(1)
self.obj148.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(40.0,40.0,self.obj148)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj148.graphObject_ = new_obj
self.obj1480= AttrCalc()
self.obj1480.Copy=ATOM3Boolean()
self.obj1480.Copy.setValue(('Copy from LHS', 1))
self.obj1480.Copy.config = 0
self.obj1480.Specify=ATOM3Constraint()
self.obj1480.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.obj148.GGset2Any['MaxFlow']= self.obj1480
self.obj1481= AttrCalc()
self.obj1481.Copy=ATOM3Boolean()
self.obj1481.Copy.setValue(('Copy from LHS', 1))
self.obj1481.Copy.config = 0
self.obj1481.Specify=ATOM3Constraint()
self.obj1481.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.obj148.GGset2Any['price']= self.obj1481
self.obj1482= AttrCalc()
self.obj1482.Copy=ATOM3Boolean()
self.obj1482.Copy.setValue(('Copy from LHS', 1))
self.obj1482.Copy.config = 0
self.obj1482.Specify=ATOM3Constraint()
self.obj1482.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.obj148.GGset2Any['Name']= self.obj1482
self.obj1483= AttrCalc()
self.obj1483.Copy=ATOM3Boolean()
self.obj1483.Copy.setValue(('Copy from LHS', 1))
self.obj1483.Copy.config = 0
self.obj1483.Specify=ATOM3Constraint()
self.obj1483.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.obj148.GGset2Any['ReqFlow']= self.obj1483
# Add node to the root: self.RHS
self.RHS.addNode(self.obj148)
self.obj148.postAction( self.RHS.CREATE )
self.obj149=metarial(parent)
self.obj149.preAction( self.RHS.CREATE )
self.obj149.isGraphObjectVisual = True
if(hasattr(self.obj149, '_setHierarchicalLink')):
self.obj149._setHierarchicalLink(False)
# MaxFlow
self.obj149.MaxFlow.setNone()
# price
self.obj149.price.setNone()
# Name
self.obj149.Name.setValue('')
self.obj149.Name.setNone()
# ReqFlow
self.obj149.ReqFlow.setNone()
self.obj149.GGLabel.setValue(3)
self.obj149.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(360.0,160.0,self.obj149)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj149.graphObject_ = new_obj
self.obj1490= AttrCalc()
self.obj1490.Copy=ATOM3Boolean()
self.obj1490.Copy.setValue(('Copy from LHS', 1))
self.obj1490.Copy.config = 0
self.obj1490.Specify=ATOM3Constraint()
self.obj1490.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.obj149.GGset2Any['MaxFlow']= self.obj1490
self.obj1491= AttrCalc()
self.obj1491.Copy=ATOM3Boolean()
self.obj1491.Copy.setValue(('Copy from LHS', 1))
self.obj1491.Copy.config = 0
self.obj1491.Specify=ATOM3Constraint()
self.obj1491.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.obj149.GGset2Any['price']= self.obj1491
self.obj1492= AttrCalc()
self.obj1492.Copy=ATOM3Boolean()
self.obj1492.Copy.setValue(('Copy from LHS', 1))
self.obj1492.Copy.config = 0
self.obj1492.Specify=ATOM3Constraint()
self.obj1492.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.obj149.GGset2Any['Name']= self.obj1492
self.obj1493= AttrCalc()
self.obj1493.Copy=ATOM3Boolean()
self.obj1493.Copy.setValue(('Copy from LHS', 1))
self.obj1493.Copy.config = 0
self.obj1493.Specify=ATOM3Constraint()
self.obj1493.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.obj149.GGset2Any['ReqFlow']= self.obj1493
# Add node to the root: self.RHS
self.RHS.addNode(self.obj149)
self.obj149.postAction( self.RHS.CREATE )
self.obj150=operatingUnit(parent)
self.obj150.preAction( self.RHS.CREATE )
self.obj150.isGraphObjectVisual = True
if(hasattr(self.obj150, '_setHierarchicalLink')):
self.obj150._setHierarchicalLink(False)
# OperCostProp
self.obj150.OperCostProp.setNone()
# name
self.obj150.name.setValue('')
self.obj150.name.setNone()
# OperCostFix
self.obj150.OperCostFix.setNone()
self.obj150.GGLabel.setValue(2)
self.obj150.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(180.0,100.0,self.obj150)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj150.graphObject_ = new_obj
self.obj1500= AttrCalc()
self.obj1500.Copy=ATOM3Boolean()
self.obj1500.Copy.setValue(('Copy from LHS', 1))
self.obj1500.Copy.config = 0
self.obj1500.Specify=ATOM3Constraint()
self.obj1500.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.obj150.GGset2Any['OperCostProp']= self.obj1500
self.obj1501= AttrCalc()
self.obj1501.Copy=ATOM3Boolean()
self.obj1501.Copy.setValue(('Copy from LHS', 1))
self.obj1501.Copy.config = 0
self.obj1501.Specify=ATOM3Constraint()
self.obj1501.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.obj150.GGset2Any['name']= self.obj1501
self.obj1502= AttrCalc()
self.obj1502.Copy=ATOM3Boolean()
self.obj1502.Copy.setValue(('Copy from LHS', 1))
self.obj1502.Copy.config = 0
self.obj1502.Specify=ATOM3Constraint()
self.obj1502.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.obj150.GGset2Any['OperCostFix']= self.obj1502
# Add node to the root: self.RHS
self.RHS.addNode(self.obj150)
self.obj150.postAction( self.RHS.CREATE )
self.obj151=intoMaterial(parent)
self.obj151.preAction( self.RHS.CREATE )
self.obj151.isGraphObjectVisual = True
if(hasattr(self.obj151, '_setHierarchicalLink')):
self.obj151._setHierarchicalLink(False)
# rate
self.obj151.rate.setNone()
self.obj151.GGLabel.setValue(5)
self.obj151.graphClass_= graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(210.75,161.5,self.obj151)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['Text Scale'] = 0.68
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj151.graphObject_ = new_obj
self.obj1510= AttrCalc()
self.obj1510.Copy=ATOM3Boolean()
self.obj1510.Copy.setValue(('Copy from LHS', 1))
self.obj1510.Copy.config = 0
self.obj1510.Specify=ATOM3Constraint()
self.obj1510.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.obj151.GGset2Any['rate']= self.obj1510
# Add node to the root: self.RHS
self.RHS.addNode(self.obj151)
self.obj151.postAction( self.RHS.CREATE )
self.obj152=fromMaterial(parent)
self.obj152.preAction( self.RHS.CREATE )
self.obj152.isGraphObjectVisual = True
if(hasattr(self.obj152, '_setHierarchicalLink')):
self.obj152._setHierarchicalLink(False)
# rate
self.obj152.rate.setNone()
self.obj152.GGLabel.setValue(4)
self.obj152.graphClass_= graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(175.0,68.75,self.obj152)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj152.graphObject_ = new_obj
self.obj1520= AttrCalc()
self.obj1520.Copy=ATOM3Boolean()
self.obj1520.Copy.setValue(('Copy from LHS', 1))
self.obj1520.Copy.config = 0
self.obj1520.Specify=ATOM3Constraint()
self.obj1520.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.obj152.GGset2Any['rate']= self.obj1520
# Add node to the root: self.RHS
self.RHS.addNode(self.obj152)
self.obj152.postAction( self.RHS.CREATE )
self.obj148.out_connections_.append(self.obj152)
self.obj152.in_connections_.append(self.obj148)
self.obj148.graphObject_.pendingConnections.append((self.obj148.graphObject_.tag, self.obj152.graphObject_.tag, [86.0, 50.0, 175.0, 68.75], 2, 0))
self.obj150.out_connections_.append(self.obj151)
self.obj151.in_connections_.append(self.obj150)
self.obj150.graphObject_.pendingConnections.append((self.obj150.graphObject_.tag, self.obj151.graphObject_.tag, [233.0, 108.0, 210.75, 161.5], 2, 0))
self.obj151.out_connections_.append(self.obj149)
self.obj149.in_connections_.append(self.obj151)
self.obj151.graphObject_.pendingConnections.append((self.obj151.graphObject_.tag, self.obj149.graphObject_.tag, [370.0, 165.0, 248.75, 168.5], 2, 0))
self.obj152.out_connections_.append(self.obj150)
self.obj150.in_connections_.append(self.obj152)
self.obj152.graphObject_.pendingConnections.append((self.obj152.graphObject_.tag, self.obj150.graphObject_.tag, [230.0, 101.0, 175.0, 68.75], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 10)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_omacs(parent)
self.obj1622=Agent(parent)
self.obj1622.preAction( self.LHS.CREATE )
self.obj1622.isGraphObjectVisual = True
if(hasattr(self.obj1622, '_setHierarchicalLink')):
self.obj1622._setHierarchicalLink(False)
# price
self.obj1622.price.setNone()
# name
self.obj1622.name.setValue('')
self.obj1622.name.setNone()
self.obj1622.GGLabel.setValue(1)
self.obj1622.graphClass_= graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(60.0,40.0,self.obj1622)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1622.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1622)
self.obj1622.postAction( self.LHS.CREATE )
self.obj1623=Role(parent)
self.obj1623.preAction( self.LHS.CREATE )
self.obj1623.isGraphObjectVisual = True
if(hasattr(self.obj1623, '_setHierarchicalLink')):
self.obj1623._setHierarchicalLink(False)
# name
self.obj1623.name.setValue('')
self.obj1623.name.setNone()
self.obj1623.GGLabel.setValue(2)
self.obj1623.graphClass_= graph_Role
if parent.genGraphics:
new_obj = graph_Role(320.0,220.0,self.obj1623)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1623.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1623)
self.obj1623.postAction( self.LHS.CREATE )
self.obj1624=CapableOf(parent)
self.obj1624.preAction( self.LHS.CREATE )
self.obj1624.isGraphObjectVisual = True
if(hasattr(self.obj1624, '_setHierarchicalLink')):
self.obj1624._setHierarchicalLink(False)
# rate
self.obj1624.rate.setNone()
self.obj1624.GGLabel.setValue(3)
self.obj1624.graphClass_= graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(230.0,173.0,self.obj1624)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1624.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1624)
self.obj1624.postAction( self.LHS.CREATE )
self.obj1622.out_connections_.append(self.obj1624)
self.obj1624.in_connections_.append(self.obj1622)
self.obj1622.graphObject_.pendingConnections.append((self.obj1622.graphObject_.tag, self.obj1624.graphObject_.tag, [85.0, 102.0, 117.0, 188.0, 230.0, 173.0], 2, True))
self.obj1624.out_connections_.append(self.obj1623)
self.obj1623.in_connections_.append(self.obj1624)
self.obj1624.graphObject_.pendingConnections.append((self.obj1624.graphObject_.tag, self.obj1623.graphObject_.tag, [344.0, 221.0, 343.0, 158.0, 230.0, 173.0], 2, True))
self.RHS = ASG_omacs(parent)
self.RHS.merge(ASG_pns(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1628=Agent(parent)
self.obj1628.preAction( self.RHS.CREATE )
self.obj1628.isGraphObjectVisual = True
if(hasattr(self.obj1628, '_setHierarchicalLink')):
self.obj1628._setHierarchicalLink(False)
# price
self.obj1628.price.setNone()
# name
self.obj1628.name.setValue('')
self.obj1628.name.setNone()
self.obj1628.GGLabel.setValue(1)
self.obj1628.graphClass_= graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(60.0,40.0,self.obj1628)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1628.graphObject_ = new_obj
self.obj16280= AttrCalc()
self.obj16280.Copy=ATOM3Boolean()
self.obj16280.Copy.setValue(('Copy from LHS', 1))
self.obj16280.Copy.config = 0
self.obj16280.Specify=ATOM3Constraint()
self.obj16280.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.obj1628.GGset2Any['price']= self.obj16280
self.obj16281= AttrCalc()
self.obj16281.Copy=ATOM3Boolean()
self.obj16281.Copy.setValue(('Copy from LHS', 1))
self.obj16281.Copy.config = 0
self.obj16281.Specify=ATOM3Constraint()
self.obj16281.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.obj1628.GGset2Any['name']= self.obj16281
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1628)
self.obj1628.postAction( self.RHS.CREATE )
self.obj1629=Role(parent)
self.obj1629.preAction( self.RHS.CREATE )
self.obj1629.isGraphObjectVisual = True
if(hasattr(self.obj1629, '_setHierarchicalLink')):
self.obj1629._setHierarchicalLink(False)
# name
self.obj1629.name.setValue('')
self.obj1629.name.setNone()
self.obj1629.GGLabel.setValue(2)
self.obj1629.graphClass_= graph_Role
if parent.genGraphics:
new_obj = graph_Role(320.0,220.0,self.obj1629)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1629.graphObject_ = new_obj
self.obj16290= AttrCalc()
self.obj16290.Copy=ATOM3Boolean()
self.obj16290.Copy.setValue(('Copy from LHS', 1))
self.obj16290.Copy.config = 0
self.obj16290.Specify=ATOM3Constraint()
self.obj16290.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.obj1629.GGset2Any['name']= self.obj16290
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1629)
self.obj1629.postAction( self.RHS.CREATE )
self.obj1630=CapableOf(parent)
self.obj1630.preAction( self.RHS.CREATE )
self.obj1630.isGraphObjectVisual = True
if(hasattr(self.obj1630, '_setHierarchicalLink')):
self.obj1630._setHierarchicalLink(False)
# rate
self.obj1630.rate.setNone()
self.obj1630.GGLabel.setValue(3)
self.obj1630.graphClass_= graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(230.0,173.0,self.obj1630)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1630.graphObject_ = new_obj
self.obj16300= AttrCalc()
self.obj16300.Copy=ATOM3Boolean()
self.obj16300.Copy.setValue(('Copy from LHS', 1))
self.obj16300.Copy.config = 0
self.obj16300.Specify=ATOM3Constraint()
self.obj16300.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.obj1630.GGset2Any['rate']= self.obj16300
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1630)
self.obj1630.postAction( self.RHS.CREATE )
self.obj1631=operatingUnit(parent)
self.obj1631.preAction( self.RHS.CREATE )
self.obj1631.isGraphObjectVisual = True
if(hasattr(self.obj1631, '_setHierarchicalLink')):
self.obj1631._setHierarchicalLink(False)
# OperCostProp
self.obj1631.OperCostProp.setValue(0.0)
# name
self.obj1631.name.setValue('')
self.obj1631.name.setNone()
# OperCostFix
self.obj1631.OperCostFix.setValue(0.0)
self.obj1631.GGLabel.setValue(5)
self.obj1631.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(60.0,220.0,self.obj1631)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1631.graphObject_ = new_obj
self.obj16310= AttrCalc()
self.obj16310.Copy=ATOM3Boolean()
self.obj16310.Copy.setValue(('Copy from LHS', 1))
self.obj16310.Copy.config = 0
self.obj16310.Specify=ATOM3Constraint()
self.obj16310.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.obj1631.GGset2Any['OperCostProp']= self.obj16310
self.obj16311= AttrCalc()
self.obj16311.Copy=ATOM3Boolean()
self.obj16311.Copy.setValue(('Copy from LHS', 0))
self.obj16311.Copy.config = 0
self.obj16311.Specify=ATOM3Constraint()
self.obj16311.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(1)).name.getValue()+\' \'+self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()\n\n\n\n'))
self.obj1631.GGset2Any['name']= self.obj16311
self.obj16312= AttrCalc()
self.obj16312.Copy=ATOM3Boolean()
self.obj16312.Copy.setValue(('Copy from LHS', 1))
self.obj16312.Copy.config = 0
self.obj16312.Specify=ATOM3Constraint()
self.obj16312.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.obj1631.GGset2Any['OperCostFix']= self.obj16312
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1631)
self.obj1631.postAction( self.RHS.CREATE )
self.obj1632=GenericGraphEdge(parent)
self.obj1632.preAction( self.RHS.CREATE )
self.obj1632.isGraphObjectVisual = True
if(hasattr(self.obj1632, '_setHierarchicalLink')):
self.obj1632._setHierarchicalLink(False)
self.obj1632.GGLabel.setValue(6)
self.obj1632.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(103.5,161.5,self.obj1632)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1632.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1632)
self.obj1632.postAction( self.RHS.CREATE )
self.obj1628.out_connections_.append(self.obj1630)
self.obj1630.in_connections_.append(self.obj1628)
self.obj1628.graphObject_.pendingConnections.append((self.obj1628.graphObject_.tag, self.obj1630.graphObject_.tag, [97.0, 102.0, 230.0, 173.0], 2, 0))
self.obj1628.out_connections_.append(self.obj1632)
self.obj1632.in_connections_.append(self.obj1628)
self.obj1628.graphObject_.pendingConnections.append((self.obj1628.graphObject_.tag, self.obj1632.graphObject_.tag, [97.0, 102.0, 103.5, 161.5], 0, True))
self.obj1630.out_connections_.append(self.obj1629)
self.obj1629.in_connections_.append(self.obj1630)
self.obj1630.graphObject_.pendingConnections.append((self.obj1630.graphObject_.tag, self.obj1629.graphObject_.tag, [351.0, 220.0, 230.0, 173.0], 2, 0))
self.obj1632.out_connections_.append(self.obj1631)
self.obj1631.in_connections_.append(self.obj1632)
self.obj1632.graphObject_.pendingConnections.append((self.obj1632.graphObject_.tag, self.obj1631.graphObject_.tag, [110.0, 221.0, 103.5, 161.5], 0, True))
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))
def __init__(self, parent):
GGrule.__init__(self, 23)
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.obj1796 = operatingUnit(parent)
self.obj1796.preAction(self.LHS.CREATE)
self.obj1796.isGraphObjectVisual = True
if (hasattr(self.obj1796, '_setHierarchicalLink')):
self.obj1796._setHierarchicalLink(False)
# OperCostProp
self.obj1796.OperCostProp.setNone()
# name
self.obj1796.name.setValue('')
self.obj1796.name.setNone()
# OperCostFix
self.obj1796.OperCostFix.setNone()
self.obj1796.GGLabel.setValue(4)
self.obj1796.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(280.0, 120.0, self.obj1796)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1796.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1796)
self.obj1796.postAction(self.LHS.CREATE)
self.obj1797 = CapableOf(parent)
self.obj1797.preAction(self.LHS.CREATE)
self.obj1797.isGraphObjectVisual = True
if (hasattr(self.obj1797, '_setHierarchicalLink')):
self.obj1797._setHierarchicalLink(False)
# rate
self.obj1797.rate.setNone()
self.obj1797.GGLabel.setValue(5)
self.obj1797.graphClass_ = graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(160.5, 121.5, self.obj1797)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1797.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1797)
self.obj1797.postAction(self.LHS.CREATE)
self.obj1798 = Agent(parent)
self.obj1798.preAction(self.LHS.CREATE)
self.obj1798.isGraphObjectVisual = True
if (hasattr(self.obj1798, '_setHierarchicalLink')):
self.obj1798._setHierarchicalLink(False)
# price
self.obj1798.price.setNone()
# name
self.obj1798.name.setValue('')
self.obj1798.name.setNone()
self.obj1798.GGLabel.setValue(1)
self.obj1798.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(120.0, 40.0, self.obj1798)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1798.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1798)
self.obj1798.postAction(self.LHS.CREATE)
self.obj1799 = Role(parent)
self.obj1799.preAction(self.LHS.CREATE)
self.obj1799.isGraphObjectVisual = True
if (hasattr(self.obj1799, '_setHierarchicalLink')):
self.obj1799._setHierarchicalLink(False)
# name
self.obj1799.name.setValue('')
self.obj1799.name.setNone()
self.obj1799.GGLabel.setValue(2)
self.obj1799.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(140.0, 140.0, self.obj1799)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1799.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1799)
self.obj1799.postAction(self.LHS.CREATE)
self.obj1800 = GenericGraphEdge(parent)
self.obj1800.preAction(self.LHS.CREATE)
self.obj1800.isGraphObjectVisual = True
if (hasattr(self.obj1800, '_setHierarchicalLink')):
self.obj1800._setHierarchicalLink(False)
self.obj1800.GGLabel.setValue(3)
self.obj1800.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(264.75, 85.25, self.obj1800)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1800.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1800)
self.obj1800.postAction(self.LHS.CREATE)
self.obj1797.out_connections_.append(self.obj1799)
self.obj1799.in_connections_.append(self.obj1797)
self.obj1797.graphObject_.pendingConnections.append(
(self.obj1797.graphObject_.tag, self.obj1799.graphObject_.tag,
[164.0, 141.0, 160.5, 121.5], 0, True))
self.obj1798.out_connections_.append(self.obj1800)
self.obj1800.in_connections_.append(self.obj1798)
self.obj1798.graphObject_.pendingConnections.append(
(self.obj1798.graphObject_.tag, self.obj1800.graphObject_.tag,
[145.0, 102.0, 226.0, 83.0, 264.75, 85.25], 2, True))
self.obj1798.out_connections_.append(self.obj1797)
self.obj1797.in_connections_.append(self.obj1798)
self.obj1798.graphObject_.pendingConnections.append(
(self.obj1798.graphObject_.tag, self.obj1797.graphObject_.tag,
[157.0, 102.0, 160.5, 121.5], 0, True))
self.obj1800.out_connections_.append(self.obj1796)
self.obj1796.in_connections_.append(self.obj1800)
self.obj1800.graphObject_.pendingConnections.append(
(self.obj1800.graphObject_.tag, self.obj1796.graphObject_.tag,
[300.0, 121.0, 264.75, 85.25], 2, 0))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1804 = operatingUnit(parent)
self.obj1804.preAction(self.RHS.CREATE)
self.obj1804.isGraphObjectVisual = True
if (hasattr(self.obj1804, '_setHierarchicalLink')):
self.obj1804._setHierarchicalLink(False)
# OperCostProp
self.obj1804.OperCostProp.setNone()
# name
self.obj1804.name.setValue('')
self.obj1804.name.setNone()
# OperCostFix
self.obj1804.OperCostFix.setNone()
self.obj1804.GGLabel.setValue(4)
self.obj1804.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(280.0, 120.0, self.obj1804)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1804.graphObject_ = new_obj
self.obj18040 = AttrCalc()
self.obj18040.Copy = ATOM3Boolean()
self.obj18040.Copy.setValue(('Copy from LHS', 0))
self.obj18040.Copy.config = 0
self.obj18040.Specify = ATOM3Constraint()
self.obj18040.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]),
'a = self.getMatched ( graphID , self.LHS.nodeWithLabel(1) ).name.getValue()\nb = self.getMatched ( graphID , self.LHS.nodeWithLabel(2) ).name.getValue()\nreturn self.graphRewritingSystem.Dictag[ a ][b]\n\n'
))
self.obj1804.GGset2Any['OperCostProp'] = self.obj18040
self.obj18041 = AttrCalc()
self.obj18041.Copy = ATOM3Boolean()
self.obj18041.Copy.setValue(('Copy from LHS', 1))
self.obj18041.Copy.config = 0
self.obj18041.Specify = ATOM3Constraint()
self.obj18041.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.obj1804.GGset2Any['name'] = self.obj18041
self.obj18042 = AttrCalc()
self.obj18042.Copy = ATOM3Boolean()
self.obj18042.Copy.setValue(('Copy from LHS', 0))
self.obj18042.Copy.config = 0
self.obj18042.Specify = ATOM3Constraint()
self.obj18042.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.obj1804.GGset2Any['OperCostFix'] = self.obj18042
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1804)
self.obj1804.postAction(self.RHS.CREATE)
self.obj1805 = CapableOf(parent)
self.obj1805.preAction(self.RHS.CREATE)
self.obj1805.isGraphObjectVisual = True
if (hasattr(self.obj1805, '_setHierarchicalLink')):
self.obj1805._setHierarchicalLink(False)
# rate
self.obj1805.rate.setNone()
self.obj1805.GGLabel.setValue(5)
self.obj1805.graphClass_ = graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(160.5, 121.5, self.obj1805)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1805.graphObject_ = new_obj
self.obj18050 = AttrCalc()
self.obj18050.Copy = ATOM3Boolean()
self.obj18050.Copy.setValue(('Copy from LHS', 1))
self.obj18050.Copy.config = 0
self.obj18050.Specify = ATOM3Constraint()
self.obj18050.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.obj1805.GGset2Any['rate'] = self.obj18050
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1805)
self.obj1805.postAction(self.RHS.CREATE)
self.obj1806 = Agent(parent)
self.obj1806.preAction(self.RHS.CREATE)
self.obj1806.isGraphObjectVisual = True
if (hasattr(self.obj1806, '_setHierarchicalLink')):
self.obj1806._setHierarchicalLink(False)
# price
self.obj1806.price.setNone()
# name
self.obj1806.name.setValue('')
self.obj1806.name.setNone()
self.obj1806.GGLabel.setValue(1)
self.obj1806.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(120.0, 40.0, self.obj1806)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1806.graphObject_ = new_obj
self.obj18060 = AttrCalc()
self.obj18060.Copy = ATOM3Boolean()
self.obj18060.Copy.setValue(('Copy from LHS', 1))
self.obj18060.Copy.config = 0
self.obj18060.Specify = ATOM3Constraint()
self.obj18060.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.obj1806.GGset2Any['price'] = self.obj18060
self.obj18061 = AttrCalc()
self.obj18061.Copy = ATOM3Boolean()
self.obj18061.Copy.setValue(('Copy from LHS', 1))
self.obj18061.Copy.config = 0
self.obj18061.Specify = ATOM3Constraint()
self.obj18061.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.obj1806.GGset2Any['name'] = self.obj18061
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1806)
self.obj1806.postAction(self.RHS.CREATE)
self.obj1807 = Role(parent)
self.obj1807.preAction(self.RHS.CREATE)
self.obj1807.isGraphObjectVisual = True
if (hasattr(self.obj1807, '_setHierarchicalLink')):
self.obj1807._setHierarchicalLink(False)
# name
self.obj1807.name.setValue('')
self.obj1807.name.setNone()
self.obj1807.GGLabel.setValue(2)
self.obj1807.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(140.0, 140.0, self.obj1807)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1807.graphObject_ = new_obj
self.obj18070 = AttrCalc()
self.obj18070.Copy = ATOM3Boolean()
self.obj18070.Copy.setValue(('Copy from LHS', 1))
self.obj18070.Copy.config = 0
self.obj18070.Specify = ATOM3Constraint()
self.obj18070.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.obj1807.GGset2Any['name'] = self.obj18070
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1807)
self.obj1807.postAction(self.RHS.CREATE)
self.obj1808 = GenericGraphEdge(parent)
self.obj1808.preAction(self.RHS.CREATE)
self.obj1808.isGraphObjectVisual = True
if (hasattr(self.obj1808, '_setHierarchicalLink')):
self.obj1808._setHierarchicalLink(False)
self.obj1808.GGLabel.setValue(3)
self.obj1808.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(264.75, 85.25, self.obj1808)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1808.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1808)
self.obj1808.postAction(self.RHS.CREATE)
self.obj1805.out_connections_.append(self.obj1807)
self.obj1807.in_connections_.append(self.obj1805)
self.obj1805.graphObject_.pendingConnections.append(
(self.obj1805.graphObject_.tag, self.obj1807.graphObject_.tag,
[171.0, 140.0, 160.5, 121.5], 2, 0))
self.obj1806.out_connections_.append(self.obj1808)
self.obj1808.in_connections_.append(self.obj1806)
self.obj1806.graphObject_.pendingConnections.append(
(self.obj1806.graphObject_.tag, self.obj1808.graphObject_.tag,
[157.0, 102.0, 264.75, 85.25], 2, 0))
self.obj1806.out_connections_.append(self.obj1805)
self.obj1805.in_connections_.append(self.obj1806)
self.obj1806.graphObject_.pendingConnections.append(
(self.obj1806.graphObject_.tag, self.obj1805.graphObject_.tag,
[157.0, 102.0, 160.5, 121.5], 2, 0))
self.obj1808.out_connections_.append(self.obj1804)
self.obj1804.in_connections_.append(self.obj1808)
self.obj1808.graphObject_.pendingConnections.append(
(self.obj1808.graphObject_.tag, self.obj1804.graphObject_.tag,
[300.0, 121.0, 264.75, 85.25], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 19)
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.obj1719 = metarial(parent)
self.obj1719.preAction(self.LHS.CREATE)
self.obj1719.isGraphObjectVisual = True
if (hasattr(self.obj1719, '_setHierarchicalLink')):
self.obj1719._setHierarchicalLink(False)
# MaxFlow
self.obj1719.MaxFlow.setNone()
# price
self.obj1719.price.setValue(0)
# Name
self.obj1719.Name.setValue('')
self.obj1719.Name.setNone()
# ReqFlow
self.obj1719.ReqFlow.setNone()
self.obj1719.GGLabel.setValue(4)
self.obj1719.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(240.0, 20.0, self.obj1719)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1719.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1719)
self.obj1719.postAction(self.LHS.CREATE)
self.obj1720 = metarial(parent)
self.obj1720.preAction(self.LHS.CREATE)
self.obj1720.isGraphObjectVisual = True
if (hasattr(self.obj1720, '_setHierarchicalLink')):
self.obj1720._setHierarchicalLink(False)
# MaxFlow
self.obj1720.MaxFlow.setNone()
# price
self.obj1720.price.setValue(0)
# Name
self.obj1720.Name.setValue('')
self.obj1720.Name.setNone()
# ReqFlow
self.obj1720.ReqFlow.setNone()
self.obj1720.GGLabel.setValue(6)
self.obj1720.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(240.0, 240.0, self.obj1720)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1720.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1720)
self.obj1720.postAction(self.LHS.CREATE)
self.obj1721 = operatingUnit(parent)
self.obj1721.preAction(self.LHS.CREATE)
self.obj1721.isGraphObjectVisual = True
if (hasattr(self.obj1721, '_setHierarchicalLink')):
self.obj1721._setHierarchicalLink(False)
# OperCostProp
self.obj1721.OperCostProp.setNone()
# name
self.obj1721.name.setValue('')
self.obj1721.name.setNone()
# OperCostFix
self.obj1721.OperCostFix.setNone()
self.obj1721.GGLabel.setValue(5)
self.obj1721.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(240.0, 140.0, self.obj1721)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1721.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1721)
self.obj1721.postAction(self.LHS.CREATE)
self.obj1722 = fromMaterial(parent)
self.obj1722.preAction(self.LHS.CREATE)
self.obj1722.isGraphObjectVisual = True
if (hasattr(self.obj1722, '_setHierarchicalLink')):
self.obj1722._setHierarchicalLink(False)
# rate
self.obj1722.rate.setNone()
self.obj1722.GGLabel.setValue(8)
self.obj1722.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(265.0, 100.0, self.obj1722)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1722.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1722)
self.obj1722.postAction(self.LHS.CREATE)
self.obj1723 = Goal(parent)
self.obj1723.preAction(self.LHS.CREATE)
self.obj1723.isGraphObjectVisual = True
if (hasattr(self.obj1723, '_setHierarchicalLink')):
self.obj1723._setHierarchicalLink(False)
# name
self.obj1723.name.setValue('')
self.obj1723.name.setNone()
self.obj1723.GGLabel.setValue(2)
self.obj1723.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(60.0, 220.0, self.obj1723)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1723.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1723)
self.obj1723.postAction(self.LHS.CREATE)
self.obj1724 = Role(parent)
self.obj1724.preAction(self.LHS.CREATE)
self.obj1724.isGraphObjectVisual = True
if (hasattr(self.obj1724, '_setHierarchicalLink')):
self.obj1724._setHierarchicalLink(False)
# name
self.obj1724.name.setValue('')
self.obj1724.name.setNone()
self.obj1724.GGLabel.setValue(1)
self.obj1724.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(60.0, 40.0, self.obj1724)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1724.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1724)
self.obj1724.postAction(self.LHS.CREATE)
self.obj1725 = achieve(parent)
self.obj1725.preAction(self.LHS.CREATE)
self.obj1725.isGraphObjectVisual = True
if (hasattr(self.obj1725, '_setHierarchicalLink')):
self.obj1725._setHierarchicalLink(False)
# rate
self.obj1725.rate.setNone()
self.obj1725.GGLabel.setValue(3)
self.obj1725.graphClass_ = graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(97.5, 137.5, self.obj1725)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1725.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1725)
self.obj1725.postAction(self.LHS.CREATE)
self.obj1726 = GenericGraphEdge(parent)
self.obj1726.preAction(self.LHS.CREATE)
self.obj1726.isGraphObjectVisual = True
if (hasattr(self.obj1726, '_setHierarchicalLink')):
self.obj1726._setHierarchicalLink(False)
self.obj1726.GGLabel.setValue(7)
self.obj1726.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(215.0, 41.5, self.obj1726)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1726.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1726)
self.obj1726.postAction(self.LHS.CREATE)
self.obj1727 = GenericGraphEdge(parent)
self.obj1727.preAction(self.LHS.CREATE)
self.obj1727.isGraphObjectVisual = True
if (hasattr(self.obj1727, '_setHierarchicalLink')):
self.obj1727._setHierarchicalLink(False)
self.obj1727.GGLabel.setValue(9)
self.obj1727.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(185.0, 276.0, self.obj1727)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1727.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1727)
self.obj1727.postAction(self.LHS.CREATE)
self.obj1719.out_connections_.append(self.obj1722)
self.obj1722.in_connections_.append(self.obj1719)
self.obj1719.graphObject_.pendingConnections.append(
(self.obj1719.graphObject_.tag, self.obj1722.graphObject_.tag,
[264.0, 69.0, 265.0, 100.0], 0, True))
self.obj1722.out_connections_.append(self.obj1721)
self.obj1721.in_connections_.append(self.obj1722)
self.obj1722.graphObject_.pendingConnections.append(
(self.obj1722.graphObject_.tag, self.obj1721.graphObject_.tag,
[260.0, 151.0, 352.0, 90.0], 0, True))
self.obj1723.out_connections_.append(self.obj1727)
self.obj1727.in_connections_.append(self.obj1723)
self.obj1723.graphObject_.pendingConnections.append(
(self.obj1723.graphObject_.tag, self.obj1727.graphObject_.tag,
[84.0, 270.0, 185.0, 276.0], 0, True))
self.obj1724.out_connections_.append(self.obj1725)
self.obj1725.in_connections_.append(self.obj1724)
self.obj1724.graphObject_.pendingConnections.append(
(self.obj1724.graphObject_.tag, self.obj1725.graphObject_.tag,
[84.0, 86.0, 97.5, 137.5], 0, True))
self.obj1724.out_connections_.append(self.obj1726)
self.obj1726.in_connections_.append(self.obj1724)
self.obj1724.graphObject_.pendingConnections.append(
(self.obj1724.graphObject_.tag, self.obj1726.graphObject_.tag,
[84.0, 41.0, 215.0, 41.5], 0, True))
self.obj1725.out_connections_.append(self.obj1723)
self.obj1723.in_connections_.append(self.obj1725)
self.obj1725.graphObject_.pendingConnections.append(
(self.obj1725.graphObject_.tag, self.obj1723.graphObject_.tag,
[83.0, 221.0, 93.5, 143.5], 0, True))
self.obj1726.out_connections_.append(self.obj1719)
self.obj1719.in_connections_.append(self.obj1726)
self.obj1726.graphObject_.pendingConnections.append(
(self.obj1726.graphObject_.tag, self.obj1719.graphObject_.tag,
[246.0, 62.0, 215.0, 41.5], 0, True))
self.obj1727.out_connections_.append(self.obj1720)
self.obj1720.in_connections_.append(self.obj1727)
self.obj1727.graphObject_.pendingConnections.append(
(self.obj1727.graphObject_.tag, self.obj1720.graphObject_.tag,
[246.0, 282.0, 185.0, 276.0], 0, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1731 = metarial(parent)
self.obj1731.preAction(self.RHS.CREATE)
self.obj1731.isGraphObjectVisual = True
if (hasattr(self.obj1731, '_setHierarchicalLink')):
self.obj1731._setHierarchicalLink(False)
# MaxFlow
self.obj1731.MaxFlow.setNone()
# price
self.obj1731.price.setValue(0)
# Name
self.obj1731.Name.setValue('')
self.obj1731.Name.setNone()
# ReqFlow
self.obj1731.ReqFlow.setNone()
self.obj1731.GGLabel.setValue(4)
self.obj1731.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(280.0, 20.0, self.obj1731)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1731.graphObject_ = new_obj
self.obj17310 = AttrCalc()
self.obj17310.Copy = ATOM3Boolean()
self.obj17310.Copy.setValue(('Copy from LHS', 1))
self.obj17310.Copy.config = 0
self.obj17310.Specify = ATOM3Constraint()
self.obj17310.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.obj1731.GGset2Any['MaxFlow'] = self.obj17310
self.obj17311 = AttrCalc()
self.obj17311.Copy = ATOM3Boolean()
self.obj17311.Copy.setValue(('Copy from LHS', 1))
self.obj17311.Copy.config = 0
self.obj17311.Specify = ATOM3Constraint()
self.obj17311.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.obj1731.GGset2Any['Name'] = self.obj17311
self.obj17312 = AttrCalc()
self.obj17312.Copy = ATOM3Boolean()
self.obj17312.Copy.setValue(('Copy from LHS', 1))
self.obj17312.Copy.config = 0
self.obj17312.Specify = ATOM3Constraint()
self.obj17312.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.obj1731.GGset2Any['ReqFlow'] = self.obj17312
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1731)
self.obj1731.postAction(self.RHS.CREATE)
self.obj1732 = metarial(parent)
self.obj1732.preAction(self.RHS.CREATE)
self.obj1732.isGraphObjectVisual = True
if (hasattr(self.obj1732, '_setHierarchicalLink')):
self.obj1732._setHierarchicalLink(False)
# MaxFlow
self.obj1732.MaxFlow.setNone()
# price
self.obj1732.price.setValue(0)
# Name
self.obj1732.Name.setValue('')
self.obj1732.Name.setNone()
# ReqFlow
self.obj1732.ReqFlow.setNone()
self.obj1732.GGLabel.setValue(6)
self.obj1732.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(280.0, 240.0, self.obj1732)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1732.graphObject_ = new_obj
self.obj17320 = AttrCalc()
self.obj17320.Copy = ATOM3Boolean()
self.obj17320.Copy.setValue(('Copy from LHS', 1))
self.obj17320.Copy.config = 0
self.obj17320.Specify = ATOM3Constraint()
self.obj17320.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.obj1732.GGset2Any['MaxFlow'] = self.obj17320
self.obj17321 = AttrCalc()
self.obj17321.Copy = ATOM3Boolean()
self.obj17321.Copy.setValue(('Copy from LHS', 1))
self.obj17321.Copy.config = 0
self.obj17321.Specify = ATOM3Constraint()
self.obj17321.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.obj1732.GGset2Any['Name'] = self.obj17321
self.obj17322 = AttrCalc()
self.obj17322.Copy = ATOM3Boolean()
self.obj17322.Copy.setValue(('Copy from LHS', 1))
self.obj17322.Copy.config = 0
self.obj17322.Specify = ATOM3Constraint()
self.obj17322.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.obj1732.GGset2Any['ReqFlow'] = self.obj17322
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1732)
self.obj1732.postAction(self.RHS.CREATE)
self.obj1733 = operatingUnit(parent)
self.obj1733.preAction(self.RHS.CREATE)
self.obj1733.isGraphObjectVisual = True
if (hasattr(self.obj1733, '_setHierarchicalLink')):
self.obj1733._setHierarchicalLink(False)
# OperCostProp
self.obj1733.OperCostProp.setNone()
# name
self.obj1733.name.setValue('')
self.obj1733.name.setNone()
# OperCostFix
self.obj1733.OperCostFix.setNone()
self.obj1733.GGLabel.setValue(5)
self.obj1733.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(280.0, 140.0, self.obj1733)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1733.graphObject_ = new_obj
self.obj17330 = AttrCalc()
self.obj17330.Copy = ATOM3Boolean()
self.obj17330.Copy.setValue(('Copy from LHS', 1))
self.obj17330.Copy.config = 0
self.obj17330.Specify = ATOM3Constraint()
self.obj17330.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.obj1733.GGset2Any['OperCostProp'] = self.obj17330
self.obj17331 = AttrCalc()
self.obj17331.Copy = ATOM3Boolean()
self.obj17331.Copy.setValue(('Copy from LHS', 1))
self.obj17331.Copy.config = 0
self.obj17331.Specify = ATOM3Constraint()
self.obj17331.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.obj1733.GGset2Any['name'] = self.obj17331
self.obj17332 = AttrCalc()
self.obj17332.Copy = ATOM3Boolean()
self.obj17332.Copy.setValue(('Copy from LHS', 1))
self.obj17332.Copy.config = 0
self.obj17332.Specify = ATOM3Constraint()
self.obj17332.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.obj1733.GGset2Any['OperCostFix'] = self.obj17332
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1733)
self.obj1733.postAction(self.RHS.CREATE)
self.obj1734 = intoMaterial(parent)
self.obj1734.preAction(self.RHS.CREATE)
self.obj1734.isGraphObjectVisual = True
if (hasattr(self.obj1734, '_setHierarchicalLink')):
self.obj1734._setHierarchicalLink(False)
# rate
self.obj1734.rate.setValue(0.0)
self.obj1734.GGLabel.setValue(10)
self.obj1734.graphClass_ = graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(315.25, 202.5, self.obj1734)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1734.graphObject_ = new_obj
self.obj17340 = AttrCalc()
self.obj17340.Copy = ATOM3Boolean()
self.obj17340.Copy.setValue(('Copy from LHS', 0))
self.obj17340.Copy.config = 0
self.obj17340.Specify = ATOM3Constraint()
self.obj17340.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(3)).rate.getValue()\n\n\n\n\n\n\n\n\n\n'
))
self.obj1734.GGset2Any['rate'] = self.obj17340
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1734)
self.obj1734.postAction(self.RHS.CREATE)
self.obj1735 = fromMaterial(parent)
self.obj1735.preAction(self.RHS.CREATE)
self.obj1735.isGraphObjectVisual = True
if (hasattr(self.obj1735, '_setHierarchicalLink')):
self.obj1735._setHierarchicalLink(False)
# rate
self.obj1735.rate.setNone()
self.obj1735.GGLabel.setValue(8)
self.obj1735.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(323.0, 83.0, self.obj1735)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1735.graphObject_ = new_obj
self.obj17350 = AttrCalc()
self.obj17350.Copy = ATOM3Boolean()
self.obj17350.Copy.setValue(('Copy from LHS', 1))
self.obj17350.Copy.config = 0
self.obj17350.Specify = ATOM3Constraint()
self.obj17350.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.obj1735.GGset2Any['rate'] = self.obj17350
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1735)
self.obj1735.postAction(self.RHS.CREATE)
self.obj1736 = Goal(parent)
self.obj1736.preAction(self.RHS.CREATE)
self.obj1736.isGraphObjectVisual = True
if (hasattr(self.obj1736, '_setHierarchicalLink')):
self.obj1736._setHierarchicalLink(False)
# name
self.obj1736.name.setValue('')
self.obj1736.name.setNone()
self.obj1736.GGLabel.setValue(2)
self.obj1736.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(60.0, 220.0, self.obj1736)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1736.graphObject_ = new_obj
self.obj17360 = AttrCalc()
self.obj17360.Copy = ATOM3Boolean()
self.obj17360.Copy.setValue(('Copy from LHS', 1))
self.obj17360.Copy.config = 0
self.obj17360.Specify = ATOM3Constraint()
self.obj17360.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.obj1736.GGset2Any['name'] = self.obj17360
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1736)
self.obj1736.postAction(self.RHS.CREATE)
self.obj1737 = Role(parent)
self.obj1737.preAction(self.RHS.CREATE)
self.obj1737.isGraphObjectVisual = True
if (hasattr(self.obj1737, '_setHierarchicalLink')):
self.obj1737._setHierarchicalLink(False)
# name
self.obj1737.name.setValue('')
self.obj1737.name.setNone()
self.obj1737.GGLabel.setValue(1)
self.obj1737.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(60.0, 40.0, self.obj1737)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1737.graphObject_ = new_obj
self.obj17370 = AttrCalc()
self.obj17370.Copy = ATOM3Boolean()
self.obj17370.Copy.setValue(('Copy from LHS', 1))
self.obj17370.Copy.config = 0
self.obj17370.Specify = ATOM3Constraint()
self.obj17370.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.obj1737.GGset2Any['name'] = self.obj17370
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1737)
self.obj1737.postAction(self.RHS.CREATE)
self.obj1738 = achieve(parent)
self.obj1738.preAction(self.RHS.CREATE)
self.obj1738.isGraphObjectVisual = True
if (hasattr(self.obj1738, '_setHierarchicalLink')):
self.obj1738._setHierarchicalLink(False)
# rate
self.obj1738.rate.setNone()
self.obj1738.GGLabel.setValue(3)
self.obj1738.graphClass_ = graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(93.5, 143.5, self.obj1738)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1738.graphObject_ = new_obj
self.obj17380 = AttrCalc()
self.obj17380.Copy = ATOM3Boolean()
self.obj17380.Copy.setValue(('Copy from LHS', 1))
self.obj17380.Copy.config = 0
self.obj17380.Specify = ATOM3Constraint()
self.obj17380.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.obj1738.GGset2Any['rate'] = self.obj17380
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1738)
self.obj1738.postAction(self.RHS.CREATE)
self.obj1739 = GenericGraphEdge(parent)
self.obj1739.preAction(self.RHS.CREATE)
self.obj1739.isGraphObjectVisual = True
if (hasattr(self.obj1739, '_setHierarchicalLink')):
self.obj1739._setHierarchicalLink(False)
self.obj1739.GGLabel.setValue(7)
self.obj1739.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(215.0, 41.5, self.obj1739)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1739.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1739)
self.obj1739.postAction(self.RHS.CREATE)
self.obj1740 = GenericGraphEdge(parent)
self.obj1740.preAction(self.RHS.CREATE)
self.obj1740.isGraphObjectVisual = True
if (hasattr(self.obj1740, '_setHierarchicalLink')):
self.obj1740._setHierarchicalLink(False)
self.obj1740.GGLabel.setValue(9)
self.obj1740.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(185.0, 276.0, self.obj1740)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1740.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1740)
self.obj1740.postAction(self.RHS.CREATE)
self.obj1731.out_connections_.append(self.obj1735)
self.obj1735.in_connections_.append(self.obj1731)
self.obj1731.graphObject_.pendingConnections.append(
(self.obj1731.graphObject_.tag, self.obj1735.graphObject_.tag,
[284.0, 69.0, 323.0, 83.0], 2, 0))
self.obj1733.out_connections_.append(self.obj1734)
self.obj1734.in_connections_.append(self.obj1733)
self.obj1733.graphObject_.pendingConnections.append(
(self.obj1733.graphObject_.tag, self.obj1734.graphObject_.tag,
[333.0, 148.0, 332.0, 167.0, 371.25, 179.5], 2, True))
self.obj1734.out_connections_.append(self.obj1732)
self.obj1732.in_connections_.append(self.obj1734)
self.obj1734.graphObject_.pendingConnections.append(
(self.obj1734.graphObject_.tag, self.obj1732.graphObject_.tag,
[326.0, 250.0, 354.5, 215.0, 371.25, 179.5], 2, True))
self.obj1735.out_connections_.append(self.obj1733)
self.obj1733.in_connections_.append(self.obj1735)
self.obj1735.graphObject_.pendingConnections.append(
(self.obj1735.graphObject_.tag, self.obj1733.graphObject_.tag,
[333.0, 148.0, 352.0, 90.0], 2, 0))
self.obj1736.out_connections_.append(self.obj1740)
self.obj1740.in_connections_.append(self.obj1736)
self.obj1736.graphObject_.pendingConnections.append(
(self.obj1736.graphObject_.tag, self.obj1740.graphObject_.tag,
[94.0, 270.0, 185.0, 276.0], 2, 0))
self.obj1737.out_connections_.append(self.obj1738)
self.obj1738.in_connections_.append(self.obj1737)
self.obj1737.graphObject_.pendingConnections.append(
(self.obj1737.graphObject_.tag, self.obj1738.graphObject_.tag,
[91.0, 85.0, 93.5, 143.5], 2, 0))
self.obj1737.out_connections_.append(self.obj1739)
self.obj1739.in_connections_.append(self.obj1737)
self.obj1737.graphObject_.pendingConnections.append(
(self.obj1737.graphObject_.tag, self.obj1739.graphObject_.tag,
[91.0, 40.0, 215.0, 41.5], 2, 0))
self.obj1738.out_connections_.append(self.obj1736)
self.obj1736.in_connections_.append(self.obj1738)
self.obj1738.graphObject_.pendingConnections.append(
(self.obj1738.graphObject_.tag, self.obj1736.graphObject_.tag,
[93.0, 221.0, 93.5, 143.5], 2, 0))
self.obj1739.out_connections_.append(self.obj1731)
self.obj1731.in_connections_.append(self.obj1739)
self.obj1739.graphObject_.pendingConnections.append(
(self.obj1739.graphObject_.tag, self.obj1731.graphObject_.tag,
[266.0, 62.0, 215.0, 41.5], 2, 0))
self.obj1740.out_connections_.append(self.obj1732)
self.obj1732.in_connections_.append(self.obj1740)
self.obj1740.graphObject_.pendingConnections.append(
(self.obj1740.graphObject_.tag, self.obj1732.graphObject_.tag,
[286.0, 282.0, 185.0, 276.0], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 17)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.obj1696=CapableOf(parent)
self.obj1696.preAction( self.LHS.CREATE )
self.obj1696.isGraphObjectVisual = True
if(hasattr(self.obj1696, '_setHierarchicalLink')):
self.obj1696._setHierarchicalLink(False)
# rate
self.obj1696.rate.setNone()
self.obj1696.GGLabel.setValue(4)
self.obj1696.graphClass_= graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(250.75,110.75,self.obj1696)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1696.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1696)
self.obj1696.postAction( self.LHS.CREATE )
self.obj1697=Goal(parent)
self.obj1697.preAction( self.LHS.CREATE )
self.obj1697.isGraphObjectVisual = True
if(hasattr(self.obj1697, '_setHierarchicalLink')):
self.obj1697._setHierarchicalLink(False)
# name
self.obj1697.name.setValue('')
self.obj1697.name.setNone()
self.obj1697.GGLabel.setValue(3)
self.obj1697.graphClass_= graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(100.0,240.0,self.obj1697)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1697.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1697)
self.obj1697.postAction( self.LHS.CREATE )
self.obj1698=Agent(parent)
self.obj1698.preAction( self.LHS.CREATE )
self.obj1698.isGraphObjectVisual = True
if(hasattr(self.obj1698, '_setHierarchicalLink')):
self.obj1698._setHierarchicalLink(False)
# price
self.obj1698.price.setNone()
# name
self.obj1698.name.setValue('')
self.obj1698.name.setNone()
self.obj1698.GGLabel.setValue(1)
self.obj1698.graphClass_= graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(80.0,40.0,self.obj1698)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1698.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1698)
self.obj1698.postAction( self.LHS.CREATE )
self.obj1699=Role(parent)
self.obj1699.preAction( self.LHS.CREATE )
self.obj1699.isGraphObjectVisual = True
if(hasattr(self.obj1699, '_setHierarchicalLink')):
self.obj1699._setHierarchicalLink(False)
# name
self.obj1699.name.setValue('')
self.obj1699.name.setNone()
self.obj1699.GGLabel.setValue(2)
self.obj1699.graphClass_= graph_Role
if parent.genGraphics:
new_obj = graph_Role(280.0,140.0,self.obj1699)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1699.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1699)
self.obj1699.postAction( self.LHS.CREATE )
self.obj1700=achieve(parent)
self.obj1700.preAction( self.LHS.CREATE )
self.obj1700.isGraphObjectVisual = True
if(hasattr(self.obj1700, '_setHierarchicalLink')):
self.obj1700._setHierarchicalLink(False)
# rate
self.obj1700.rate.setNone()
self.obj1700.GGLabel.setValue(5)
self.obj1700.graphClass_= graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(258.5,259.0,self.obj1700)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1700.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1700)
self.obj1700.postAction( self.LHS.CREATE )
self.obj1696.out_connections_.append(self.obj1699)
self.obj1699.in_connections_.append(self.obj1696)
self.obj1696.graphObject_.pendingConnections.append((self.obj1696.graphObject_.tag, self.obj1699.graphObject_.tag, [304.0, 141.0, 300.5, 120.5, 250.75, 110.75], 2, True))
self.obj1698.out_connections_.append(self.obj1696)
self.obj1696.in_connections_.append(self.obj1698)
self.obj1698.graphObject_.pendingConnections.append((self.obj1698.graphObject_.tag, self.obj1696.graphObject_.tag, [105.0, 102.0, 201.0, 101.0, 250.75, 110.75], 2, True))
self.obj1699.out_connections_.append(self.obj1700)
self.obj1700.in_connections_.append(self.obj1699)
self.obj1699.graphObject_.pendingConnections.append((self.obj1699.graphObject_.tag, self.obj1700.graphObject_.tag, [304.0, 186.0, 303.5, 233.0, 258.5, 259.0], 2, True))
self.obj1700.out_connections_.append(self.obj1697)
self.obj1697.in_connections_.append(self.obj1700)
self.obj1700.graphObject_.pendingConnections.append((self.obj1700.graphObject_.tag, self.obj1697.graphObject_.tag, [124.0, 290.0, 213.5, 285.0, 258.5, 259.0], 2, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1704=metarial(parent)
self.obj1704.preAction( self.RHS.CREATE )
self.obj1704.isGraphObjectVisual = True
if(hasattr(self.obj1704, '_setHierarchicalLink')):
self.obj1704._setHierarchicalLink(False)
# MaxFlow
self.obj1704.MaxFlow.setValue(999999)
# price
self.obj1704.price.setValue(0)
# Name
self.obj1704.Name.setValue('')
self.obj1704.Name.setNone()
# ReqFlow
self.obj1704.ReqFlow.setValue(0)
self.obj1704.GGLabel.setValue(8)
self.obj1704.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(400.0,80.0,self.obj1704)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1704.graphObject_ = new_obj
self.obj17040= AttrCalc()
self.obj17040.Copy=ATOM3Boolean()
self.obj17040.Copy.setValue(('Copy from LHS', 1))
self.obj17040.Copy.config = 0
self.obj17040.Specify=ATOM3Constraint()
self.obj17040.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.obj1704.GGset2Any['MaxFlow']= self.obj17040
self.obj17041= AttrCalc()
self.obj17041.Copy=ATOM3Boolean()
self.obj17041.Copy.setValue(('Copy from LHS', 0))
self.obj17041.Copy.config = 0
self.obj17041.Specify=ATOM3Constraint()
self.obj17041.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(1)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(3)).name.getValue()\n\n'))
self.obj1704.GGset2Any['Name']= self.obj17041
self.obj17042= AttrCalc()
self.obj17042.Copy=ATOM3Boolean()
self.obj17042.Copy.setValue(('Copy from LHS', 1))
self.obj17042.Copy.config = 0
self.obj17042.Specify=ATOM3Constraint()
self.obj17042.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.obj1704.GGset2Any['ReqFlow']= self.obj17042
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1704)
self.obj1704.postAction( self.RHS.CREATE )
self.obj1705=operatingUnit(parent)
self.obj1705.preAction( self.RHS.CREATE )
self.obj1705.isGraphObjectVisual = True
if(hasattr(self.obj1705, '_setHierarchicalLink')):
self.obj1705._setHierarchicalLink(False)
# OperCostProp
self.obj1705.OperCostProp.setValue(0.0)
# name
self.obj1705.name.setValue('')
self.obj1705.name.setNone()
# OperCostFix
self.obj1705.OperCostFix.setValue(0.0)
self.obj1705.GGLabel.setValue(7)
self.obj1705.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(400.0,240.0,self.obj1705)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1705.graphObject_ = new_obj
self.obj17050= AttrCalc()
self.obj17050.Copy=ATOM3Boolean()
self.obj17050.Copy.setValue(('Copy from LHS', 0))
self.obj17050.Copy.config = 0
self.obj17050.Specify=ATOM3Constraint()
self.obj17050.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(5)).rate.getValue()\n'))
self.obj1705.GGset2Any['OperCostProp']= self.obj17050
self.obj17051= AttrCalc()
self.obj17051.Copy=ATOM3Boolean()
self.obj17051.Copy.setValue(('Copy from LHS', 0))
self.obj17051.Copy.config = 0
self.obj17051.Specify=ATOM3Constraint()
self.obj17051.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(1)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(3)).name.getValue()\n\n\n\n\n\n\n'))
self.obj1705.GGset2Any['name']= self.obj17051
self.obj17052= AttrCalc()
self.obj17052.Copy=ATOM3Boolean()
self.obj17052.Copy.setValue(('Copy from LHS', 0))
self.obj17052.Copy.config = 0
self.obj17052.Specify=ATOM3Constraint()
self.obj17052.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 2.0\n'))
self.obj1705.GGset2Any['OperCostFix']= self.obj17052
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1705)
self.obj1705.postAction( self.RHS.CREATE )
self.obj1706=fromMaterial(parent)
self.obj1706.preAction( self.RHS.CREATE )
self.obj1706.isGraphObjectVisual = True
if(hasattr(self.obj1706, '_setHierarchicalLink')):
self.obj1706._setHierarchicalLink(False)
# rate
self.obj1706.rate.setValue(1.0)
self.obj1706.GGLabel.setValue(9)
self.obj1706.graphClass_= graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(422.0,190.0,self.obj1706)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1706.graphObject_ = new_obj
self.obj17060= AttrCalc()
self.obj17060.Copy=ATOM3Boolean()
self.obj17060.Copy.setValue(('Copy from LHS', 0))
self.obj17060.Copy.config = 0
self.obj17060.Specify=ATOM3Constraint()
self.obj17060.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.obj1706.GGset2Any['rate']= self.obj17060
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1706)
self.obj1706.postAction( self.RHS.CREATE )
self.obj1707=CapableOf(parent)
self.obj1707.preAction( self.RHS.CREATE )
self.obj1707.isGraphObjectVisual = True
if(hasattr(self.obj1707, '_setHierarchicalLink')):
self.obj1707._setHierarchicalLink(False)
# rate
self.obj1707.rate.setNone()
self.obj1707.GGLabel.setValue(4)
self.obj1707.graphClass_= graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(250.75,110.75,self.obj1707)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1707.graphObject_ = new_obj
self.obj17070= AttrCalc()
self.obj17070.Copy=ATOM3Boolean()
self.obj17070.Copy.setValue(('Copy from LHS', 1))
self.obj17070.Copy.config = 0
self.obj17070.Specify=ATOM3Constraint()
self.obj17070.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.obj1707.GGset2Any['rate']= self.obj17070
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1707)
self.obj1707.postAction( self.RHS.CREATE )
self.obj1708=Goal(parent)
self.obj1708.preAction( self.RHS.CREATE )
self.obj1708.isGraphObjectVisual = True
if(hasattr(self.obj1708, '_setHierarchicalLink')):
self.obj1708._setHierarchicalLink(False)
# name
self.obj1708.name.setValue('')
self.obj1708.name.setNone()
self.obj1708.GGLabel.setValue(3)
self.obj1708.graphClass_= graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(100.0,240.0,self.obj1708)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1708.graphObject_ = new_obj
self.obj17080= AttrCalc()
self.obj17080.Copy=ATOM3Boolean()
self.obj17080.Copy.setValue(('Copy from LHS', 1))
self.obj17080.Copy.config = 0
self.obj17080.Specify=ATOM3Constraint()
self.obj17080.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.obj1708.GGset2Any['name']= self.obj17080
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1708)
self.obj1708.postAction( self.RHS.CREATE )
self.obj1709=Agent(parent)
self.obj1709.preAction( self.RHS.CREATE )
self.obj1709.isGraphObjectVisual = True
if(hasattr(self.obj1709, '_setHierarchicalLink')):
self.obj1709._setHierarchicalLink(False)
# price
self.obj1709.price.setNone()
# name
self.obj1709.name.setValue('')
self.obj1709.name.setNone()
self.obj1709.GGLabel.setValue(1)
self.obj1709.graphClass_= graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(80.0,40.0,self.obj1709)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1709.graphObject_ = new_obj
self.obj17090= AttrCalc()
self.obj17090.Copy=ATOM3Boolean()
self.obj17090.Copy.setValue(('Copy from LHS', 1))
self.obj17090.Copy.config = 0
self.obj17090.Specify=ATOM3Constraint()
self.obj17090.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.obj1709.GGset2Any['price']= self.obj17090
self.obj17091= AttrCalc()
self.obj17091.Copy=ATOM3Boolean()
self.obj17091.Copy.setValue(('Copy from LHS', 1))
self.obj17091.Copy.config = 0
self.obj17091.Specify=ATOM3Constraint()
self.obj17091.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.obj1709.GGset2Any['name']= self.obj17091
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1709)
self.obj1709.postAction( self.RHS.CREATE )
self.obj1710=Role(parent)
self.obj1710.preAction( self.RHS.CREATE )
self.obj1710.isGraphObjectVisual = True
if(hasattr(self.obj1710, '_setHierarchicalLink')):
self.obj1710._setHierarchicalLink(False)
# name
self.obj1710.name.setValue('')
self.obj1710.name.setNone()
self.obj1710.GGLabel.setValue(2)
self.obj1710.graphClass_= graph_Role
if parent.genGraphics:
new_obj = graph_Role(280.0,140.0,self.obj1710)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1710.graphObject_ = new_obj
self.obj17100= AttrCalc()
self.obj17100.Copy=ATOM3Boolean()
self.obj17100.Copy.setValue(('Copy from LHS', 1))
self.obj17100.Copy.config = 0
self.obj17100.Specify=ATOM3Constraint()
self.obj17100.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.obj1710.GGset2Any['name']= self.obj17100
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1710)
self.obj1710.postAction( self.RHS.CREATE )
self.obj1711=achieve(parent)
self.obj1711.preAction( self.RHS.CREATE )
self.obj1711.isGraphObjectVisual = True
if(hasattr(self.obj1711, '_setHierarchicalLink')):
self.obj1711._setHierarchicalLink(False)
# rate
self.obj1711.rate.setNone()
self.obj1711.GGLabel.setValue(5)
self.obj1711.graphClass_= graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(258.5,259.0,self.obj1711)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1711.graphObject_ = new_obj
self.obj17110= AttrCalc()
self.obj17110.Copy=ATOM3Boolean()
self.obj17110.Copy.setValue(('Copy from LHS', 1))
self.obj17110.Copy.config = 0
self.obj17110.Specify=ATOM3Constraint()
self.obj17110.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.obj1711.GGset2Any['rate']= self.obj17110
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1711)
self.obj1711.postAction( self.RHS.CREATE )
self.obj1712=GenericGraphEdge(parent)
self.obj1712.preAction( self.RHS.CREATE )
self.obj1712.isGraphObjectVisual = True
if(hasattr(self.obj1712, '_setHierarchicalLink')):
self.obj1712._setHierarchicalLink(False)
self.obj1712.GGLabel.setValue(10)
self.obj1712.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(358.5,131.0,self.obj1712)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1712.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1712)
self.obj1712.postAction( self.RHS.CREATE )
self.obj1704.out_connections_.append(self.obj1706)
self.obj1706.in_connections_.append(self.obj1704)
self.obj1704.graphObject_.pendingConnections.append((self.obj1704.graphObject_.tag, self.obj1706.graphObject_.tag, [424.0, 129.0, 422.0, 190.0], 0, True))
self.obj1706.out_connections_.append(self.obj1705)
self.obj1705.in_connections_.append(self.obj1706)
self.obj1706.graphObject_.pendingConnections.append((self.obj1706.graphObject_.tag, self.obj1705.graphObject_.tag, [420.0, 251.0, 422.0, 190.0], 0, True))
self.obj1707.out_connections_.append(self.obj1710)
self.obj1710.in_connections_.append(self.obj1707)
self.obj1707.graphObject_.pendingConnections.append((self.obj1707.graphObject_.tag, self.obj1710.graphObject_.tag, [311.0, 140.0, 250.75, 110.75], 2, 0))
self.obj1709.out_connections_.append(self.obj1707)
self.obj1707.in_connections_.append(self.obj1709)
self.obj1709.graphObject_.pendingConnections.append((self.obj1709.graphObject_.tag, self.obj1707.graphObject_.tag, [117.0, 102.0, 250.75, 110.75], 2, 0))
self.obj1710.out_connections_.append(self.obj1711)
self.obj1711.in_connections_.append(self.obj1710)
self.obj1710.graphObject_.pendingConnections.append((self.obj1710.graphObject_.tag, self.obj1711.graphObject_.tag, [311.0, 185.0, 258.5, 259.0], 2, 0))
self.obj1710.out_connections_.append(self.obj1712)
self.obj1712.in_connections_.append(self.obj1710)
self.obj1710.graphObject_.pendingConnections.append((self.obj1710.graphObject_.tag, self.obj1712.graphObject_.tag, [311.0, 140.0, 358.5, 131.0], 0, True))
self.obj1711.out_connections_.append(self.obj1708)
self.obj1708.in_connections_.append(self.obj1711)
self.obj1711.graphObject_.pendingConnections.append((self.obj1711.graphObject_.tag, self.obj1708.graphObject_.tag, [134.0, 290.0, 258.5, 259.0], 2, 0))
self.obj1712.out_connections_.append(self.obj1704)
self.obj1704.in_connections_.append(self.obj1712)
self.obj1712.graphObject_.pendingConnections.append((self.obj1712.graphObject_.tag, self.obj1704.graphObject_.tag, [406.0, 122.0, 358.5, 131.0], 0, True))
def __init__(self, parent):
GGrule.__init__(self, 12)
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.obj1651 = rawMaterial(parent)
self.obj1651.preAction(self.LHS.CREATE)
self.obj1651.isGraphObjectVisual = True
if (hasattr(self.obj1651, '_setHierarchicalLink')):
self.obj1651._setHierarchicalLink(False)
# MaxFlow
self.obj1651.MaxFlow.setValue(999999)
# price
self.obj1651.price.setValue(0)
# Name
self.obj1651.Name.setValue('')
self.obj1651.Name.setNone()
# ReqFlow
self.obj1651.ReqFlow.setValue(0)
self.obj1651.GGLabel.setValue(3)
self.obj1651.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(220.0, 20.0, self.obj1651)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1651.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1651)
self.obj1651.postAction(self.LHS.CREATE)
self.obj1652 = operatingUnit(parent)
self.obj1652.preAction(self.LHS.CREATE)
self.obj1652.isGraphObjectVisual = True
if (hasattr(self.obj1652, '_setHierarchicalLink')):
self.obj1652._setHierarchicalLink(False)
# OperCostProp
self.obj1652.OperCostProp.setValue(0.0)
# name
self.obj1652.name.setValue('')
self.obj1652.name.setNone()
# OperCostFix
self.obj1652.OperCostFix.setValue(0.0)
self.obj1652.GGLabel.setValue(2)
self.obj1652.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(260.0, 160.0, self.obj1652)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1652.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1652)
self.obj1652.postAction(self.LHS.CREATE)
self.obj1653 = Agent(parent)
self.obj1653.preAction(self.LHS.CREATE)
self.obj1653.isGraphObjectVisual = True
if (hasattr(self.obj1653, '_setHierarchicalLink')):
self.obj1653._setHierarchicalLink(False)
# price
self.obj1653.price.setNone()
# name
self.obj1653.name.setValue('')
self.obj1653.name.setNone()
self.obj1653.GGLabel.setValue(1)
self.obj1653.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(80.0, 120.0, self.obj1653)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1653.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1653)
self.obj1653.postAction(self.LHS.CREATE)
self.obj1654 = GenericGraphEdge(parent)
self.obj1654.preAction(self.LHS.CREATE)
self.obj1654.isGraphObjectVisual = True
if (hasattr(self.obj1654, '_setHierarchicalLink')):
self.obj1654._setHierarchicalLink(False)
self.obj1654.GGLabel.setValue(4)
self.obj1654.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(181.75, 114.0, self.obj1654)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1654.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1654)
self.obj1654.postAction(self.LHS.CREATE)
self.obj1655 = GenericGraphEdge(parent)
self.obj1655.preAction(self.LHS.CREATE)
self.obj1655.isGraphObjectVisual = True
if (hasattr(self.obj1655, '_setHierarchicalLink')):
self.obj1655._setHierarchicalLink(False)
self.obj1655.GGLabel.setValue(5)
self.obj1655.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(229.25, 150.25, self.obj1655)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1655.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1655)
self.obj1655.postAction(self.LHS.CREATE)
self.obj1653.out_connections_.append(self.obj1654)
self.obj1654.in_connections_.append(self.obj1653)
self.obj1653.graphObject_.pendingConnections.append(
(self.obj1653.graphObject_.tag, self.obj1654.graphObject_.tag,
[105.0, 182.0, 147.0, 140.5, 181.75, 114.0], 2, True))
self.obj1653.out_connections_.append(self.obj1655)
self.obj1655.in_connections_.append(self.obj1653)
self.obj1653.graphObject_.pendingConnections.append(
(self.obj1653.graphObject_.tag, self.obj1655.graphObject_.tag,
[105.0, 182.0, 185.5, 153.0, 229.25, 150.25], 2, True))
self.obj1654.out_connections_.append(self.obj1651)
self.obj1651.in_connections_.append(self.obj1654)
self.obj1654.graphObject_.pendingConnections.append(
(self.obj1654.graphObject_.tag, self.obj1651.graphObject_.tag,
[244.0, 76.0, 216.5, 87.5, 181.75, 114.0], 2, True))
self.obj1655.out_connections_.append(self.obj1652)
self.obj1652.in_connections_.append(self.obj1655)
self.obj1655.graphObject_.pendingConnections.append(
(self.obj1655.graphObject_.tag, self.obj1652.graphObject_.tag,
[280.0, 171.0, 273.0, 147.5, 229.25, 150.25], 2, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1659 = rawMaterial(parent)
self.obj1659.preAction(self.RHS.CREATE)
self.obj1659.isGraphObjectVisual = True
if (hasattr(self.obj1659, '_setHierarchicalLink')):
self.obj1659._setHierarchicalLink(False)
# MaxFlow
self.obj1659.MaxFlow.setValue(999999)
# price
self.obj1659.price.setValue(0)
# Name
self.obj1659.Name.setValue('')
self.obj1659.Name.setNone()
# ReqFlow
self.obj1659.ReqFlow.setValue(0)
self.obj1659.GGLabel.setValue(3)
self.obj1659.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(220.0, 20.0, self.obj1659)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1659.graphObject_ = new_obj
self.obj16590 = AttrCalc()
self.obj16590.Copy = ATOM3Boolean()
self.obj16590.Copy.setValue(('Copy from LHS', 1))
self.obj16590.Copy.config = 0
self.obj16590.Specify = ATOM3Constraint()
self.obj16590.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.obj1659.GGset2Any['MaxFlow'] = self.obj16590
self.obj16591 = AttrCalc()
self.obj16591.Copy = ATOM3Boolean()
self.obj16591.Copy.setValue(('Copy from LHS', 1))
self.obj16591.Copy.config = 0
self.obj16591.Specify = ATOM3Constraint()
self.obj16591.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.obj1659.GGset2Any['Name'] = self.obj16591
self.obj16592 = AttrCalc()
self.obj16592.Copy = ATOM3Boolean()
self.obj16592.Copy.setValue(('Copy from LHS', 1))
self.obj16592.Copy.config = 0
self.obj16592.Specify = ATOM3Constraint()
self.obj16592.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.obj1659.GGset2Any['ReqFlow'] = self.obj16592
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1659)
self.obj1659.postAction(self.RHS.CREATE)
self.obj1660 = operatingUnit(parent)
self.obj1660.preAction(self.RHS.CREATE)
self.obj1660.isGraphObjectVisual = True
if (hasattr(self.obj1660, '_setHierarchicalLink')):
self.obj1660._setHierarchicalLink(False)
# OperCostProp
self.obj1660.OperCostProp.setValue(0.0)
# name
self.obj1660.name.setValue('')
self.obj1660.name.setNone()
# OperCostFix
self.obj1660.OperCostFix.setValue(0.0)
self.obj1660.GGLabel.setValue(2)
self.obj1660.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(260.0, 160.0, self.obj1660)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1660.graphObject_ = new_obj
self.obj16600 = AttrCalc()
self.obj16600.Copy = ATOM3Boolean()
self.obj16600.Copy.setValue(('Copy from LHS', 1))
self.obj16600.Copy.config = 0
self.obj16600.Specify = ATOM3Constraint()
self.obj16600.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.obj1660.GGset2Any['OperCostProp'] = self.obj16600
self.obj16601 = AttrCalc()
self.obj16601.Copy = ATOM3Boolean()
self.obj16601.Copy.setValue(('Copy from LHS', 1))
self.obj16601.Copy.config = 0
self.obj16601.Specify = ATOM3Constraint()
self.obj16601.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.obj1660.GGset2Any['name'] = self.obj16601
self.obj16602 = AttrCalc()
self.obj16602.Copy = ATOM3Boolean()
self.obj16602.Copy.setValue(('Copy from LHS', 1))
self.obj16602.Copy.config = 0
self.obj16602.Specify = ATOM3Constraint()
self.obj16602.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.obj1660.GGset2Any['OperCostFix'] = self.obj16602
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1660)
self.obj1660.postAction(self.RHS.CREATE)
self.obj1661 = fromRaw(parent)
self.obj1661.preAction(self.RHS.CREATE)
self.obj1661.isGraphObjectVisual = True
if (hasattr(self.obj1661, '_setHierarchicalLink')):
self.obj1661._setHierarchicalLink(False)
# rate
self.obj1661.rate.setValue(1.0)
self.obj1661.GGLabel.setValue(7)
self.obj1661.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(262.0, 115.5, self.obj1661)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1661.graphObject_ = new_obj
self.obj16610 = AttrCalc()
self.obj16610.Copy = ATOM3Boolean()
self.obj16610.Copy.setValue(('Copy from LHS', 0))
self.obj16610.Copy.config = 0
self.obj16610.Specify = ATOM3Constraint()
self.obj16610.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.obj1661.GGset2Any['rate'] = self.obj16610
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1661)
self.obj1661.postAction(self.RHS.CREATE)
self.obj1662 = Agent(parent)
self.obj1662.preAction(self.RHS.CREATE)
self.obj1662.isGraphObjectVisual = True
if (hasattr(self.obj1662, '_setHierarchicalLink')):
self.obj1662._setHierarchicalLink(False)
# price
self.obj1662.price.setNone()
# name
self.obj1662.name.setValue('')
self.obj1662.name.setNone()
self.obj1662.GGLabel.setValue(1)
self.obj1662.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(80.0, 120.0, self.obj1662)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1662.graphObject_ = new_obj
self.obj16620 = AttrCalc()
self.obj16620.Copy = ATOM3Boolean()
self.obj16620.Copy.setValue(('Copy from LHS', 1))
self.obj16620.Copy.config = 0
self.obj16620.Specify = ATOM3Constraint()
self.obj16620.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.obj1662.GGset2Any['price'] = self.obj16620
self.obj16621 = AttrCalc()
self.obj16621.Copy = ATOM3Boolean()
self.obj16621.Copy.setValue(('Copy from LHS', 1))
self.obj16621.Copy.config = 0
self.obj16621.Specify = ATOM3Constraint()
self.obj16621.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.obj1662.GGset2Any['name'] = self.obj16621
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1662)
self.obj1662.postAction(self.RHS.CREATE)
self.obj1663 = GenericGraphEdge(parent)
self.obj1663.preAction(self.RHS.CREATE)
self.obj1663.isGraphObjectVisual = True
if (hasattr(self.obj1663, '_setHierarchicalLink')):
self.obj1663._setHierarchicalLink(False)
self.obj1663.GGLabel.setValue(4)
self.obj1663.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(181.75, 114.0, self.obj1663)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1663.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1663)
self.obj1663.postAction(self.RHS.CREATE)
self.obj1664 = GenericGraphEdge(parent)
self.obj1664.preAction(self.RHS.CREATE)
self.obj1664.isGraphObjectVisual = True
if (hasattr(self.obj1664, '_setHierarchicalLink')):
self.obj1664._setHierarchicalLink(False)
self.obj1664.GGLabel.setValue(5)
self.obj1664.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(229.25, 150.25, self.obj1664)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1664.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1664)
self.obj1664.postAction(self.RHS.CREATE)
self.obj1659.out_connections_.append(self.obj1661)
self.obj1661.in_connections_.append(self.obj1659)
self.obj1659.graphObject_.pendingConnections.append(
(self.obj1659.graphObject_.tag, self.obj1661.graphObject_.tag,
[244.0, 70.0, 262.0, 115.5], 0, True))
self.obj1661.out_connections_.append(self.obj1660)
self.obj1660.in_connections_.append(self.obj1661)
self.obj1661.graphObject_.pendingConnections.append(
(self.obj1661.graphObject_.tag, self.obj1660.graphObject_.tag,
[280.0, 161.0, 262.0, 115.5], 0, True))
self.obj1662.out_connections_.append(self.obj1663)
self.obj1663.in_connections_.append(self.obj1662)
self.obj1662.graphObject_.pendingConnections.append(
(self.obj1662.graphObject_.tag, self.obj1663.graphObject_.tag,
[117.0, 182.0, 181.75, 114.0], 2, 0))
self.obj1662.out_connections_.append(self.obj1664)
self.obj1664.in_connections_.append(self.obj1662)
self.obj1662.graphObject_.pendingConnections.append(
(self.obj1662.graphObject_.tag, self.obj1664.graphObject_.tag,
[117.0, 182.0, 229.25, 150.25], 2, 0))
self.obj1663.out_connections_.append(self.obj1659)
self.obj1659.in_connections_.append(self.obj1663)
self.obj1663.graphObject_.pendingConnections.append(
(self.obj1663.graphObject_.tag, self.obj1659.graphObject_.tag,
[244.0, 70.0, 181.75, 114.0], 2, 0))
self.obj1664.out_connections_.append(self.obj1660)
self.obj1660.in_connections_.append(self.obj1664)
self.obj1664.graphObject_.pendingConnections.append(
(self.obj1664.graphObject_.tag, self.obj1660.graphObject_.tag,
[280.0, 161.0, 229.25, 150.25], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 26)
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.obj1826 = rawMaterial(parent)
self.obj1826.preAction(self.LHS.CREATE)
self.obj1826.isGraphObjectVisual = True
if (hasattr(self.obj1826, '_setHierarchicalLink')):
self.obj1826._setHierarchicalLink(False)
# MaxFlow
self.obj1826.MaxFlow.setNone()
# price
self.obj1826.price.setNone()
# Name
self.obj1826.Name.setValue('')
self.obj1826.Name.setNone()
# ReqFlow
self.obj1826.ReqFlow.setNone()
self.obj1826.GGLabel.setValue(2)
self.obj1826.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(260.0, 40.0, self.obj1826)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1826.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1826)
self.obj1826.postAction(self.LHS.CREATE)
self.obj1827 = operatingUnit(parent)
self.obj1827.preAction(self.LHS.CREATE)
self.obj1827.isGraphObjectVisual = True
if (hasattr(self.obj1827, '_setHierarchicalLink')):
self.obj1827._setHierarchicalLink(False)
# OperCostProp
self.obj1827.OperCostProp.setNone()
# name
self.obj1827.name.setValue('')
self.obj1827.name.setNone()
# OperCostFix
self.obj1827.OperCostFix.setNone()
self.obj1827.GGLabel.setValue(3)
self.obj1827.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(280.0, 140.0, self.obj1827)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1827.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1827)
self.obj1827.postAction(self.LHS.CREATE)
self.obj1828 = fromRaw(parent)
self.obj1828.preAction(self.LHS.CREATE)
self.obj1828.isGraphObjectVisual = True
if (hasattr(self.obj1828, '_setHierarchicalLink')):
self.obj1828._setHierarchicalLink(False)
# rate
self.obj1828.rate.setNone()
self.obj1828.GGLabel.setValue(5)
self.obj1828.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(292.0, 123.5, self.obj1828)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1828.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1828)
self.obj1828.postAction(self.LHS.CREATE)
self.obj1829 = Agent(parent)
self.obj1829.preAction(self.LHS.CREATE)
self.obj1829.isGraphObjectVisual = True
if (hasattr(self.obj1829, '_setHierarchicalLink')):
self.obj1829._setHierarchicalLink(False)
# price
self.obj1829.price.setNone()
# name
self.obj1829.name.setValue('')
self.obj1829.name.setNone()
self.obj1829.GGLabel.setValue(1)
self.obj1829.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(60.0, 60.0, self.obj1829)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1829.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1829)
self.obj1829.postAction(self.LHS.CREATE)
self.obj1830 = GenericGraphEdge(parent)
self.obj1830.preAction(self.LHS.CREATE)
self.obj1830.isGraphObjectVisual = True
if (hasattr(self.obj1830, '_setHierarchicalLink')):
self.obj1830._setHierarchicalLink(False)
self.obj1830.GGLabel.setValue(4)
self.obj1830.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(184.5, 109.0, self.obj1830)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1830.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1830)
self.obj1830.postAction(self.LHS.CREATE)
self.obj1831 = GenericGraphEdge(parent)
self.obj1831.preAction(self.LHS.CREATE)
self.obj1831.isGraphObjectVisual = True
if (hasattr(self.obj1831, '_setHierarchicalLink')):
self.obj1831._setHierarchicalLink(False)
self.obj1831.GGLabel.setValue(6)
self.obj1831.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(159.0, 150.5, self.obj1831)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1831.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1831)
self.obj1831.postAction(self.LHS.CREATE)
self.obj1826.out_connections_.append(self.obj1828)
self.obj1828.in_connections_.append(self.obj1826)
self.obj1826.graphObject_.pendingConnections.append(
(self.obj1826.graphObject_.tag, self.obj1828.graphObject_.tag,
[284.0, 96.0, 292.0, 123.5], 0, True))
self.obj1828.out_connections_.append(self.obj1827)
self.obj1827.in_connections_.append(self.obj1828)
self.obj1828.graphObject_.pendingConnections.append(
(self.obj1828.graphObject_.tag, self.obj1827.graphObject_.tag,
[300.0, 151.0, 292.0, 123.5], 0, True))
self.obj1829.out_connections_.append(self.obj1830)
self.obj1830.in_connections_.append(self.obj1829)
self.obj1829.graphObject_.pendingConnections.append(
(self.obj1829.graphObject_.tag, self.obj1830.graphObject_.tag,
[85.0, 122.0, 184.5, 109.0], 0, True))
self.obj1829.out_connections_.append(self.obj1831)
self.obj1831.in_connections_.append(self.obj1829)
self.obj1829.graphObject_.pendingConnections.append(
(self.obj1829.graphObject_.tag, self.obj1831.graphObject_.tag,
[85.0, 122.0, 105.5, 141.5, 159.0, 150.5], 2, True))
self.obj1830.out_connections_.append(self.obj1826)
self.obj1826.in_connections_.append(self.obj1830)
self.obj1830.graphObject_.pendingConnections.append(
(self.obj1830.graphObject_.tag, self.obj1826.graphObject_.tag,
[284.0, 96.0, 184.5, 109.0], 0, True))
self.obj1831.out_connections_.append(self.obj1827)
self.obj1827.in_connections_.append(self.obj1831)
self.obj1831.graphObject_.pendingConnections.append(
(self.obj1831.graphObject_.tag, self.obj1827.graphObject_.tag,
[299.0, 158.0, 212.5, 159.5, 159.0, 150.5], 2, True))
self.RHS = ASG_pns(parent)
self.obj1833 = rawMaterial(parent)
self.obj1833.preAction(self.RHS.CREATE)
self.obj1833.isGraphObjectVisual = True
if (hasattr(self.obj1833, '_setHierarchicalLink')):
self.obj1833._setHierarchicalLink(False)
# MaxFlow
self.obj1833.MaxFlow.setValue(999999)
# price
self.obj1833.price.setValue(0)
# Name
self.obj1833.Name.setValue('')
self.obj1833.Name.setNone()
# ReqFlow
self.obj1833.ReqFlow.setValue(0)
self.obj1833.GGLabel.setValue(2)
self.obj1833.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(160.0, 40.0, self.obj1833)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['Text Scale'] = 1.0
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1833.graphObject_ = new_obj
self.obj18330 = AttrCalc()
self.obj18330.Copy = ATOM3Boolean()
self.obj18330.Copy.setValue(('Copy from LHS', 1))
self.obj18330.Copy.config = 0
self.obj18330.Specify = ATOM3Constraint()
self.obj18330.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.obj1833.GGset2Any['MaxFlow'] = self.obj18330
self.obj18331 = AttrCalc()
self.obj18331.Copy = ATOM3Boolean()
self.obj18331.Copy.setValue(('Copy from LHS', 0))
self.obj18331.Copy.config = 0
self.obj18331.Specify = ATOM3Constraint()
self.obj18331.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(1)).price.getValue()\n'
))
self.obj1833.GGset2Any['price'] = self.obj18331
self.obj18332 = AttrCalc()
self.obj18332.Copy = ATOM3Boolean()
self.obj18332.Copy.setValue(('Copy from LHS', 1))
self.obj18332.Copy.config = 0
self.obj18332.Specify = ATOM3Constraint()
self.obj18332.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.obj1833.GGset2Any['Name'] = self.obj18332
self.obj18333 = AttrCalc()
self.obj18333.Copy = ATOM3Boolean()
self.obj18333.Copy.setValue(('Copy from LHS', 1))
self.obj18333.Copy.config = 0
self.obj18333.Specify = ATOM3Constraint()
self.obj18333.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.obj1833.GGset2Any['ReqFlow'] = self.obj18333
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1833)
self.obj1833.postAction(self.RHS.CREATE)
self.obj1834 = operatingUnit(parent)
self.obj1834.preAction(self.RHS.CREATE)
self.obj1834.isGraphObjectVisual = True
if (hasattr(self.obj1834, '_setHierarchicalLink')):
self.obj1834._setHierarchicalLink(False)
# OperCostProp
self.obj1834.OperCostProp.setValue(0.0)
# name
self.obj1834.name.setValue('')
self.obj1834.name.setNone()
# OperCostFix
self.obj1834.OperCostFix.setValue(0.0)
self.obj1834.GGLabel.setValue(3)
self.obj1834.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(120.0, 160.0, self.obj1834)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1834.graphObject_ = new_obj
self.obj18340 = AttrCalc()
self.obj18340.Copy = ATOM3Boolean()
self.obj18340.Copy.setValue(('Copy from LHS', 1))
self.obj18340.Copy.config = 0
self.obj18340.Specify = ATOM3Constraint()
self.obj18340.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.obj1834.GGset2Any['OperCostProp'] = self.obj18340
self.obj18341 = AttrCalc()
self.obj18341.Copy = ATOM3Boolean()
self.obj18341.Copy.setValue(('Copy from LHS', 1))
self.obj18341.Copy.config = 0
self.obj18341.Specify = ATOM3Constraint()
self.obj18341.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.obj1834.GGset2Any['name'] = self.obj18341
self.obj18342 = AttrCalc()
self.obj18342.Copy = ATOM3Boolean()
self.obj18342.Copy.setValue(('Copy from LHS', 1))
self.obj18342.Copy.config = 0
self.obj18342.Specify = ATOM3Constraint()
self.obj18342.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.obj1834.GGset2Any['OperCostFix'] = self.obj18342
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1834)
self.obj1834.postAction(self.RHS.CREATE)
self.obj1835 = fromRaw(parent)
self.obj1835.preAction(self.RHS.CREATE)
self.obj1835.isGraphObjectVisual = True
if (hasattr(self.obj1835, '_setHierarchicalLink')):
self.obj1835._setHierarchicalLink(False)
# rate
self.obj1835.rate.setValue(0.0)
self.obj1835.GGLabel.setValue(5)
self.obj1835.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(177.0, 133.5, self.obj1835)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1835.graphObject_ = new_obj
self.obj18350 = AttrCalc()
self.obj18350.Copy = ATOM3Boolean()
self.obj18350.Copy.setValue(('Copy from LHS', 1))
self.obj18350.Copy.config = 0
self.obj18350.Specify = ATOM3Constraint()
self.obj18350.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.obj1835.GGset2Any['rate'] = self.obj18350
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1835)
self.obj1835.postAction(self.RHS.CREATE)
self.obj1833.out_connections_.append(self.obj1835)
self.obj1835.in_connections_.append(self.obj1833)
self.obj1833.graphObject_.pendingConnections.append(
(self.obj1833.graphObject_.tag, self.obj1835.graphObject_.tag,
[184.0, 96.0, 177.0, 133.5], 0, True))
self.obj1835.out_connections_.append(self.obj1834)
self.obj1834.in_connections_.append(self.obj1835)
self.obj1835.graphObject_.pendingConnections.append(
(self.obj1835.graphObject_.tag, self.obj1834.graphObject_.tag,
[170.0, 171.0, 177.0, 133.5], 0, True))
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 __init__(self, parent):
GGrule.__init__(self, 7)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.obj976 = metarial(parent)
self.obj976.preAction(self.LHS.CREATE)
self.obj976.isGraphObjectVisual = True
if (hasattr(self.obj976, '_setHierarchicalLink')):
self.obj976._setHierarchicalLink(False)
# MaxFlow
self.obj976.MaxFlow.setNone()
# price
self.obj976.price.setNone()
# Name
self.obj976.Name.setValue('')
self.obj976.Name.setNone()
# ReqFlow
self.obj976.ReqFlow.setNone()
self.obj976.GGLabel.setValue(1)
self.obj976.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(200.0, 20.0, self.obj976)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj976.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj976)
self.obj976.postAction(self.LHS.CREATE)
self.obj977 = operatingUnit(parent)
self.obj977.preAction(self.LHS.CREATE)
self.obj977.isGraphObjectVisual = True
if (hasattr(self.obj977, '_setHierarchicalLink')):
self.obj977._setHierarchicalLink(False)
# OperCostProp
self.obj977.OperCostProp.setNone()
# name
self.obj977.name.setValue('')
self.obj977.name.setNone()
# OperCostFix
self.obj977.OperCostFix.setNone()
self.obj977.GGLabel.setValue(2)
self.obj977.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(220.0, 160.0, self.obj977)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj977.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj977)
self.obj977.postAction(self.LHS.CREATE)
self.obj978 = fromMaterial(parent)
self.obj978.preAction(self.LHS.CREATE)
self.obj978.isGraphObjectVisual = True
if (hasattr(self.obj978, '_setHierarchicalLink')):
self.obj978._setHierarchicalLink(False)
# rate
self.obj978.rate.setNone()
self.obj978.GGLabel.setValue(3)
self.obj978.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(232.0, 120.0, self.obj978)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj978.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj978)
self.obj978.postAction(self.LHS.CREATE)
self.obj976.out_connections_.append(self.obj978)
self.obj978.in_connections_.append(self.obj976)
self.obj976.graphObject_.pendingConnections.append(
(self.obj976.graphObject_.tag, self.obj978.graphObject_.tag,
[224.0, 69.0, 232.0, 120.0], 0, True))
self.obj978.out_connections_.append(self.obj977)
self.obj977.in_connections_.append(self.obj978)
self.obj978.graphObject_.pendingConnections.append(
(self.obj978.graphObject_.tag, self.obj977.graphObject_.tag,
[240.0, 171.0, 232.0, 120.0], 0, True))
self.RHS = ASG_pns(parent)
self.obj980 = metarial(parent)
self.obj980.preAction(self.RHS.CREATE)
self.obj980.isGraphObjectVisual = True
if (hasattr(self.obj980, '_setHierarchicalLink')):
self.obj980._setHierarchicalLink(False)
# MaxFlow
self.obj980.MaxFlow.setNone()
# price
self.obj980.price.setNone()
# Name
self.obj980.Name.setValue('')
self.obj980.Name.setNone()
# ReqFlow
self.obj980.ReqFlow.setNone()
self.obj980.GGLabel.setValue(1)
self.obj980.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(200.0, 20.0, self.obj980)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj980.graphObject_ = new_obj
self.obj9800 = AttrCalc()
self.obj9800.Copy = ATOM3Boolean()
self.obj9800.Copy.setValue(('Copy from LHS', 1))
self.obj9800.Copy.config = 0
self.obj9800.Specify = ATOM3Constraint()
self.obj9800.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.obj980.GGset2Any['MaxFlow'] = self.obj9800
self.obj9801 = AttrCalc()
self.obj9801.Copy = ATOM3Boolean()
self.obj9801.Copy.setValue(('Copy from LHS', 1))
self.obj9801.Copy.config = 0
self.obj9801.Specify = ATOM3Constraint()
self.obj9801.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.obj980.GGset2Any['price'] = self.obj9801
self.obj9802 = AttrCalc()
self.obj9802.Copy = ATOM3Boolean()
self.obj9802.Copy.setValue(('Copy from LHS', 1))
self.obj9802.Copy.config = 0
self.obj9802.Specify = ATOM3Constraint()
self.obj9802.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.obj980.GGset2Any['Name'] = self.obj9802
self.obj9803 = AttrCalc()
self.obj9803.Copy = ATOM3Boolean()
self.obj9803.Copy.setValue(('Copy from LHS', 1))
self.obj9803.Copy.config = 0
self.obj9803.Specify = ATOM3Constraint()
self.obj9803.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.obj980.GGset2Any['ReqFlow'] = self.obj9803
# Add node to the root: self.RHS
self.RHS.addNode(self.obj980)
self.obj980.postAction(self.RHS.CREATE)
self.obj981 = operatingUnit(parent)
self.obj981.preAction(self.RHS.CREATE)
self.obj981.isGraphObjectVisual = True
if (hasattr(self.obj981, '_setHierarchicalLink')):
self.obj981._setHierarchicalLink(False)
# OperCostProp
self.obj981.OperCostProp.setNone()
# name
self.obj981.name.setValue('')
self.obj981.name.setNone()
# OperCostFix
self.obj981.OperCostFix.setNone()
self.obj981.GGLabel.setValue(2)
self.obj981.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(220.0, 160.0, self.obj981)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj981.graphObject_ = new_obj
self.obj9810 = AttrCalc()
self.obj9810.Copy = ATOM3Boolean()
self.obj9810.Copy.setValue(('Copy from LHS', 1))
self.obj9810.Copy.config = 0
self.obj9810.Specify = ATOM3Constraint()
self.obj9810.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.obj981.GGset2Any['OperCostProp'] = self.obj9810
self.obj9811 = AttrCalc()
self.obj9811.Copy = ATOM3Boolean()
self.obj9811.Copy.setValue(('Copy from LHS', 1))
self.obj9811.Copy.config = 0
self.obj9811.Specify = ATOM3Constraint()
self.obj9811.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.obj981.GGset2Any['name'] = self.obj9811
self.obj9812 = AttrCalc()
self.obj9812.Copy = ATOM3Boolean()
self.obj9812.Copy.setValue(('Copy from LHS', 1))
self.obj9812.Copy.config = 0
self.obj9812.Specify = ATOM3Constraint()
self.obj9812.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.obj981.GGset2Any['OperCostFix'] = self.obj9812
# Add node to the root: self.RHS
self.RHS.addNode(self.obj981)
self.obj981.postAction(self.RHS.CREATE)
self.obj982 = fromMaterial(parent)
self.obj982.preAction(self.RHS.CREATE)
self.obj982.isGraphObjectVisual = True
if (hasattr(self.obj982, '_setHierarchicalLink')):
self.obj982._setHierarchicalLink(False)
# rate
self.obj982.rate.setNone()
self.obj982.GGLabel.setValue(3)
self.obj982.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(232.0, 120.0, self.obj982)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj982.graphObject_ = new_obj
self.obj9820 = AttrCalc()
self.obj9820.Copy = ATOM3Boolean()
self.obj9820.Copy.setValue(('Copy from LHS', 1))
self.obj9820.Copy.config = 0
self.obj9820.Specify = ATOM3Constraint()
self.obj9820.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.obj982.GGset2Any['rate'] = self.obj9820
# Add node to the root: self.RHS
self.RHS.addNode(self.obj982)
self.obj982.postAction(self.RHS.CREATE)
self.obj980.out_connections_.append(self.obj982)
self.obj982.in_connections_.append(self.obj980)
self.obj980.graphObject_.pendingConnections.append(
(self.obj980.graphObject_.tag, self.obj982.graphObject_.tag,
[224.0, 69.0, 232.0, 120.0], 2, 0))
self.obj982.out_connections_.append(self.obj981)
self.obj981.in_connections_.append(self.obj982)
self.obj982.graphObject_.pendingConnections.append(
(self.obj982.graphObject_.tag, self.obj981.graphObject_.tag,
[270.0, 161.0, 232.0, 120.0], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 1)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.obj107=rawMaterial(parent)
self.obj107.preAction( self.LHS.CREATE )
self.obj107.isGraphObjectVisual = True
if(hasattr(self.obj107, '_setHierarchicalLink')):
self.obj107._setHierarchicalLink(False)
# MaxFlow
self.obj107.MaxFlow.setNone()
# price
self.obj107.price.setNone()
# Name
self.obj107.Name.setValue('')
self.obj107.Name.setNone()
# ReqFlow
self.obj107.ReqFlow.setNone()
self.obj107.GGLabel.setValue(1)
self.obj107.graphClass_= graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(60.0,20.0,self.obj107)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj107.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj107)
self.obj107.postAction( self.LHS.CREATE )
self.obj108=metarial(parent)
self.obj108.preAction( self.LHS.CREATE )
self.obj108.isGraphObjectVisual = True
if(hasattr(self.obj108, '_setHierarchicalLink')):
self.obj108._setHierarchicalLink(False)
# MaxFlow
self.obj108.MaxFlow.setNone()
# price
self.obj108.price.setNone()
# Name
self.obj108.Name.setValue('')
self.obj108.Name.setNone()
# ReqFlow
self.obj108.ReqFlow.setNone()
self.obj108.GGLabel.setValue(4)
self.obj108.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(360.0,160.0,self.obj108)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj108.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj108)
self.obj108.postAction( self.LHS.CREATE )
self.obj109=operatingUnit(parent)
self.obj109.preAction( self.LHS.CREATE )
self.obj109.isGraphObjectVisual = True
if(hasattr(self.obj109, '_setHierarchicalLink')):
self.obj109._setHierarchicalLink(False)
# OperCostProp
self.obj109.OperCostProp.setNone()
# name
self.obj109.name.setValue('')
self.obj109.name.setNone()
# OperCostFix
self.obj109.OperCostFix.setNone()
self.obj109.GGLabel.setValue(2)
self.obj109.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(180.0,120.0,self.obj109)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj109.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj109)
self.obj109.postAction( self.LHS.CREATE )
self.obj110=fromRaw(parent)
self.obj110.preAction( self.LHS.CREATE )
self.obj110.isGraphObjectVisual = True
if(hasattr(self.obj110, '_setHierarchicalLink')):
self.obj110._setHierarchicalLink(False)
# rate
self.obj110.rate.setNone()
self.obj110.GGLabel.setValue(3)
self.obj110.graphClass_= graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(135.5,78.0,self.obj110)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj110.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj110)
self.obj110.postAction( self.LHS.CREATE )
self.obj111=intoMaterial(parent)
self.obj111.preAction( self.LHS.CREATE )
self.obj111.isGraphObjectVisual = True
if(hasattr(self.obj111, '_setHierarchicalLink')):
self.obj111._setHierarchicalLink(False)
# rate
self.obj111.rate.setNone()
self.obj111.GGLabel.setValue(5)
self.obj111.graphClass_= graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(291.5,140.5,self.obj111)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj111.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj111)
self.obj111.postAction( self.LHS.CREATE )
self.obj107.out_connections_.append(self.obj110)
self.obj110.in_connections_.append(self.obj107)
self.obj107.graphObject_.pendingConnections.append((self.obj107.graphObject_.tag, self.obj110.graphObject_.tag, [84.0, 76.0, 84.0, 118.0, 135.5, 78.0], 2, True))
self.obj109.out_connections_.append(self.obj111)
self.obj111.in_connections_.append(self.obj109)
self.obj109.graphObject_.pendingConnections.append((self.obj109.graphObject_.tag, self.obj111.graphObject_.tag, [233.0, 138.0, 212.0, 177.0, 291.5, 140.5], 2, True))
self.obj110.out_connections_.append(self.obj109)
self.obj109.in_connections_.append(self.obj110)
self.obj110.graphObject_.pendingConnections.append((self.obj110.graphObject_.tag, self.obj109.graphObject_.tag, [200.0, 131.0, 187.0, 38.0, 135.5, 78.0], 2, True))
self.obj111.out_connections_.append(self.obj108)
self.obj108.in_connections_.append(self.obj111)
self.obj111.graphObject_.pendingConnections.append((self.obj111.graphObject_.tag, self.obj108.graphObject_.tag, [386.0, 158.0, 371.0, 104.0, 291.5, 140.5], 2, True))
self.RHS = ASG_pns(parent)
self.obj113=rawMaterial(parent)
self.obj113.preAction( self.RHS.CREATE )
self.obj113.isGraphObjectVisual = True
if(hasattr(self.obj113, '_setHierarchicalLink')):
self.obj113._setHierarchicalLink(False)
# MaxFlow
self.obj113.MaxFlow.setNone()
# price
self.obj113.price.setNone()
# Name
self.obj113.Name.setValue('')
self.obj113.Name.setNone()
# ReqFlow
self.obj113.ReqFlow.setNone()
self.obj113.GGLabel.setValue(1)
self.obj113.graphClass_= graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(60.0,20.0,self.obj113)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj113.graphObject_ = new_obj
self.obj1130= AttrCalc()
self.obj1130.Copy=ATOM3Boolean()
self.obj1130.Copy.setValue(('Copy from LHS', 1))
self.obj1130.Copy.config = 0
self.obj1130.Specify=ATOM3Constraint()
self.obj1130.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.obj113.GGset2Any['MaxFlow']= self.obj1130
self.obj1131= AttrCalc()
self.obj1131.Copy=ATOM3Boolean()
self.obj1131.Copy.setValue(('Copy from LHS', 1))
self.obj1131.Copy.config = 0
self.obj1131.Specify=ATOM3Constraint()
self.obj1131.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.obj113.GGset2Any['price']= self.obj1131
self.obj1132= AttrCalc()
self.obj1132.Copy=ATOM3Boolean()
self.obj1132.Copy.setValue(('Copy from LHS', 1))
self.obj1132.Copy.config = 0
self.obj1132.Specify=ATOM3Constraint()
self.obj1132.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.obj113.GGset2Any['Name']= self.obj1132
self.obj1133= AttrCalc()
self.obj1133.Copy=ATOM3Boolean()
self.obj1133.Copy.setValue(('Copy from LHS', 1))
self.obj1133.Copy.config = 0
self.obj1133.Specify=ATOM3Constraint()
self.obj1133.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.obj113.GGset2Any['ReqFlow']= self.obj1133
# Add node to the root: self.RHS
self.RHS.addNode(self.obj113)
self.obj113.postAction( self.RHS.CREATE )
self.obj114=metarial(parent)
self.obj114.preAction( self.RHS.CREATE )
self.obj114.isGraphObjectVisual = True
if(hasattr(self.obj114, '_setHierarchicalLink')):
self.obj114._setHierarchicalLink(False)
# MaxFlow
self.obj114.MaxFlow.setNone()
# price
self.obj114.price.setNone()
# Name
self.obj114.Name.setValue('')
self.obj114.Name.setNone()
# ReqFlow
self.obj114.ReqFlow.setNone()
self.obj114.GGLabel.setValue(4)
self.obj114.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(360.0,160.0,self.obj114)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj114.graphObject_ = new_obj
self.obj1140= AttrCalc()
self.obj1140.Copy=ATOM3Boolean()
self.obj1140.Copy.setValue(('Copy from LHS', 1))
self.obj1140.Copy.config = 0
self.obj1140.Specify=ATOM3Constraint()
self.obj1140.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.obj114.GGset2Any['MaxFlow']= self.obj1140
self.obj1141= AttrCalc()
self.obj1141.Copy=ATOM3Boolean()
self.obj1141.Copy.setValue(('Copy from LHS', 1))
self.obj1141.Copy.config = 0
self.obj1141.Specify=ATOM3Constraint()
self.obj1141.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.obj114.GGset2Any['price']= self.obj1141
self.obj1142= AttrCalc()
self.obj1142.Copy=ATOM3Boolean()
self.obj1142.Copy.setValue(('Copy from LHS', 1))
self.obj1142.Copy.config = 0
self.obj1142.Specify=ATOM3Constraint()
self.obj1142.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.obj114.GGset2Any['Name']= self.obj1142
self.obj1143= AttrCalc()
self.obj1143.Copy=ATOM3Boolean()
self.obj1143.Copy.setValue(('Copy from LHS', 1))
self.obj1143.Copy.config = 0
self.obj1143.Specify=ATOM3Constraint()
self.obj1143.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.obj114.GGset2Any['ReqFlow']= self.obj1143
# Add node to the root: self.RHS
self.RHS.addNode(self.obj114)
self.obj114.postAction( self.RHS.CREATE )
self.obj115=operatingUnit(parent)
self.obj115.preAction( self.RHS.CREATE )
self.obj115.isGraphObjectVisual = True
if(hasattr(self.obj115, '_setHierarchicalLink')):
self.obj115._setHierarchicalLink(False)
# OperCostProp
self.obj115.OperCostProp.setNone()
# name
self.obj115.name.setValue('')
self.obj115.name.setNone()
# OperCostFix
self.obj115.OperCostFix.setNone()
self.obj115.GGLabel.setValue(2)
self.obj115.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(160.0,100.0,self.obj115)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj115.graphObject_ = new_obj
self.obj1150= AttrCalc()
self.obj1150.Copy=ATOM3Boolean()
self.obj1150.Copy.setValue(('Copy from LHS', 1))
self.obj1150.Copy.config = 0
self.obj1150.Specify=ATOM3Constraint()
self.obj1150.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.obj115.GGset2Any['OperCostProp']= self.obj1150
self.obj1151= AttrCalc()
self.obj1151.Copy=ATOM3Boolean()
self.obj1151.Copy.setValue(('Copy from LHS', 1))
self.obj1151.Copy.config = 0
self.obj1151.Specify=ATOM3Constraint()
self.obj1151.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.obj115.GGset2Any['name']= self.obj1151
self.obj1152= AttrCalc()
self.obj1152.Copy=ATOM3Boolean()
self.obj1152.Copy.setValue(('Copy from LHS', 1))
self.obj1152.Copy.config = 0
self.obj1152.Specify=ATOM3Constraint()
self.obj1152.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.obj115.GGset2Any['OperCostFix']= self.obj1152
# Add node to the root: self.RHS
self.RHS.addNode(self.obj115)
self.obj115.postAction( self.RHS.CREATE )
self.obj116=fromRaw(parent)
self.obj116.preAction( self.RHS.CREATE )
self.obj116.isGraphObjectVisual = True
if(hasattr(self.obj116, '_setHierarchicalLink')):
self.obj116._setHierarchicalLink(False)
# rate
self.obj116.rate.setNone()
self.obj116.GGLabel.setValue(3)
self.obj116.graphClass_= graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(135.5,78.0,self.obj116)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj116.graphObject_ = new_obj
self.obj1160= AttrCalc()
self.obj1160.Copy=ATOM3Boolean()
self.obj1160.Copy.setValue(('Copy from LHS', 1))
self.obj1160.Copy.config = 0
self.obj1160.Specify=ATOM3Constraint()
self.obj1160.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.obj116.GGset2Any['rate']= self.obj1160
# Add node to the root: self.RHS
self.RHS.addNode(self.obj116)
self.obj116.postAction( self.RHS.CREATE )
self.obj117=intoMaterial(parent)
self.obj117.preAction( self.RHS.CREATE )
self.obj117.isGraphObjectVisual = True
if(hasattr(self.obj117, '_setHierarchicalLink')):
self.obj117._setHierarchicalLink(False)
# rate
self.obj117.rate.setNone()
self.obj117.GGLabel.setValue(5)
self.obj117.graphClass_= graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(291.5,140.5,self.obj117)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj117.graphObject_ = new_obj
self.obj1170= AttrCalc()
self.obj1170.Copy=ATOM3Boolean()
self.obj1170.Copy.setValue(('Copy from LHS', 1))
self.obj1170.Copy.config = 0
self.obj1170.Specify=ATOM3Constraint()
self.obj1170.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.obj117.GGset2Any['rate']= self.obj1170
# Add node to the root: self.RHS
self.RHS.addNode(self.obj117)
self.obj117.postAction( self.RHS.CREATE )
self.obj113.out_connections_.append(self.obj116)
self.obj116.in_connections_.append(self.obj113)
self.obj113.graphObject_.pendingConnections.append((self.obj113.graphObject_.tag, self.obj116.graphObject_.tag, [84.0, 70.0, 135.5, 78.0], 2, 0))
self.obj115.out_connections_.append(self.obj117)
self.obj117.in_connections_.append(self.obj115)
self.obj115.graphObject_.pendingConnections.append((self.obj115.graphObject_.tag, self.obj117.graphObject_.tag, [213.0, 108.0, 291.5, 140.5], 2, 0))
self.obj116.out_connections_.append(self.obj115)
self.obj115.in_connections_.append(self.obj116)
self.obj116.graphObject_.pendingConnections.append((self.obj116.graphObject_.tag, self.obj115.graphObject_.tag, [210.0, 101.0, 135.5, 78.0], 2, 0))
self.obj117.out_connections_.append(self.obj114)
self.obj114.in_connections_.append(self.obj117)
self.obj117.graphObject_.pendingConnections.append((self.obj117.graphObject_.tag, self.obj114.graphObject_.tag, [370.0, 165.0, 291.5, 140.5], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 21)
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.obj1747 = rawMaterial(parent)
self.obj1747.preAction(self.LHS.CREATE)
self.obj1747.isGraphObjectVisual = True
if (hasattr(self.obj1747, '_setHierarchicalLink')):
self.obj1747._setHierarchicalLink(False)
# MaxFlow
self.obj1747.MaxFlow.setNone()
# price
self.obj1747.price.setValue(0)
# Name
self.obj1747.Name.setValue('')
self.obj1747.Name.setNone()
# ReqFlow
self.obj1747.ReqFlow.setNone()
self.obj1747.GGLabel.setValue(6)
self.obj1747.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(240.0, 0.0, self.obj1747)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1747.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1747)
self.obj1747.postAction(self.LHS.CREATE)
self.obj1748 = metarial(parent)
self.obj1748.preAction(self.LHS.CREATE)
self.obj1748.isGraphObjectVisual = True
if (hasattr(self.obj1748, '_setHierarchicalLink')):
self.obj1748._setHierarchicalLink(False)
# MaxFlow
self.obj1748.MaxFlow.setNone()
# price
self.obj1748.price.setValue(0)
# Name
self.obj1748.Name.setValue('')
self.obj1748.Name.setNone()
# ReqFlow
self.obj1748.ReqFlow.setNone()
self.obj1748.GGLabel.setValue(11)
self.obj1748.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(260.0, 200.0, self.obj1748)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1748.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1748)
self.obj1748.postAction(self.LHS.CREATE)
self.obj1749 = operatingUnit(parent)
self.obj1749.preAction(self.LHS.CREATE)
self.obj1749.isGraphObjectVisual = True
if (hasattr(self.obj1749, '_setHierarchicalLink')):
self.obj1749._setHierarchicalLink(False)
# OperCostProp
self.obj1749.OperCostProp.setNone()
# name
self.obj1749.name.setValue('')
self.obj1749.name.setNone()
# OperCostFix
self.obj1749.OperCostFix.setNone()
self.obj1749.GGLabel.setValue(7)
self.obj1749.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(280.0, 100.0, self.obj1749)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1749.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1749)
self.obj1749.postAction(self.LHS.CREATE)
self.obj1750 = operatingUnit(parent)
self.obj1750.preAction(self.LHS.CREATE)
self.obj1750.isGraphObjectVisual = True
if (hasattr(self.obj1750, '_setHierarchicalLink')):
self.obj1750._setHierarchicalLink(False)
# OperCostProp
self.obj1750.OperCostProp.setNone()
# name
self.obj1750.name.setValue('')
self.obj1750.name.setNone()
# OperCostFix
self.obj1750.OperCostFix.setNone()
self.obj1750.GGLabel.setValue(12)
self.obj1750.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(360.0, 260.0, self.obj1750)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1750.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1750)
self.obj1750.postAction(self.LHS.CREATE)
self.obj1751 = fromRaw(parent)
self.obj1751.preAction(self.LHS.CREATE)
self.obj1751.isGraphObjectVisual = True
if (hasattr(self.obj1751, '_setHierarchicalLink')):
self.obj1751._setHierarchicalLink(False)
# rate
self.obj1751.rate.setNone()
self.obj1751.GGLabel.setValue(8)
self.obj1751.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(311.5, 63.25, self.obj1751)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1751.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1751)
self.obj1751.postAction(self.LHS.CREATE)
self.obj1752 = fromMaterial(parent)
self.obj1752.preAction(self.LHS.CREATE)
self.obj1752.isGraphObjectVisual = True
if (hasattr(self.obj1752, '_setHierarchicalLink')):
self.obj1752._setHierarchicalLink(False)
# rate
self.obj1752.rate.setNone()
self.obj1752.GGLabel.setValue(14)
self.obj1752.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(379.5, 235.25, self.obj1752)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1752.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1752)
self.obj1752.postAction(self.LHS.CREATE)
self.obj1753 = CapableOf(parent)
self.obj1753.preAction(self.LHS.CREATE)
self.obj1753.isGraphObjectVisual = True
if (hasattr(self.obj1753, '_setHierarchicalLink')):
self.obj1753._setHierarchicalLink(False)
# rate
self.obj1753.rate.setNone()
self.obj1753.GGLabel.setValue(3)
self.obj1753.graphClass_ = graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(84.5, 131.5, self.obj1753)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1753.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1753)
self.obj1753.postAction(self.LHS.CREATE)
self.obj1754 = Agent(parent)
self.obj1754.preAction(self.LHS.CREATE)
self.obj1754.isGraphObjectVisual = True
if (hasattr(self.obj1754, '_setHierarchicalLink')):
self.obj1754._setHierarchicalLink(False)
# price
self.obj1754.price.setNone()
# name
self.obj1754.name.setValue('')
self.obj1754.name.setNone()
self.obj1754.GGLabel.setValue(1)
self.obj1754.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(60.0, 20.0, self.obj1754)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1754.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1754)
self.obj1754.postAction(self.LHS.CREATE)
self.obj1755 = Role(parent)
self.obj1755.preAction(self.LHS.CREATE)
self.obj1755.isGraphObjectVisual = True
if (hasattr(self.obj1755, '_setHierarchicalLink')):
self.obj1755._setHierarchicalLink(False)
# name
self.obj1755.name.setValue('')
self.obj1755.name.setNone()
self.obj1755.GGLabel.setValue(2)
self.obj1755.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(60.0, 180.0, self.obj1755)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1755.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1755)
self.obj1755.postAction(self.LHS.CREATE)
self.obj1756 = GenericGraphEdge(parent)
self.obj1756.preAction(self.LHS.CREATE)
self.obj1756.isGraphObjectVisual = True
if (hasattr(self.obj1756, '_setHierarchicalLink')):
self.obj1756._setHierarchicalLink(False)
self.obj1756.GGLabel.setValue(15)
self.obj1756.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(174.5, 69.0, self.obj1756)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1756.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1756)
self.obj1756.postAction(self.LHS.CREATE)
self.obj1757 = GenericGraphEdge(parent)
self.obj1757.preAction(self.LHS.CREATE)
self.obj1757.isGraphObjectVisual = True
if (hasattr(self.obj1757, '_setHierarchicalLink')):
self.obj1757._setHierarchicalLink(False)
self.obj1757.GGLabel.setValue(10)
self.obj1757.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(245.75, 97.25, self.obj1757)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1757.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1757)
self.obj1757.postAction(self.LHS.CREATE)
self.obj1758 = GenericGraphEdge(parent)
self.obj1758.preAction(self.LHS.CREATE)
self.obj1758.isGraphObjectVisual = True
if (hasattr(self.obj1758, '_setHierarchicalLink')):
self.obj1758._setHierarchicalLink(False)
self.obj1758.GGLabel.setValue(13)
self.obj1758.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(175.0, 234.0, self.obj1758)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1758.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1758)
self.obj1758.postAction(self.LHS.CREATE)
self.obj1747.out_connections_.append(self.obj1751)
self.obj1751.in_connections_.append(self.obj1747)
self.obj1747.graphObject_.pendingConnections.append(
(self.obj1747.graphObject_.tag, self.obj1751.graphObject_.tag,
[264.0, 56.0, 295.0, 49.5, 311.5, 63.25], 2, True))
self.obj1748.out_connections_.append(self.obj1752)
self.obj1752.in_connections_.append(self.obj1748)
self.obj1748.graphObject_.pendingConnections.append(
(self.obj1748.graphObject_.tag, self.obj1752.graphObject_.tag,
[306.0, 210.0, 353.5, 220.0, 379.5, 235.25], 2, True))
self.obj1751.out_connections_.append(self.obj1749)
self.obj1749.in_connections_.append(self.obj1751)
self.obj1751.graphObject_.pendingConnections.append(
(self.obj1751.graphObject_.tag, self.obj1749.graphObject_.tag,
[330.0, 111.0, 328.0, 77.0, 311.5, 63.25], 2, True))
self.obj1752.out_connections_.append(self.obj1750)
self.obj1750.in_connections_.append(self.obj1752)
self.obj1752.graphObject_.pendingConnections.append(
(self.obj1752.graphObject_.tag, self.obj1750.graphObject_.tag,
[410.0, 271.0, 405.5, 250.5, 379.5, 235.25], 2, True))
self.obj1753.out_connections_.append(self.obj1755)
self.obj1755.in_connections_.append(self.obj1753)
self.obj1753.graphObject_.pendingConnections.append(
(self.obj1753.graphObject_.tag, self.obj1755.graphObject_.tag,
[84.0, 181.0, 84.5, 131.5], 0, True))
self.obj1754.out_connections_.append(self.obj1753)
self.obj1753.in_connections_.append(self.obj1754)
self.obj1754.graphObject_.pendingConnections.append(
(self.obj1754.graphObject_.tag, self.obj1753.graphObject_.tag,
[85.0, 82.0, 84.5, 131.5], 0, True))
self.obj1754.out_connections_.append(self.obj1756)
self.obj1756.in_connections_.append(self.obj1754)
self.obj1754.graphObject_.pendingConnections.append(
(self.obj1754.graphObject_.tag, self.obj1756.graphObject_.tag,
[85.0, 82.0, 174.5, 69.0], 0, True))
self.obj1754.out_connections_.append(self.obj1757)
self.obj1757.in_connections_.append(self.obj1754)
self.obj1754.graphObject_.pendingConnections.append(
(self.obj1754.graphObject_.tag, self.obj1757.graphObject_.tag,
[85.0, 82.0, 192.0, 90.0, 245.75, 97.25], 2, True))
self.obj1755.out_connections_.append(self.obj1758)
self.obj1758.in_connections_.append(self.obj1755)
self.obj1755.graphObject_.pendingConnections.append(
(self.obj1755.graphObject_.tag, self.obj1758.graphObject_.tag,
[84.0, 226.0, 175.0, 234.0], 0, True))
self.obj1756.out_connections_.append(self.obj1747)
self.obj1747.in_connections_.append(self.obj1756)
self.obj1756.graphObject_.pendingConnections.append(
(self.obj1756.graphObject_.tag, self.obj1747.graphObject_.tag,
[264.0, 56.0, 174.5, 69.0], 0, True))
self.obj1757.out_connections_.append(self.obj1749)
self.obj1749.in_connections_.append(self.obj1757)
self.obj1757.graphObject_.pendingConnections.append(
(self.obj1757.graphObject_.tag, self.obj1749.graphObject_.tag,
[300.0, 111.0, 299.5, 104.5, 245.75, 97.25], 2, True))
self.obj1758.out_connections_.append(self.obj1748)
self.obj1748.in_connections_.append(self.obj1758)
self.obj1758.graphObject_.pendingConnections.append(
(self.obj1758.graphObject_.tag, self.obj1748.graphObject_.tag,
[266.0, 242.0, 175.0, 234.0], 0, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1762 = rawMaterial(parent)
self.obj1762.preAction(self.RHS.CREATE)
self.obj1762.isGraphObjectVisual = True
if (hasattr(self.obj1762, '_setHierarchicalLink')):
self.obj1762._setHierarchicalLink(False)
# MaxFlow
self.obj1762.MaxFlow.setNone()
# price
self.obj1762.price.setValue(0)
# Name
self.obj1762.Name.setValue('')
self.obj1762.Name.setNone()
# ReqFlow
self.obj1762.ReqFlow.setNone()
self.obj1762.GGLabel.setValue(6)
self.obj1762.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(240.0, 0.0, self.obj1762)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1762.graphObject_ = new_obj
self.obj17620 = AttrCalc()
self.obj17620.Copy = ATOM3Boolean()
self.obj17620.Copy.setValue(('Copy from LHS', 1))
self.obj17620.Copy.config = 0
self.obj17620.Specify = ATOM3Constraint()
self.obj17620.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.obj1762.GGset2Any['MaxFlow'] = self.obj17620
self.obj17621 = AttrCalc()
self.obj17621.Copy = ATOM3Boolean()
self.obj17621.Copy.setValue(('Copy from LHS', 1))
self.obj17621.Copy.config = 0
self.obj17621.Specify = ATOM3Constraint()
self.obj17621.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.obj1762.GGset2Any['Name'] = self.obj17621
self.obj17622 = AttrCalc()
self.obj17622.Copy = ATOM3Boolean()
self.obj17622.Copy.setValue(('Copy from LHS', 1))
self.obj17622.Copy.config = 0
self.obj17622.Specify = ATOM3Constraint()
self.obj17622.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.obj1762.GGset2Any['ReqFlow'] = self.obj17622
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1762)
self.obj1762.postAction(self.RHS.CREATE)
self.obj1763 = metarial(parent)
self.obj1763.preAction(self.RHS.CREATE)
self.obj1763.isGraphObjectVisual = True
if (hasattr(self.obj1763, '_setHierarchicalLink')):
self.obj1763._setHierarchicalLink(False)
# MaxFlow
self.obj1763.MaxFlow.setNone()
# price
self.obj1763.price.setValue(0)
# Name
self.obj1763.Name.setValue('')
self.obj1763.Name.setNone()
# ReqFlow
self.obj1763.ReqFlow.setNone()
self.obj1763.GGLabel.setValue(11)
self.obj1763.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(260.0, 200.0, self.obj1763)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1763.graphObject_ = new_obj
self.obj17630 = AttrCalc()
self.obj17630.Copy = ATOM3Boolean()
self.obj17630.Copy.setValue(('Copy from LHS', 1))
self.obj17630.Copy.config = 0
self.obj17630.Specify = ATOM3Constraint()
self.obj17630.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.obj1763.GGset2Any['MaxFlow'] = self.obj17630
self.obj17631 = AttrCalc()
self.obj17631.Copy = ATOM3Boolean()
self.obj17631.Copy.setValue(('Copy from LHS', 1))
self.obj17631.Copy.config = 0
self.obj17631.Specify = ATOM3Constraint()
self.obj17631.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.obj1763.GGset2Any['Name'] = self.obj17631
self.obj17632 = AttrCalc()
self.obj17632.Copy = ATOM3Boolean()
self.obj17632.Copy.setValue(('Copy from LHS', 1))
self.obj17632.Copy.config = 0
self.obj17632.Specify = ATOM3Constraint()
self.obj17632.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.obj1763.GGset2Any['ReqFlow'] = self.obj17632
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1763)
self.obj1763.postAction(self.RHS.CREATE)
self.obj1764 = operatingUnit(parent)
self.obj1764.preAction(self.RHS.CREATE)
self.obj1764.isGraphObjectVisual = True
if (hasattr(self.obj1764, '_setHierarchicalLink')):
self.obj1764._setHierarchicalLink(False)
# OperCostProp
self.obj1764.OperCostProp.setNone()
# name
self.obj1764.name.setValue('')
self.obj1764.name.setNone()
# OperCostFix
self.obj1764.OperCostFix.setNone()
self.obj1764.GGLabel.setValue(7)
self.obj1764.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(280.0, 100.0, self.obj1764)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1764.graphObject_ = new_obj
self.obj17640 = AttrCalc()
self.obj17640.Copy = ATOM3Boolean()
self.obj17640.Copy.setValue(('Copy from LHS', 1))
self.obj17640.Copy.config = 0
self.obj17640.Specify = ATOM3Constraint()
self.obj17640.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.obj1764.GGset2Any['OperCostProp'] = self.obj17640
self.obj17641 = AttrCalc()
self.obj17641.Copy = ATOM3Boolean()
self.obj17641.Copy.setValue(('Copy from LHS', 1))
self.obj17641.Copy.config = 0
self.obj17641.Specify = ATOM3Constraint()
self.obj17641.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.obj1764.GGset2Any['name'] = self.obj17641
self.obj17642 = AttrCalc()
self.obj17642.Copy = ATOM3Boolean()
self.obj17642.Copy.setValue(('Copy from LHS', 1))
self.obj17642.Copy.config = 0
self.obj17642.Specify = ATOM3Constraint()
self.obj17642.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.obj1764.GGset2Any['OperCostFix'] = self.obj17642
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1764)
self.obj1764.postAction(self.RHS.CREATE)
self.obj1765 = operatingUnit(parent)
self.obj1765.preAction(self.RHS.CREATE)
self.obj1765.isGraphObjectVisual = True
if (hasattr(self.obj1765, '_setHierarchicalLink')):
self.obj1765._setHierarchicalLink(False)
# OperCostProp
self.obj1765.OperCostProp.setNone()
# name
self.obj1765.name.setValue('')
self.obj1765.name.setNone()
# OperCostFix
self.obj1765.OperCostFix.setNone()
self.obj1765.GGLabel.setValue(12)
self.obj1765.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(360.0, 260.0, self.obj1765)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1765.graphObject_ = new_obj
self.obj17650 = AttrCalc()
self.obj17650.Copy = ATOM3Boolean()
self.obj17650.Copy.setValue(('Copy from LHS', 1))
self.obj17650.Copy.config = 0
self.obj17650.Specify = ATOM3Constraint()
self.obj17650.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.obj1765.GGset2Any['OperCostProp'] = self.obj17650
self.obj17651 = AttrCalc()
self.obj17651.Copy = ATOM3Boolean()
self.obj17651.Copy.setValue(('Copy from LHS', 1))
self.obj17651.Copy.config = 0
self.obj17651.Specify = ATOM3Constraint()
self.obj17651.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.obj1765.GGset2Any['name'] = self.obj17651
self.obj17652 = AttrCalc()
self.obj17652.Copy = ATOM3Boolean()
self.obj17652.Copy.setValue(('Copy from LHS', 1))
self.obj17652.Copy.config = 0
self.obj17652.Specify = ATOM3Constraint()
self.obj17652.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.obj1765.GGset2Any['OperCostFix'] = self.obj17652
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1765)
self.obj1765.postAction(self.RHS.CREATE)
self.obj1766 = fromRaw(parent)
self.obj1766.preAction(self.RHS.CREATE)
self.obj1766.isGraphObjectVisual = True
if (hasattr(self.obj1766, '_setHierarchicalLink')):
self.obj1766._setHierarchicalLink(False)
# rate
self.obj1766.rate.setNone()
self.obj1766.GGLabel.setValue(8)
self.obj1766.graphClass_ = graph_fromRaw
if parent.genGraphics:
new_obj = graph_fromRaw(311.5, 63.25, self.obj1766)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1766.graphObject_ = new_obj
self.obj17660 = AttrCalc()
self.obj17660.Copy = ATOM3Boolean()
self.obj17660.Copy.setValue(('Copy from LHS', 1))
self.obj17660.Copy.config = 0
self.obj17660.Specify = ATOM3Constraint()
self.obj17660.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.obj1766.GGset2Any['rate'] = self.obj17660
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1766)
self.obj1766.postAction(self.RHS.CREATE)
self.obj1767 = intoMaterial(parent)
self.obj1767.preAction(self.RHS.CREATE)
self.obj1767.isGraphObjectVisual = True
if (hasattr(self.obj1767, '_setHierarchicalLink')):
self.obj1767._setHierarchicalLink(False)
# rate
self.obj1767.rate.setValue(0.0)
self.obj1767.GGLabel.setValue(17)
self.obj1767.graphClass_ = graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(324.25, 167.5, self.obj1767)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1767.graphObject_ = new_obj
self.obj17670 = AttrCalc()
self.obj17670.Copy = ATOM3Boolean()
self.obj17670.Copy.setValue(('Copy from LHS', 0))
self.obj17670.Copy.config = 0
self.obj17670.Specify = ATOM3Constraint()
self.obj17670.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]),
'a = self.getMatched ( graphID , self.LHS.nodeWithLabel(1) ).name.getValue()\nb = self.getMatched ( graphID , self.LHS.nodeWithLabel(2) ).name.getValue()\nreturn self.graphRewritingSystem.Dictag[ a ][b]\n\n'
))
self.obj1767.GGset2Any['rate'] = self.obj17670
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1767)
self.obj1767.postAction(self.RHS.CREATE)
self.obj1768 = fromMaterial(parent)
self.obj1768.preAction(self.RHS.CREATE)
self.obj1768.isGraphObjectVisual = True
if (hasattr(self.obj1768, '_setHierarchicalLink')):
self.obj1768._setHierarchicalLink(False)
# rate
self.obj1768.rate.setNone()
self.obj1768.GGLabel.setValue(14)
self.obj1768.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(379.5, 235.25, self.obj1768)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1768.graphObject_ = new_obj
self.obj17680 = AttrCalc()
self.obj17680.Copy = ATOM3Boolean()
self.obj17680.Copy.setValue(('Copy from LHS', 1))
self.obj17680.Copy.config = 0
self.obj17680.Specify = ATOM3Constraint()
self.obj17680.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.obj1768.GGset2Any['rate'] = self.obj17680
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1768)
self.obj1768.postAction(self.RHS.CREATE)
self.obj1769 = CapableOf(parent)
self.obj1769.preAction(self.RHS.CREATE)
self.obj1769.isGraphObjectVisual = True
if (hasattr(self.obj1769, '_setHierarchicalLink')):
self.obj1769._setHierarchicalLink(False)
# rate
self.obj1769.rate.setNone()
self.obj1769.GGLabel.setValue(3)
self.obj1769.graphClass_ = graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(84.5, 131.5, self.obj1769)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1769.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1769)
self.obj1769.postAction(self.RHS.CREATE)
self.obj1770 = Agent(parent)
self.obj1770.preAction(self.RHS.CREATE)
self.obj1770.isGraphObjectVisual = True
if (hasattr(self.obj1770, '_setHierarchicalLink')):
self.obj1770._setHierarchicalLink(False)
# price
self.obj1770.price.setNone()
# name
self.obj1770.name.setValue('')
self.obj1770.name.setNone()
self.obj1770.GGLabel.setValue(1)
self.obj1770.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(60.0, 20.0, self.obj1770)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1770.graphObject_ = new_obj
self.obj17700 = AttrCalc()
self.obj17700.Copy = ATOM3Boolean()
self.obj17700.Copy.setValue(('Copy from LHS', 1))
self.obj17700.Copy.config = 0
self.obj17700.Specify = ATOM3Constraint()
self.obj17700.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.obj1770.GGset2Any['price'] = self.obj17700
self.obj17701 = AttrCalc()
self.obj17701.Copy = ATOM3Boolean()
self.obj17701.Copy.setValue(('Copy from LHS', 1))
self.obj17701.Copy.config = 0
self.obj17701.Specify = ATOM3Constraint()
self.obj17701.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.obj1770.GGset2Any['name'] = self.obj17701
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1770)
self.obj1770.postAction(self.RHS.CREATE)
self.obj1771 = Role(parent)
self.obj1771.preAction(self.RHS.CREATE)
self.obj1771.isGraphObjectVisual = True
if (hasattr(self.obj1771, '_setHierarchicalLink')):
self.obj1771._setHierarchicalLink(False)
# name
self.obj1771.name.setValue('')
self.obj1771.name.setNone()
self.obj1771.GGLabel.setValue(2)
self.obj1771.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(60.0, 180.0, self.obj1771)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1771.graphObject_ = new_obj
self.obj17710 = AttrCalc()
self.obj17710.Copy = ATOM3Boolean()
self.obj17710.Copy.setValue(('Copy from LHS', 1))
self.obj17710.Copy.config = 0
self.obj17710.Specify = ATOM3Constraint()
self.obj17710.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.obj1771.GGset2Any['name'] = self.obj17710
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1771)
self.obj1771.postAction(self.RHS.CREATE)
self.obj1772 = GenericGraphEdge(parent)
self.obj1772.preAction(self.RHS.CREATE)
self.obj1772.isGraphObjectVisual = True
if (hasattr(self.obj1772, '_setHierarchicalLink')):
self.obj1772._setHierarchicalLink(False)
self.obj1772.GGLabel.setValue(15)
self.obj1772.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(174.5, 69.0, self.obj1772)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1772.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1772)
self.obj1772.postAction(self.RHS.CREATE)
self.obj1773 = GenericGraphEdge(parent)
self.obj1773.preAction(self.RHS.CREATE)
self.obj1773.isGraphObjectVisual = True
if (hasattr(self.obj1773, '_setHierarchicalLink')):
self.obj1773._setHierarchicalLink(False)
self.obj1773.GGLabel.setValue(10)
self.obj1773.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(245.75, 97.25, self.obj1773)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1773.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1773)
self.obj1773.postAction(self.RHS.CREATE)
self.obj1774 = GenericGraphEdge(parent)
self.obj1774.preAction(self.RHS.CREATE)
self.obj1774.isGraphObjectVisual = True
if (hasattr(self.obj1774, '_setHierarchicalLink')):
self.obj1774._setHierarchicalLink(False)
self.obj1774.GGLabel.setValue(13)
self.obj1774.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(175.0, 234.0, self.obj1774)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1774.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1774)
self.obj1774.postAction(self.RHS.CREATE)
self.obj1762.out_connections_.append(self.obj1766)
self.obj1766.in_connections_.append(self.obj1762)
self.obj1762.graphObject_.pendingConnections.append(
(self.obj1762.graphObject_.tag, self.obj1766.graphObject_.tag,
[264.0, 50.0, 311.5, 63.25], 2, 0))
self.obj1763.out_connections_.append(self.obj1768)
self.obj1768.in_connections_.append(self.obj1763)
self.obj1763.graphObject_.pendingConnections.append(
(self.obj1763.graphObject_.tag, self.obj1768.graphObject_.tag,
[306.0, 210.0, 379.5, 235.25], 2, 0))
self.obj1764.out_connections_.append(self.obj1767)
self.obj1767.in_connections_.append(self.obj1764)
self.obj1764.graphObject_.pendingConnections.append(
(self.obj1764.graphObject_.tag, self.obj1767.graphObject_.tag,
[333.0, 108.0, 331.0, 142.0, 324.25, 167.5], 2, True))
self.obj1766.out_connections_.append(self.obj1764)
self.obj1764.in_connections_.append(self.obj1766)
self.obj1766.graphObject_.pendingConnections.append(
(self.obj1766.graphObject_.tag, self.obj1764.graphObject_.tag,
[330.0, 101.0, 311.5, 63.25], 2, 0))
self.obj1767.out_connections_.append(self.obj1763)
self.obj1763.in_connections_.append(self.obj1767)
self.obj1767.graphObject_.pendingConnections.append(
(self.obj1767.graphObject_.tag, self.obj1763.graphObject_.tag,
[306.0, 210.0, 317.5, 193.0, 324.25, 167.5], 2, True))
self.obj1768.out_connections_.append(self.obj1765)
self.obj1765.in_connections_.append(self.obj1768)
self.obj1768.graphObject_.pendingConnections.append(
(self.obj1768.graphObject_.tag, self.obj1765.graphObject_.tag,
[413.0, 268.0, 379.5, 235.25], 2, 0))
self.obj1769.out_connections_.append(self.obj1771)
self.obj1771.in_connections_.append(self.obj1769)
self.obj1769.graphObject_.pendingConnections.append(
(self.obj1769.graphObject_.tag, self.obj1771.graphObject_.tag,
[91.0, 180.0, 84.5, 131.5], 2, 0))
self.obj1770.out_connections_.append(self.obj1769)
self.obj1769.in_connections_.append(self.obj1770)
self.obj1770.graphObject_.pendingConnections.append(
(self.obj1770.graphObject_.tag, self.obj1769.graphObject_.tag,
[97.0, 82.0, 84.5, 131.5], 2, 0))
self.obj1770.out_connections_.append(self.obj1772)
self.obj1772.in_connections_.append(self.obj1770)
self.obj1770.graphObject_.pendingConnections.append(
(self.obj1770.graphObject_.tag, self.obj1772.graphObject_.tag,
[97.0, 82.0, 174.5, 69.0], 2, 0))
self.obj1770.out_connections_.append(self.obj1773)
self.obj1773.in_connections_.append(self.obj1770)
self.obj1770.graphObject_.pendingConnections.append(
(self.obj1770.graphObject_.tag, self.obj1773.graphObject_.tag,
[97.0, 82.0, 245.75, 97.25], 2, 0))
self.obj1771.out_connections_.append(self.obj1774)
self.obj1774.in_connections_.append(self.obj1771)
self.obj1771.graphObject_.pendingConnections.append(
(self.obj1771.graphObject_.tag, self.obj1774.graphObject_.tag,
[91.0, 225.0, 175.0, 234.0], 2, 0))
self.obj1772.out_connections_.append(self.obj1762)
self.obj1762.in_connections_.append(self.obj1772)
self.obj1772.graphObject_.pendingConnections.append(
(self.obj1772.graphObject_.tag, self.obj1762.graphObject_.tag,
[264.0, 50.0, 174.5, 69.0], 2, 0))
self.obj1773.out_connections_.append(self.obj1764)
self.obj1764.in_connections_.append(self.obj1773)
self.obj1773.graphObject_.pendingConnections.append(
(self.obj1773.graphObject_.tag, self.obj1764.graphObject_.tag,
[300.0, 101.0, 245.75, 97.25], 2, 0))
self.obj1774.out_connections_.append(self.obj1763)
self.obj1763.in_connections_.append(self.obj1774)
self.obj1774.graphObject_.pendingConnections.append(
(self.obj1774.graphObject_.tag, self.obj1763.graphObject_.tag,
[266.0, 242.0, 175.0, 234.0], 2, 0))