class AssignPrice4Raw_GG_rule(GGrule):
def __init__(self, parent):
GGrule.__init__(self, 22)
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.obj1781 = rawMaterial(parent)
self.obj1781.preAction(self.LHS.CREATE)
self.obj1781.isGraphObjectVisual = True
if (hasattr(self.obj1781, '_setHierarchicalLink')):
self.obj1781._setHierarchicalLink(False)
# MaxFlow
self.obj1781.MaxFlow.setNone()
# price
self.obj1781.price.setNone()
# Name
self.obj1781.Name.setValue('')
self.obj1781.Name.setNone()
# ReqFlow
self.obj1781.ReqFlow.setNone()
self.obj1781.GGLabel.setValue(1)
self.obj1781.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(280.0, 60.0, self.obj1781)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['Text Scale'] = 0.5
new_obj.layConstraints['scale'] = [0.5, 0.5]
else:
new_obj = None
self.obj1781.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1781)
self.obj1781.postAction(self.LHS.CREATE)
self.obj1782 = Agent(parent)
self.obj1782.preAction(self.LHS.CREATE)
self.obj1782.isGraphObjectVisual = True
if (hasattr(self.obj1782, '_setHierarchicalLink')):
self.obj1782._setHierarchicalLink(False)
# price
self.obj1782.price.setNone()
# name
self.obj1782.name.setValue('')
self.obj1782.name.setNone()
self.obj1782.GGLabel.setValue(2)
self.obj1782.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(120.0, 60.0, self.obj1782)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['Text Scale'] = 0.5
new_obj.layConstraints['scale'] = [0.5, 0.5]
else:
new_obj = None
self.obj1782.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1782)
self.obj1782.postAction(self.LHS.CREATE)
self.obj1783 = GenericGraphEdge(parent)
self.obj1783.preAction(self.LHS.CREATE)
self.obj1783.isGraphObjectVisual = True
if (hasattr(self.obj1783, '_setHierarchicalLink')):
self.obj1783._setHierarchicalLink(False)
self.obj1783.GGLabel.setValue(3)
self.obj1783.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(198.5, 126.5, self.obj1783)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1783.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1783)
self.obj1783.postAction(self.LHS.CREATE)
self.obj1782.out_connections_.append(self.obj1783)
self.obj1783.in_connections_.append(self.obj1782)
self.obj1782.graphObject_.pendingConnections.append(
(self.obj1782.graphObject_.tag, self.obj1783.graphObject_.tag,
[105.0, 89.5, 130.0, 127.0, 198.5, 126.5], 2, True))
self.obj1783.out_connections_.append(self.obj1781)
self.obj1781.in_connections_.append(self.obj1783)
self.obj1783.graphObject_.pendingConnections.append(
(self.obj1783.graphObject_.tag, self.obj1781.graphObject_.tag,
[290.5, 89.5, 267.0, 126.0, 198.5, 126.5], 2, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1787 = rawMaterial(parent)
self.obj1787.preAction(self.RHS.CREATE)
self.obj1787.isGraphObjectVisual = True
if (hasattr(self.obj1787, '_setHierarchicalLink')):
self.obj1787._setHierarchicalLink(False)
# MaxFlow
self.obj1787.MaxFlow.setNone()
# price
self.obj1787.price.setNone()
# Name
self.obj1787.Name.setValue('')
self.obj1787.Name.setNone()
# ReqFlow
self.obj1787.ReqFlow.setNone()
self.obj1787.GGLabel.setValue(1)
self.obj1787.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(280.0, 60.0, self.obj1787)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1787.graphObject_ = new_obj
self.obj17870 = AttrCalc()
self.obj17870.Copy = ATOM3Boolean()
self.obj17870.Copy.setValue(('Copy from LHS', 1))
self.obj17870.Copy.config = 0
self.obj17870.Specify = ATOM3Constraint()
self.obj17870.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.obj1787.GGset2Any['MaxFlow'] = self.obj17870
self.obj17871 = AttrCalc()
self.obj17871.Copy = ATOM3Boolean()
self.obj17871.Copy.setValue(('Copy from LHS', 0))
self.obj17871.Copy.config = 0
self.obj17871.Specify = ATOM3Constraint()
self.obj17871.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)).price.getValue()\n\n\n\n\n\n\n'
))
self.obj1787.GGset2Any['price'] = self.obj17871
self.obj17872 = AttrCalc()
self.obj17872.Copy = ATOM3Boolean()
self.obj17872.Copy.setValue(('Copy from LHS', 1))
self.obj17872.Copy.config = 0
self.obj17872.Specify = ATOM3Constraint()
self.obj17872.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.obj1787.GGset2Any['Name'] = self.obj17872
self.obj17873 = AttrCalc()
self.obj17873.Copy = ATOM3Boolean()
self.obj17873.Copy.setValue(('Copy from LHS', 1))
self.obj17873.Copy.config = 0
self.obj17873.Specify = ATOM3Constraint()
self.obj17873.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.obj1787.GGset2Any['ReqFlow'] = self.obj17873
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1787)
self.obj1787.postAction(self.RHS.CREATE)
self.obj1788 = Agent(parent)
self.obj1788.preAction(self.RHS.CREATE)
self.obj1788.isGraphObjectVisual = True
if (hasattr(self.obj1788, '_setHierarchicalLink')):
self.obj1788._setHierarchicalLink(False)
# price
self.obj1788.price.setNone()
# name
self.obj1788.name.setValue('')
self.obj1788.name.setNone()
self.obj1788.GGLabel.setValue(2)
self.obj1788.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(120.0, 60.0, self.obj1788)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1788.graphObject_ = new_obj
self.obj17880 = AttrCalc()
self.obj17880.Copy = ATOM3Boolean()
self.obj17880.Copy.setValue(('Copy from LHS', 1))
self.obj17880.Copy.config = 0
self.obj17880.Specify = ATOM3Constraint()
self.obj17880.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.obj1788.GGset2Any['price'] = self.obj17880
self.obj17881 = AttrCalc()
self.obj17881.Copy = ATOM3Boolean()
self.obj17881.Copy.setValue(('Copy from LHS', 1))
self.obj17881.Copy.config = 0
self.obj17881.Specify = ATOM3Constraint()
self.obj17881.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.obj1788.GGset2Any['name'] = self.obj17881
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1788)
self.obj1788.postAction(self.RHS.CREATE)
self.obj1789 = GenericGraphEdge(parent)
self.obj1789.preAction(self.RHS.CREATE)
self.obj1789.isGraphObjectVisual = True
if (hasattr(self.obj1789, '_setHierarchicalLink')):
self.obj1789._setHierarchicalLink(False)
self.obj1789.GGLabel.setValue(3)
self.obj1789.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(198.5, 126.5, self.obj1789)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1789.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1789)
self.obj1789.postAction(self.RHS.CREATE)
self.obj1788.out_connections_.append(self.obj1789)
self.obj1789.in_connections_.append(self.obj1788)
self.obj1788.graphObject_.pendingConnections.append(
(self.obj1788.graphObject_.tag, self.obj1789.graphObject_.tag,
[157.0, 122.0, 198.5, 126.5], 2, 0))
self.obj1789.out_connections_.append(self.obj1787)
self.obj1787.in_connections_.append(self.obj1789)
self.obj1789.graphObject_.pendingConnections.append(
(self.obj1789.graphObject_.tag, self.obj1787.graphObject_.tag,
[304.0, 110.0, 198.5, 126.5], 2, 0))
def condition(self, graphID, isograph, atom3i):
raw = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
return not (hasattr(raw, "AssignPrice"))
def action(self, graphID, isograph, atom3i):
raw = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
raw.AssignPrice = True
print '######################## Assign Price for ' + raw.Name.getValue(
)
class publishTwist2outputDiffSpeedee_GG_rule (GGrule):
def __init__(self, parent):
GGrule.__init__(self, 1)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_RDIS(parent)
self.LHS.merge(ASG_ROSApp(parent))
self.obj194=DifferentialSpeedAdapter(parent)
self.obj194.preAction( self.LHS.CREATE )
self.obj194.isGraphObjectVisual = True
if(hasattr(self.obj194, '_setHierarchicalLink')):
self.obj194._setHierarchicalLink(False)
# angular
self.obj194.angular.setValue('')
self.obj194.angular.setNone()
# linear
self.obj194.linear.setValue('')
self.obj194.linear.setNone()
self.obj194.GGLabel.setValue(7)
self.obj194.graphClass_= graph_DifferentialSpeedAdapter
if parent.genGraphics:
new_obj = graph_DifferentialSpeedAdapter(360.0,20.0,self.obj194)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj194.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj194)
self.obj194.postAction( self.LHS.CREATE )
self.obj195=DomainOutput(parent)
self.obj195.preAction( self.LHS.CREATE )
self.obj195.isGraphObjectVisual = True
if(hasattr(self.obj195, '_setHierarchicalLink')):
self.obj195._setHierarchicalLink(False)
# name
self.obj195.name.setValue('')
self.obj195.name.setNone()
self.obj195.GGLabel.setValue(6)
self.obj195.graphClass_= graph_DomainOutput
if parent.genGraphics:
new_obj = graph_DomainOutput(340.0,140.0,self.obj195)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj195.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj195)
self.obj195.postAction( self.LHS.CREATE )
self.obj196=domainAdapter2domainOutput(parent)
self.obj196.preAction( self.LHS.CREATE )
self.obj196.isGraphObjectVisual = True
if(hasattr(self.obj196, '_setHierarchicalLink')):
self.obj196._setHierarchicalLink(False)
self.obj196.GGLabel.setValue(8)
self.obj196.graphClass_= graph_domainAdapter2domainOutput
if parent.genGraphics:
new_obj = graph_domainAdapter2domainOutput(446.0,158.0,self.obj196)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj196.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj196)
self.obj196.postAction( self.LHS.CREATE )
self.obj197=ROSTwist(parent)
self.obj197.preAction( self.LHS.CREATE )
self.obj197.isGraphObjectVisual = True
if(hasattr(self.obj197, '_setHierarchicalLink')):
self.obj197._setHierarchicalLink(False)
# angular
self.obj197.angular.setActionFlags([ 0, 0, 0, 0])
lcobj2 =[]
cobj2=ATOM3String('x', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('y', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('z', 20)
lcobj2.append(cobj2)
self.obj197.angular.setValue(lcobj2)
self.obj197.angular.setNone()
# linear
self.obj197.linear.setActionFlags([ 0, 0, 0, 0])
lcobj2 =[]
cobj2=ATOM3String('x', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('y', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('z', 20)
lcobj2.append(cobj2)
self.obj197.linear.setValue(lcobj2)
self.obj197.linear.setNone()
self.obj197.GGLabel.setValue(4)
self.obj197.graphClass_= graph_ROSTwist
if parent.genGraphics:
new_obj = graph_ROSTwist(100.0,260.0,self.obj197)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj197.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj197)
self.obj197.postAction( self.LHS.CREATE )
self.obj198=ROSType(parent)
self.obj198.preAction( self.LHS.CREATE )
self.obj198.isGraphObjectVisual = True
if(hasattr(self.obj198, '_setHierarchicalLink')):
self.obj198._setHierarchicalLink(False)
self.obj198.GGLabel.setValue(5)
self.obj198.graphClass_= graph_ROSType
if parent.genGraphics:
new_obj = graph_ROSType(154.5,256.0,self.obj198)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj198.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj198)
self.obj198.postAction( self.LHS.CREATE )
self.obj199=ROSTopic(parent)
self.obj199.preAction( self.LHS.CREATE )
self.obj199.isGraphObjectVisual = True
if(hasattr(self.obj199, '_setHierarchicalLink')):
self.obj199._setHierarchicalLink(False)
# name
self.obj199.name.setValue('')
self.obj199.name.setNone()
self.obj199.GGLabel.setValue(2)
self.obj199.graphClass_= graph_ROSTopic
if parent.genGraphics:
new_obj = graph_ROSTopic(80.0,160.0,self.obj199)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj199.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj199)
self.obj199.postAction( self.LHS.CREATE )
self.obj200=ROSNode(parent)
self.obj200.preAction( self.LHS.CREATE )
self.obj200.isGraphObjectVisual = True
if(hasattr(self.obj200, '_setHierarchicalLink')):
self.obj200._setHierarchicalLink(False)
# name
self.obj200.name.setValue('')
self.obj200.name.setNone()
self.obj200.GGLabel.setValue(1)
self.obj200.graphClass_= graph_ROSNode
if parent.genGraphics:
new_obj = graph_ROSNode(80.0,40.0,self.obj200)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj200.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj200)
self.obj200.postAction( self.LHS.CREATE )
self.obj201=ROSSubscribe(parent)
self.obj201.preAction( self.LHS.CREATE )
self.obj201.isGraphObjectVisual = True
if(hasattr(self.obj201, '_setHierarchicalLink')):
self.obj201._setHierarchicalLink(False)
self.obj201.GGLabel.setValue(3)
self.obj201.graphClass_= graph_ROSSubscribe
if parent.genGraphics:
new_obj = graph_ROSSubscribe(157.5,147.0,self.obj201)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj201.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj201)
self.obj201.postAction( self.LHS.CREATE )
self.obj194.out_connections_.append(self.obj196)
self.obj196.in_connections_.append(self.obj194)
self.obj194.graphObject_.pendingConnections.append((self.obj194.graphObject_.tag, self.obj196.graphObject_.tag, [433.0, 121.0, 446.0, 158.0], 0, True))
self.obj196.out_connections_.append(self.obj195)
self.obj195.in_connections_.append(self.obj196)
self.obj196.graphObject_.pendingConnections.append((self.obj196.graphObject_.tag, self.obj195.graphObject_.tag, [459.0, 195.0, 446.0, 158.0], 0, True))
self.obj198.out_connections_.append(self.obj197)
self.obj197.in_connections_.append(self.obj198)
self.obj198.graphObject_.pendingConnections.append((self.obj198.graphObject_.tag, self.obj197.graphObject_.tag, [152.0, 265.0, 154.5, 256.0], 0, True))
self.obj199.out_connections_.append(self.obj201)
self.obj201.in_connections_.append(self.obj199)
self.obj199.graphObject_.pendingConnections.append((self.obj199.graphObject_.tag, self.obj201.graphObject_.tag, [163.0, 164.0, 157.5, 147.0], 0, True))
self.obj199.out_connections_.append(self.obj198)
self.obj198.in_connections_.append(self.obj199)
self.obj199.graphObject_.pendingConnections.append((self.obj199.graphObject_.tag, self.obj198.graphObject_.tag, [157.0, 247.0, 154.5, 256.0], 0, True))
self.obj201.out_connections_.append(self.obj200)
self.obj200.in_connections_.append(self.obj201)
self.obj201.graphObject_.pendingConnections.append((self.obj201.graphObject_.tag, self.obj200.graphObject_.tag, [152.0, 130.0, 157.5, 147.0], 0, True))
self.RHS = ASG_RDIS(parent)
self.RHS.merge(ASG_ROSApp(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj205=DifferentialSpeedAdapter(parent)
self.obj205.preAction( self.RHS.CREATE )
self.obj205.isGraphObjectVisual = True
if(hasattr(self.obj205, '_setHierarchicalLink')):
self.obj205._setHierarchicalLink(False)
# angular
self.obj205.angular.setValue('')
self.obj205.angular.setNone()
# linear
self.obj205.linear.setValue('')
self.obj205.linear.setNone()
self.obj205.GGLabel.setValue(7)
self.obj205.graphClass_= graph_DifferentialSpeedAdapter
if parent.genGraphics:
new_obj = graph_DifferentialSpeedAdapter(400.0,20.0,self.obj205)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj205.graphObject_ = new_obj
self.obj2050= AttrCalc()
self.obj2050.Copy=ATOM3Boolean()
self.obj2050.Copy.setValue(('Copy from LHS', 1))
self.obj2050.Copy.config = 0
self.obj2050.Specify=ATOM3Constraint()
self.obj2050.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.obj205.GGset2Any['angular']= self.obj2050
self.obj2051= AttrCalc()
self.obj2051.Copy=ATOM3Boolean()
self.obj2051.Copy.setValue(('Copy from LHS', 1))
self.obj2051.Copy.config = 0
self.obj2051.Specify=ATOM3Constraint()
self.obj2051.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.obj205.GGset2Any['linear']= self.obj2051
# Add node to the root: self.RHS
self.RHS.addNode(self.obj205)
self.obj205.postAction( self.RHS.CREATE )
self.obj206=DomainOutput(parent)
self.obj206.preAction( self.RHS.CREATE )
self.obj206.isGraphObjectVisual = True
if(hasattr(self.obj206, '_setHierarchicalLink')):
self.obj206._setHierarchicalLink(False)
# name
self.obj206.name.setValue('')
self.obj206.name.setNone()
self.obj206.GGLabel.setValue(6)
self.obj206.graphClass_= graph_DomainOutput
if parent.genGraphics:
new_obj = graph_DomainOutput(200.0,140.0,self.obj206)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj206.graphObject_ = new_obj
self.obj2060= AttrCalc()
self.obj2060.Copy=ATOM3Boolean()
self.obj2060.Copy.setValue(('Copy from LHS', 1))
self.obj2060.Copy.config = 0
self.obj2060.Specify=ATOM3Constraint()
self.obj2060.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.obj206.GGset2Any['name']= self.obj2060
# Add node to the root: self.RHS
self.RHS.addNode(self.obj206)
self.obj206.postAction( self.RHS.CREATE )
self.obj207=domainAdapter2domainOutput(parent)
self.obj207.preAction( self.RHS.CREATE )
self.obj207.isGraphObjectVisual = True
if(hasattr(self.obj207, '_setHierarchicalLink')):
self.obj207._setHierarchicalLink(False)
self.obj207.GGLabel.setValue(8)
self.obj207.graphClass_= graph_domainAdapter2domainOutput
if parent.genGraphics:
new_obj = graph_domainAdapter2domainOutput(446.0,158.0,self.obj207)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj207.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj207)
self.obj207.postAction( self.RHS.CREATE )
self.obj208=ROSTwist(parent)
self.obj208.preAction( self.RHS.CREATE )
self.obj208.isGraphObjectVisual = True
if(hasattr(self.obj208, '_setHierarchicalLink')):
self.obj208._setHierarchicalLink(False)
# angular
self.obj208.angular.setActionFlags([ 0, 0, 0, 0])
lcobj2 =[]
cobj2=ATOM3String('<angular>', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('<0.0>', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('<0.0>', 20)
lcobj2.append(cobj2)
self.obj208.angular.setValue(lcobj2)
self.obj208.angular.setNone()
# linear
self.obj208.linear.setActionFlags([ 0, 0, 0, 0])
lcobj2 =[]
cobj2=ATOM3String('<linear>', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('<0.0>', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('<0.0>', 20)
lcobj2.append(cobj2)
self.obj208.linear.setValue(lcobj2)
self.obj208.linear.setNone()
self.obj208.GGLabel.setValue(4)
self.obj208.graphClass_= graph_ROSTwist
if parent.genGraphics:
new_obj = graph_ROSTwist(-100.0,180.0,self.obj208)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj208.graphObject_ = new_obj
self.obj2080= AttrCalc()
self.obj2080.Copy=ATOM3Boolean()
self.obj2080.Copy.setValue(('Copy from LHS', 0))
self.obj2080.Copy.config = 0
self.obj2080.Specify=ATOM3Constraint()
self.obj2080.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.obj208.GGset2Any['angular']= self.obj2080
self.obj2081= AttrCalc()
self.obj2081.Copy=ATOM3Boolean()
self.obj2081.Copy.setValue(('Copy from LHS', 0))
self.obj2081.Copy.config = 0
self.obj2081.Specify=ATOM3Constraint()
self.obj2081.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.obj208.GGset2Any['linear']= self.obj2081
# Add node to the root: self.RHS
self.RHS.addNode(self.obj208)
self.obj208.postAction( self.RHS.CREATE )
self.obj209=ROSType(parent)
self.obj209.preAction( self.RHS.CREATE )
self.obj209.isGraphObjectVisual = True
if(hasattr(self.obj209, '_setHierarchicalLink')):
self.obj209._setHierarchicalLink(False)
self.obj209.GGLabel.setValue(5)
self.obj209.graphClass_= graph_ROSType
if parent.genGraphics:
new_obj = graph_ROSType(154.5,256.0,self.obj209)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj209.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj209)
self.obj209.postAction( self.RHS.CREATE )
self.obj210=ROSTopic(parent)
self.obj210.preAction( self.RHS.CREATE )
self.obj210.isGraphObjectVisual = True
if(hasattr(self.obj210, '_setHierarchicalLink')):
self.obj210._setHierarchicalLink(False)
# name
self.obj210.name.setValue('')
self.obj210.name.setNone()
self.obj210.GGLabel.setValue(2)
self.obj210.graphClass_= graph_ROSTopic
if parent.genGraphics:
new_obj = graph_ROSTopic(-140.0,60.0,self.obj210)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj210.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj210)
self.obj210.postAction( self.RHS.CREATE )
self.obj211=ROSNode(parent)
self.obj211.preAction( self.RHS.CREATE )
self.obj211.isGraphObjectVisual = True
if(hasattr(self.obj211, '_setHierarchicalLink')):
self.obj211._setHierarchicalLink(False)
# name
self.obj211.name.setValue('')
self.obj211.name.setNone()
self.obj211.GGLabel.setValue(1)
self.obj211.graphClass_= graph_ROSNode
if parent.genGraphics:
new_obj = graph_ROSNode(-120.0,-100.0,self.obj211)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj211.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj211)
self.obj211.postAction( self.RHS.CREATE )
self.obj212=ROSSubscribe(parent)
self.obj212.preAction( self.RHS.CREATE )
self.obj212.isGraphObjectVisual = True
if(hasattr(self.obj212, '_setHierarchicalLink')):
self.obj212._setHierarchicalLink(False)
self.obj212.GGLabel.setValue(3)
self.obj212.graphClass_= graph_ROSSubscribe
if parent.genGraphics:
new_obj = graph_ROSSubscribe(157.5,147.0,self.obj212)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj212.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj212)
self.obj212.postAction( self.RHS.CREATE )
self.obj213=GenericGraphEdge(parent)
self.obj213.preAction( self.RHS.CREATE )
self.obj213.isGraphObjectVisual = True
if(hasattr(self.obj213, '_setHierarchicalLink')):
self.obj213._setHierarchicalLink(False)
self.obj213.GGLabel.setValue(10)
self.obj213.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(368.0,264.0,self.obj213)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj213.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj213)
self.obj213.postAction( self.RHS.CREATE )
self.obj205.out_connections_.append(self.obj207)
self.obj207.in_connections_.append(self.obj205)
self.obj205.graphObject_.pendingConnections.append((self.obj205.graphObject_.tag, self.obj207.graphObject_.tag, [603.0, 164.0, 446.0, 158.0], 2, 0))
self.obj206.out_connections_.append(self.obj213)
self.obj213.in_connections_.append(self.obj206)
self.obj206.graphObject_.pendingConnections.append((self.obj206.graphObject_.tag, self.obj213.graphObject_.tag, [486.0, 293.0, 368.0, 264.0], 0, True))
self.obj207.out_connections_.append(self.obj206)
self.obj206.in_connections_.append(self.obj207)
self.obj207.graphObject_.pendingConnections.append((self.obj207.graphObject_.tag, self.obj206.graphObject_.tag, [486.0, 293.0, 446.0, 158.0], 2, 0))
self.obj209.out_connections_.append(self.obj208)
self.obj208.in_connections_.append(self.obj209)
self.obj209.graphObject_.pendingConnections.append((self.obj209.graphObject_.tag, self.obj208.graphObject_.tag, [101.0, 285.0, 154.5, 256.0], 2, 0))
self.obj210.out_connections_.append(self.obj212)
self.obj212.in_connections_.append(self.obj210)
self.obj210.graphObject_.pendingConnections.append((self.obj210.graphObject_.tag, self.obj212.graphObject_.tag, [124.0, 211.0, 157.5, 147.0], 2, 0))
self.obj210.out_connections_.append(self.obj209)
self.obj209.in_connections_.append(self.obj210)
self.obj210.graphObject_.pendingConnections.append((self.obj210.graphObject_.tag, self.obj209.graphObject_.tag, [124.0, 211.0, 154.5, 256.0], 2, 0))
self.obj212.out_connections_.append(self.obj211)
self.obj211.in_connections_.append(self.obj212)
self.obj212.graphObject_.pendingConnections.append((self.obj212.graphObject_.tag, self.obj211.graphObject_.tag, [157.0, 104.0, 157.5, 147.0], 2, 0))
self.obj213.out_connections_.append(self.obj210)
self.obj210.in_connections_.append(self.obj213)
self.obj213.graphObject_.pendingConnections.append((self.obj213.graphObject_.tag, self.obj210.graphObject_.tag, [250.0, 235.0, 368.0, 264.0], 0, True))
def condition(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the ACTION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName27 is not guaranteed to be unique (so change it, be safe!)
node2 = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
node6 = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
return not hasattr(node2, "_uniqueName27") and not hasattr(node6, "_uniqueName27")
def action(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the CONDITION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName27 is not guaranteed to be unique (so change it, be safe!)
node2 = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
node6 = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
node2._uniqueName27 = True
node6._uniqueName27 = True
class RemoveRole_GG_rule(GGrule):
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 condition(self, graphID, isograph, atom3i):
return self.graphRewritingSystem.finalStat > 20
def action(self, graphID, isograph, atom3i):
pass
class RemoveAgent_GG_rule(GGrule):
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 condition(self, graphID, isograph, atom3i):
return self.graphRewritingSystem.finalStat > 20
def action(self, graphID, isograph, atom3i):
pass
class RemoveGoal_GG_rule(GGrule):
def __init__(self, parent):
GGrule.__init__(self, 25)
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.obj1815 = metarial(parent)
self.obj1815.preAction(self.LHS.CREATE)
self.obj1815.isGraphObjectVisual = True
if (hasattr(self.obj1815, '_setHierarchicalLink')):
self.obj1815._setHierarchicalLink(False)
# MaxFlow
self.obj1815.MaxFlow.setNone()
# price
self.obj1815.price.setValue(0)
# Name
self.obj1815.Name.setValue('')
self.obj1815.Name.setNone()
# ReqFlow
self.obj1815.ReqFlow.setNone()
self.obj1815.GGLabel.setValue(1)
self.obj1815.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(280.0, 60.0, self.obj1815)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1815.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1815)
self.obj1815.postAction(self.LHS.CREATE)
self.obj1816 = Goal(parent)
self.obj1816.preAction(self.LHS.CREATE)
self.obj1816.isGraphObjectVisual = True
if (hasattr(self.obj1816, '_setHierarchicalLink')):
self.obj1816._setHierarchicalLink(False)
# name
self.obj1816.name.setValue('')
self.obj1816.name.setNone()
self.obj1816.GGLabel.setValue(3)
self.obj1816.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(100.0, 60.0, self.obj1816)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1816.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1816)
self.obj1816.postAction(self.LHS.CREATE)
self.obj1817 = GenericGraphEdge(parent)
self.obj1817.preAction(self.LHS.CREATE)
self.obj1817.isGraphObjectVisual = True
if (hasattr(self.obj1817, '_setHierarchicalLink')):
self.obj1817._setHierarchicalLink(False)
self.obj1817.GGLabel.setValue(4)
self.obj1817.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(205.0, 106.0, self.obj1817)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1817.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1817)
self.obj1817.postAction(self.LHS.CREATE)
self.obj1816.out_connections_.append(self.obj1817)
self.obj1817.in_connections_.append(self.obj1816)
self.obj1816.graphObject_.pendingConnections.append(
(self.obj1816.graphObject_.tag, self.obj1817.graphObject_.tag,
[124.0, 110.0, 205.0, 106.0], 0, True))
self.obj1817.out_connections_.append(self.obj1815)
self.obj1815.in_connections_.append(self.obj1817)
self.obj1817.graphObject_.pendingConnections.append(
(self.obj1817.graphObject_.tag, self.obj1815.graphObject_.tag,
[286.0, 102.0, 205.0, 106.0], 0, True))
self.RHS = ASG_pns(parent)
self.obj1819 = metarial(parent)
self.obj1819.preAction(self.RHS.CREATE)
self.obj1819.isGraphObjectVisual = True
if (hasattr(self.obj1819, '_setHierarchicalLink')):
self.obj1819._setHierarchicalLink(False)
# MaxFlow
self.obj1819.MaxFlow.setNone()
# price
self.obj1819.price.setValue(0)
# Name
self.obj1819.Name.setValue('')
self.obj1819.Name.setNone()
# ReqFlow
self.obj1819.ReqFlow.setNone()
self.obj1819.GGLabel.setValue(1)
self.obj1819.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(180.0, 40.0, self.obj1819)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1819.graphObject_ = new_obj
self.obj18190 = AttrCalc()
self.obj18190.Copy = ATOM3Boolean()
self.obj18190.Copy.setValue(('Copy from LHS', 1))
self.obj18190.Copy.config = 0
self.obj18190.Specify = ATOM3Constraint()
self.obj18190.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.obj1819.GGset2Any['MaxFlow'] = self.obj18190
self.obj18191 = AttrCalc()
self.obj18191.Copy = ATOM3Boolean()
self.obj18191.Copy.setValue(('Copy from LHS', 1))
self.obj18191.Copy.config = 0
self.obj18191.Specify = ATOM3Constraint()
self.obj18191.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.obj1819.GGset2Any['Name'] = self.obj18191
self.obj18192 = AttrCalc()
self.obj18192.Copy = ATOM3Boolean()
self.obj18192.Copy.setValue(('Copy from LHS', 1))
self.obj18192.Copy.config = 0
self.obj18192.Specify = ATOM3Constraint()
self.obj18192.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.obj1819.GGset2Any['ReqFlow'] = self.obj18192
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1819)
self.obj1819.postAction(self.RHS.CREATE)
def condition(self, graphID, isograph, atom3i):
return self.graphRewritingSystem.finalStat > 20
def action(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the CONDITION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName503 is not guaranteed to be unique (so change it, be safe!)
#node = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
#node._uniqueName503 = True
pass
class CreateLinkMatr2OAF_GG_rule(GGrule):
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 condition(self, graphID, isograph, atom3i):
node = self.getMatched(graphID, self.LHS.nodeWithLabel(3))
return not hasattr(node, "link2oaf")
def action(self, graphID, isograph, atom3i):
node = self.getMatched(graphID, self.LHS.nodeWithLabel(3))
node.link2oaf = True
class AssignCost4AR_GG_rule(GGrule):
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 condition(self, graphID, isograph, atom3i):
AR = self.getMatched(graphID, self.LHS.nodeWithLabel(4))
return not (hasattr(AR, "AssignCost"))
def action(self, graphID, isograph, atom3i):
AR = self.getMatched(graphID, self.LHS.nodeWithLabel(4))
AR.AssignCost = True
print '######################## Assign Cost for ' + AR.name.getValue()
class CreatLinkRaw2AR_GG_rule(GGrule):
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 condition(self, graphID, isograph, atom3i):
node = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
return not hasattr(node, "LinkRaw2AR")
def action(self, graphID, isograph, atom3i):
node = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
node.LinkRaw2AR = True
class publishBoolean2domainOutputRange_GG_rule (GGrule):
def __init__(self, parent):
GGrule.__init__(self, 1)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_RDIS(parent)
self.LHS.merge(ASG_ROSApp(parent))
self.obj219=RangeAdapter(parent)
self.obj219.preAction( self.LHS.CREATE )
self.obj219.isGraphObjectVisual = True
if(hasattr(self.obj219, '_setHierarchicalLink')):
self.obj219._setHierarchicalLink(False)
# distance
self.obj219.distance.setValue('')
self.obj219.distance.setNone()
self.obj219.GGLabel.setValue(7)
self.obj219.graphClass_= graph_RangeAdapter
if parent.genGraphics:
new_obj = graph_RangeAdapter(300.0,0.0,self.obj219)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj219.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj219)
self.obj219.postAction( self.LHS.CREATE )
self.obj220=DomainOutput(parent)
self.obj220.preAction( self.LHS.CREATE )
self.obj220.isGraphObjectVisual = True
if(hasattr(self.obj220, '_setHierarchicalLink')):
self.obj220._setHierarchicalLink(False)
# name
self.obj220.name.setValue('')
self.obj220.name.setNone()
self.obj220.GGLabel.setValue(6)
self.obj220.graphClass_= graph_DomainOutput
if parent.genGraphics:
new_obj = graph_DomainOutput(300.0,140.0,self.obj220)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj220.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj220)
self.obj220.postAction( self.LHS.CREATE )
self.obj221=domainAdapter2domainOutput(parent)
self.obj221.preAction( self.LHS.CREATE )
self.obj221.isGraphObjectVisual = True
if(hasattr(self.obj221, '_setHierarchicalLink')):
self.obj221._setHierarchicalLink(False)
self.obj221.GGLabel.setValue(8)
self.obj221.graphClass_= graph_domainAdapter2domainOutput
if parent.genGraphics:
new_obj = graph_domainAdapter2domainOutput(399.0,148.5,self.obj221)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj221.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj221)
self.obj221.postAction( self.LHS.CREATE )
self.obj222=ROSType(parent)
self.obj222.preAction( self.LHS.CREATE )
self.obj222.isGraphObjectVisual = True
if(hasattr(self.obj222, '_setHierarchicalLink')):
self.obj222._setHierarchicalLink(False)
self.obj222.GGLabel.setValue(5)
self.obj222.graphClass_= graph_ROSType
if parent.genGraphics:
new_obj = graph_ROSType(175.5,264.5,self.obj222)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj222.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj222)
self.obj222.postAction( self.LHS.CREATE )
self.obj223=ROSPublish(parent)
self.obj223.preAction( self.LHS.CREATE )
self.obj223.isGraphObjectVisual = True
if(hasattr(self.obj223, '_setHierarchicalLink')):
self.obj223._setHierarchicalLink(False)
self.obj223.GGLabel.setValue(3)
self.obj223.graphClass_= graph_ROSPublish
if parent.genGraphics:
new_obj = graph_ROSPublish(177.5,147.0,self.obj223)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj223.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj223)
self.obj223.postAction( self.LHS.CREATE )
self.obj224=ROSTopic(parent)
self.obj224.preAction( self.LHS.CREATE )
self.obj224.isGraphObjectVisual = True
if(hasattr(self.obj224, '_setHierarchicalLink')):
self.obj224._setHierarchicalLink(False)
# name
self.obj224.name.setValue('')
self.obj224.name.setNone()
self.obj224.GGLabel.setValue(2)
self.obj224.graphClass_= graph_ROSTopic
if parent.genGraphics:
new_obj = graph_ROSTopic(100.0,160.0,self.obj224)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj224.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj224)
self.obj224.postAction( self.LHS.CREATE )
self.obj225=ROSBoolean(parent)
self.obj225.preAction( self.LHS.CREATE )
self.obj225.isGraphObjectVisual = True
if(hasattr(self.obj225, '_setHierarchicalLink')):
self.obj225._setHierarchicalLink(False)
# data
self.obj225.data.setValue('')
self.obj225.data.setNone()
self.obj225.GGLabel.setValue(4)
self.obj225.graphClass_= graph_ROSBoolean
if parent.genGraphics:
new_obj = graph_ROSBoolean(120.0,280.0,self.obj225)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj225.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj225)
self.obj225.postAction( self.LHS.CREATE )
self.obj226=ROSNode(parent)
self.obj226.preAction( self.LHS.CREATE )
self.obj226.isGraphObjectVisual = True
if(hasattr(self.obj226, '_setHierarchicalLink')):
self.obj226._setHierarchicalLink(False)
# name
self.obj226.name.setValue('')
self.obj226.name.setNone()
self.obj226.GGLabel.setValue(1)
self.obj226.graphClass_= graph_ROSNode
if parent.genGraphics:
new_obj = graph_ROSNode(100.0,40.0,self.obj226)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj226.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj226)
self.obj226.postAction( self.LHS.CREATE )
self.obj219.out_connections_.append(self.obj221)
self.obj221.in_connections_.append(self.obj219)
self.obj219.graphObject_.pendingConnections.append((self.obj219.graphObject_.tag, self.obj221.graphObject_.tag, [379.0, 102.0, 399.0, 148.5], 0, True))
self.obj221.out_connections_.append(self.obj220)
self.obj220.in_connections_.append(self.obj221)
self.obj221.graphObject_.pendingConnections.append((self.obj221.graphObject_.tag, self.obj220.graphObject_.tag, [419.0, 195.0, 399.0, 148.5], 0, True))
self.obj222.out_connections_.append(self.obj225)
self.obj225.in_connections_.append(self.obj222)
self.obj222.graphObject_.pendingConnections.append((self.obj222.graphObject_.tag, self.obj225.graphObject_.tag, [174.0, 282.0, 175.5, 264.5], 0, True))
self.obj223.out_connections_.append(self.obj224)
self.obj224.in_connections_.append(self.obj223)
self.obj223.graphObject_.pendingConnections.append((self.obj223.graphObject_.tag, self.obj224.graphObject_.tag, [183.0, 164.0, 177.5, 147.0], 0, True))
self.obj224.out_connections_.append(self.obj222)
self.obj222.in_connections_.append(self.obj224)
self.obj224.graphObject_.pendingConnections.append((self.obj224.graphObject_.tag, self.obj222.graphObject_.tag, [177.0, 247.0, 175.5, 264.5], 0, True))
self.obj226.out_connections_.append(self.obj223)
self.obj223.in_connections_.append(self.obj226)
self.obj226.graphObject_.pendingConnections.append((self.obj226.graphObject_.tag, self.obj223.graphObject_.tag, [172.0, 130.0, 177.5, 147.0], 0, True))
self.RHS = ASG_RDIS(parent)
self.RHS.merge(ASG_ROSApp(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj230=RangeAdapter(parent)
self.obj230.preAction( self.RHS.CREATE )
self.obj230.isGraphObjectVisual = True
if(hasattr(self.obj230, '_setHierarchicalLink')):
self.obj230._setHierarchicalLink(False)
# distance
self.obj230.distance.setValue('')
self.obj230.distance.setNone()
self.obj230.GGLabel.setValue(7)
self.obj230.graphClass_= graph_RangeAdapter
if parent.genGraphics:
new_obj = graph_RangeAdapter(300.0,0.0,self.obj230)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj230.graphObject_ = new_obj
self.obj2300= AttrCalc()
self.obj2300.Copy=ATOM3Boolean()
self.obj2300.Copy.setValue(('Copy from LHS', 1))
self.obj2300.Copy.config = 0
self.obj2300.Specify=ATOM3Constraint()
self.obj2300.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.obj230.GGset2Any['distance']= self.obj2300
# Add node to the root: self.RHS
self.RHS.addNode(self.obj230)
self.obj230.postAction( self.RHS.CREATE )
self.obj231=DomainOutput(parent)
self.obj231.preAction( self.RHS.CREATE )
self.obj231.isGraphObjectVisual = True
if(hasattr(self.obj231, '_setHierarchicalLink')):
self.obj231._setHierarchicalLink(False)
# name
self.obj231.name.setValue('')
self.obj231.name.setNone()
self.obj231.GGLabel.setValue(6)
self.obj231.graphClass_= graph_DomainOutput
if parent.genGraphics:
new_obj = graph_DomainOutput(200.0,140.0,self.obj231)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj231.graphObject_ = new_obj
self.obj2310= AttrCalc()
self.obj2310.Copy=ATOM3Boolean()
self.obj2310.Copy.setValue(('Copy from LHS', 1))
self.obj2310.Copy.config = 0
self.obj2310.Specify=ATOM3Constraint()
self.obj2310.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.obj231.GGset2Any['name']= self.obj2310
# Add node to the root: self.RHS
self.RHS.addNode(self.obj231)
self.obj231.postAction( self.RHS.CREATE )
self.obj232=domainAdapter2domainOutput(parent)
self.obj232.preAction( self.RHS.CREATE )
self.obj232.isGraphObjectVisual = True
if(hasattr(self.obj232, '_setHierarchicalLink')):
self.obj232._setHierarchicalLink(False)
self.obj232.GGLabel.setValue(8)
self.obj232.graphClass_= graph_domainAdapter2domainOutput
if parent.genGraphics:
new_obj = graph_domainAdapter2domainOutput(399.0,148.5,self.obj232)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj232.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj232)
self.obj232.postAction( self.RHS.CREATE )
self.obj233=ROSType(parent)
self.obj233.preAction( self.RHS.CREATE )
self.obj233.isGraphObjectVisual = True
if(hasattr(self.obj233, '_setHierarchicalLink')):
self.obj233._setHierarchicalLink(False)
self.obj233.GGLabel.setValue(5)
self.obj233.graphClass_= graph_ROSType
if parent.genGraphics:
new_obj = graph_ROSType(175.5,264.5,self.obj233)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj233.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj233)
self.obj233.postAction( self.RHS.CREATE )
self.obj234=ROSPublish(parent)
self.obj234.preAction( self.RHS.CREATE )
self.obj234.isGraphObjectVisual = True
if(hasattr(self.obj234, '_setHierarchicalLink')):
self.obj234._setHierarchicalLink(False)
self.obj234.GGLabel.setValue(3)
self.obj234.graphClass_= graph_ROSPublish
if parent.genGraphics:
new_obj = graph_ROSPublish(177.5,147.0,self.obj234)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj234.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj234)
self.obj234.postAction( self.RHS.CREATE )
self.obj235=ROSTopic(parent)
self.obj235.preAction( self.RHS.CREATE )
self.obj235.isGraphObjectVisual = True
if(hasattr(self.obj235, '_setHierarchicalLink')):
self.obj235._setHierarchicalLink(False)
# name
self.obj235.name.setValue('')
self.obj235.name.setNone()
self.obj235.GGLabel.setValue(2)
self.obj235.graphClass_= graph_ROSTopic
if parent.genGraphics:
new_obj = graph_ROSTopic(-160.0,20.0,self.obj235)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj235.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj235)
self.obj235.postAction( self.RHS.CREATE )
self.obj236=ROSBoolean(parent)
self.obj236.preAction( self.RHS.CREATE )
self.obj236.isGraphObjectVisual = True
if(hasattr(self.obj236, '_setHierarchicalLink')):
self.obj236._setHierarchicalLink(False)
# data
self.obj236.data.setValue('<distance == 0>')
self.obj236.GGLabel.setValue(4)
self.obj236.graphClass_= graph_ROSBoolean
if parent.genGraphics:
new_obj = graph_ROSBoolean(-120.0,200.0,self.obj236)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj236.graphObject_ = new_obj
self.obj2360= AttrCalc()
self.obj2360.Copy=ATOM3Boolean()
self.obj2360.Copy.setValue(('Copy from LHS', 0))
self.obj2360.Copy.config = 0
self.obj2360.Specify=ATOM3Constraint()
self.obj2360.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.obj236.GGset2Any['data']= self.obj2360
# Add node to the root: self.RHS
self.RHS.addNode(self.obj236)
self.obj236.postAction( self.RHS.CREATE )
self.obj237=ROSNode(parent)
self.obj237.preAction( self.RHS.CREATE )
self.obj237.isGraphObjectVisual = True
if(hasattr(self.obj237, '_setHierarchicalLink')):
self.obj237._setHierarchicalLink(False)
# name
self.obj237.name.setValue('')
self.obj237.name.setNone()
self.obj237.GGLabel.setValue(1)
self.obj237.graphClass_= graph_ROSNode
if parent.genGraphics:
new_obj = graph_ROSNode(-200.0,-140.0,self.obj237)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj237.graphObject_ = new_obj
self.obj2370= AttrCalc()
self.obj2370.Copy=ATOM3Boolean()
self.obj2370.Copy.setValue(('Copy from LHS', 1))
self.obj2370.Copy.config = 0
self.obj2370.Specify=ATOM3Constraint()
self.obj2370.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.obj237.GGset2Any['name']= self.obj2370
# Add node to the root: self.RHS
self.RHS.addNode(self.obj237)
self.obj237.postAction( self.RHS.CREATE )
self.obj238=GenericGraphEdge(parent)
self.obj238.preAction( self.RHS.CREATE )
self.obj238.isGraphObjectVisual = True
if(hasattr(self.obj238, '_setHierarchicalLink')):
self.obj238._setHierarchicalLink(False)
self.obj238.GGLabel.setValue(10)
self.obj238.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(358.0,244.0,self.obj238)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj238.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj238)
self.obj238.postAction( self.RHS.CREATE )
self.obj230.out_connections_.append(self.obj232)
self.obj232.in_connections_.append(self.obj230)
self.obj230.graphObject_.pendingConnections.append((self.obj230.graphObject_.tag, self.obj232.graphObject_.tag, [499.0, 158.0, 399.0, 148.5], 2, 0))
self.obj231.out_connections_.append(self.obj238)
self.obj238.in_connections_.append(self.obj231)
self.obj231.graphObject_.pendingConnections.append((self.obj231.graphObject_.tag, self.obj238.graphObject_.tag, [486.0, 293.0, 358.0, 244.0], 0, True))
self.obj232.out_connections_.append(self.obj231)
self.obj231.in_connections_.append(self.obj232)
self.obj232.graphObject_.pendingConnections.append((self.obj232.graphObject_.tag, self.obj231.graphObject_.tag, [486.0, 293.0, 399.0, 148.5], 2, 0))
self.obj233.out_connections_.append(self.obj236)
self.obj236.in_connections_.append(self.obj233)
self.obj233.graphObject_.pendingConnections.append((self.obj233.graphObject_.tag, self.obj236.graphObject_.tag, [196.0, 300.0, 175.5, 264.5], 2, 0))
self.obj234.out_connections_.append(self.obj235)
self.obj235.in_connections_.append(self.obj234)
self.obj234.graphObject_.pendingConnections.append((self.obj234.graphObject_.tag, self.obj235.graphObject_.tag, [104.0, 171.0, 177.5, 147.0], 2, 0))
self.obj235.out_connections_.append(self.obj233)
self.obj233.in_connections_.append(self.obj235)
self.obj235.graphObject_.pendingConnections.append((self.obj235.graphObject_.tag, self.obj233.graphObject_.tag, [104.0, 171.0, 175.5, 264.5], 2, 0))
self.obj237.out_connections_.append(self.obj234)
self.obj234.in_connections_.append(self.obj237)
self.obj237.graphObject_.pendingConnections.append((self.obj237.graphObject_.tag, self.obj234.graphObject_.tag, [77.0, 64.0, 177.5, 147.0], 2, 0))
self.obj238.out_connections_.append(self.obj235)
self.obj235.in_connections_.append(self.obj238)
self.obj238.graphObject_.pendingConnections.append((self.obj238.graphObject_.tag, self.obj235.graphObject_.tag, [230.0, 195.0, 358.0, 244.0], 0, True))
def condition(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the ACTION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName35 is not guaranteed to be unique (so change it, be safe!)
node2 = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
node6 = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
return not hasattr(node2, "_uniqueName35") and not hasattr(node6, "_uniqueName35")
def action(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the CONDITION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName35 is not guaranteed to be unique (so change it, be safe!)
node2 = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
node6 = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
node2._uniqueName35 = True
node6._uniqueName35 = True
class CreateLinkMat_ARG2Goal_GG_rule(GGrule):
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 condition(self, graphID, isograph, atom3i):
print '======> Link Aux Condition' # _ Agent2Raw_GG_rule.py _
aRg = self.getMatched(graphID, self.LHS.nodeWithLabel(4))
nameARG = aRg.Name.getValue()
g = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
# test if nameARG end with name of Goal
print nameARG + ' END WITH ' + g.Name.getValue()
print nameARG.endswith(g.Name.getValue())
if nameARG.endswith(g.Name.getValue()) and not hasattr(aRg, 'LinkAux'):
print 'Real True'
return True
else:
print 'Real False'
return False
def action(self, graphID, isograph, atom3i):
print '======> Link Aux Action'
aRg = self.getMatched(graphID, self.LHS.nodeWithLabel(4))
aRg.LinkAux = True
class TransGoal2Mat_GG_rule(GGrule):
def __init__(self, parent):
GGrule.__init__(self, 11)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.obj1638 = Goal(parent)
self.obj1638.preAction(self.LHS.CREATE)
self.obj1638.isGraphObjectVisual = True
if (hasattr(self.obj1638, '_setHierarchicalLink')):
self.obj1638._setHierarchicalLink(False)
# name
self.obj1638.name.setValue('')
self.obj1638.name.setNone()
self.obj1638.GGLabel.setValue(1)
self.obj1638.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(80.0, 80.0, self.obj1638)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1638.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1638)
self.obj1638.postAction(self.LHS.CREATE)
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1642 = metarial(parent)
self.obj1642.preAction(self.RHS.CREATE)
self.obj1642.isGraphObjectVisual = True
if (hasattr(self.obj1642, '_setHierarchicalLink')):
self.obj1642._setHierarchicalLink(False)
# MaxFlow
self.obj1642.MaxFlow.setValue(999999)
# price
self.obj1642.price.setValue(0)
# Name
self.obj1642.Name.setValue('')
self.obj1642.Name.setNone()
# ReqFlow
self.obj1642.ReqFlow.setValue(0)
self.obj1642.GGLabel.setValue(2)
self.obj1642.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(300.0, 60.0, self.obj1642)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1642.graphObject_ = new_obj
self.obj16420 = AttrCalc()
self.obj16420.Copy = ATOM3Boolean()
self.obj16420.Copy.setValue(('Copy from LHS', 1))
self.obj16420.Copy.config = 0
self.obj16420.Specify = ATOM3Constraint()
self.obj16420.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.obj1642.GGset2Any['MaxFlow'] = self.obj16420
self.obj16421 = AttrCalc()
self.obj16421.Copy = ATOM3Boolean()
self.obj16421.Copy.setValue(('Copy from LHS', 0))
self.obj16421.Copy.config = 0
self.obj16421.Specify = ATOM3Constraint()
self.obj16421.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()\n'
))
self.obj1642.GGset2Any['Name'] = self.obj16421
self.obj16422 = AttrCalc()
self.obj16422.Copy = ATOM3Boolean()
self.obj16422.Copy.setValue(('Copy from LHS', 1))
self.obj16422.Copy.config = 0
self.obj16422.Specify = ATOM3Constraint()
self.obj16422.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.obj1642.GGset2Any['ReqFlow'] = self.obj16422
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1642)
self.obj1642.postAction(self.RHS.CREATE)
self.obj1643 = Goal(parent)
self.obj1643.preAction(self.RHS.CREATE)
self.obj1643.isGraphObjectVisual = True
if (hasattr(self.obj1643, '_setHierarchicalLink')):
self.obj1643._setHierarchicalLink(False)
# name
self.obj1643.name.setValue('')
self.obj1643.name.setNone()
self.obj1643.GGLabel.setValue(1)
self.obj1643.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(80.0, 80.0, self.obj1643)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1643.graphObject_ = new_obj
self.obj16430 = AttrCalc()
self.obj16430.Copy = ATOM3Boolean()
self.obj16430.Copy.setValue(('Copy from LHS', 1))
self.obj16430.Copy.config = 0
self.obj16430.Specify = ATOM3Constraint()
self.obj16430.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.obj1643.GGset2Any['name'] = self.obj16430
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1643)
self.obj1643.postAction(self.RHS.CREATE)
self.obj1644 = GenericGraphEdge(parent)
self.obj1644.preAction(self.RHS.CREATE)
self.obj1644.isGraphObjectVisual = True
if (hasattr(self.obj1644, '_setHierarchicalLink')):
self.obj1644._setHierarchicalLink(False)
self.obj1644.GGLabel.setValue(4)
self.obj1644.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(209.5, 91.5, self.obj1644)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1644.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1644)
self.obj1644.postAction(self.RHS.CREATE)
self.obj1643.out_connections_.append(self.obj1644)
self.obj1644.in_connections_.append(self.obj1643)
self.obj1643.graphObject_.pendingConnections.append(
(self.obj1643.graphObject_.tag, self.obj1644.graphObject_.tag,
[113.0, 81.0, 209.5, 91.5], 0, True))
self.obj1644.out_connections_.append(self.obj1642)
self.obj1642.in_connections_.append(self.obj1644)
self.obj1644.graphObject_.pendingConnections.append(
(self.obj1644.graphObject_.tag, self.obj1642.graphObject_.tag,
[306.0, 102.0, 209.5, 91.5], 0, True))
def condition(self, graphID, isograph, atom3i):
node = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
return not hasattr(node, "Goal2Mat")
def action(self, graphID, isograph, atom3i):
node = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
node.Goal2Mat = True
class CreateMat_ARG_GG_rule (GGrule):
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 condition(self, graphID, isograph, atom3i):
print '======> GenAux1 Condition'
a = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
aN = a.name.getValue()
#print a.name.getValue()+' has att AUX : '+str( hasattr(a, "AUX") )
r = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
Rn = r.name.getValue()
g = self.getMatched(graphID, self.LHS.nodeWithLabel(3))
Gn = g.name.getValue()
# add list to the Agent Node
if not hasattr(a,'markedNode') :
a.markedNode = []
print 'add List to '+aN
print 'CHeck if '+aN+'Have'
for ele in a.markedNode :
if ele == (Rn,Gn) : return False
return True
# print 'Check if '+aN+'Have '
# for ele in a.markedNode :
# if ele == (Rn,Gn) : return False
# return True
def action(self, graphID, isograph, atom3i):
print '======> GenAux1 ACtion'
a = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
aN = a.name.getValue()
#print a.name.getValue()+' has att AUX : '+str( hasattr(a, "AUX") )
r = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
Rn = r.name.getValue()
g = self.getMatched(graphID, self.LHS.nodeWithLabel(3))
Gn = g.name.getValue()
# add ele list to the Agent Node
print 'Add Ele into list of '+aN
a.markedNode.append( (Rn,Gn) )
print 'List of MarkedNode'
for ele in a.markedNode :
print ele
class subscribeTwist2interfaceDiffSpeede_GG_rule (GGrule):
def __init__(self, parent):
GGrule.__init__(self, 1)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_RDIS(parent)
self.LHS.merge(ASG_ROSApp(parent))
self.obj503=DifferentialSpeedAdapter(parent)
self.obj503.preAction( self.LHS.CREATE )
self.obj503.isGraphObjectVisual = True
if(hasattr(self.obj503, '_setHierarchicalLink')):
self.obj503._setHierarchicalLink(False)
# angular
self.obj503.angular.setValue('')
self.obj503.angular.setNone()
# linear
self.obj503.linear.setValue('')
self.obj503.linear.setNone()
self.obj503.GGLabel.setValue(7)
self.obj503.graphClass_= graph_DifferentialSpeedAdapter
if parent.genGraphics:
new_obj = graph_DifferentialSpeedAdapter(320.0,0.0,self.obj503)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj503.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj503)
self.obj503.postAction( self.LHS.CREATE )
self.obj500=DomainInterface(parent)
self.obj500.preAction( self.LHS.CREATE )
self.obj500.isGraphObjectVisual = True
if(hasattr(self.obj500, '_setHierarchicalLink')):
self.obj500._setHierarchicalLink(False)
# name
self.obj500.name.setValue('')
self.obj500.name.setNone()
self.obj500.GGLabel.setValue(6)
self.obj500.graphClass_= graph_DomainInterface
if parent.genGraphics:
new_obj = graph_DomainInterface(300.0,180.0,self.obj500)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj500.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj500)
self.obj500.postAction( self.LHS.CREATE )
self.obj504=domainAdapter2domainInterface(parent)
self.obj504.preAction( self.LHS.CREATE )
self.obj504.isGraphObjectVisual = True
if(hasattr(self.obj504, '_setHierarchicalLink')):
self.obj504._setHierarchicalLink(False)
self.obj504.GGLabel.setValue(8)
self.obj504.graphClass_= graph_domainAdapter2domainInterface
if parent.genGraphics:
new_obj = graph_domainAdapter2domainInterface(452.5,155.0,self.obj504)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj504.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj504)
self.obj504.postAction( self.LHS.CREATE )
self.obj492=ROSTwist(parent)
self.obj492.preAction( self.LHS.CREATE )
self.obj492.isGraphObjectVisual = True
if(hasattr(self.obj492, '_setHierarchicalLink')):
self.obj492._setHierarchicalLink(False)
# angular
self.obj492.angular.setActionFlags([ 0, 0, 0, 0])
lcobj2 =[]
cobj2=ATOM3String('x', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('y', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('z', 20)
lcobj2.append(cobj2)
self.obj492.angular.setValue(lcobj2)
self.obj492.angular.setNone()
# linear
self.obj492.linear.setActionFlags([ 0, 0, 0, 0])
lcobj2 =[]
cobj2=ATOM3String('x', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('y', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('z', 20)
lcobj2.append(cobj2)
self.obj492.linear.setValue(lcobj2)
self.obj492.linear.setNone()
self.obj492.GGLabel.setValue(4)
self.obj492.graphClass_= graph_ROSTwist
if parent.genGraphics:
new_obj = graph_ROSTwist(80.0,320.0,self.obj492)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj492.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj492)
self.obj492.postAction( self.LHS.CREATE )
self.obj493=ROSType(parent)
self.obj493.preAction( self.LHS.CREATE )
self.obj493.isGraphObjectVisual = True
if(hasattr(self.obj493, '_setHierarchicalLink')):
self.obj493._setHierarchicalLink(False)
self.obj493.GGLabel.setValue(5)
self.obj493.graphClass_= graph_ROSType
if parent.genGraphics:
new_obj = graph_ROSType(87.0,301.0,self.obj493)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj493.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj493)
self.obj493.postAction( self.LHS.CREATE )
self.obj490=ROSTopic(parent)
self.obj490.preAction( self.LHS.CREATE )
self.obj490.isGraphObjectVisual = True
if(hasattr(self.obj490, '_setHierarchicalLink')):
self.obj490._setHierarchicalLink(False)
# name
self.obj490.name.setValue('')
self.obj490.name.setNone()
self.obj490.GGLabel.setValue(2)
self.obj490.graphClass_= graph_ROSTopic
if parent.genGraphics:
new_obj = graph_ROSTopic(80.0,180.0,self.obj490)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj490.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj490)
self.obj490.postAction( self.LHS.CREATE )
self.obj489=ROSNode(parent)
self.obj489.preAction( self.LHS.CREATE )
self.obj489.isGraphObjectVisual = True
if(hasattr(self.obj489, '_setHierarchicalLink')):
self.obj489._setHierarchicalLink(False)
# name
self.obj489.name.setValue('')
self.obj489.name.setNone()
self.obj489.GGLabel.setValue(1)
self.obj489.graphClass_= graph_ROSNode
if parent.genGraphics:
new_obj = graph_ROSNode(80.0,40.0,self.obj489)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj489.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj489)
self.obj489.postAction( self.LHS.CREATE )
self.obj491=ROSSubscribe(parent)
self.obj491.preAction( self.LHS.CREATE )
self.obj491.isGraphObjectVisual = True
if(hasattr(self.obj491, '_setHierarchicalLink')):
self.obj491._setHierarchicalLink(False)
self.obj491.GGLabel.setValue(3)
self.obj491.graphClass_= graph_ROSSubscribe
if parent.genGraphics:
new_obj = graph_ROSSubscribe(157.5,157.0,self.obj491)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj491.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj491)
self.obj491.postAction( self.LHS.CREATE )
self.obj503.out_connections_.append(self.obj504)
self.obj504.in_connections_.append(self.obj503)
self.obj503.graphObject_.pendingConnections.append((self.obj503.graphObject_.tag, self.obj504.graphObject_.tag, [422.0, 91.0, 452.5, 155.0], 0, True))
self.obj504.out_connections_.append(self.obj500)
self.obj500.in_connections_.append(self.obj504)
self.obj504.graphObject_.pendingConnections.append((self.obj504.graphObject_.tag, self.obj500.graphObject_.tag, [443.0, 239.0, 452.5, 155.0], 0, True))
self.obj493.out_connections_.append(self.obj492)
self.obj492.in_connections_.append(self.obj493)
self.obj493.graphObject_.pendingConnections.append((self.obj493.graphObject_.tag, self.obj492.graphObject_.tag, [83.0, 324.0, 87.0, 301.0], 0, True))
self.obj490.out_connections_.append(self.obj491)
self.obj491.in_connections_.append(self.obj490)
self.obj490.graphObject_.pendingConnections.append((self.obj490.graphObject_.tag, self.obj491.graphObject_.tag, [163.0, 184.0, 157.5, 157.0], 0, True))
self.obj490.out_connections_.append(self.obj493)
self.obj493.in_connections_.append(self.obj490)
self.obj490.graphObject_.pendingConnections.append((self.obj490.graphObject_.tag, self.obj493.graphObject_.tag, [91.0, 278.0, 87.0, 301.0], 0, True))
self.obj491.out_connections_.append(self.obj489)
self.obj489.in_connections_.append(self.obj491)
self.obj491.graphObject_.pendingConnections.append((self.obj491.graphObject_.tag, self.obj489.graphObject_.tag, [152.0, 130.0, 157.5, 157.0], 0, True))
self.RHS = ASG_RDIS(parent)
self.RHS.merge(ASG_ROSApp(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj503=DifferentialSpeedAdapter(parent)
self.obj503.preAction( self.RHS.CREATE )
self.obj503.isGraphObjectVisual = True
if(hasattr(self.obj503, '_setHierarchicalLink')):
self.obj503._setHierarchicalLink(False)
# angular
self.obj503.angular.setValue('<angular[0]>')
# linear
self.obj503.linear.setValue('<linear[0]>')
self.obj503.GGLabel.setValue(7)
self.obj503.graphClass_= graph_DifferentialSpeedAdapter
if parent.genGraphics:
new_obj = graph_DifferentialSpeedAdapter(320.0,0.0,self.obj503)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj503.graphObject_ = new_obj
self.obj5030= AttrCalc()
self.obj5030.Copy=ATOM3Boolean()
self.obj5030.Copy.setValue(('Copy from LHS', 0))
self.obj5030.Copy.config = 0
self.obj5030.Specify=ATOM3Constraint()
self.obj5030.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.obj503.GGset2Any['angular']= self.obj5030
self.obj5031= AttrCalc()
self.obj5031.Copy=ATOM3Boolean()
self.obj5031.Copy.setValue(('Copy from LHS', 0))
self.obj5031.Copy.config = 0
self.obj5031.Specify=ATOM3Constraint()
self.obj5031.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.obj503.GGset2Any['linear']= self.obj5031
# Add node to the root: self.RHS
self.RHS.addNode(self.obj503)
self.obj503.postAction( self.RHS.CREATE )
self.obj500=DomainInterface(parent)
self.obj500.preAction( self.RHS.CREATE )
self.obj500.isGraphObjectVisual = True
if(hasattr(self.obj500, '_setHierarchicalLink')):
self.obj500._setHierarchicalLink(False)
# name
self.obj500.name.setValue('')
self.obj500.name.setNone()
self.obj500.GGLabel.setValue(6)
self.obj500.graphClass_= graph_DomainInterface
if parent.genGraphics:
new_obj = graph_DomainInterface(300.0,80.0,self.obj500)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj500.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj500)
self.obj500.postAction( self.RHS.CREATE )
self.obj504=domainAdapter2domainInterface(parent)
self.obj504.preAction( self.RHS.CREATE )
self.obj504.isGraphObjectVisual = True
if(hasattr(self.obj504, '_setHierarchicalLink')):
self.obj504._setHierarchicalLink(False)
self.obj504.GGLabel.setValue(8)
self.obj504.graphClass_= graph_domainAdapter2domainInterface
if parent.genGraphics:
new_obj = graph_domainAdapter2domainInterface(452.5,155.0,self.obj504)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj504.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj504)
self.obj504.postAction( self.RHS.CREATE )
self.obj492=ROSTwist(parent)
self.obj492.preAction( self.RHS.CREATE )
self.obj492.isGraphObjectVisual = True
if(hasattr(self.obj492, '_setHierarchicalLink')):
self.obj492._setHierarchicalLink(False)
# angular
self.obj492.angular.setActionFlags([ 0, 0, 0, 0])
lcobj2 =[]
cobj2=ATOM3String('x', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('y', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('z', 20)
lcobj2.append(cobj2)
self.obj492.angular.setValue(lcobj2)
self.obj492.angular.setNone()
# linear
self.obj492.linear.setActionFlags([ 0, 0, 0, 0])
lcobj2 =[]
cobj2=ATOM3String('x', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('y', 20)
lcobj2.append(cobj2)
cobj2=ATOM3String('z', 20)
lcobj2.append(cobj2)
self.obj492.linear.setValue(lcobj2)
self.obj492.linear.setNone()
self.obj492.GGLabel.setValue(4)
self.obj492.graphClass_= graph_ROSTwist
if parent.genGraphics:
new_obj = graph_ROSTwist(80.0,260.0,self.obj492)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj492.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj492)
self.obj492.postAction( self.RHS.CREATE )
self.obj493=ROSType(parent)
self.obj493.preAction( self.RHS.CREATE )
self.obj493.isGraphObjectVisual = True
if(hasattr(self.obj493, '_setHierarchicalLink')):
self.obj493._setHierarchicalLink(False)
self.obj493.GGLabel.setValue(5)
self.obj493.graphClass_= graph_ROSType
if parent.genGraphics:
new_obj = graph_ROSType(87.0,301.0,self.obj493)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj493.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj493)
self.obj493.postAction( self.RHS.CREATE )
self.obj490=ROSTopic(parent)
self.obj490.preAction( self.RHS.CREATE )
self.obj490.isGraphObjectVisual = True
if(hasattr(self.obj490, '_setHierarchicalLink')):
self.obj490._setHierarchicalLink(False)
# name
self.obj490.name.setValue('')
self.obj490.name.setNone()
self.obj490.GGLabel.setValue(2)
self.obj490.graphClass_= graph_ROSTopic
if parent.genGraphics:
new_obj = graph_ROSTopic(80.0,80.0,self.obj490)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj490.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj490)
self.obj490.postAction( self.RHS.CREATE )
self.obj489=ROSNode(parent)
self.obj489.preAction( self.RHS.CREATE )
self.obj489.isGraphObjectVisual = True
if(hasattr(self.obj489, '_setHierarchicalLink')):
self.obj489._setHierarchicalLink(False)
# name
self.obj489.name.setValue('')
self.obj489.name.setNone()
self.obj489.GGLabel.setValue(1)
self.obj489.graphClass_= graph_ROSNode
if parent.genGraphics:
new_obj = graph_ROSNode(80.0,-140.0,self.obj489)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj489.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj489)
self.obj489.postAction( self.RHS.CREATE )
self.obj491=ROSSubscribe(parent)
self.obj491.preAction( self.RHS.CREATE )
self.obj491.isGraphObjectVisual = True
if(hasattr(self.obj491, '_setHierarchicalLink')):
self.obj491._setHierarchicalLink(False)
self.obj491.GGLabel.setValue(3)
self.obj491.graphClass_= graph_ROSSubscribe
if parent.genGraphics:
new_obj = graph_ROSSubscribe(157.5,157.0,self.obj491)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj491.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj491)
self.obj491.postAction( self.RHS.CREATE )
self.obj517=GenericGraphEdge(parent)
self.obj517.preAction( self.RHS.CREATE )
self.obj517.isGraphObjectVisual = True
if(hasattr(self.obj517, '_setHierarchicalLink')):
self.obj517._setHierarchicalLink(False)
self.obj517.GGLabel.setValue(10)
self.obj517.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(261.0,226.5,self.obj517)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj517.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj517)
self.obj517.postAction( self.RHS.CREATE )
self.obj503.out_connections_.append(self.obj504)
self.obj504.in_connections_.append(self.obj503)
self.obj503.graphObject_.pendingConnections.append((self.obj503.graphObject_.tag, self.obj504.graphObject_.tag, [523.0, 164.0, 452.5, 155.0], 2, 0))
self.obj504.out_connections_.append(self.obj500)
self.obj500.in_connections_.append(self.obj504)
self.obj504.graphObject_.pendingConnections.append((self.obj504.graphObject_.tag, self.obj500.graphObject_.tag, [305.0, 234.0, 452.5, 155.0], 2, 0))
self.obj493.out_connections_.append(self.obj492)
self.obj492.in_connections_.append(self.obj493)
self.obj493.graphObject_.pendingConnections.append((self.obj493.graphObject_.tag, self.obj492.graphObject_.tag, [101.0, 365.0, 87.0, 301.0], 2, 0))
self.obj490.out_connections_.append(self.obj491)
self.obj491.in_connections_.append(self.obj490)
self.obj490.graphObject_.pendingConnections.append((self.obj490.graphObject_.tag, self.obj491.graphObject_.tag, [84.0, 231.0, 157.5, 157.0], 2, 0))
self.obj490.out_connections_.append(self.obj493)
self.obj493.in_connections_.append(self.obj490)
self.obj490.graphObject_.pendingConnections.append((self.obj490.graphObject_.tag, self.obj493.graphObject_.tag, [84.0, 231.0, 87.0, 301.0], 2, 0))
self.obj490.out_connections_.append(self.obj517)
self.obj517.in_connections_.append(self.obj490)
self.obj490.graphObject_.pendingConnections.append((self.obj490.graphObject_.tag, self.obj517.graphObject_.tag, [217.0, 219.0, 261.0, 226.5], 0, True))
self.obj491.out_connections_.append(self.obj489)
self.obj489.in_connections_.append(self.obj491)
self.obj491.graphObject_.pendingConnections.append((self.obj491.graphObject_.tag, self.obj489.graphObject_.tag, [97.0, 64.0, 157.5, 157.0], 2, 0))
self.obj517.out_connections_.append(self.obj500)
self.obj500.in_connections_.append(self.obj517)
self.obj517.graphObject_.pendingConnections.append((self.obj517.graphObject_.tag, self.obj500.graphObject_.tag, [305.0, 234.0, 261.0, 226.5], 0, True))
def condition(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the ACTION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName20 is not guaranteed to be unique (so change it, be safe!)
node2 = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
node6 = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
return not hasattr(node2, "_uniqueName20") and not hasattr(node6, "_uniqueName20")
def action(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the CONDITION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName20 is not guaranteed to be unique (so change it, be safe!)
node2 = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
node6 = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
node2._uniqueName20 = True
node6._uniqueName20 = True
class TransLinkAR2OpUnit_GG_rule (GGrule):
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 condition(self, graphID, isograph, atom3i):
node = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
node2 = self.getMatched(graphID, self.LHS.nodeWithLabel(2))
print node.name.getValue()+' '+node2.name.getValue()
# remplaceed by "LinkAR2OpUnit"
return not( hasattr(node,node2.name.getValue()+'7') and hasattr(node2, node.name.getValue()+'7') )
def action(self, graphID, isograph, atom3i):
node = self.getMatched ( graphID , self.LHS.nodeWithLabel(1) )
node2 = self.getMatched ( graphID , self.LHS.nodeWithLabel(2) )
setattr( node ,node2.name.getValue()+'7' ,True )
setattr( node2 ,node.name.getValue()+'7' ,True )
class TransAgent2Raw_GG_rule(GGrule):
def __init__(self, parent):
GGrule.__init__(self, 9)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_omacs(parent)
self.obj1607 = Agent(parent)
self.obj1607.preAction(self.LHS.CREATE)
self.obj1607.isGraphObjectVisual = True
if (hasattr(self.obj1607, '_setHierarchicalLink')):
self.obj1607._setHierarchicalLink(False)
# price
self.obj1607.price.setNone()
# name
self.obj1607.name.setValue('')
self.obj1607.name.setNone()
self.obj1607.GGLabel.setValue(1)
self.obj1607.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(100.0, 20.0, self.obj1607)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1607.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1607)
self.obj1607.postAction(self.LHS.CREATE)
self.obj1608 = Role(parent)
self.obj1608.preAction(self.LHS.CREATE)
self.obj1608.isGraphObjectVisual = True
if (hasattr(self.obj1608, '_setHierarchicalLink')):
self.obj1608._setHierarchicalLink(False)
# name
self.obj1608.name.setValue('')
self.obj1608.name.setNone()
self.obj1608.GGLabel.setValue(2)
self.obj1608.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(360.0, 160.0, self.obj1608)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1608.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1608)
self.obj1608.postAction(self.LHS.CREATE)
self.obj1609 = CapableOf(parent)
self.obj1609.preAction(self.LHS.CREATE)
self.obj1609.isGraphObjectVisual = True
if (hasattr(self.obj1609, '_setHierarchicalLink')):
self.obj1609._setHierarchicalLink(False)
# rate
self.obj1609.rate.setNone()
self.obj1609.GGLabel.setValue(3)
self.obj1609.graphClass_ = graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(281.5, 134.0, self.obj1609)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1609.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1609)
self.obj1609.postAction(self.LHS.CREATE)
self.obj1607.out_connections_.append(self.obj1609)
self.obj1609.in_connections_.append(self.obj1607)
self.obj1607.graphObject_.pendingConnections.append(
(self.obj1607.graphObject_.tag, self.obj1609.graphObject_.tag,
[125.0, 82.0, 161.0, 153.0, 281.5, 134.0], 2, True))
self.obj1609.out_connections_.append(self.obj1608)
self.obj1608.in_connections_.append(self.obj1609)
self.obj1609.graphObject_.pendingConnections.append(
(self.obj1609.graphObject_.tag, self.obj1608.graphObject_.tag,
[384.0, 161.0, 402.0, 115.0, 281.5, 134.0], 2, True))
self.RHS = ASG_omacs(parent)
self.RHS.merge(ASG_pns(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1613 = Agent(parent)
self.obj1613.preAction(self.RHS.CREATE)
self.obj1613.isGraphObjectVisual = True
if (hasattr(self.obj1613, '_setHierarchicalLink')):
self.obj1613._setHierarchicalLink(False)
# price
self.obj1613.price.setNone()
# name
self.obj1613.name.setValue('')
self.obj1613.name.setNone()
self.obj1613.GGLabel.setValue(1)
self.obj1613.graphClass_ = graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(100.0, 20.0, self.obj1613)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1613.graphObject_ = new_obj
self.obj16130 = AttrCalc()
self.obj16130.Copy = ATOM3Boolean()
self.obj16130.Copy.setValue(('Copy from LHS', 1))
self.obj16130.Copy.config = 0
self.obj16130.Specify = ATOM3Constraint()
self.obj16130.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.obj1613.GGset2Any['price'] = self.obj16130
self.obj16131 = AttrCalc()
self.obj16131.Copy = ATOM3Boolean()
self.obj16131.Copy.setValue(('Copy from LHS', 1))
self.obj16131.Copy.config = 0
self.obj16131.Specify = ATOM3Constraint()
self.obj16131.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.obj1613.GGset2Any['name'] = self.obj16131
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1613)
self.obj1613.postAction(self.RHS.CREATE)
self.obj1614 = Role(parent)
self.obj1614.preAction(self.RHS.CREATE)
self.obj1614.isGraphObjectVisual = True
if (hasattr(self.obj1614, '_setHierarchicalLink')):
self.obj1614._setHierarchicalLink(False)
# name
self.obj1614.name.setValue('')
self.obj1614.name.setNone()
self.obj1614.GGLabel.setValue(2)
self.obj1614.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(360.0, 160.0, self.obj1614)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1614.graphObject_ = new_obj
self.obj16140 = AttrCalc()
self.obj16140.Copy = ATOM3Boolean()
self.obj16140.Copy.setValue(('Copy from LHS', 1))
self.obj16140.Copy.config = 0
self.obj16140.Specify = ATOM3Constraint()
self.obj16140.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.obj1614.GGset2Any['name'] = self.obj16140
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1614)
self.obj1614.postAction(self.RHS.CREATE)
self.obj1615 = CapableOf(parent)
self.obj1615.preAction(self.RHS.CREATE)
self.obj1615.isGraphObjectVisual = True
if (hasattr(self.obj1615, '_setHierarchicalLink')):
self.obj1615._setHierarchicalLink(False)
# rate
self.obj1615.rate.setValue(0.0)
self.obj1615.GGLabel.setValue(3)
self.obj1615.graphClass_ = graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(281.5, 134.0, self.obj1615)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1615.graphObject_ = new_obj
self.obj16150 = AttrCalc()
self.obj16150.Copy = ATOM3Boolean()
self.obj16150.Copy.setValue(('Copy from LHS', 1))
self.obj16150.Copy.config = 0
self.obj16150.Specify = ATOM3Constraint()
self.obj16150.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.obj1615.GGset2Any['rate'] = self.obj16150
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1615)
self.obj1615.postAction(self.RHS.CREATE)
self.obj1616 = rawMaterial(parent)
self.obj1616.preAction(self.RHS.CREATE)
self.obj1616.isGraphObjectVisual = True
if (hasattr(self.obj1616, '_setHierarchicalLink')):
self.obj1616._setHierarchicalLink(False)
# MaxFlow
self.obj1616.MaxFlow.setValue(999999)
# price
self.obj1616.price.setValue(0)
# Name
self.obj1616.Name.setValue('')
self.obj1616.Name.setNone()
# ReqFlow
self.obj1616.ReqFlow.setValue(0)
self.obj1616.GGLabel.setValue(6)
self.obj1616.graphClass_ = graph_rawMaterial
if parent.genGraphics:
new_obj = graph_rawMaterial(280.0, 20.0, self.obj1616)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1616.graphObject_ = new_obj
self.obj16160 = AttrCalc()
self.obj16160.Copy = ATOM3Boolean()
self.obj16160.Copy.setValue(('Copy from LHS', 1))
self.obj16160.Copy.config = 0
self.obj16160.Specify = ATOM3Constraint()
self.obj16160.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.obj1616.GGset2Any['MaxFlow'] = self.obj16160
self.obj16161 = AttrCalc()
self.obj16161.Copy = ATOM3Boolean()
self.obj16161.Copy.setValue(('Copy from LHS', 1))
self.obj16161.Copy.config = 0
self.obj16161.Specify = ATOM3Constraint()
self.obj16161.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.obj1616.GGset2Any['price'] = self.obj16161
self.obj16162 = AttrCalc()
self.obj16162.Copy = ATOM3Boolean()
self.obj16162.Copy.setValue(('Copy from LHS', 0))
self.obj16162.Copy.config = 0
self.obj16162.Specify = ATOM3Constraint()
self.obj16162.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()\n\n\n\n'
))
self.obj1616.GGset2Any['Name'] = self.obj16162
self.obj16163 = AttrCalc()
self.obj16163.Copy = ATOM3Boolean()
self.obj16163.Copy.setValue(('Copy from LHS', 1))
self.obj16163.Copy.config = 0
self.obj16163.Specify = ATOM3Constraint()
self.obj16163.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.obj1616.GGset2Any['ReqFlow'] = self.obj16163
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1616)
self.obj1616.postAction(self.RHS.CREATE)
self.obj1617 = GenericGraphEdge(parent)
self.obj1617.preAction(self.RHS.CREATE)
self.obj1617.isGraphObjectVisual = True
if (hasattr(self.obj1617, '_setHierarchicalLink')):
self.obj1617._setHierarchicalLink(False)
self.obj1617.GGLabel.setValue(7)
self.obj1617.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(220.5, 79.0, self.obj1617)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1617.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1617)
self.obj1617.postAction(self.RHS.CREATE)
self.obj1613.out_connections_.append(self.obj1615)
self.obj1615.in_connections_.append(self.obj1613)
self.obj1613.graphObject_.pendingConnections.append(
(self.obj1613.graphObject_.tag, self.obj1615.graphObject_.tag,
[137.0, 82.0, 281.5, 134.0], 2, 0))
self.obj1613.out_connections_.append(self.obj1617)
self.obj1617.in_connections_.append(self.obj1613)
self.obj1613.graphObject_.pendingConnections.append(
(self.obj1613.graphObject_.tag, self.obj1617.graphObject_.tag,
[137.0, 82.0, 220.5, 79.0], 0, True))
self.obj1615.out_connections_.append(self.obj1614)
self.obj1614.in_connections_.append(self.obj1615)
self.obj1615.graphObject_.pendingConnections.append(
(self.obj1615.graphObject_.tag, self.obj1614.graphObject_.tag,
[391.0, 160.0, 281.5, 134.0], 2, 0))
self.obj1617.out_connections_.append(self.obj1616)
self.obj1616.in_connections_.append(self.obj1617)
self.obj1617.graphObject_.pendingConnections.append(
(self.obj1617.graphObject_.tag, self.obj1616.graphObject_.tag,
[304.0, 76.0, 220.5, 79.0], 0, True))
def condition(self, graphID, isograph, atom3i):
print "Dic ro " + str(self.graphRewritingSystem.Dictro)
print "Dic ag" + str(self.graphRewritingSystem.Dictag)
node = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
return not hasattr(node, "Agent2Raw")
def action(self, graphID, isograph, atom3i):
node = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
node.Agent2Raw = True
class subscribeBoolean2domainOutputRangeee_GG_rule (GGrule):
def __init__(self, parent):
GGrule.__init__(self, 1)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_RDIS(parent)
self.LHS.merge(ASG_ROSApp(parent))
self.obj1132=RangeAdapter(parent)
self.obj1132.preAction( self.LHS.CREATE )
self.obj1132.isGraphObjectVisual = True
if(hasattr(self.obj1132, '_setHierarchicalLink')):
self.obj1132._setHierarchicalLink(False)
# distance
self.obj1132.distance.setValue('')
self.obj1132.distance.setNone()
self.obj1132.GGLabel.setValue(7)
self.obj1132.graphClass_= graph_RangeAdapter
if parent.genGraphics:
new_obj = graph_RangeAdapter(340.0,20.0,self.obj1132)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1132.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1132)
self.obj1132.postAction( self.LHS.CREATE )
self.obj1131=DomainOutput(parent)
self.obj1131.preAction( self.LHS.CREATE )
self.obj1131.isGraphObjectVisual = True
if(hasattr(self.obj1131, '_setHierarchicalLink')):
self.obj1131._setHierarchicalLink(False)
# name
self.obj1131.name.setValue('')
self.obj1131.name.setNone()
self.obj1131.GGLabel.setValue(6)
self.obj1131.graphClass_= graph_DomainOutput
if parent.genGraphics:
new_obj = graph_DomainOutput(320.0,140.0,self.obj1131)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1131.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1131)
self.obj1131.postAction( self.LHS.CREATE )
self.obj1133=domainAdapter2domainOutput(parent)
self.obj1133.preAction( self.LHS.CREATE )
self.obj1133.isGraphObjectVisual = True
if(hasattr(self.obj1133, '_setHierarchicalLink')):
self.obj1133._setHierarchicalLink(False)
self.obj1133.GGLabel.setValue(8)
self.obj1133.graphClass_= graph_domainAdapter2domainOutput
if parent.genGraphics:
new_obj = graph_domainAdapter2domainOutput(415.5,158.5,self.obj1133)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1133.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1133)
self.obj1133.postAction( self.LHS.CREATE )
self.obj1124=ROSType(parent)
self.obj1124.preAction( self.LHS.CREATE )
self.obj1124.isGraphObjectVisual = True
if(hasattr(self.obj1124, '_setHierarchicalLink')):
self.obj1124._setHierarchicalLink(False)
self.obj1124.GGLabel.setValue(5)
self.obj1124.graphClass_= graph_ROSType
if parent.genGraphics:
new_obj = graph_ROSType(155.5,264.5,self.obj1124)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1124.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1124)
self.obj1124.postAction( self.LHS.CREATE )
self.obj1122=ROSTopic(parent)
self.obj1122.preAction( self.LHS.CREATE )
self.obj1122.isGraphObjectVisual = True
if(hasattr(self.obj1122, '_setHierarchicalLink')):
self.obj1122._setHierarchicalLink(False)
# name
self.obj1122.name.setValue('')
self.obj1122.name.setNone()
self.obj1122.GGLabel.setValue(3)
self.obj1122.graphClass_= graph_ROSTopic
if parent.genGraphics:
new_obj = graph_ROSTopic(80.0,160.0,self.obj1122)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1122.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1122)
self.obj1122.postAction( self.LHS.CREATE )
self.obj1121=ROSBoolean(parent)
self.obj1121.preAction( self.LHS.CREATE )
self.obj1121.isGraphObjectVisual = True
if(hasattr(self.obj1121, '_setHierarchicalLink')):
self.obj1121._setHierarchicalLink(False)
# data
self.obj1121.data.setValue('')
self.obj1121.data.setNone()
self.obj1121.GGLabel.setValue(2)
self.obj1121.graphClass_= graph_ROSBoolean
if parent.genGraphics:
new_obj = graph_ROSBoolean(100.0,280.0,self.obj1121)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1121.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1121)
self.obj1121.postAction( self.LHS.CREATE )
self.obj1120=ROSNode(parent)
self.obj1120.preAction( self.LHS.CREATE )
self.obj1120.isGraphObjectVisual = True
if(hasattr(self.obj1120, '_setHierarchicalLink')):
self.obj1120._setHierarchicalLink(False)
# name
self.obj1120.name.setValue('')
self.obj1120.name.setNone()
self.obj1120.GGLabel.setValue(1)
self.obj1120.graphClass_= graph_ROSNode
if parent.genGraphics:
new_obj = graph_ROSNode(80.0,40.0,self.obj1120)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1120.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1120)
self.obj1120.postAction( self.LHS.CREATE )
self.obj1123=ROSSubscribe(parent)
self.obj1123.preAction( self.LHS.CREATE )
self.obj1123.isGraphObjectVisual = True
if(hasattr(self.obj1123, '_setHierarchicalLink')):
self.obj1123._setHierarchicalLink(False)
self.obj1123.GGLabel.setValue(4)
self.obj1123.graphClass_= graph_ROSSubscribe
if parent.genGraphics:
new_obj = graph_ROSSubscribe(157.5,147.0,self.obj1123)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1123.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1123)
self.obj1123.postAction( self.LHS.CREATE )
self.obj1132.out_connections_.append(self.obj1133)
self.obj1133.in_connections_.append(self.obj1132)
self.obj1132.graphObject_.pendingConnections.append((self.obj1132.graphObject_.tag, self.obj1133.graphObject_.tag, [392.0, 122.0, 415.5, 158.5], 0, True))
self.obj1133.out_connections_.append(self.obj1131)
self.obj1131.in_connections_.append(self.obj1133)
self.obj1133.graphObject_.pendingConnections.append((self.obj1133.graphObject_.tag, self.obj1131.graphObject_.tag, [439.0, 195.0, 415.5, 158.5], 0, True))
self.obj1124.out_connections_.append(self.obj1121)
self.obj1121.in_connections_.append(self.obj1124)
self.obj1124.graphObject_.pendingConnections.append((self.obj1124.graphObject_.tag, self.obj1121.graphObject_.tag, [154.0, 282.0, 155.5, 264.5], 0, True))
self.obj1122.out_connections_.append(self.obj1123)
self.obj1123.in_connections_.append(self.obj1122)
self.obj1122.graphObject_.pendingConnections.append((self.obj1122.graphObject_.tag, self.obj1123.graphObject_.tag, [163.0, 164.0, 157.5, 147.0], 0, True))
self.obj1122.out_connections_.append(self.obj1124)
self.obj1124.in_connections_.append(self.obj1122)
self.obj1122.graphObject_.pendingConnections.append((self.obj1122.graphObject_.tag, self.obj1124.graphObject_.tag, [157.0, 247.0, 155.5, 264.5], 0, True))
self.obj1123.out_connections_.append(self.obj1120)
self.obj1120.in_connections_.append(self.obj1123)
self.obj1123.graphObject_.pendingConnections.append((self.obj1123.graphObject_.tag, self.obj1120.graphObject_.tag, [152.0, 130.0, 157.5, 147.0], 0, True))
self.RHS = ASG_RDIS(parent)
self.RHS.merge(ASG_GenericGraph(parent))
self.RHS.merge(ASG_ROSApp(parent))
self.obj1132=RangeAdapter(parent)
self.obj1132.preAction( self.RHS.CREATE )
self.obj1132.isGraphObjectVisual = True
if(hasattr(self.obj1132, '_setHierarchicalLink')):
self.obj1132._setHierarchicalLink(False)
# distance
self.obj1132.distance.setValue('')
self.obj1132.distance.setNone()
self.obj1132.GGLabel.setValue(7)
self.obj1132.graphClass_= graph_RangeAdapter
if parent.genGraphics:
new_obj = graph_RangeAdapter(140.0,-20.0,self.obj1132)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1132.graphObject_ = new_obj
self.obj11320= AttrCalc()
self.obj11320.Copy=ATOM3Boolean()
self.obj11320.Copy.setValue(('Copy from LHS', 1))
self.obj11320.Copy.config = 0
self.obj11320.Specify=ATOM3Constraint()
self.obj11320.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.obj1132.GGset2Any['distance']= self.obj11320
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1132)
self.obj1132.postAction( self.RHS.CREATE )
self.obj1131=DomainOutput(parent)
self.obj1131.preAction( self.RHS.CREATE )
self.obj1131.isGraphObjectVisual = True
if(hasattr(self.obj1131, '_setHierarchicalLink')):
self.obj1131._setHierarchicalLink(False)
# name
self.obj1131.name.setValue('')
self.obj1131.name.setNone()
self.obj1131.GGLabel.setValue(6)
self.obj1131.graphClass_= graph_DomainOutput
if parent.genGraphics:
new_obj = graph_DomainOutput(40.0,140.0,self.obj1131)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1131.graphObject_ = new_obj
self.obj11310= AttrCalc()
self.obj11310.Copy=ATOM3Boolean()
self.obj11310.Copy.setValue(('Copy from LHS', 1))
self.obj11310.Copy.config = 0
self.obj11310.Specify=ATOM3Constraint()
self.obj11310.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.obj1131.GGset2Any['name']= self.obj11310
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1131)
self.obj1131.postAction( self.RHS.CREATE )
self.obj1133=domainAdapter2domainOutput(parent)
self.obj1133.preAction( self.RHS.CREATE )
self.obj1133.isGraphObjectVisual = True
if(hasattr(self.obj1133, '_setHierarchicalLink')):
self.obj1133._setHierarchicalLink(False)
self.obj1133.GGLabel.setValue(8)
self.obj1133.graphClass_= graph_domainAdapter2domainOutput
if parent.genGraphics:
new_obj = graph_domainAdapter2domainOutput(415.5,158.5,self.obj1133)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1133.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1133)
self.obj1133.postAction( self.RHS.CREATE )
self.obj1148=GenericGraphEdge(parent)
self.obj1148.preAction( self.RHS.CREATE )
self.obj1148.isGraphObjectVisual = True
if(hasattr(self.obj1148, '_setHierarchicalLink')):
self.obj1148._setHierarchicalLink(False)
self.obj1148.GGLabel.setValue(10)
self.obj1148.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(404.25,115.0,self.obj1148)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1148.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1148)
self.obj1148.postAction( self.RHS.CREATE )
self.obj1149=GenericGraphEdge(parent)
self.obj1149.preAction( self.RHS.CREATE )
self.obj1149.isGraphObjectVisual = True
if(hasattr(self.obj1149, '_setHierarchicalLink')):
self.obj1149._setHierarchicalLink(False)
self.obj1149.GGLabel.setValue(11)
self.obj1149.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(399.5,171.25,self.obj1149)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1149.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1149)
self.obj1149.postAction( self.RHS.CREATE )
self.obj1159=GenericGraphEdge(parent)
self.obj1159.preAction( self.RHS.CREATE )
self.obj1159.isGraphObjectVisual = True
if(hasattr(self.obj1159, '_setHierarchicalLink')):
self.obj1159._setHierarchicalLink(False)
self.obj1159.GGLabel.setValue(12)
self.obj1159.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(278.0,254.0,self.obj1159)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1159.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1159)
self.obj1159.postAction( self.RHS.CREATE )
self.obj1124=ROSType(parent)
self.obj1124.preAction( self.RHS.CREATE )
self.obj1124.isGraphObjectVisual = True
if(hasattr(self.obj1124, '_setHierarchicalLink')):
self.obj1124._setHierarchicalLink(False)
self.obj1124.GGLabel.setValue(5)
self.obj1124.graphClass_= graph_ROSType
if parent.genGraphics:
new_obj = graph_ROSType(155.5,264.5,self.obj1124)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1124.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1124)
self.obj1124.postAction( self.RHS.CREATE )
self.obj1122=ROSTopic(parent)
self.obj1122.preAction( self.RHS.CREATE )
self.obj1122.isGraphObjectVisual = True
if(hasattr(self.obj1122, '_setHierarchicalLink')):
self.obj1122._setHierarchicalLink(False)
# name
self.obj1122.name.setValue('')
self.obj1122.name.setNone()
self.obj1122.GGLabel.setValue(3)
self.obj1122.graphClass_= graph_ROSTopic
if parent.genGraphics:
new_obj = graph_ROSTopic(-160.0,40.0,self.obj1122)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1122.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1122)
self.obj1122.postAction( self.RHS.CREATE )
self.obj1121=ROSBoolean(parent)
self.obj1121.preAction( self.RHS.CREATE )
self.obj1121.isGraphObjectVisual = True
if(hasattr(self.obj1121, '_setHierarchicalLink')):
self.obj1121._setHierarchicalLink(False)
# data
self.obj1121.data.setValue('<distance == 0>')
self.obj1121.GGLabel.setValue(2)
self.obj1121.graphClass_= graph_ROSBoolean
if parent.genGraphics:
new_obj = graph_ROSBoolean(-180.0,200.0,self.obj1121)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1121.graphObject_ = new_obj
self.obj11210= AttrCalc()
self.obj11210.Copy=ATOM3Boolean()
self.obj11210.Copy.setValue(('Copy from LHS', 0))
self.obj11210.Copy.config = 0
self.obj11210.Specify=ATOM3Constraint()
self.obj11210.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.obj1121.GGset2Any['data']= self.obj11210
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1121)
self.obj1121.postAction( self.RHS.CREATE )
self.obj1120=ROSNode(parent)
self.obj1120.preAction( self.RHS.CREATE )
self.obj1120.isGraphObjectVisual = True
if(hasattr(self.obj1120, '_setHierarchicalLink')):
self.obj1120._setHierarchicalLink(False)
# name
self.obj1120.name.setValue('')
self.obj1120.name.setNone()
self.obj1120.GGLabel.setValue(1)
self.obj1120.graphClass_= graph_ROSNode
if parent.genGraphics:
new_obj = graph_ROSNode(-160.0,-120.0,self.obj1120)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1120.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1120)
self.obj1120.postAction( self.RHS.CREATE )
self.obj1123=ROSSubscribe(parent)
self.obj1123.preAction( self.RHS.CREATE )
self.obj1123.isGraphObjectVisual = True
if(hasattr(self.obj1123, '_setHierarchicalLink')):
self.obj1123._setHierarchicalLink(False)
self.obj1123.GGLabel.setValue(4)
self.obj1123.graphClass_= graph_ROSSubscribe
if parent.genGraphics:
new_obj = graph_ROSSubscribe(157.5,147.0,self.obj1123)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1123.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1123)
self.obj1123.postAction( self.RHS.CREATE )
self.obj1132.out_connections_.append(self.obj1133)
self.obj1133.in_connections_.append(self.obj1132)
self.obj1131.out_connections_.append(self.obj1159)
self.obj1159.in_connections_.append(self.obj1131)
self.obj1131.graphObject_.pendingConnections.append((self.obj1131.graphObject_.tag, self.obj1159.graphObject_.tag, [326.0, 293.0, 278.0, 254.0], 0, True))
self.obj1133.out_connections_.append(self.obj1131)
self.obj1131.in_connections_.append(self.obj1133)
self.obj1159.out_connections_.append(self.obj1122)
self.obj1122.in_connections_.append(self.obj1159)
self.obj1159.graphObject_.pendingConnections.append((self.obj1159.graphObject_.tag, self.obj1122.graphObject_.tag, [230.0, 215.0, 278.0, 254.0], 0, True))
self.obj1124.out_connections_.append(self.obj1121)
self.obj1121.in_connections_.append(self.obj1124)
self.obj1124.graphObject_.pendingConnections.append((self.obj1124.graphObject_.tag, self.obj1121.graphObject_.tag, [136.0, 300.0, 155.5, 264.5], 2, 0))
self.obj1122.out_connections_.append(self.obj1123)
self.obj1123.in_connections_.append(self.obj1122)
self.obj1122.graphObject_.pendingConnections.append((self.obj1122.graphObject_.tag, self.obj1123.graphObject_.tag, [104.0, 191.0, 157.5, 147.0], 2, 0))
self.obj1122.out_connections_.append(self.obj1124)
self.obj1124.in_connections_.append(self.obj1122)
self.obj1122.graphObject_.pendingConnections.append((self.obj1122.graphObject_.tag, self.obj1124.graphObject_.tag, [104.0, 191.0, 155.5, 264.5], 2, 0))
self.obj1123.out_connections_.append(self.obj1120)
self.obj1120.in_connections_.append(self.obj1123)
self.obj1123.graphObject_.pendingConnections.append((self.obj1123.graphObject_.tag, self.obj1120.graphObject_.tag, [117.0, 84.0, 157.5, 147.0], 2, 0))
def condition(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the ACTION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName45 is not guaranteed to be unique (so change it, be safe!)
node3 = self.getMatched(graphID, self.LHS.nodeWithLabel(3))
node6 = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
return not hasattr(node3, "_uniqueName45") and not hasattr(node6, "_uniqueName45")
def action(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the CONDITION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName45 is not guaranteed to be unique (so change it, be safe!)
node3 = self.getMatched(graphID, self.LHS.nodeWithLabel(3))
node6 = self.getMatched(graphID, self.LHS.nodeWithLabel(6))
node3._uniqueName45 = True
node6._uniqueName45 = True
class CreateLinkAR2Mat_GG_rule(GGrule):
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))
def condition(self, graphID, isograph, atom3i):
print 'Rule 21 '
node7 = self.getMatched(graphID, self.LHS.nodeWithLabel(7))
node11 = self.getMatched(graphID, self.LHS.nodeWithLabel(11))
node1 = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
print node7.name.getValue() + ' in ' + node11.Name.getValue()
print node7.name.getValue() in node11.Name.getValue()
test = not (hasattr(node11, "linkAux2") and hasattr(node7, "linkAux2"))
print test
if test:
return (node7.name.getValue() in node11.Name.getValue())
else:
return False
def action(self, graphID, isograph, atom3i):
# code action of rule
node = self.getMatched(graphID, self.LHS.nodeWithLabel(7))
node.linkAux2 = True
node = self.getMatched(graphID, self.LHS.nodeWithLabel(11))
node.linkAux2 = True
self.graphRewritingSystem.finalStat = 21