def createNewoperatingUnit(self, wherex, wherey, screenCoordinates=1): self.fromClass = None self.toClass = None # try the global constraints... res = self.ASGroot.preCondition(ASG.CREATE) if res: self.constraintViolation(res) self.mode = self.IDLEMODE return new_semantic_obj = operatingUnit(self) res = new_semantic_obj.preCondition(ASGNode.CREATE) if res: return self.constraintViolation(res) new_semantic_obj.preAction(ASGNode.CREATE) ne = len(self.ASGroot.listNodes["operatingUnit"]) if new_semantic_obj.keyword_: new_semantic_obj.keyword_.setValue( new_semantic_obj.keyword_.toString() + str(ne)) if screenCoordinates: new_obj = graph_operatingUnit(self.UMLmodel.canvasx(wherex), self.UMLmodel.canvasy(wherey), new_semantic_obj) else: # already in canvas coordinates new_obj = graph_operatingUnit(wherex, wherey, new_semantic_obj) new_obj.DrawObject(self.UMLmodel, self.editGGLabel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_semantic_obj.graphObject_ = new_obj self.ASGroot.addNode(new_semantic_obj) res = self.ASGroot.postCondition(ASG.CREATE) if res: self.constraintViolation(res) self.mode = self.IDLEMODE return res = new_semantic_obj.postCondition(ASGNode.CREATE) if res: self.constraintViolation(res) self.mode = self.IDLEMODE return new_semantic_obj.postAction(ASGNode.CREATE) self.mode = self.IDLEMODE if self.editGGLabel: self.statusbar.event(StatusBar.TRANSFORMATION, StatusBar.CREATE) else: self.statusbar.event(StatusBar.MODEL, StatusBar.CREATE) return new_semantic_obj
def __init__(self, parent): GGrule.__init__(self, 28) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.LHS.merge(ASG_omacs(parent)) self.LHS.merge(ASG_GenericGraph(parent)) self.obj1849 = metarial(parent) self.obj1849.preAction(self.LHS.CREATE) self.obj1849.isGraphObjectVisual = True if (hasattr(self.obj1849, '_setHierarchicalLink')): self.obj1849._setHierarchicalLink(False) # MaxFlow self.obj1849.MaxFlow.setNone() # price self.obj1849.price.setValue(0) # Name self.obj1849.Name.setValue('') self.obj1849.Name.setNone() # ReqFlow self.obj1849.ReqFlow.setNone() self.obj1849.GGLabel.setValue(2) self.obj1849.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(280.0, 40.0, self.obj1849) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1849.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1849) self.obj1849.postAction(self.LHS.CREATE) self.obj1850 = operatingUnit(parent) self.obj1850.preAction(self.LHS.CREATE) self.obj1850.isGraphObjectVisual = True if (hasattr(self.obj1850, '_setHierarchicalLink')): self.obj1850._setHierarchicalLink(False) # OperCostProp self.obj1850.OperCostProp.setNone() # name self.obj1850.name.setValue('') self.obj1850.name.setNone() # OperCostFix self.obj1850.OperCostFix.setNone() self.obj1850.GGLabel.setValue(3) self.obj1850.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(300.0, 140.0, self.obj1850) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1850.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1850) self.obj1850.postAction(self.LHS.CREATE) self.obj1851 = fromMaterial(parent) self.obj1851.preAction(self.LHS.CREATE) self.obj1851.isGraphObjectVisual = True if (hasattr(self.obj1851, '_setHierarchicalLink')): self.obj1851._setHierarchicalLink(False) # rate self.obj1851.rate.setNone() self.obj1851.GGLabel.setValue(4) self.obj1851.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(342.75, 113.75, self.obj1851) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1851.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1851) self.obj1851.postAction(self.LHS.CREATE) self.obj1852 = Role(parent) self.obj1852.preAction(self.LHS.CREATE) self.obj1852.isGraphObjectVisual = True if (hasattr(self.obj1852, '_setHierarchicalLink')): self.obj1852._setHierarchicalLink(False) # name self.obj1852.name.setValue('') self.obj1852.name.setNone() self.obj1852.GGLabel.setValue(1) self.obj1852.graphClass_ = graph_Role if parent.genGraphics: new_obj = graph_Role(80.0, 60.0, self.obj1852) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1852.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1852) self.obj1852.postAction(self.LHS.CREATE) self.obj1853 = GenericGraphEdge(parent) self.obj1853.preAction(self.LHS.CREATE) self.obj1853.isGraphObjectVisual = True if (hasattr(self.obj1853, '_setHierarchicalLink')): self.obj1853._setHierarchicalLink(False) self.obj1853.GGLabel.setValue(5) self.obj1853.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(195.0, 71.5, self.obj1853) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1853.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1853) self.obj1853.postAction(self.LHS.CREATE) self.obj1849.out_connections_.append(self.obj1851) self.obj1851.in_connections_.append(self.obj1849) self.obj1849.graphObject_.pendingConnections.append( (self.obj1849.graphObject_.tag, self.obj1851.graphObject_.tag, [321.0, 82.0, 335.5, 96.5, 342.75, 113.75], 2, True)) self.obj1851.out_connections_.append(self.obj1850) self.obj1850.in_connections_.append(self.obj1851) self.obj1851.graphObject_.pendingConnections.append( (self.obj1851.graphObject_.tag, self.obj1850.graphObject_.tag, [350.0, 151.0, 350.0, 131.0, 342.75, 113.75], 2, True)) self.obj1852.out_connections_.append(self.obj1853) self.obj1853.in_connections_.append(self.obj1852) self.obj1852.graphObject_.pendingConnections.append( (self.obj1852.graphObject_.tag, self.obj1853.graphObject_.tag, [104.0, 61.0, 195.0, 71.5], 0, True)) self.obj1853.out_connections_.append(self.obj1849) self.obj1849.in_connections_.append(self.obj1853) self.obj1853.graphObject_.pendingConnections.append( (self.obj1853.graphObject_.tag, self.obj1849.graphObject_.tag, [286.0, 82.0, 195.0, 71.5], 0, True)) self.RHS = ASG_pns(parent) self.obj1855 = metarial(parent) self.obj1855.preAction(self.RHS.CREATE) self.obj1855.isGraphObjectVisual = True if (hasattr(self.obj1855, '_setHierarchicalLink')): self.obj1855._setHierarchicalLink(False) # MaxFlow self.obj1855.MaxFlow.setValue(999999) # price self.obj1855.price.setValue(0) # Name self.obj1855.Name.setValue('') self.obj1855.Name.setNone() # ReqFlow self.obj1855.ReqFlow.setValue(0) self.obj1855.GGLabel.setValue(2) self.obj1855.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(160.0, 40.0, self.obj1855) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1855.graphObject_ = new_obj self.obj18550 = AttrCalc() self.obj18550.Copy = ATOM3Boolean() self.obj18550.Copy.setValue(('Copy from LHS', 1)) self.obj18550.Copy.config = 0 self.obj18550.Specify = ATOM3Constraint() self.obj18550.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1855.GGset2Any['MaxFlow'] = self.obj18550 self.obj18551 = AttrCalc() self.obj18551.Copy = ATOM3Boolean() self.obj18551.Copy.setValue(('Copy from LHS', 1)) self.obj18551.Copy.config = 0 self.obj18551.Specify = ATOM3Constraint() self.obj18551.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1855.GGset2Any['Name'] = self.obj18551 self.obj18552 = AttrCalc() self.obj18552.Copy = ATOM3Boolean() self.obj18552.Copy.setValue(('Copy from LHS', 1)) self.obj18552.Copy.config = 0 self.obj18552.Specify = ATOM3Constraint() self.obj18552.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1855.GGset2Any['ReqFlow'] = self.obj18552 # Add node to the root: self.RHS self.RHS.addNode(self.obj1855) self.obj1855.postAction(self.RHS.CREATE) self.obj1856 = operatingUnit(parent) self.obj1856.preAction(self.RHS.CREATE) self.obj1856.isGraphObjectVisual = True if (hasattr(self.obj1856, '_setHierarchicalLink')): self.obj1856._setHierarchicalLink(False) # OperCostProp self.obj1856.OperCostProp.setValue(0.0) # name self.obj1856.name.setValue('') self.obj1856.name.setNone() # OperCostFix self.obj1856.OperCostFix.setValue(0.0) self.obj1856.GGLabel.setValue(3) self.obj1856.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(200.0, 140.0, self.obj1856) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1856.graphObject_ = new_obj self.obj18560 = AttrCalc() self.obj18560.Copy = ATOM3Boolean() self.obj18560.Copy.setValue(('Copy from LHS', 1)) self.obj18560.Copy.config = 0 self.obj18560.Specify = ATOM3Constraint() self.obj18560.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1856.GGset2Any['OperCostProp'] = self.obj18560 self.obj18561 = AttrCalc() self.obj18561.Copy = ATOM3Boolean() self.obj18561.Copy.setValue(('Copy from LHS', 1)) self.obj18561.Copy.config = 0 self.obj18561.Specify = ATOM3Constraint() self.obj18561.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1856.GGset2Any['name'] = self.obj18561 self.obj18562 = AttrCalc() self.obj18562.Copy = ATOM3Boolean() self.obj18562.Copy.setValue(('Copy from LHS', 1)) self.obj18562.Copy.config = 0 self.obj18562.Specify = ATOM3Constraint() self.obj18562.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1856.GGset2Any['OperCostFix'] = self.obj18562 # Add node to the root: self.RHS self.RHS.addNode(self.obj1856) self.obj1856.postAction(self.RHS.CREATE) self.obj1857 = fromMaterial(parent) self.obj1857.preAction(self.RHS.CREATE) self.obj1857.isGraphObjectVisual = True if (hasattr(self.obj1857, '_setHierarchicalLink')): self.obj1857._setHierarchicalLink(False) # rate self.obj1857.rate.setValue(0.0) self.obj1857.GGLabel.setValue(4) self.obj1857.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(238.75, 106.25, self.obj1857) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1857.graphObject_ = new_obj self.obj18570 = AttrCalc() self.obj18570.Copy = ATOM3Boolean() self.obj18570.Copy.setValue(('Copy from LHS', 1)) self.obj18570.Copy.config = 0 self.obj18570.Specify = ATOM3Constraint() self.obj18570.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1857.GGset2Any['rate'] = self.obj18570 # Add node to the root: self.RHS self.RHS.addNode(self.obj1857) self.obj1857.postAction(self.RHS.CREATE) self.obj1855.out_connections_.append(self.obj1857) self.obj1857.in_connections_.append(self.obj1855) self.obj1855.graphObject_.pendingConnections.append( (self.obj1855.graphObject_.tag, self.obj1857.graphObject_.tag, [201.0, 82.0, 226.5, 89.0, 238.75, 106.25], 2, True)) self.obj1857.out_connections_.append(self.obj1856) self.obj1856.in_connections_.append(self.obj1857) self.obj1857.graphObject_.pendingConnections.append( (self.obj1857.graphObject_.tag, self.obj1856.graphObject_.tag, [250.0, 151.0, 251.0, 123.5, 238.75, 106.25], 2, True))
def __init__(self, parent): GGrule.__init__(self, 8) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.obj987=metarial(parent) self.obj987.preAction( self.LHS.CREATE ) self.obj987.isGraphObjectVisual = True if(hasattr(self.obj987, '_setHierarchicalLink')): self.obj987._setHierarchicalLink(False) # MaxFlow self.obj987.MaxFlow.setNone() # price self.obj987.price.setNone() # Name self.obj987.Name.setValue('') self.obj987.Name.setNone() # ReqFlow self.obj987.ReqFlow.setNone() self.obj987.GGLabel.setValue(2) self.obj987.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(240.0,140.0,self.obj987) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj987.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj987) self.obj987.postAction( self.LHS.CREATE ) self.obj988=operatingUnit(parent) self.obj988.preAction( self.LHS.CREATE ) self.obj988.isGraphObjectVisual = True if(hasattr(self.obj988, '_setHierarchicalLink')): self.obj988._setHierarchicalLink(False) # OperCostProp self.obj988.OperCostProp.setNone() # name self.obj988.name.setValue('') self.obj988.name.setNone() # OperCostFix self.obj988.OperCostFix.setNone() self.obj988.GGLabel.setValue(1) self.obj988.graphClass_= graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(220.0,20.0,self.obj988) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj988.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj988) self.obj988.postAction( self.LHS.CREATE ) self.obj989=intoMaterial(parent) self.obj989.preAction( self.LHS.CREATE ) self.obj989.isGraphObjectVisual = True if(hasattr(self.obj989, '_setHierarchicalLink')): self.obj989._setHierarchicalLink(False) # rate self.obj989.rate.setNone() self.obj989.GGLabel.setValue(3) self.obj989.graphClass_= graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(269.5,88.0,self.obj989) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj989.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj989) self.obj989.postAction( self.LHS.CREATE ) self.obj988.out_connections_.append(self.obj989) self.obj989.in_connections_.append(self.obj988) self.obj988.graphObject_.pendingConnections.append((self.obj988.graphObject_.tag, self.obj989.graphObject_.tag, [273.0, 38.0, 269.5, 88.0], 0, True)) self.obj989.out_connections_.append(self.obj987) self.obj987.in_connections_.append(self.obj989) self.obj989.graphObject_.pendingConnections.append((self.obj989.graphObject_.tag, self.obj987.graphObject_.tag, [266.0, 138.0, 269.5, 88.0], 0, True)) self.RHS = ASG_pns(parent) self.obj991=metarial(parent) self.obj991.preAction( self.RHS.CREATE ) self.obj991.isGraphObjectVisual = True if(hasattr(self.obj991, '_setHierarchicalLink')): self.obj991._setHierarchicalLink(False) # MaxFlow self.obj991.MaxFlow.setNone() # price self.obj991.price.setNone() # Name self.obj991.Name.setValue('') self.obj991.Name.setNone() # ReqFlow self.obj991.ReqFlow.setNone() self.obj991.GGLabel.setValue(2) self.obj991.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(240.0,140.0,self.obj991) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj991.graphObject_ = new_obj self.obj9910= AttrCalc() self.obj9910.Copy=ATOM3Boolean() self.obj9910.Copy.setValue(('Copy from LHS', 1)) self.obj9910.Copy.config = 0 self.obj9910.Specify=ATOM3Constraint() self.obj9910.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj991.GGset2Any['MaxFlow']= self.obj9910 self.obj9911= AttrCalc() self.obj9911.Copy=ATOM3Boolean() self.obj9911.Copy.setValue(('Copy from LHS', 1)) self.obj9911.Copy.config = 0 self.obj9911.Specify=ATOM3Constraint() self.obj9911.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj991.GGset2Any['price']= self.obj9911 self.obj9912= AttrCalc() self.obj9912.Copy=ATOM3Boolean() self.obj9912.Copy.setValue(('Copy from LHS', 1)) self.obj9912.Copy.config = 0 self.obj9912.Specify=ATOM3Constraint() self.obj9912.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj991.GGset2Any['Name']= self.obj9912 self.obj9913= AttrCalc() self.obj9913.Copy=ATOM3Boolean() self.obj9913.Copy.setValue(('Copy from LHS', 1)) self.obj9913.Copy.config = 0 self.obj9913.Specify=ATOM3Constraint() self.obj9913.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj991.GGset2Any['ReqFlow']= self.obj9913 # Add node to the root: self.RHS self.RHS.addNode(self.obj991) self.obj991.postAction( self.RHS.CREATE ) self.obj992=operatingUnit(parent) self.obj992.preAction( self.RHS.CREATE ) self.obj992.isGraphObjectVisual = True if(hasattr(self.obj992, '_setHierarchicalLink')): self.obj992._setHierarchicalLink(False) # OperCostProp self.obj992.OperCostProp.setNone() # name self.obj992.name.setValue('') self.obj992.name.setNone() # OperCostFix self.obj992.OperCostFix.setNone() self.obj992.GGLabel.setValue(1) self.obj992.graphClass_= graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(220.0,20.0,self.obj992) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj992.graphObject_ = new_obj self.obj9920= AttrCalc() self.obj9920.Copy=ATOM3Boolean() self.obj9920.Copy.setValue(('Copy from LHS', 1)) self.obj9920.Copy.config = 0 self.obj9920.Specify=ATOM3Constraint() self.obj9920.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj992.GGset2Any['OperCostProp']= self.obj9920 self.obj9921= AttrCalc() self.obj9921.Copy=ATOM3Boolean() self.obj9921.Copy.setValue(('Copy from LHS', 1)) self.obj9921.Copy.config = 0 self.obj9921.Specify=ATOM3Constraint() self.obj9921.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj992.GGset2Any['name']= self.obj9921 self.obj9922= AttrCalc() self.obj9922.Copy=ATOM3Boolean() self.obj9922.Copy.setValue(('Copy from LHS', 1)) self.obj9922.Copy.config = 0 self.obj9922.Specify=ATOM3Constraint() self.obj9922.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj992.GGset2Any['OperCostFix']= self.obj9922 # Add node to the root: self.RHS self.RHS.addNode(self.obj992) self.obj992.postAction( self.RHS.CREATE ) self.obj993=intoMaterial(parent) self.obj993.preAction( self.RHS.CREATE ) self.obj993.isGraphObjectVisual = True if(hasattr(self.obj993, '_setHierarchicalLink')): self.obj993._setHierarchicalLink(False) # rate self.obj993.rate.setNone() self.obj993.GGLabel.setValue(3) self.obj993.graphClass_= graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(269.5,88.0,self.obj993) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj993.graphObject_ = new_obj self.obj9930= AttrCalc() self.obj9930.Copy=ATOM3Boolean() self.obj9930.Copy.setValue(('Copy from LHS', 1)) self.obj9930.Copy.config = 0 self.obj9930.Specify=ATOM3Constraint() self.obj9930.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj993.GGset2Any['rate']= self.obj9930 # Add node to the root: self.RHS self.RHS.addNode(self.obj993) self.obj993.postAction( self.RHS.CREATE ) self.obj992.out_connections_.append(self.obj993) self.obj993.in_connections_.append(self.obj992) self.obj992.graphObject_.pendingConnections.append((self.obj992.graphObject_.tag, self.obj993.graphObject_.tag, [273.0, 28.0, 269.5, 88.0], 2, 0)) self.obj993.out_connections_.append(self.obj991) self.obj991.in_connections_.append(self.obj993) self.obj993.graphObject_.pendingConnections.append((self.obj993.graphObject_.tag, self.obj991.graphObject_.tag, [286.0, 150.0, 269.5, 88.0], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 5) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.obj954 = rawMaterial(parent) self.obj954.preAction(self.LHS.CREATE) self.obj954.isGraphObjectVisual = True if (hasattr(self.obj954, '_setHierarchicalLink')): self.obj954._setHierarchicalLink(False) # MaxFlow self.obj954.MaxFlow.setNone() # price self.obj954.price.setNone() # Name self.obj954.Name.setValue('') self.obj954.Name.setNone() # ReqFlow self.obj954.ReqFlow.setNone() self.obj954.GGLabel.setValue(1) self.obj954.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(200.0, 20.0, self.obj954) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj954.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj954) self.obj954.postAction(self.LHS.CREATE) self.obj955 = operatingUnit(parent) self.obj955.preAction(self.LHS.CREATE) self.obj955.isGraphObjectVisual = True if (hasattr(self.obj955, '_setHierarchicalLink')): self.obj955._setHierarchicalLink(False) # OperCostProp self.obj955.OperCostProp.setNone() # name self.obj955.name.setValue('') self.obj955.name.setNone() # OperCostFix self.obj955.OperCostFix.setNone() self.obj955.GGLabel.setValue(2) self.obj955.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(200.0, 160.0, self.obj955) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj955.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj955) self.obj955.postAction(self.LHS.CREATE) self.obj956 = fromRaw(parent) self.obj956.preAction(self.LHS.CREATE) self.obj956.isGraphObjectVisual = True if (hasattr(self.obj956, '_setHierarchicalLink')): self.obj956._setHierarchicalLink(False) # rate self.obj956.rate.setNone() self.obj956.GGLabel.setValue(3) self.obj956.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(222.0, 123.5, self.obj956) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj956.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj956) self.obj956.postAction(self.LHS.CREATE) self.obj954.out_connections_.append(self.obj956) self.obj956.in_connections_.append(self.obj954) self.obj954.graphObject_.pendingConnections.append( (self.obj954.graphObject_.tag, self.obj956.graphObject_.tag, [224.0, 76.0, 222.0, 123.5], 0, True)) self.obj956.out_connections_.append(self.obj955) self.obj955.in_connections_.append(self.obj956) self.obj956.graphObject_.pendingConnections.append( (self.obj956.graphObject_.tag, self.obj955.graphObject_.tag, [220.0, 171.0, 222.0, 123.5], 0, True)) self.RHS = ASG_pns(parent) self.obj958 = rawMaterial(parent) self.obj958.preAction(self.RHS.CREATE) self.obj958.isGraphObjectVisual = True if (hasattr(self.obj958, '_setHierarchicalLink')): self.obj958._setHierarchicalLink(False) # MaxFlow self.obj958.MaxFlow.setNone() # price self.obj958.price.setNone() # Name self.obj958.Name.setValue('') self.obj958.Name.setNone() # ReqFlow self.obj958.ReqFlow.setNone() self.obj958.GGLabel.setValue(1) self.obj958.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(200.0, 20.0, self.obj958) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj958.graphObject_ = new_obj self.obj9580 = AttrCalc() self.obj9580.Copy = ATOM3Boolean() self.obj9580.Copy.setValue(('Copy from LHS', 1)) self.obj9580.Copy.config = 0 self.obj9580.Specify = ATOM3Constraint() self.obj9580.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj958.GGset2Any['MaxFlow'] = self.obj9580 self.obj9581 = AttrCalc() self.obj9581.Copy = ATOM3Boolean() self.obj9581.Copy.setValue(('Copy from LHS', 1)) self.obj9581.Copy.config = 0 self.obj9581.Specify = ATOM3Constraint() self.obj9581.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj958.GGset2Any['price'] = self.obj9581 self.obj9582 = AttrCalc() self.obj9582.Copy = ATOM3Boolean() self.obj9582.Copy.setValue(('Copy from LHS', 1)) self.obj9582.Copy.config = 0 self.obj9582.Specify = ATOM3Constraint() self.obj9582.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj958.GGset2Any['Name'] = self.obj9582 self.obj9583 = AttrCalc() self.obj9583.Copy = ATOM3Boolean() self.obj9583.Copy.setValue(('Copy from LHS', 1)) self.obj9583.Copy.config = 0 self.obj9583.Specify = ATOM3Constraint() self.obj9583.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj958.GGset2Any['ReqFlow'] = self.obj9583 # Add node to the root: self.RHS self.RHS.addNode(self.obj958) self.obj958.postAction(self.RHS.CREATE) self.obj959 = operatingUnit(parent) self.obj959.preAction(self.RHS.CREATE) self.obj959.isGraphObjectVisual = True if (hasattr(self.obj959, '_setHierarchicalLink')): self.obj959._setHierarchicalLink(False) # OperCostProp self.obj959.OperCostProp.setNone() # name self.obj959.name.setValue('') self.obj959.name.setNone() # OperCostFix self.obj959.OperCostFix.setNone() self.obj959.GGLabel.setValue(2) self.obj959.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(200.0, 160.0, self.obj959) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj959.graphObject_ = new_obj self.obj9590 = AttrCalc() self.obj9590.Copy = ATOM3Boolean() self.obj9590.Copy.setValue(('Copy from LHS', 1)) self.obj9590.Copy.config = 0 self.obj9590.Specify = ATOM3Constraint() self.obj9590.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj959.GGset2Any['OperCostProp'] = self.obj9590 self.obj9591 = AttrCalc() self.obj9591.Copy = ATOM3Boolean() self.obj9591.Copy.setValue(('Copy from LHS', 1)) self.obj9591.Copy.config = 0 self.obj9591.Specify = ATOM3Constraint() self.obj9591.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj959.GGset2Any['name'] = self.obj9591 self.obj9592 = AttrCalc() self.obj9592.Copy = ATOM3Boolean() self.obj9592.Copy.setValue(('Copy from LHS', 1)) self.obj9592.Copy.config = 0 self.obj9592.Specify = ATOM3Constraint() self.obj9592.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj959.GGset2Any['OperCostFix'] = self.obj9592 # Add node to the root: self.RHS self.RHS.addNode(self.obj959) self.obj959.postAction(self.RHS.CREATE) self.obj960 = fromRaw(parent) self.obj960.preAction(self.RHS.CREATE) self.obj960.isGraphObjectVisual = True if (hasattr(self.obj960, '_setHierarchicalLink')): self.obj960._setHierarchicalLink(False) # rate self.obj960.rate.setNone() self.obj960.GGLabel.setValue(3) self.obj960.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(222.0, 123.5, self.obj960) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj960.graphObject_ = new_obj self.obj9600 = AttrCalc() self.obj9600.Copy = ATOM3Boolean() self.obj9600.Copy.setValue(('Copy from LHS', 1)) self.obj9600.Copy.config = 0 self.obj9600.Specify = ATOM3Constraint() self.obj9600.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj960.GGset2Any['rate'] = self.obj9600 # Add node to the root: self.RHS self.RHS.addNode(self.obj960) self.obj960.postAction(self.RHS.CREATE) self.obj958.out_connections_.append(self.obj960) self.obj960.in_connections_.append(self.obj958) self.obj958.graphObject_.pendingConnections.append( (self.obj958.graphObject_.tag, self.obj960.graphObject_.tag, [224.0, 70.0, 222.0, 123.5], 2, 0)) self.obj960.out_connections_.append(self.obj959) self.obj959.in_connections_.append(self.obj960) self.obj960.graphObject_.pendingConnections.append( (self.obj960.graphObject_.tag, self.obj959.graphObject_.tag, [250.0, 161.0, 222.0, 123.5], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 15) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.LHS.merge(ASG_omacs(parent)) self.LHS.merge(ASG_GenericGraph(parent)) self.obj1677 = product(parent) self.obj1677.preAction(self.LHS.CREATE) self.obj1677.isGraphObjectVisual = True if (hasattr(self.obj1677, '_setHierarchicalLink')): self.obj1677._setHierarchicalLink(False) # MaxFlow self.obj1677.MaxFlow.setNone() # price self.obj1677.price.setValue(0) # Name self.obj1677.Name.setValue('') self.obj1677.Name.setNone() # ReqFlow self.obj1677.ReqFlow.setNone() self.obj1677.GGLabel.setValue(5) self.obj1677.graphClass_ = graph_product if parent.genGraphics: new_obj = graph_product(280.0, 220.0, self.obj1677) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1677.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1677) self.obj1677.postAction(self.LHS.CREATE) self.obj1678 = metarial(parent) self.obj1678.preAction(self.LHS.CREATE) self.obj1678.isGraphObjectVisual = True if (hasattr(self.obj1678, '_setHierarchicalLink')): self.obj1678._setHierarchicalLink(False) # MaxFlow self.obj1678.MaxFlow.setNone() # price self.obj1678.price.setValue(0) # Name self.obj1678.Name.setValue('') self.obj1678.Name.setNone() # ReqFlow self.obj1678.ReqFlow.setNone() self.obj1678.GGLabel.setValue(3) self.obj1678.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(320.0, 40.0, self.obj1678) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1678.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1678) self.obj1678.postAction(self.LHS.CREATE) self.obj1679 = Goal(parent) self.obj1679.preAction(self.LHS.CREATE) self.obj1679.isGraphObjectVisual = True if (hasattr(self.obj1679, '_setHierarchicalLink')): self.obj1679._setHierarchicalLink(False) # name self.obj1679.name.setValue('') self.obj1679.name.setNone() self.obj1679.GGLabel.setValue(2) self.obj1679.graphClass_ = graph_Goal if parent.genGraphics: new_obj = graph_Goal(180.0, 60.0, self.obj1679) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1679.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1679) self.obj1679.postAction(self.LHS.CREATE) self.obj1680 = GenericGraphEdge(parent) self.obj1680.preAction(self.LHS.CREATE) self.obj1680.isGraphObjectVisual = True if (hasattr(self.obj1680, '_setHierarchicalLink')): self.obj1680._setHierarchicalLink(False) self.obj1680.GGLabel.setValue(4) self.obj1680.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(264.5, 71.5, self.obj1680) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1680.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1680) self.obj1680.postAction(self.LHS.CREATE) self.obj1679.out_connections_.append(self.obj1680) self.obj1680.in_connections_.append(self.obj1679) self.obj1679.graphObject_.pendingConnections.append( (self.obj1679.graphObject_.tag, self.obj1680.graphObject_.tag, [203.0, 61.0, 264.5, 71.5], 0, True)) self.obj1680.out_connections_.append(self.obj1678) self.obj1678.in_connections_.append(self.obj1680) self.obj1680.graphObject_.pendingConnections.append( (self.obj1680.graphObject_.tag, self.obj1678.graphObject_.tag, [326.0, 82.0, 264.5, 71.5], 0, True)) self.RHS = ASG_pns(parent) self.RHS.merge(ASG_omacs(parent)) self.RHS.merge(ASG_GenericGraph(parent)) self.obj1684 = product(parent) self.obj1684.preAction(self.RHS.CREATE) self.obj1684.isGraphObjectVisual = True if (hasattr(self.obj1684, '_setHierarchicalLink')): self.obj1684._setHierarchicalLink(False) # MaxFlow self.obj1684.MaxFlow.setNone() # price self.obj1684.price.setValue(0) # Name self.obj1684.Name.setValue('') self.obj1684.Name.setNone() # ReqFlow self.obj1684.ReqFlow.setNone() self.obj1684.GGLabel.setValue(5) self.obj1684.graphClass_ = graph_product if parent.genGraphics: new_obj = graph_product(280.0, 220.0, self.obj1684) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1684.graphObject_ = new_obj self.obj16840 = AttrCalc() self.obj16840.Copy = ATOM3Boolean() self.obj16840.Copy.setValue(('Copy from LHS', 1)) self.obj16840.Copy.config = 0 self.obj16840.Specify = ATOM3Constraint() self.obj16840.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1684.GGset2Any['MaxFlow'] = self.obj16840 self.obj16841 = AttrCalc() self.obj16841.Copy = ATOM3Boolean() self.obj16841.Copy.setValue(('Copy from LHS', 1)) self.obj16841.Copy.config = 0 self.obj16841.Specify = ATOM3Constraint() self.obj16841.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1684.GGset2Any['Name'] = self.obj16841 self.obj16842 = AttrCalc() self.obj16842.Copy = ATOM3Boolean() self.obj16842.Copy.setValue(('Copy from LHS', 1)) self.obj16842.Copy.config = 0 self.obj16842.Specify = ATOM3Constraint() self.obj16842.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1684.GGset2Any['ReqFlow'] = self.obj16842 # Add node to the root: self.RHS self.RHS.addNode(self.obj1684) self.obj1684.postAction(self.RHS.CREATE) self.obj1685 = metarial(parent) self.obj1685.preAction(self.RHS.CREATE) self.obj1685.isGraphObjectVisual = True if (hasattr(self.obj1685, '_setHierarchicalLink')): self.obj1685._setHierarchicalLink(False) # MaxFlow self.obj1685.MaxFlow.setNone() # price self.obj1685.price.setValue(0) # Name self.obj1685.Name.setValue('') self.obj1685.Name.setNone() # ReqFlow self.obj1685.ReqFlow.setNone() self.obj1685.GGLabel.setValue(3) self.obj1685.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(320.0, 40.0, self.obj1685) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1685.graphObject_ = new_obj self.obj16850 = AttrCalc() self.obj16850.Copy = ATOM3Boolean() self.obj16850.Copy.setValue(('Copy from LHS', 1)) self.obj16850.Copy.config = 0 self.obj16850.Specify = ATOM3Constraint() self.obj16850.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1685.GGset2Any['MaxFlow'] = self.obj16850 self.obj16851 = AttrCalc() self.obj16851.Copy = ATOM3Boolean() self.obj16851.Copy.setValue(('Copy from LHS', 1)) self.obj16851.Copy.config = 0 self.obj16851.Specify = ATOM3Constraint() self.obj16851.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1685.GGset2Any['Name'] = self.obj16851 self.obj16852 = AttrCalc() self.obj16852.Copy = ATOM3Boolean() self.obj16852.Copy.setValue(('Copy from LHS', 1)) self.obj16852.Copy.config = 0 self.obj16852.Specify = ATOM3Constraint() self.obj16852.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1685.GGset2Any['ReqFlow'] = self.obj16852 # Add node to the root: self.RHS self.RHS.addNode(self.obj1685) self.obj1685.postAction(self.RHS.CREATE) self.obj1686 = operatingUnit(parent) self.obj1686.preAction(self.RHS.CREATE) self.obj1686.isGraphObjectVisual = True if (hasattr(self.obj1686, '_setHierarchicalLink')): self.obj1686._setHierarchicalLink(False) # OperCostProp self.obj1686.OperCostProp.setValue(1.0) # name self.obj1686.name.setValue('') self.obj1686.name.setNone() # OperCostFix self.obj1686.OperCostFix.setValue(2.0) self.obj1686.GGLabel.setValue(7) self.obj1686.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(320.0, 140.0, self.obj1686) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1686.graphObject_ = new_obj self.obj16860 = AttrCalc() self.obj16860.Copy = ATOM3Boolean() self.obj16860.Copy.setValue(('Copy from LHS', 0)) self.obj16860.Copy.config = 0 self.obj16860.Specify = ATOM3Constraint() self.obj16860.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1686.GGset2Any['OperCostProp'] = self.obj16860 self.obj16861 = AttrCalc() self.obj16861.Copy = ATOM3Boolean() self.obj16861.Copy.setValue(('Copy from LHS', 0)) self.obj16861.Copy.config = 0 self.obj16861.Specify = ATOM3Constraint() self.obj16861.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' OAF\'\n' )) self.obj1686.GGset2Any['name'] = self.obj16861 self.obj16862 = AttrCalc() self.obj16862.Copy = ATOM3Boolean() self.obj16862.Copy.setValue(('Copy from LHS', 0)) self.obj16862.Copy.config = 0 self.obj16862.Specify = ATOM3Constraint() self.obj16862.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1686.GGset2Any['OperCostFix'] = self.obj16862 # Add node to the root: self.RHS self.RHS.addNode(self.obj1686) self.obj1686.postAction(self.RHS.CREATE) self.obj1687 = intoProduct(parent) self.obj1687.preAction(self.RHS.CREATE) self.obj1687.isGraphObjectVisual = True if (hasattr(self.obj1687, '_setHierarchicalLink')): self.obj1687._setHierarchicalLink(False) # rate self.obj1687.rate.setValue(1.0) self.obj1687.GGLabel.setValue(9) self.obj1687.graphClass_ = graph_intoProduct if parent.genGraphics: new_obj = graph_intoProduct(322.0, 179.0, self.obj1687) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1687.graphObject_ = new_obj self.obj16870 = AttrCalc() self.obj16870.Copy = ATOM3Boolean() self.obj16870.Copy.setValue(('Copy from LHS', 0)) self.obj16870.Copy.config = 0 self.obj16870.Specify = ATOM3Constraint() self.obj16870.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1687.GGset2Any['rate'] = self.obj16870 # Add node to the root: self.RHS self.RHS.addNode(self.obj1687) self.obj1687.postAction(self.RHS.CREATE) self.obj1688 = fromMaterial(parent) self.obj1688.preAction(self.RHS.CREATE) self.obj1688.isGraphObjectVisual = True if (hasattr(self.obj1688, '_setHierarchicalLink')): self.obj1688._setHierarchicalLink(False) # rate self.obj1688.rate.setValue(1.0) self.obj1688.GGLabel.setValue(8) self.obj1688.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(342.0, 110.0, self.obj1688) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1688.graphObject_ = new_obj self.obj16880 = AttrCalc() self.obj16880.Copy = ATOM3Boolean() self.obj16880.Copy.setValue(('Copy from LHS', 0)) self.obj16880.Copy.config = 0 self.obj16880.Specify = ATOM3Constraint() self.obj16880.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1688.GGset2Any['rate'] = self.obj16880 # Add node to the root: self.RHS self.RHS.addNode(self.obj1688) self.obj1688.postAction(self.RHS.CREATE) self.obj1689 = Goal(parent) self.obj1689.preAction(self.RHS.CREATE) self.obj1689.isGraphObjectVisual = True if (hasattr(self.obj1689, '_setHierarchicalLink')): self.obj1689._setHierarchicalLink(False) # name self.obj1689.name.setValue('') self.obj1689.name.setNone() self.obj1689.GGLabel.setValue(2) self.obj1689.graphClass_ = graph_Goal if parent.genGraphics: new_obj = graph_Goal(180.0, 60.0, self.obj1689) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1689.graphObject_ = new_obj self.obj16890 = AttrCalc() self.obj16890.Copy = ATOM3Boolean() self.obj16890.Copy.setValue(('Copy from LHS', 1)) self.obj16890.Copy.config = 0 self.obj16890.Specify = ATOM3Constraint() self.obj16890.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1689.GGset2Any['name'] = self.obj16890 # Add node to the root: self.RHS self.RHS.addNode(self.obj1689) self.obj1689.postAction(self.RHS.CREATE) self.obj1690 = GenericGraphEdge(parent) self.obj1690.preAction(self.RHS.CREATE) self.obj1690.isGraphObjectVisual = True if (hasattr(self.obj1690, '_setHierarchicalLink')): self.obj1690._setHierarchicalLink(False) self.obj1690.GGLabel.setValue(4) self.obj1690.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(264.5, 71.5, self.obj1690) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1690.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1690) self.obj1690.postAction(self.RHS.CREATE) self.obj1685.out_connections_.append(self.obj1688) self.obj1688.in_connections_.append(self.obj1685) self.obj1685.graphObject_.pendingConnections.append( (self.obj1685.graphObject_.tag, self.obj1688.graphObject_.tag, [244.0, 89.0, 342.0, 110.0], 0, True)) self.obj1686.out_connections_.append(self.obj1687) self.obj1687.in_connections_.append(self.obj1686) self.obj1686.graphObject_.pendingConnections.append( (self.obj1686.graphObject_.tag, self.obj1687.graphObject_.tag, [339.0, 158.0, 322.0, 179.0], 0, True)) self.obj1687.out_connections_.append(self.obj1684) self.obj1684.in_connections_.append(self.obj1687) self.obj1687.graphObject_.pendingConnections.append( (self.obj1687.graphObject_.tag, self.obj1684.graphObject_.tag, [305.0, 220.0, 322.0, 179.0], 0, True)) self.obj1688.out_connections_.append(self.obj1686) self.obj1686.in_connections_.append(self.obj1688) self.obj1688.graphObject_.pendingConnections.append( (self.obj1688.graphObject_.tag, self.obj1686.graphObject_.tag, [340.0, 151.0, 342.0, 110.0], 0, True)) self.obj1689.out_connections_.append(self.obj1690) self.obj1690.in_connections_.append(self.obj1689) self.obj1689.graphObject_.pendingConnections.append( (self.obj1689.graphObject_.tag, self.obj1690.graphObject_.tag, [93.0, 61.0, 264.5, 71.5], 2, 0)) self.obj1690.out_connections_.append(self.obj1685) self.obj1685.in_connections_.append(self.obj1690) self.obj1690.graphObject_.pendingConnections.append( (self.obj1690.graphObject_.tag, self.obj1685.graphObject_.tag, [226.0, 82.0, 264.5, 71.5], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 1) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.obj91 = rawMaterial(parent) self.obj91.preAction(self.LHS.CREATE) self.obj91.isGraphObjectVisual = True if (hasattr(self.obj91, '_setHierarchicalLink')): self.obj91._setHierarchicalLink(False) # MaxFlow self.obj91.MaxFlow.setNone() # price self.obj91.price.setNone() # Name self.obj91.Name.setValue('') self.obj91.Name.setNone() # ReqFlow self.obj91.ReqFlow.setNone() self.obj91.GGLabel.setValue(1) self.obj91.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(60.0, 20.0, self.obj91) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj91.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj91) self.obj91.postAction(self.LHS.CREATE) self.obj92 = metarial(parent) self.obj92.preAction(self.LHS.CREATE) self.obj92.isGraphObjectVisual = True if (hasattr(self.obj92, '_setHierarchicalLink')): self.obj92._setHierarchicalLink(False) # MaxFlow self.obj92.MaxFlow.setNone() # price self.obj92.price.setNone() # Name self.obj92.Name.setValue('') self.obj92.Name.setNone() # ReqFlow self.obj92.ReqFlow.setNone() self.obj92.GGLabel.setValue(4) self.obj92.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(360.0, 160.0, self.obj92) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj92.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj92) self.obj92.postAction(self.LHS.CREATE) self.obj93 = operatingUnit(parent) self.obj93.preAction(self.LHS.CREATE) self.obj93.isGraphObjectVisual = True if (hasattr(self.obj93, '_setHierarchicalLink')): self.obj93._setHierarchicalLink(False) # OperCostProp self.obj93.OperCostProp.setNone() # name self.obj93.name.setValue('') self.obj93.name.setNone() # OperCostFix self.obj93.OperCostFix.setNone() self.obj93.GGLabel.setValue(2) self.obj93.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(160.0, 100.0, self.obj93) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj93.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj93) self.obj93.postAction(self.LHS.CREATE) self.obj94 = fromRaw(parent) self.obj94.preAction(self.LHS.CREATE) self.obj94.isGraphObjectVisual = True if (hasattr(self.obj94, '_setHierarchicalLink')): self.obj94._setHierarchicalLink(False) # rate self.obj94.rate.setNone() self.obj94.GGLabel.setValue(3) self.obj94.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(135.5, 78.0, self.obj94) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj94.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj94) self.obj94.postAction(self.LHS.CREATE) self.obj95 = intoMaterial(parent) self.obj95.preAction(self.LHS.CREATE) self.obj95.isGraphObjectVisual = True if (hasattr(self.obj95, '_setHierarchicalLink')): self.obj95._setHierarchicalLink(False) # rate self.obj95.rate.setNone() self.obj95.GGLabel.setValue(5) self.obj95.graphClass_ = graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(291.5, 140.5, self.obj95) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj95.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj95) self.obj95.postAction(self.LHS.CREATE) self.obj91.out_connections_.append(self.obj94) self.obj94.in_connections_.append(self.obj91) self.obj91.graphObject_.pendingConnections.append( (self.obj91.graphObject_.tag, self.obj94.graphObject_.tag, [84.0, 76.0, 84.0, 118.0, 135.5, 78.0], 2, True)) self.obj93.out_connections_.append(self.obj95) self.obj95.in_connections_.append(self.obj93) self.obj93.graphObject_.pendingConnections.append( (self.obj93.graphObject_.tag, self.obj95.graphObject_.tag, [213.0, 118.0, 212.0, 177.0, 291.5, 140.5], 2, True)) self.obj94.out_connections_.append(self.obj93) self.obj93.in_connections_.append(self.obj94) self.obj94.graphObject_.pendingConnections.append( (self.obj94.graphObject_.tag, self.obj93.graphObject_.tag, [180.0, 111.0, 187.0, 38.0, 135.5, 78.0], 2, True)) self.obj95.out_connections_.append(self.obj92) self.obj92.in_connections_.append(self.obj95) self.obj95.graphObject_.pendingConnections.append( (self.obj95.graphObject_.tag, self.obj92.graphObject_.tag, [386.0, 158.0, 371.0, 104.0, 291.5, 140.5], 2, True)) self.RHS = ASG_pns(parent) self.obj97 = rawMaterial(parent) self.obj97.preAction(self.RHS.CREATE) self.obj97.isGraphObjectVisual = True if (hasattr(self.obj97, '_setHierarchicalLink')): self.obj97._setHierarchicalLink(False) # MaxFlow self.obj97.MaxFlow.setNone() # price self.obj97.price.setNone() # Name self.obj97.Name.setValue('') self.obj97.Name.setNone() # ReqFlow self.obj97.ReqFlow.setNone() self.obj97.GGLabel.setValue(1) self.obj97.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(60.0, 20.0, self.obj97) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj97.graphObject_ = new_obj self.obj970 = AttrCalc() self.obj970.Copy = ATOM3Boolean() self.obj970.Copy.setValue(('Copy from LHS', 1)) self.obj970.Copy.config = 0 self.obj970.Specify = ATOM3Constraint() self.obj970.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj97.GGset2Any['MaxFlow'] = self.obj970 self.obj971 = AttrCalc() self.obj971.Copy = ATOM3Boolean() self.obj971.Copy.setValue(('Copy from LHS', 1)) self.obj971.Copy.config = 0 self.obj971.Specify = ATOM3Constraint() self.obj971.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj97.GGset2Any['price'] = self.obj971 self.obj972 = AttrCalc() self.obj972.Copy = ATOM3Boolean() self.obj972.Copy.setValue(('Copy from LHS', 1)) self.obj972.Copy.config = 0 self.obj972.Specify = ATOM3Constraint() self.obj972.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj97.GGset2Any['Name'] = self.obj972 self.obj973 = AttrCalc() self.obj973.Copy = ATOM3Boolean() self.obj973.Copy.setValue(('Copy from LHS', 1)) self.obj973.Copy.config = 0 self.obj973.Specify = ATOM3Constraint() self.obj973.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj97.GGset2Any['ReqFlow'] = self.obj973 # Add node to the root: self.RHS self.RHS.addNode(self.obj97) self.obj97.postAction(self.RHS.CREATE) self.obj98 = metarial(parent) self.obj98.preAction(self.RHS.CREATE) self.obj98.isGraphObjectVisual = True if (hasattr(self.obj98, '_setHierarchicalLink')): self.obj98._setHierarchicalLink(False) # MaxFlow self.obj98.MaxFlow.setNone() # price self.obj98.price.setNone() # Name self.obj98.Name.setValue('') self.obj98.Name.setNone() # ReqFlow self.obj98.ReqFlow.setNone() self.obj98.GGLabel.setValue(4) self.obj98.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(360.0, 160.0, self.obj98) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj98.graphObject_ = new_obj self.obj980 = AttrCalc() self.obj980.Copy = ATOM3Boolean() self.obj980.Copy.setValue(('Copy from LHS', 1)) self.obj980.Copy.config = 0 self.obj980.Specify = ATOM3Constraint() self.obj980.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj98.GGset2Any['MaxFlow'] = self.obj980 self.obj981 = AttrCalc() self.obj981.Copy = ATOM3Boolean() self.obj981.Copy.setValue(('Copy from LHS', 1)) self.obj981.Copy.config = 0 self.obj981.Specify = ATOM3Constraint() self.obj981.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj98.GGset2Any['price'] = self.obj981 self.obj982 = AttrCalc() self.obj982.Copy = ATOM3Boolean() self.obj982.Copy.setValue(('Copy from LHS', 1)) self.obj982.Copy.config = 0 self.obj982.Specify = ATOM3Constraint() self.obj982.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj98.GGset2Any['Name'] = self.obj982 self.obj983 = AttrCalc() self.obj983.Copy = ATOM3Boolean() self.obj983.Copy.setValue(('Copy from LHS', 1)) self.obj983.Copy.config = 0 self.obj983.Specify = ATOM3Constraint() self.obj983.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj98.GGset2Any['ReqFlow'] = self.obj983 # Add node to the root: self.RHS self.RHS.addNode(self.obj98) self.obj98.postAction(self.RHS.CREATE) self.obj99 = operatingUnit(parent) self.obj99.preAction(self.RHS.CREATE) self.obj99.isGraphObjectVisual = True if (hasattr(self.obj99, '_setHierarchicalLink')): self.obj99._setHierarchicalLink(False) # OperCostProp self.obj99.OperCostProp.setNone() # name self.obj99.name.setValue('') self.obj99.name.setNone() # OperCostFix self.obj99.OperCostFix.setNone() self.obj99.GGLabel.setValue(2) self.obj99.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(160.0, 100.0, self.obj99) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj99.graphObject_ = new_obj self.obj990 = AttrCalc() self.obj990.Copy = ATOM3Boolean() self.obj990.Copy.setValue(('Copy from LHS', 1)) self.obj990.Copy.config = 0 self.obj990.Specify = ATOM3Constraint() self.obj990.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj99.GGset2Any['OperCostProp'] = self.obj990 self.obj991 = AttrCalc() self.obj991.Copy = ATOM3Boolean() self.obj991.Copy.setValue(('Copy from LHS', 1)) self.obj991.Copy.config = 0 self.obj991.Specify = ATOM3Constraint() self.obj991.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj99.GGset2Any['name'] = self.obj991 self.obj992 = AttrCalc() self.obj992.Copy = ATOM3Boolean() self.obj992.Copy.setValue(('Copy from LHS', 1)) self.obj992.Copy.config = 0 self.obj992.Specify = ATOM3Constraint() self.obj992.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj99.GGset2Any['OperCostFix'] = self.obj992 # Add node to the root: self.RHS self.RHS.addNode(self.obj99) self.obj99.postAction(self.RHS.CREATE) self.obj100 = fromRaw(parent) self.obj100.preAction(self.RHS.CREATE) self.obj100.isGraphObjectVisual = True if (hasattr(self.obj100, '_setHierarchicalLink')): self.obj100._setHierarchicalLink(False) # rate self.obj100.rate.setNone() self.obj100.GGLabel.setValue(3) self.obj100.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(135.5, 78.0, self.obj100) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj100.graphObject_ = new_obj self.obj1000 = AttrCalc() self.obj1000.Copy = ATOM3Boolean() self.obj1000.Copy.setValue(('Copy from LHS', 1)) self.obj1000.Copy.config = 0 self.obj1000.Specify = ATOM3Constraint() self.obj1000.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj100.GGset2Any['rate'] = self.obj1000 # Add node to the root: self.RHS self.RHS.addNode(self.obj100) self.obj100.postAction(self.RHS.CREATE) self.obj101 = intoMaterial(parent) self.obj101.preAction(self.RHS.CREATE) self.obj101.isGraphObjectVisual = True if (hasattr(self.obj101, '_setHierarchicalLink')): self.obj101._setHierarchicalLink(False) # rate self.obj101.rate.setNone() self.obj101.GGLabel.setValue(5) self.obj101.graphClass_ = graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(291.5, 140.5, self.obj101) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj101.graphObject_ = new_obj self.obj1010 = AttrCalc() self.obj1010.Copy = ATOM3Boolean() self.obj1010.Copy.setValue(('Copy from LHS', 1)) self.obj1010.Copy.config = 0 self.obj1010.Specify = ATOM3Constraint() self.obj1010.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj101.GGset2Any['rate'] = self.obj1010 # Add node to the root: self.RHS self.RHS.addNode(self.obj101) self.obj101.postAction(self.RHS.CREATE) self.obj97.out_connections_.append(self.obj100) self.obj100.in_connections_.append(self.obj97) self.obj97.graphObject_.pendingConnections.append( (self.obj97.graphObject_.tag, self.obj100.graphObject_.tag, [84.0, 70.0, 135.5, 78.0], 2, 0)) self.obj99.out_connections_.append(self.obj101) self.obj101.in_connections_.append(self.obj99) self.obj99.graphObject_.pendingConnections.append( (self.obj99.graphObject_.tag, self.obj101.graphObject_.tag, [213.0, 108.0, 291.5, 140.5], 2, 0)) self.obj100.out_connections_.append(self.obj99) self.obj99.in_connections_.append(self.obj100) self.obj100.graphObject_.pendingConnections.append( (self.obj100.graphObject_.tag, self.obj99.graphObject_.tag, [210.0, 101.0, 135.5, 78.0], 2, 0)) self.obj101.out_connections_.append(self.obj98) self.obj98.in_connections_.append(self.obj101) self.obj101.graphObject_.pendingConnections.append( (self.obj101.graphObject_.tag, self.obj98.graphObject_.tag, [370.0, 165.0, 291.5, 140.5], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 5) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.obj142=metarial(parent) self.obj142.preAction( self.LHS.CREATE ) self.obj142.isGraphObjectVisual = True if(hasattr(self.obj142, '_setHierarchicalLink')): self.obj142._setHierarchicalLink(False) # MaxFlow self.obj142.MaxFlow.setNone() # price self.obj142.price.setNone() # Name self.obj142.Name.setValue('') self.obj142.Name.setNone() # ReqFlow self.obj142.ReqFlow.setNone() self.obj142.GGLabel.setValue(1) self.obj142.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(40.0,40.0,self.obj142) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj142.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj142) self.obj142.postAction( self.LHS.CREATE ) self.obj143=metarial(parent) self.obj143.preAction( self.LHS.CREATE ) self.obj143.isGraphObjectVisual = True if(hasattr(self.obj143, '_setHierarchicalLink')): self.obj143._setHierarchicalLink(False) # MaxFlow self.obj143.MaxFlow.setNone() # price self.obj143.price.setNone() # Name self.obj143.Name.setValue('') self.obj143.Name.setNone() # ReqFlow self.obj143.ReqFlow.setNone() self.obj143.GGLabel.setValue(3) self.obj143.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(360.0,160.0,self.obj143) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj143.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj143) self.obj143.postAction( self.LHS.CREATE ) self.obj144=operatingUnit(parent) self.obj144.preAction( self.LHS.CREATE ) self.obj144.isGraphObjectVisual = True if(hasattr(self.obj144, '_setHierarchicalLink')): self.obj144._setHierarchicalLink(False) # OperCostProp self.obj144.OperCostProp.setNone() # name self.obj144.name.setValue('') self.obj144.name.setNone() # OperCostFix self.obj144.OperCostFix.setNone() self.obj144.GGLabel.setValue(2) self.obj144.graphClass_= graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(180.0,100.0,self.obj144) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj144.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj144) self.obj144.postAction( self.LHS.CREATE ) self.obj145=intoMaterial(parent) self.obj145.preAction( self.LHS.CREATE ) self.obj145.isGraphObjectVisual = True if(hasattr(self.obj145, '_setHierarchicalLink')): self.obj145._setHierarchicalLink(False) # rate self.obj145.rate.setNone() self.obj145.GGLabel.setValue(5) self.obj145.graphClass_= graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(248.75,168.5,self.obj145) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj145.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj145) self.obj145.postAction( self.LHS.CREATE ) self.obj146=fromMaterial(parent) self.obj146.preAction( self.LHS.CREATE ) self.obj146.isGraphObjectVisual = True if(hasattr(self.obj146, '_setHierarchicalLink')): self.obj146._setHierarchicalLink(False) # rate self.obj146.rate.setNone() self.obj146.GGLabel.setValue(4) self.obj146.graphClass_= graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(175.0,68.75,self.obj146) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj146.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj146) self.obj146.postAction( self.LHS.CREATE ) self.obj142.out_connections_.append(self.obj146) self.obj146.in_connections_.append(self.obj142) self.obj142.graphObject_.pendingConnections.append((self.obj142.graphObject_.tag, self.obj146.graphObject_.tag, [86.0, 50.0, 146.5, 53.5, 175.0, 68.75], 2, True)) self.obj144.out_connections_.append(self.obj145) self.obj145.in_connections_.append(self.obj144) self.obj144.graphObject_.pendingConnections.append((self.obj144.graphObject_.tag, self.obj145.graphObject_.tag, [199.0, 118.0, 207.0, 147.5, 248.75, 168.5], 2, True)) self.obj145.out_connections_.append(self.obj143) self.obj143.in_connections_.append(self.obj145) self.obj145.graphObject_.pendingConnections.append((self.obj145.graphObject_.tag, self.obj143.graphObject_.tag, [366.0, 202.0, 290.5, 189.5, 248.75, 168.5], 2, True)) self.obj146.out_connections_.append(self.obj144) self.obj144.in_connections_.append(self.obj146) self.obj146.graphObject_.pendingConnections.append((self.obj146.graphObject_.tag, self.obj144.graphObject_.tag, [200.0, 111.0, 203.5, 84.0, 175.0, 68.75], 2, True)) self.RHS = ASG_pns(parent) self.obj148=metarial(parent) self.obj148.preAction( self.RHS.CREATE ) self.obj148.isGraphObjectVisual = True if(hasattr(self.obj148, '_setHierarchicalLink')): self.obj148._setHierarchicalLink(False) # MaxFlow self.obj148.MaxFlow.setNone() # price self.obj148.price.setNone() # Name self.obj148.Name.setValue('') self.obj148.Name.setNone() # ReqFlow self.obj148.ReqFlow.setNone() self.obj148.GGLabel.setValue(1) self.obj148.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(40.0,40.0,self.obj148) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj148.graphObject_ = new_obj self.obj1480= AttrCalc() self.obj1480.Copy=ATOM3Boolean() self.obj1480.Copy.setValue(('Copy from LHS', 1)) self.obj1480.Copy.config = 0 self.obj1480.Specify=ATOM3Constraint() self.obj1480.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj148.GGset2Any['MaxFlow']= self.obj1480 self.obj1481= AttrCalc() self.obj1481.Copy=ATOM3Boolean() self.obj1481.Copy.setValue(('Copy from LHS', 1)) self.obj1481.Copy.config = 0 self.obj1481.Specify=ATOM3Constraint() self.obj1481.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj148.GGset2Any['price']= self.obj1481 self.obj1482= AttrCalc() self.obj1482.Copy=ATOM3Boolean() self.obj1482.Copy.setValue(('Copy from LHS', 1)) self.obj1482.Copy.config = 0 self.obj1482.Specify=ATOM3Constraint() self.obj1482.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj148.GGset2Any['Name']= self.obj1482 self.obj1483= AttrCalc() self.obj1483.Copy=ATOM3Boolean() self.obj1483.Copy.setValue(('Copy from LHS', 1)) self.obj1483.Copy.config = 0 self.obj1483.Specify=ATOM3Constraint() self.obj1483.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj148.GGset2Any['ReqFlow']= self.obj1483 # Add node to the root: self.RHS self.RHS.addNode(self.obj148) self.obj148.postAction( self.RHS.CREATE ) self.obj149=metarial(parent) self.obj149.preAction( self.RHS.CREATE ) self.obj149.isGraphObjectVisual = True if(hasattr(self.obj149, '_setHierarchicalLink')): self.obj149._setHierarchicalLink(False) # MaxFlow self.obj149.MaxFlow.setNone() # price self.obj149.price.setNone() # Name self.obj149.Name.setValue('') self.obj149.Name.setNone() # ReqFlow self.obj149.ReqFlow.setNone() self.obj149.GGLabel.setValue(3) self.obj149.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(360.0,160.0,self.obj149) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj149.graphObject_ = new_obj self.obj1490= AttrCalc() self.obj1490.Copy=ATOM3Boolean() self.obj1490.Copy.setValue(('Copy from LHS', 1)) self.obj1490.Copy.config = 0 self.obj1490.Specify=ATOM3Constraint() self.obj1490.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj149.GGset2Any['MaxFlow']= self.obj1490 self.obj1491= AttrCalc() self.obj1491.Copy=ATOM3Boolean() self.obj1491.Copy.setValue(('Copy from LHS', 1)) self.obj1491.Copy.config = 0 self.obj1491.Specify=ATOM3Constraint() self.obj1491.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj149.GGset2Any['price']= self.obj1491 self.obj1492= AttrCalc() self.obj1492.Copy=ATOM3Boolean() self.obj1492.Copy.setValue(('Copy from LHS', 1)) self.obj1492.Copy.config = 0 self.obj1492.Specify=ATOM3Constraint() self.obj1492.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj149.GGset2Any['Name']= self.obj1492 self.obj1493= AttrCalc() self.obj1493.Copy=ATOM3Boolean() self.obj1493.Copy.setValue(('Copy from LHS', 1)) self.obj1493.Copy.config = 0 self.obj1493.Specify=ATOM3Constraint() self.obj1493.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj149.GGset2Any['ReqFlow']= self.obj1493 # Add node to the root: self.RHS self.RHS.addNode(self.obj149) self.obj149.postAction( self.RHS.CREATE ) self.obj150=operatingUnit(parent) self.obj150.preAction( self.RHS.CREATE ) self.obj150.isGraphObjectVisual = True if(hasattr(self.obj150, '_setHierarchicalLink')): self.obj150._setHierarchicalLink(False) # OperCostProp self.obj150.OperCostProp.setNone() # name self.obj150.name.setValue('') self.obj150.name.setNone() # OperCostFix self.obj150.OperCostFix.setNone() self.obj150.GGLabel.setValue(2) self.obj150.graphClass_= graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(180.0,100.0,self.obj150) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj150.graphObject_ = new_obj self.obj1500= AttrCalc() self.obj1500.Copy=ATOM3Boolean() self.obj1500.Copy.setValue(('Copy from LHS', 1)) self.obj1500.Copy.config = 0 self.obj1500.Specify=ATOM3Constraint() self.obj1500.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj150.GGset2Any['OperCostProp']= self.obj1500 self.obj1501= AttrCalc() self.obj1501.Copy=ATOM3Boolean() self.obj1501.Copy.setValue(('Copy from LHS', 1)) self.obj1501.Copy.config = 0 self.obj1501.Specify=ATOM3Constraint() self.obj1501.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj150.GGset2Any['name']= self.obj1501 self.obj1502= AttrCalc() self.obj1502.Copy=ATOM3Boolean() self.obj1502.Copy.setValue(('Copy from LHS', 1)) self.obj1502.Copy.config = 0 self.obj1502.Specify=ATOM3Constraint() self.obj1502.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj150.GGset2Any['OperCostFix']= self.obj1502 # Add node to the root: self.RHS self.RHS.addNode(self.obj150) self.obj150.postAction( self.RHS.CREATE ) self.obj151=intoMaterial(parent) self.obj151.preAction( self.RHS.CREATE ) self.obj151.isGraphObjectVisual = True if(hasattr(self.obj151, '_setHierarchicalLink')): self.obj151._setHierarchicalLink(False) # rate self.obj151.rate.setNone() self.obj151.GGLabel.setValue(5) self.obj151.graphClass_= graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(210.75,161.5,self.obj151) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['Text Scale'] = 0.68 new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj151.graphObject_ = new_obj self.obj1510= AttrCalc() self.obj1510.Copy=ATOM3Boolean() self.obj1510.Copy.setValue(('Copy from LHS', 1)) self.obj1510.Copy.config = 0 self.obj1510.Specify=ATOM3Constraint() self.obj1510.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj151.GGset2Any['rate']= self.obj1510 # Add node to the root: self.RHS self.RHS.addNode(self.obj151) self.obj151.postAction( self.RHS.CREATE ) self.obj152=fromMaterial(parent) self.obj152.preAction( self.RHS.CREATE ) self.obj152.isGraphObjectVisual = True if(hasattr(self.obj152, '_setHierarchicalLink')): self.obj152._setHierarchicalLink(False) # rate self.obj152.rate.setNone() self.obj152.GGLabel.setValue(4) self.obj152.graphClass_= graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(175.0,68.75,self.obj152) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj152.graphObject_ = new_obj self.obj1520= AttrCalc() self.obj1520.Copy=ATOM3Boolean() self.obj1520.Copy.setValue(('Copy from LHS', 1)) self.obj1520.Copy.config = 0 self.obj1520.Specify=ATOM3Constraint() self.obj1520.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj152.GGset2Any['rate']= self.obj1520 # Add node to the root: self.RHS self.RHS.addNode(self.obj152) self.obj152.postAction( self.RHS.CREATE ) self.obj148.out_connections_.append(self.obj152) self.obj152.in_connections_.append(self.obj148) self.obj148.graphObject_.pendingConnections.append((self.obj148.graphObject_.tag, self.obj152.graphObject_.tag, [86.0, 50.0, 175.0, 68.75], 2, 0)) self.obj150.out_connections_.append(self.obj151) self.obj151.in_connections_.append(self.obj150) self.obj150.graphObject_.pendingConnections.append((self.obj150.graphObject_.tag, self.obj151.graphObject_.tag, [233.0, 108.0, 210.75, 161.5], 2, 0)) self.obj151.out_connections_.append(self.obj149) self.obj149.in_connections_.append(self.obj151) self.obj151.graphObject_.pendingConnections.append((self.obj151.graphObject_.tag, self.obj149.graphObject_.tag, [370.0, 165.0, 248.75, 168.5], 2, 0)) self.obj152.out_connections_.append(self.obj150) self.obj150.in_connections_.append(self.obj152) self.obj152.graphObject_.pendingConnections.append((self.obj152.graphObject_.tag, self.obj150.graphObject_.tag, [230.0, 101.0, 175.0, 68.75], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 10) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_omacs(parent) self.obj1622=Agent(parent) self.obj1622.preAction( self.LHS.CREATE ) self.obj1622.isGraphObjectVisual = True if(hasattr(self.obj1622, '_setHierarchicalLink')): self.obj1622._setHierarchicalLink(False) # price self.obj1622.price.setNone() # name self.obj1622.name.setValue('') self.obj1622.name.setNone() self.obj1622.GGLabel.setValue(1) self.obj1622.graphClass_= graph_Agent if parent.genGraphics: new_obj = graph_Agent(60.0,40.0,self.obj1622) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1622.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1622) self.obj1622.postAction( self.LHS.CREATE ) self.obj1623=Role(parent) self.obj1623.preAction( self.LHS.CREATE ) self.obj1623.isGraphObjectVisual = True if(hasattr(self.obj1623, '_setHierarchicalLink')): self.obj1623._setHierarchicalLink(False) # name self.obj1623.name.setValue('') self.obj1623.name.setNone() self.obj1623.GGLabel.setValue(2) self.obj1623.graphClass_= graph_Role if parent.genGraphics: new_obj = graph_Role(320.0,220.0,self.obj1623) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1623.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1623) self.obj1623.postAction( self.LHS.CREATE ) self.obj1624=CapableOf(parent) self.obj1624.preAction( self.LHS.CREATE ) self.obj1624.isGraphObjectVisual = True if(hasattr(self.obj1624, '_setHierarchicalLink')): self.obj1624._setHierarchicalLink(False) # rate self.obj1624.rate.setNone() self.obj1624.GGLabel.setValue(3) self.obj1624.graphClass_= graph_CapableOf if parent.genGraphics: new_obj = graph_CapableOf(230.0,173.0,self.obj1624) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1624.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1624) self.obj1624.postAction( self.LHS.CREATE ) self.obj1622.out_connections_.append(self.obj1624) self.obj1624.in_connections_.append(self.obj1622) self.obj1622.graphObject_.pendingConnections.append((self.obj1622.graphObject_.tag, self.obj1624.graphObject_.tag, [85.0, 102.0, 117.0, 188.0, 230.0, 173.0], 2, True)) self.obj1624.out_connections_.append(self.obj1623) self.obj1623.in_connections_.append(self.obj1624) self.obj1624.graphObject_.pendingConnections.append((self.obj1624.graphObject_.tag, self.obj1623.graphObject_.tag, [344.0, 221.0, 343.0, 158.0, 230.0, 173.0], 2, True)) self.RHS = ASG_omacs(parent) self.RHS.merge(ASG_pns(parent)) self.RHS.merge(ASG_GenericGraph(parent)) self.obj1628=Agent(parent) self.obj1628.preAction( self.RHS.CREATE ) self.obj1628.isGraphObjectVisual = True if(hasattr(self.obj1628, '_setHierarchicalLink')): self.obj1628._setHierarchicalLink(False) # price self.obj1628.price.setNone() # name self.obj1628.name.setValue('') self.obj1628.name.setNone() self.obj1628.GGLabel.setValue(1) self.obj1628.graphClass_= graph_Agent if parent.genGraphics: new_obj = graph_Agent(60.0,40.0,self.obj1628) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1628.graphObject_ = new_obj self.obj16280= AttrCalc() self.obj16280.Copy=ATOM3Boolean() self.obj16280.Copy.setValue(('Copy from LHS', 1)) self.obj16280.Copy.config = 0 self.obj16280.Specify=ATOM3Constraint() self.obj16280.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1628.GGset2Any['price']= self.obj16280 self.obj16281= AttrCalc() self.obj16281.Copy=ATOM3Boolean() self.obj16281.Copy.setValue(('Copy from LHS', 1)) self.obj16281.Copy.config = 0 self.obj16281.Specify=ATOM3Constraint() self.obj16281.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1628.GGset2Any['name']= self.obj16281 # Add node to the root: self.RHS self.RHS.addNode(self.obj1628) self.obj1628.postAction( self.RHS.CREATE ) self.obj1629=Role(parent) self.obj1629.preAction( self.RHS.CREATE ) self.obj1629.isGraphObjectVisual = True if(hasattr(self.obj1629, '_setHierarchicalLink')): self.obj1629._setHierarchicalLink(False) # name self.obj1629.name.setValue('') self.obj1629.name.setNone() self.obj1629.GGLabel.setValue(2) self.obj1629.graphClass_= graph_Role if parent.genGraphics: new_obj = graph_Role(320.0,220.0,self.obj1629) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1629.graphObject_ = new_obj self.obj16290= AttrCalc() self.obj16290.Copy=ATOM3Boolean() self.obj16290.Copy.setValue(('Copy from LHS', 1)) self.obj16290.Copy.config = 0 self.obj16290.Specify=ATOM3Constraint() self.obj16290.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1629.GGset2Any['name']= self.obj16290 # Add node to the root: self.RHS self.RHS.addNode(self.obj1629) self.obj1629.postAction( self.RHS.CREATE ) self.obj1630=CapableOf(parent) self.obj1630.preAction( self.RHS.CREATE ) self.obj1630.isGraphObjectVisual = True if(hasattr(self.obj1630, '_setHierarchicalLink')): self.obj1630._setHierarchicalLink(False) # rate self.obj1630.rate.setNone() self.obj1630.GGLabel.setValue(3) self.obj1630.graphClass_= graph_CapableOf if parent.genGraphics: new_obj = graph_CapableOf(230.0,173.0,self.obj1630) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1630.graphObject_ = new_obj self.obj16300= AttrCalc() self.obj16300.Copy=ATOM3Boolean() self.obj16300.Copy.setValue(('Copy from LHS', 1)) self.obj16300.Copy.config = 0 self.obj16300.Specify=ATOM3Constraint() self.obj16300.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1630.GGset2Any['rate']= self.obj16300 # Add node to the root: self.RHS self.RHS.addNode(self.obj1630) self.obj1630.postAction( self.RHS.CREATE ) self.obj1631=operatingUnit(parent) self.obj1631.preAction( self.RHS.CREATE ) self.obj1631.isGraphObjectVisual = True if(hasattr(self.obj1631, '_setHierarchicalLink')): self.obj1631._setHierarchicalLink(False) # OperCostProp self.obj1631.OperCostProp.setValue(0.0) # name self.obj1631.name.setValue('') self.obj1631.name.setNone() # OperCostFix self.obj1631.OperCostFix.setValue(0.0) self.obj1631.GGLabel.setValue(5) self.obj1631.graphClass_= graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(60.0,220.0,self.obj1631) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1631.graphObject_ = new_obj self.obj16310= AttrCalc() self.obj16310.Copy=ATOM3Boolean() self.obj16310.Copy.setValue(('Copy from LHS', 1)) self.obj16310.Copy.config = 0 self.obj16310.Specify=ATOM3Constraint() self.obj16310.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1631.GGset2Any['OperCostProp']= self.obj16310 self.obj16311= AttrCalc() self.obj16311.Copy=ATOM3Boolean() self.obj16311.Copy.setValue(('Copy from LHS', 0)) self.obj16311.Copy.config = 0 self.obj16311.Specify=ATOM3Constraint() self.obj16311.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(1)).name.getValue()+\' \'+self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()\n\n\n\n')) self.obj1631.GGset2Any['name']= self.obj16311 self.obj16312= AttrCalc() self.obj16312.Copy=ATOM3Boolean() self.obj16312.Copy.setValue(('Copy from LHS', 1)) self.obj16312.Copy.config = 0 self.obj16312.Specify=ATOM3Constraint() self.obj16312.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1631.GGset2Any['OperCostFix']= self.obj16312 # Add node to the root: self.RHS self.RHS.addNode(self.obj1631) self.obj1631.postAction( self.RHS.CREATE ) self.obj1632=GenericGraphEdge(parent) self.obj1632.preAction( self.RHS.CREATE ) self.obj1632.isGraphObjectVisual = True if(hasattr(self.obj1632, '_setHierarchicalLink')): self.obj1632._setHierarchicalLink(False) self.obj1632.GGLabel.setValue(6) self.obj1632.graphClass_= graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(103.5,161.5,self.obj1632) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1632.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1632) self.obj1632.postAction( self.RHS.CREATE ) self.obj1628.out_connections_.append(self.obj1630) self.obj1630.in_connections_.append(self.obj1628) self.obj1628.graphObject_.pendingConnections.append((self.obj1628.graphObject_.tag, self.obj1630.graphObject_.tag, [97.0, 102.0, 230.0, 173.0], 2, 0)) self.obj1628.out_connections_.append(self.obj1632) self.obj1632.in_connections_.append(self.obj1628) self.obj1628.graphObject_.pendingConnections.append((self.obj1628.graphObject_.tag, self.obj1632.graphObject_.tag, [97.0, 102.0, 103.5, 161.5], 0, True)) self.obj1630.out_connections_.append(self.obj1629) self.obj1629.in_connections_.append(self.obj1630) self.obj1630.graphObject_.pendingConnections.append((self.obj1630.graphObject_.tag, self.obj1629.graphObject_.tag, [351.0, 220.0, 230.0, 173.0], 2, 0)) self.obj1632.out_connections_.append(self.obj1631) self.obj1631.in_connections_.append(self.obj1632) self.obj1632.graphObject_.pendingConnections.append((self.obj1632.graphObject_.tag, self.obj1631.graphObject_.tag, [110.0, 221.0, 103.5, 161.5], 0, True))
def pnsEx1_MDL(self, rootNode, pnsRootNode=None): # --- Generating attributes code for ASG pns --- if (pnsRootNode): # author pnsRootNode.author.setValue('Annonymous') # description pnsRootNode.description.setValue('\n') pnsRootNode.description.setHeight(15) # name pnsRootNode.name.setValue('') pnsRootNode.name.setNone() # --- ASG attributes over --- self.obj1028 = rawMaterial(self) self.obj1028.isGraphObjectVisual = True if (hasattr(self.obj1028, '_setHierarchicalLink')): self.obj1028._setHierarchicalLink(False) # MaxFlow self.obj1028.MaxFlow.setValue(999999) # price self.obj1028.price.setValue(5) # Name self.obj1028.Name.setValue('A1') # ReqFlow self.obj1028.ReqFlow.setValue(0) self.obj1028.graphClass_ = graph_rawMaterial if self.genGraphics: new_obj = graph_rawMaterial(206, 0, self.obj1028) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("rawMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1028.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1028) self.globalAndLocalPostcondition(self.obj1028, rootNode) self.obj1028.postAction(rootNode.CREATE) self.obj1029 = operatingUnit(self) self.obj1029.isGraphObjectVisual = True if (hasattr(self.obj1029, '_setHierarchicalLink')): self.obj1029._setHierarchicalLink(False) # OperCostProp self.obj1029.OperCostProp.setValue(0.5) # name self.obj1029.name.setValue('A1 R1') # OperCostFix self.obj1029.OperCostFix.setValue(0.0) self.obj1029.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(206, 108, self.obj1029) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1029.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1029) self.globalAndLocalPostcondition(self.obj1029, rootNode) self.obj1029.postAction(rootNode.CREATE) self.obj1030 = operatingUnit(self) self.obj1030.isGraphObjectVisual = True if (hasattr(self.obj1030, '_setHierarchicalLink')): self.obj1030._setHierarchicalLink(False) # OperCostProp self.obj1030.OperCostProp.setValue(1.0) # name self.obj1030.name.setValue('G1 OAF') # OperCostFix self.obj1030.OperCostFix.setValue(2.0) self.obj1030.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(0, 450, self.obj1030) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1030.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1030) self.globalAndLocalPostcondition(self.obj1030, rootNode) self.obj1030.postAction(rootNode.CREATE) self.obj1031 = operatingUnit(self) self.obj1031.isGraphObjectVisual = True if (hasattr(self.obj1031, '_setHierarchicalLink')): self.obj1031._setHierarchicalLink(False) # OperCostProp self.obj1031.OperCostProp.setValue(1.0) # name self.obj1031.name.setValue('G2 OAF') # OperCostFix self.obj1031.OperCostFix.setValue(2.0) self.obj1031.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(206, 450, self.obj1031) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1031.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1031) self.globalAndLocalPostcondition(self.obj1031, rootNode) self.obj1031.postAction(rootNode.CREATE) self.obj1032 = operatingUnit(self) self.obj1032.isGraphObjectVisual = True if (hasattr(self.obj1032, '_setHierarchicalLink')): self.obj1032._setHierarchicalLink(False) # OperCostProp self.obj1032.OperCostProp.setValue(0.11) # name self.obj1032.name.setValue('A1 R1 G1') # OperCostFix self.obj1032.OperCostFix.setValue(2.0) self.obj1032.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(0, 279, self.obj1032) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1032.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1032) self.globalAndLocalPostcondition(self.obj1032, rootNode) self.obj1032.postAction(rootNode.CREATE) self.obj1033 = operatingUnit(self) self.obj1033.isGraphObjectVisual = True if (hasattr(self.obj1033, '_setHierarchicalLink')): self.obj1033._setHierarchicalLink(False) # OperCostProp self.obj1033.OperCostProp.setValue(0.12) # name self.obj1033.name.setValue('A1 R1 G2') # OperCostFix self.obj1033.OperCostFix.setValue(2.0) self.obj1033.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(206, 279, self.obj1033) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1033.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1033) self.globalAndLocalPostcondition(self.obj1033, rootNode) self.obj1033.postAction(rootNode.CREATE) self.obj1034 = metarial(self) self.obj1034.isGraphObjectVisual = True if (hasattr(self.obj1034, '_setHierarchicalLink')): self.obj1034._setHierarchicalLink(False) # MaxFlow self.obj1034.MaxFlow.setValue(999999) # price self.obj1034.price.setValue(0) # Name self.obj1034.Name.setValue('G1') # ReqFlow self.obj1034.ReqFlow.setValue(0) self.obj1034.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(0, 350, self.obj1034) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1034.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1034) self.globalAndLocalPostcondition(self.obj1034, rootNode) self.obj1034.postAction(rootNode.CREATE) self.obj1035 = metarial(self) self.obj1035.isGraphObjectVisual = True if (hasattr(self.obj1035, '_setHierarchicalLink')): self.obj1035._setHierarchicalLink(False) # MaxFlow self.obj1035.MaxFlow.setValue(999999) # price self.obj1035.price.setValue(0) # Name self.obj1035.Name.setValue('G2') # ReqFlow self.obj1035.ReqFlow.setValue(0) self.obj1035.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(206, 350, self.obj1035) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1035.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1035) self.globalAndLocalPostcondition(self.obj1035, rootNode) self.obj1035.postAction(rootNode.CREATE) self.obj1036 = metarial(self) self.obj1036.isGraphObjectVisual = True if (hasattr(self.obj1036, '_setHierarchicalLink')): self.obj1036._setHierarchicalLink(False) # MaxFlow self.obj1036.MaxFlow.setValue(999999) # price self.obj1036.price.setValue(0) # Name self.obj1036.Name.setValue('A1 R1 G1') # ReqFlow self.obj1036.ReqFlow.setValue(0) self.obj1036.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(0, 179, self.obj1036) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1036.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1036) self.globalAndLocalPostcondition(self.obj1036, rootNode) self.obj1036.postAction(rootNode.CREATE) self.obj1037 = metarial(self) self.obj1037.isGraphObjectVisual = True if (hasattr(self.obj1037, '_setHierarchicalLink')): self.obj1037._setHierarchicalLink(False) # MaxFlow self.obj1037.MaxFlow.setValue(999999) # price self.obj1037.price.setValue(0) # Name self.obj1037.Name.setValue('A1 R1 G2') # ReqFlow self.obj1037.ReqFlow.setValue(0) self.obj1037.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(206, 179, self.obj1037) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1037.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1037) self.globalAndLocalPostcondition(self.obj1037, rootNode) self.obj1037.postAction(rootNode.CREATE) self.obj1038 = product(self) self.obj1038.isGraphObjectVisual = True if (hasattr(self.obj1038, '_setHierarchicalLink')): self.obj1038._setHierarchicalLink(False) # MaxFlow self.obj1038.MaxFlow.setValue(999999) # price self.obj1038.price.setValue(0) # Name self.obj1038.Name.setValue('OAF') # ReqFlow self.obj1038.ReqFlow.setValue(0) self.obj1038.graphClass_ = graph_product if self.genGraphics: new_obj = graph_product(206, 521, self.obj1038) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("product", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1038.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1038) self.globalAndLocalPostcondition(self.obj1038, rootNode) self.obj1038.postAction(rootNode.CREATE) self.obj1039 = fromMaterial(self) self.obj1039.isGraphObjectVisual = True if (hasattr(self.obj1039, '_setHierarchicalLink')): self.obj1039._setHierarchicalLink(False) # rate self.obj1039.rate.setValue(1.0) self.obj1039.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(32.005065672, 430.467211341, self.obj1039) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1039.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1039) self.globalAndLocalPostcondition(self.obj1039, rootNode) self.obj1039.postAction(rootNode.CREATE) self.obj1040 = fromMaterial(self) self.obj1040.isGraphObjectVisual = True if (hasattr(self.obj1040, '_setHierarchicalLink')): self.obj1040._setHierarchicalLink(False) # rate self.obj1040.rate.setValue(1.0) self.obj1040.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(238.207284862, 430.669455243, self.obj1040) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1040.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1040) self.globalAndLocalPostcondition(self.obj1040, rootNode) self.obj1040.postAction(rootNode.CREATE) self.obj1041 = fromMaterial(self) self.obj1041.isGraphObjectVisual = True if (hasattr(self.obj1041, '_setHierarchicalLink')): self.obj1041._setHierarchicalLink(False) # rate self.obj1041.rate.setValue(1.0) self.obj1041.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(51.4550432196, 256.476547823, self.obj1041) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1041.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1041) self.globalAndLocalPostcondition(self.obj1041, rootNode) self.obj1041.postAction(rootNode.CREATE) self.obj1042 = fromMaterial(self) self.obj1042.isGraphObjectVisual = True if (hasattr(self.obj1042, '_setHierarchicalLink')): self.obj1042._setHierarchicalLink(False) # rate self.obj1042.rate.setValue(1.0) self.obj1042.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(257.45504322, 256.476547823, self.obj1042) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1042.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1042) self.globalAndLocalPostcondition(self.obj1042, rootNode) self.obj1042.postAction(rootNode.CREATE) self.obj1043 = intoProduct(self) self.obj1043.isGraphObjectVisual = True if (hasattr(self.obj1043, '_setHierarchicalLink')): self.obj1043._setHierarchicalLink(False) # rate self.obj1043.rate.setValue(1.0) self.obj1043.graphClass_ = graph_intoProduct if self.genGraphics: new_obj = graph_intoProduct(144.868478175, 484.858273262, self.obj1043) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoProduct", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1043.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1043) self.globalAndLocalPostcondition(self.obj1043, rootNode) self.obj1043.postAction(rootNode.CREATE) self.obj1044 = intoProduct(self) self.obj1044.isGraphObjectVisual = True if (hasattr(self.obj1044, '_setHierarchicalLink')): self.obj1044._setHierarchicalLink(False) # rate self.obj1044.rate.setValue(1.0) self.obj1044.graphClass_ = graph_intoProduct if self.genGraphics: new_obj = graph_intoProduct(238.187112626, 493.499100791, self.obj1044) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoProduct", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1044.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1044) self.globalAndLocalPostcondition(self.obj1044, rootNode) self.obj1044.postAction(rootNode.CREATE) self.obj1045 = fromRaw(self) self.obj1045.isGraphObjectVisual = True if (hasattr(self.obj1045, '_setHierarchicalLink')): self.obj1045._setHierarchicalLink(False) # rate self.obj1045.rate.setValue(1.0) self.obj1045.graphClass_ = graph_fromRaw if self.genGraphics: new_obj = graph_fromRaw(237.772666213, 87.9637186904, self.obj1045) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromRaw", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1045.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1045) self.globalAndLocalPostcondition(self.obj1045, rootNode) self.obj1045.postAction(rootNode.CREATE) self.obj1046 = intoMaterial(self) self.obj1046.isGraphObjectVisual = True if (hasattr(self.obj1046, '_setHierarchicalLink')): self.obj1046._setHierarchicalLink(False) # rate self.obj1046.rate.setValue(0.11) self.obj1046.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(32.4226168069, 321.008573698, self.obj1046) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1046.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1046) self.globalAndLocalPostcondition(self.obj1046, rootNode) self.obj1046.postAction(rootNode.CREATE) self.obj1047 = intoMaterial(self) self.obj1047.isGraphObjectVisual = True if (hasattr(self.obj1047, '_setHierarchicalLink')): self.obj1047._setHierarchicalLink(False) # rate self.obj1047.rate.setValue(0.12) self.obj1047.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(238.390600655, 321.222839546, self.obj1047) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1047.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1047) self.globalAndLocalPostcondition(self.obj1047, rootNode) self.obj1047.postAction(rootNode.CREATE) self.obj1048 = intoMaterial(self) self.obj1048.isGraphObjectVisual = True if (hasattr(self.obj1048, '_setHierarchicalLink')): self.obj1048._setHierarchicalLink(False) # rate self.obj1048.rate.setValue(0.5) self.obj1048.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(143.686831985, 166.822062776, self.obj1048) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1048.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1048) self.globalAndLocalPostcondition(self.obj1048, rootNode) self.obj1048.postAction(rootNode.CREATE) self.obj1049 = intoMaterial(self) self.obj1049.isGraphObjectVisual = True if (hasattr(self.obj1049, '_setHierarchicalLink')): self.obj1049._setHierarchicalLink(False) # rate self.obj1049.rate.setValue(0.5) self.obj1049.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(242.68883419, 148.342483174, self.obj1049) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1049.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj1049) self.globalAndLocalPostcondition(self.obj1049, rootNode) self.obj1049.postAction(rootNode.CREATE) # Connections for obj1028 (graphObject_: Obj713) of type rawMaterial self.drawConnections((self.obj1028, self.obj1045, [ 229.7927616866, 55.830073958000014, 238.77266621273276, 72.21371869016248, 237.77266621258278, 87.96371869041248 ], "true", 3)) # Connections for obj1029 (graphObject_: Obj714) named A1 R1 self.drawConnections((self.obj1029, self.obj1048, [ 224.792761686, 125.830073959, 185.99042726423008, 151.00958126939372, 143.68683198473008, 166.82206277614372 ], "true", 3), (self.obj1029, self.obj1049, [ 224.792761686, 125.830073959, 238.49242946992584, 135.53000166744766, 242.68883419042584, 148.34248317419767 ], "true", 3)) # Connections for obj1030 (graphObject_: Obj715) named G1 OAF self.drawConnections((self.obj1030, self.obj1043, [ 53.0172746084, 467.88123386200004, 100.37279682732834, 471.57858172741805, 144.86847817522835, 484.85827326191804 ], "true", 3)) # Connections for obj1031 (graphObject_: Obj716) named G2 OAF self.drawConnections((self.obj1031, self.obj1044, [ 225.482036654, 468.072046504, 236.80762178979543, 480.2671124172909, 238.18711262629543, 493.49910079129086 ], "true", 3)) # Connections for obj1032 (graphObject_: Obj717) named A1 R1 G1 self.drawConnections((self.obj1032, self.obj1046, [ 19.0, 297.0, 30.663979502928797, 308.3179567678522, 32.422616806928794, 321.00857369835217 ], "true", 3)) # Connections for obj1033 (graphObject_: Obj718) named A1 R1 G2 self.drawConnections((self.obj1033, self.obj1047, [ 225.0, 297.0, 236.6495823288382, 308.4368162949629, 238.39060065533818, 321.2228395464629 ], "true", 3)) # Connections for obj1034 (graphObject_: Obj719) of type metarial self.drawConnections((self.obj1034, self.obj1039, [ 24.034549215999988, 398.7624677220001, 33.009384323918454, 414.9375198057641, 32.00506567201846, 430.4672113407641 ], "true", 3)) # Connections for obj1035 (graphObject_: Obj720) of type metarial self.drawConnections((self.obj1035, self.obj1040, [ 229.964073306, 399.14409300600005, 239.07779402486605, 415.18746686842474, 238.20728486186607, 430.6694552429247 ], "true", 3)) # Connections for obj1036 (graphObject_: Obj721) of type metarial self.drawConnections((self.obj1036, self.obj1041, [ 33.578380568, 228.07999998599996, 47.34963836160739, 240.9965478196302, 51.45504321960739, 256.4765478231302 ], "true", 3)) # Connections for obj1037 (graphObject_: Obj722) of type metarial self.drawConnections((self.obj1037, self.obj1042, [ 239.578380568, 228.07999998600008, 253.34963836160736, 240.99654781963028, 257.4550432196074, 256.47654782313026 ], "true", 3)) # Connections for obj1038 (graphObject_: Obj723) of type product self.drawConnections() # Connections for obj1039 (graphObject_: Obj724) of type fromMaterial self.drawConnections((self.obj1039, self.obj1030, [ 32.00506567201846, 430.4672113407641, 31.00074702011846, 445.9969028757641, 20.0172746084, 460.88123386200004 ], "true", 3)) # Connections for obj1040 (graphObject_: Obj726) of type fromMaterial self.drawConnections((self.obj1040, self.obj1031, [ 238.20728486186607, 430.6694552429247, 237.3367756988661, 446.15144361742466, 226.482036654, 461.072046504 ], "true", 3)) # Connections for obj1041 (graphObject_: Obj728) of type fromMaterial self.drawConnections((self.obj1041, self.obj1032, [ 51.45504321960739, 256.4765478231302, 55.56044807760739, 271.95654782663024, 50.0, 290.0 ], "true", 3)) # Connections for obj1042 (graphObject_: Obj730) of type fromMaterial self.drawConnections((self.obj1042, self.obj1033, [ 257.4550432196074, 256.47654782313026, 261.5604480776074, 271.95654782663024, 256.0, 290.0 ], "true", 3)) # Connections for obj1043 (graphObject_: Obj732) of type intoProduct self.drawConnections((self.obj1043, self.obj1038, [ 144.86847817522835, 484.85827326191804, 189.3641595231283, 498.13796479641803, 231.0, 521.0 ], "true", 3)) # Connections for obj1044 (graphObject_: Obj734) of type intoProduct self.drawConnections((self.obj1044, self.obj1038, [ 238.18711262629543, 493.49910079129086, 239.56660346279543, 506.7310891652908, 231.0, 521.0 ], "true", 3)) # Connections for obj1045 (graphObject_: Obj736) of type fromRaw self.drawConnections((self.obj1045, self.obj1029, [ 237.77266621258278, 87.96371869041248, 236.7726662124328, 103.71371869066247, 225.792761686, 118.830073959 ], "true", 3)) # Connections for obj1046 (graphObject_: Obj738) of type intoMaterial self.drawConnections((self.obj1046, self.obj1034, [ 32.422616806928794, 321.00857369835217, 34.18125411092879, 333.69919062885214, 26.034549215999988, 347.762467722 ], "true", 3)) # Connections for obj1047 (graphObject_: Obj740) of type intoMaterial self.drawConnections((self.obj1047, self.obj1035, [ 238.39060065533818, 321.2228395464629, 240.13161898183816, 334.00886279796293, 231.964073306, 348.14409300600005 ], "true", 3)) # Connections for obj1048 (graphObject_: Obj742) of type intoMaterial self.drawConnections((self.obj1048, self.obj1036, [ 143.68683198473008, 166.82206277614372, 101.38323670523008, 182.63454428289373, 55.57838056800006, 189.07999998599996 ], "true", 3)) # Connections for obj1049 (graphObject_: Obj744) of type intoMaterial self.drawConnections((self.obj1049, self.obj1037, [ 242.68883419042584, 148.34248317419767, 246.88523891092584, 161.15496468094767, 241.578380568, 177.07999998600002 ], "true", 3))
def __init__(self, parent): GGrule.__init__(self, 6) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.obj965 = product(parent) self.obj965.preAction(self.LHS.CREATE) self.obj965.isGraphObjectVisual = True if (hasattr(self.obj965, '_setHierarchicalLink')): self.obj965._setHierarchicalLink(False) # MaxFlow self.obj965.MaxFlow.setNone() # price self.obj965.price.setNone() # Name self.obj965.Name.setValue('') self.obj965.Name.setNone() # ReqFlow self.obj965.ReqFlow.setNone() self.obj965.GGLabel.setValue(2) self.obj965.graphClass_ = graph_product if parent.genGraphics: new_obj = graph_product(220.0, 140.0, self.obj965) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj965.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj965) self.obj965.postAction(self.LHS.CREATE) self.obj966 = operatingUnit(parent) self.obj966.preAction(self.LHS.CREATE) self.obj966.isGraphObjectVisual = True if (hasattr(self.obj966, '_setHierarchicalLink')): self.obj966._setHierarchicalLink(False) # OperCostProp self.obj966.OperCostProp.setNone() # name self.obj966.name.setValue('') self.obj966.name.setNone() # OperCostFix self.obj966.OperCostFix.setNone() self.obj966.GGLabel.setValue(1) self.obj966.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(180.0, 20.0, self.obj966) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj966.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj966) self.obj966.postAction(self.LHS.CREATE) self.obj967 = intoProduct(parent) self.obj967.preAction(self.LHS.CREATE) self.obj967.isGraphObjectVisual = True if (hasattr(self.obj967, '_setHierarchicalLink')): self.obj967._setHierarchicalLink(False) # rate self.obj967.rate.setNone() self.obj967.GGLabel.setValue(3) self.obj967.graphClass_ = graph_intoProduct if parent.genGraphics: new_obj = graph_intoProduct(239.0, 89.0, self.obj967) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj967.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj967) self.obj967.postAction(self.LHS.CREATE) self.obj966.out_connections_.append(self.obj967) self.obj967.in_connections_.append(self.obj966) self.obj966.graphObject_.pendingConnections.append( (self.obj966.graphObject_.tag, self.obj967.graphObject_.tag, [233.0, 38.0, 239.0, 89.0], 0, True)) self.obj967.out_connections_.append(self.obj965) self.obj965.in_connections_.append(self.obj967) self.obj967.graphObject_.pendingConnections.append( (self.obj967.graphObject_.tag, self.obj965.graphObject_.tag, [245.0, 140.0, 239.0, 89.0], 0, True)) self.RHS = ASG_pns(parent) self.obj969 = product(parent) self.obj969.preAction(self.RHS.CREATE) self.obj969.isGraphObjectVisual = True if (hasattr(self.obj969, '_setHierarchicalLink')): self.obj969._setHierarchicalLink(False) # MaxFlow self.obj969.MaxFlow.setNone() # price self.obj969.price.setNone() # Name self.obj969.Name.setValue('') self.obj969.Name.setNone() # ReqFlow self.obj969.ReqFlow.setNone() self.obj969.GGLabel.setValue(2) self.obj969.graphClass_ = graph_product if parent.genGraphics: new_obj = graph_product(220.0, 140.0, self.obj969) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj969.graphObject_ = new_obj self.obj9690 = AttrCalc() self.obj9690.Copy = ATOM3Boolean() self.obj9690.Copy.setValue(('Copy from LHS', 1)) self.obj9690.Copy.config = 0 self.obj9690.Specify = ATOM3Constraint() self.obj9690.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj969.GGset2Any['MaxFlow'] = self.obj9690 self.obj9691 = AttrCalc() self.obj9691.Copy = ATOM3Boolean() self.obj9691.Copy.setValue(('Copy from LHS', 1)) self.obj9691.Copy.config = 0 self.obj9691.Specify = ATOM3Constraint() self.obj9691.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj969.GGset2Any['price'] = self.obj9691 self.obj9692 = AttrCalc() self.obj9692.Copy = ATOM3Boolean() self.obj9692.Copy.setValue(('Copy from LHS', 1)) self.obj9692.Copy.config = 0 self.obj9692.Specify = ATOM3Constraint() self.obj9692.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj969.GGset2Any['Name'] = self.obj9692 self.obj9693 = AttrCalc() self.obj9693.Copy = ATOM3Boolean() self.obj9693.Copy.setValue(('Copy from LHS', 1)) self.obj9693.Copy.config = 0 self.obj9693.Specify = ATOM3Constraint() self.obj9693.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj969.GGset2Any['ReqFlow'] = self.obj9693 # Add node to the root: self.RHS self.RHS.addNode(self.obj969) self.obj969.postAction(self.RHS.CREATE) self.obj970 = operatingUnit(parent) self.obj970.preAction(self.RHS.CREATE) self.obj970.isGraphObjectVisual = True if (hasattr(self.obj970, '_setHierarchicalLink')): self.obj970._setHierarchicalLink(False) # OperCostProp self.obj970.OperCostProp.setNone() # name self.obj970.name.setValue('') self.obj970.name.setNone() # OperCostFix self.obj970.OperCostFix.setNone() self.obj970.GGLabel.setValue(1) self.obj970.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(180.0, 20.0, self.obj970) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj970.graphObject_ = new_obj self.obj9700 = AttrCalc() self.obj9700.Copy = ATOM3Boolean() self.obj9700.Copy.setValue(('Copy from LHS', 1)) self.obj9700.Copy.config = 0 self.obj9700.Specify = ATOM3Constraint() self.obj9700.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj970.GGset2Any['OperCostProp'] = self.obj9700 self.obj9701 = AttrCalc() self.obj9701.Copy = ATOM3Boolean() self.obj9701.Copy.setValue(('Copy from LHS', 1)) self.obj9701.Copy.config = 0 self.obj9701.Specify = ATOM3Constraint() self.obj9701.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj970.GGset2Any['name'] = self.obj9701 self.obj9702 = AttrCalc() self.obj9702.Copy = ATOM3Boolean() self.obj9702.Copy.setValue(('Copy from LHS', 1)) self.obj9702.Copy.config = 0 self.obj9702.Specify = ATOM3Constraint() self.obj9702.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj970.GGset2Any['OperCostFix'] = self.obj9702 # Add node to the root: self.RHS self.RHS.addNode(self.obj970) self.obj970.postAction(self.RHS.CREATE) self.obj971 = intoProduct(parent) self.obj971.preAction(self.RHS.CREATE) self.obj971.isGraphObjectVisual = True if (hasattr(self.obj971, '_setHierarchicalLink')): self.obj971._setHierarchicalLink(False) # rate self.obj971.rate.setNone() self.obj971.GGLabel.setValue(3) self.obj971.graphClass_ = graph_intoProduct if parent.genGraphics: new_obj = graph_intoProduct(239.0, 89.0, self.obj971) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj971.graphObject_ = new_obj self.obj9710 = AttrCalc() self.obj9710.Copy = ATOM3Boolean() self.obj9710.Copy.setValue(('Copy from LHS', 1)) self.obj9710.Copy.config = 0 self.obj9710.Specify = ATOM3Constraint() self.obj9710.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj971.GGset2Any['rate'] = self.obj9710 # Add node to the root: self.RHS self.RHS.addNode(self.obj971) self.obj971.postAction(self.RHS.CREATE) self.obj970.out_connections_.append(self.obj971) self.obj971.in_connections_.append(self.obj970) self.obj970.graphObject_.pendingConnections.append( (self.obj970.graphObject_.tag, self.obj971.graphObject_.tag, [233.0, 28.0, 239.0, 89.0], 2, 0)) self.obj971.out_connections_.append(self.obj969) self.obj969.in_connections_.append(self.obj971) self.obj971.graphObject_.pendingConnections.append( (self.obj971.graphObject_.tag, self.obj969.graphObject_.tag, [245.0, 140.0, 239.0, 89.0], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 23) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.LHS.merge(ASG_omacs(parent)) self.LHS.merge(ASG_GenericGraph(parent)) self.obj1796 = operatingUnit(parent) self.obj1796.preAction(self.LHS.CREATE) self.obj1796.isGraphObjectVisual = True if (hasattr(self.obj1796, '_setHierarchicalLink')): self.obj1796._setHierarchicalLink(False) # OperCostProp self.obj1796.OperCostProp.setNone() # name self.obj1796.name.setValue('') self.obj1796.name.setNone() # OperCostFix self.obj1796.OperCostFix.setNone() self.obj1796.GGLabel.setValue(4) self.obj1796.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(280.0, 120.0, self.obj1796) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1796.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1796) self.obj1796.postAction(self.LHS.CREATE) self.obj1797 = CapableOf(parent) self.obj1797.preAction(self.LHS.CREATE) self.obj1797.isGraphObjectVisual = True if (hasattr(self.obj1797, '_setHierarchicalLink')): self.obj1797._setHierarchicalLink(False) # rate self.obj1797.rate.setNone() self.obj1797.GGLabel.setValue(5) self.obj1797.graphClass_ = graph_CapableOf if parent.genGraphics: new_obj = graph_CapableOf(160.5, 121.5, self.obj1797) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1797.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1797) self.obj1797.postAction(self.LHS.CREATE) self.obj1798 = Agent(parent) self.obj1798.preAction(self.LHS.CREATE) self.obj1798.isGraphObjectVisual = True if (hasattr(self.obj1798, '_setHierarchicalLink')): self.obj1798._setHierarchicalLink(False) # price self.obj1798.price.setNone() # name self.obj1798.name.setValue('') self.obj1798.name.setNone() self.obj1798.GGLabel.setValue(1) self.obj1798.graphClass_ = graph_Agent if parent.genGraphics: new_obj = graph_Agent(120.0, 40.0, self.obj1798) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1798.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1798) self.obj1798.postAction(self.LHS.CREATE) self.obj1799 = Role(parent) self.obj1799.preAction(self.LHS.CREATE) self.obj1799.isGraphObjectVisual = True if (hasattr(self.obj1799, '_setHierarchicalLink')): self.obj1799._setHierarchicalLink(False) # name self.obj1799.name.setValue('') self.obj1799.name.setNone() self.obj1799.GGLabel.setValue(2) self.obj1799.graphClass_ = graph_Role if parent.genGraphics: new_obj = graph_Role(140.0, 140.0, self.obj1799) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1799.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1799) self.obj1799.postAction(self.LHS.CREATE) self.obj1800 = GenericGraphEdge(parent) self.obj1800.preAction(self.LHS.CREATE) self.obj1800.isGraphObjectVisual = True if (hasattr(self.obj1800, '_setHierarchicalLink')): self.obj1800._setHierarchicalLink(False) self.obj1800.GGLabel.setValue(3) self.obj1800.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(264.75, 85.25, self.obj1800) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1800.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1800) self.obj1800.postAction(self.LHS.CREATE) self.obj1797.out_connections_.append(self.obj1799) self.obj1799.in_connections_.append(self.obj1797) self.obj1797.graphObject_.pendingConnections.append( (self.obj1797.graphObject_.tag, self.obj1799.graphObject_.tag, [164.0, 141.0, 160.5, 121.5], 0, True)) self.obj1798.out_connections_.append(self.obj1800) self.obj1800.in_connections_.append(self.obj1798) self.obj1798.graphObject_.pendingConnections.append( (self.obj1798.graphObject_.tag, self.obj1800.graphObject_.tag, [145.0, 102.0, 226.0, 83.0, 264.75, 85.25], 2, True)) self.obj1798.out_connections_.append(self.obj1797) self.obj1797.in_connections_.append(self.obj1798) self.obj1798.graphObject_.pendingConnections.append( (self.obj1798.graphObject_.tag, self.obj1797.graphObject_.tag, [157.0, 102.0, 160.5, 121.5], 0, True)) self.obj1800.out_connections_.append(self.obj1796) self.obj1796.in_connections_.append(self.obj1800) self.obj1800.graphObject_.pendingConnections.append( (self.obj1800.graphObject_.tag, self.obj1796.graphObject_.tag, [300.0, 121.0, 264.75, 85.25], 2, 0)) self.RHS = ASG_pns(parent) self.RHS.merge(ASG_omacs(parent)) self.RHS.merge(ASG_GenericGraph(parent)) self.obj1804 = operatingUnit(parent) self.obj1804.preAction(self.RHS.CREATE) self.obj1804.isGraphObjectVisual = True if (hasattr(self.obj1804, '_setHierarchicalLink')): self.obj1804._setHierarchicalLink(False) # OperCostProp self.obj1804.OperCostProp.setNone() # name self.obj1804.name.setValue('') self.obj1804.name.setNone() # OperCostFix self.obj1804.OperCostFix.setNone() self.obj1804.GGLabel.setValue(4) self.obj1804.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(280.0, 120.0, self.obj1804) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1804.graphObject_ = new_obj self.obj18040 = AttrCalc() self.obj18040.Copy = ATOM3Boolean() self.obj18040.Copy.setValue(('Copy from LHS', 0)) self.obj18040.Copy.config = 0 self.obj18040.Specify = ATOM3Constraint() self.obj18040.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'a = self.getMatched ( graphID , self.LHS.nodeWithLabel(1) ).name.getValue()\nb = self.getMatched ( graphID , self.LHS.nodeWithLabel(2) ).name.getValue()\nreturn self.graphRewritingSystem.Dictag[ a ][b]\n\n' )) self.obj1804.GGset2Any['OperCostProp'] = self.obj18040 self.obj18041 = AttrCalc() self.obj18041.Copy = ATOM3Boolean() self.obj18041.Copy.setValue(('Copy from LHS', 1)) self.obj18041.Copy.config = 0 self.obj18041.Specify = ATOM3Constraint() self.obj18041.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1804.GGset2Any['name'] = self.obj18041 self.obj18042 = AttrCalc() self.obj18042.Copy = ATOM3Boolean() self.obj18042.Copy.setValue(('Copy from LHS', 0)) self.obj18042.Copy.config = 0 self.obj18042.Specify = ATOM3Constraint() self.obj18042.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1804.GGset2Any['OperCostFix'] = self.obj18042 # Add node to the root: self.RHS self.RHS.addNode(self.obj1804) self.obj1804.postAction(self.RHS.CREATE) self.obj1805 = CapableOf(parent) self.obj1805.preAction(self.RHS.CREATE) self.obj1805.isGraphObjectVisual = True if (hasattr(self.obj1805, '_setHierarchicalLink')): self.obj1805._setHierarchicalLink(False) # rate self.obj1805.rate.setNone() self.obj1805.GGLabel.setValue(5) self.obj1805.graphClass_ = graph_CapableOf if parent.genGraphics: new_obj = graph_CapableOf(160.5, 121.5, self.obj1805) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1805.graphObject_ = new_obj self.obj18050 = AttrCalc() self.obj18050.Copy = ATOM3Boolean() self.obj18050.Copy.setValue(('Copy from LHS', 1)) self.obj18050.Copy.config = 0 self.obj18050.Specify = ATOM3Constraint() self.obj18050.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1805.GGset2Any['rate'] = self.obj18050 # Add node to the root: self.RHS self.RHS.addNode(self.obj1805) self.obj1805.postAction(self.RHS.CREATE) self.obj1806 = Agent(parent) self.obj1806.preAction(self.RHS.CREATE) self.obj1806.isGraphObjectVisual = True if (hasattr(self.obj1806, '_setHierarchicalLink')): self.obj1806._setHierarchicalLink(False) # price self.obj1806.price.setNone() # name self.obj1806.name.setValue('') self.obj1806.name.setNone() self.obj1806.GGLabel.setValue(1) self.obj1806.graphClass_ = graph_Agent if parent.genGraphics: new_obj = graph_Agent(120.0, 40.0, self.obj1806) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1806.graphObject_ = new_obj self.obj18060 = AttrCalc() self.obj18060.Copy = ATOM3Boolean() self.obj18060.Copy.setValue(('Copy from LHS', 1)) self.obj18060.Copy.config = 0 self.obj18060.Specify = ATOM3Constraint() self.obj18060.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1806.GGset2Any['price'] = self.obj18060 self.obj18061 = AttrCalc() self.obj18061.Copy = ATOM3Boolean() self.obj18061.Copy.setValue(('Copy from LHS', 1)) self.obj18061.Copy.config = 0 self.obj18061.Specify = ATOM3Constraint() self.obj18061.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1806.GGset2Any['name'] = self.obj18061 # Add node to the root: self.RHS self.RHS.addNode(self.obj1806) self.obj1806.postAction(self.RHS.CREATE) self.obj1807 = Role(parent) self.obj1807.preAction(self.RHS.CREATE) self.obj1807.isGraphObjectVisual = True if (hasattr(self.obj1807, '_setHierarchicalLink')): self.obj1807._setHierarchicalLink(False) # name self.obj1807.name.setValue('') self.obj1807.name.setNone() self.obj1807.GGLabel.setValue(2) self.obj1807.graphClass_ = graph_Role if parent.genGraphics: new_obj = graph_Role(140.0, 140.0, self.obj1807) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1807.graphObject_ = new_obj self.obj18070 = AttrCalc() self.obj18070.Copy = ATOM3Boolean() self.obj18070.Copy.setValue(('Copy from LHS', 1)) self.obj18070.Copy.config = 0 self.obj18070.Specify = ATOM3Constraint() self.obj18070.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1807.GGset2Any['name'] = self.obj18070 # Add node to the root: self.RHS self.RHS.addNode(self.obj1807) self.obj1807.postAction(self.RHS.CREATE) self.obj1808 = GenericGraphEdge(parent) self.obj1808.preAction(self.RHS.CREATE) self.obj1808.isGraphObjectVisual = True if (hasattr(self.obj1808, '_setHierarchicalLink')): self.obj1808._setHierarchicalLink(False) self.obj1808.GGLabel.setValue(3) self.obj1808.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(264.75, 85.25, self.obj1808) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1808.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1808) self.obj1808.postAction(self.RHS.CREATE) self.obj1805.out_connections_.append(self.obj1807) self.obj1807.in_connections_.append(self.obj1805) self.obj1805.graphObject_.pendingConnections.append( (self.obj1805.graphObject_.tag, self.obj1807.graphObject_.tag, [171.0, 140.0, 160.5, 121.5], 2, 0)) self.obj1806.out_connections_.append(self.obj1808) self.obj1808.in_connections_.append(self.obj1806) self.obj1806.graphObject_.pendingConnections.append( (self.obj1806.graphObject_.tag, self.obj1808.graphObject_.tag, [157.0, 102.0, 264.75, 85.25], 2, 0)) self.obj1806.out_connections_.append(self.obj1805) self.obj1805.in_connections_.append(self.obj1806) self.obj1806.graphObject_.pendingConnections.append( (self.obj1806.graphObject_.tag, self.obj1805.graphObject_.tag, [157.0, 102.0, 160.5, 121.5], 2, 0)) self.obj1808.out_connections_.append(self.obj1804) self.obj1804.in_connections_.append(self.obj1808) self.obj1808.graphObject_.pendingConnections.append( (self.obj1808.graphObject_.tag, self.obj1804.graphObject_.tag, [300.0, 121.0, 264.75, 85.25], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 19) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.LHS.merge(ASG_omacs(parent)) self.LHS.merge(ASG_GenericGraph(parent)) self.obj1719 = metarial(parent) self.obj1719.preAction(self.LHS.CREATE) self.obj1719.isGraphObjectVisual = True if (hasattr(self.obj1719, '_setHierarchicalLink')): self.obj1719._setHierarchicalLink(False) # MaxFlow self.obj1719.MaxFlow.setNone() # price self.obj1719.price.setValue(0) # Name self.obj1719.Name.setValue('') self.obj1719.Name.setNone() # ReqFlow self.obj1719.ReqFlow.setNone() self.obj1719.GGLabel.setValue(4) self.obj1719.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(240.0, 20.0, self.obj1719) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1719.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1719) self.obj1719.postAction(self.LHS.CREATE) self.obj1720 = metarial(parent) self.obj1720.preAction(self.LHS.CREATE) self.obj1720.isGraphObjectVisual = True if (hasattr(self.obj1720, '_setHierarchicalLink')): self.obj1720._setHierarchicalLink(False) # MaxFlow self.obj1720.MaxFlow.setNone() # price self.obj1720.price.setValue(0) # Name self.obj1720.Name.setValue('') self.obj1720.Name.setNone() # ReqFlow self.obj1720.ReqFlow.setNone() self.obj1720.GGLabel.setValue(6) self.obj1720.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(240.0, 240.0, self.obj1720) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1720.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1720) self.obj1720.postAction(self.LHS.CREATE) self.obj1721 = operatingUnit(parent) self.obj1721.preAction(self.LHS.CREATE) self.obj1721.isGraphObjectVisual = True if (hasattr(self.obj1721, '_setHierarchicalLink')): self.obj1721._setHierarchicalLink(False) # OperCostProp self.obj1721.OperCostProp.setNone() # name self.obj1721.name.setValue('') self.obj1721.name.setNone() # OperCostFix self.obj1721.OperCostFix.setNone() self.obj1721.GGLabel.setValue(5) self.obj1721.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(240.0, 140.0, self.obj1721) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1721.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1721) self.obj1721.postAction(self.LHS.CREATE) self.obj1722 = fromMaterial(parent) self.obj1722.preAction(self.LHS.CREATE) self.obj1722.isGraphObjectVisual = True if (hasattr(self.obj1722, '_setHierarchicalLink')): self.obj1722._setHierarchicalLink(False) # rate self.obj1722.rate.setNone() self.obj1722.GGLabel.setValue(8) self.obj1722.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(265.0, 100.0, self.obj1722) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1722.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1722) self.obj1722.postAction(self.LHS.CREATE) self.obj1723 = Goal(parent) self.obj1723.preAction(self.LHS.CREATE) self.obj1723.isGraphObjectVisual = True if (hasattr(self.obj1723, '_setHierarchicalLink')): self.obj1723._setHierarchicalLink(False) # name self.obj1723.name.setValue('') self.obj1723.name.setNone() self.obj1723.GGLabel.setValue(2) self.obj1723.graphClass_ = graph_Goal if parent.genGraphics: new_obj = graph_Goal(60.0, 220.0, self.obj1723) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1723.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1723) self.obj1723.postAction(self.LHS.CREATE) self.obj1724 = Role(parent) self.obj1724.preAction(self.LHS.CREATE) self.obj1724.isGraphObjectVisual = True if (hasattr(self.obj1724, '_setHierarchicalLink')): self.obj1724._setHierarchicalLink(False) # name self.obj1724.name.setValue('') self.obj1724.name.setNone() self.obj1724.GGLabel.setValue(1) self.obj1724.graphClass_ = graph_Role if parent.genGraphics: new_obj = graph_Role(60.0, 40.0, self.obj1724) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1724.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1724) self.obj1724.postAction(self.LHS.CREATE) self.obj1725 = achieve(parent) self.obj1725.preAction(self.LHS.CREATE) self.obj1725.isGraphObjectVisual = True if (hasattr(self.obj1725, '_setHierarchicalLink')): self.obj1725._setHierarchicalLink(False) # rate self.obj1725.rate.setNone() self.obj1725.GGLabel.setValue(3) self.obj1725.graphClass_ = graph_achieve if parent.genGraphics: new_obj = graph_achieve(97.5, 137.5, self.obj1725) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1725.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1725) self.obj1725.postAction(self.LHS.CREATE) self.obj1726 = GenericGraphEdge(parent) self.obj1726.preAction(self.LHS.CREATE) self.obj1726.isGraphObjectVisual = True if (hasattr(self.obj1726, '_setHierarchicalLink')): self.obj1726._setHierarchicalLink(False) self.obj1726.GGLabel.setValue(7) self.obj1726.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(215.0, 41.5, self.obj1726) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1726.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1726) self.obj1726.postAction(self.LHS.CREATE) self.obj1727 = GenericGraphEdge(parent) self.obj1727.preAction(self.LHS.CREATE) self.obj1727.isGraphObjectVisual = True if (hasattr(self.obj1727, '_setHierarchicalLink')): self.obj1727._setHierarchicalLink(False) self.obj1727.GGLabel.setValue(9) self.obj1727.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(185.0, 276.0, self.obj1727) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1727.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1727) self.obj1727.postAction(self.LHS.CREATE) self.obj1719.out_connections_.append(self.obj1722) self.obj1722.in_connections_.append(self.obj1719) self.obj1719.graphObject_.pendingConnections.append( (self.obj1719.graphObject_.tag, self.obj1722.graphObject_.tag, [264.0, 69.0, 265.0, 100.0], 0, True)) self.obj1722.out_connections_.append(self.obj1721) self.obj1721.in_connections_.append(self.obj1722) self.obj1722.graphObject_.pendingConnections.append( (self.obj1722.graphObject_.tag, self.obj1721.graphObject_.tag, [260.0, 151.0, 352.0, 90.0], 0, True)) self.obj1723.out_connections_.append(self.obj1727) self.obj1727.in_connections_.append(self.obj1723) self.obj1723.graphObject_.pendingConnections.append( (self.obj1723.graphObject_.tag, self.obj1727.graphObject_.tag, [84.0, 270.0, 185.0, 276.0], 0, True)) self.obj1724.out_connections_.append(self.obj1725) self.obj1725.in_connections_.append(self.obj1724) self.obj1724.graphObject_.pendingConnections.append( (self.obj1724.graphObject_.tag, self.obj1725.graphObject_.tag, [84.0, 86.0, 97.5, 137.5], 0, True)) self.obj1724.out_connections_.append(self.obj1726) self.obj1726.in_connections_.append(self.obj1724) self.obj1724.graphObject_.pendingConnections.append( (self.obj1724.graphObject_.tag, self.obj1726.graphObject_.tag, [84.0, 41.0, 215.0, 41.5], 0, True)) self.obj1725.out_connections_.append(self.obj1723) self.obj1723.in_connections_.append(self.obj1725) self.obj1725.graphObject_.pendingConnections.append( (self.obj1725.graphObject_.tag, self.obj1723.graphObject_.tag, [83.0, 221.0, 93.5, 143.5], 0, True)) self.obj1726.out_connections_.append(self.obj1719) self.obj1719.in_connections_.append(self.obj1726) self.obj1726.graphObject_.pendingConnections.append( (self.obj1726.graphObject_.tag, self.obj1719.graphObject_.tag, [246.0, 62.0, 215.0, 41.5], 0, True)) self.obj1727.out_connections_.append(self.obj1720) self.obj1720.in_connections_.append(self.obj1727) self.obj1727.graphObject_.pendingConnections.append( (self.obj1727.graphObject_.tag, self.obj1720.graphObject_.tag, [246.0, 282.0, 185.0, 276.0], 0, True)) self.RHS = ASG_pns(parent) self.RHS.merge(ASG_omacs(parent)) self.RHS.merge(ASG_GenericGraph(parent)) self.obj1731 = metarial(parent) self.obj1731.preAction(self.RHS.CREATE) self.obj1731.isGraphObjectVisual = True if (hasattr(self.obj1731, '_setHierarchicalLink')): self.obj1731._setHierarchicalLink(False) # MaxFlow self.obj1731.MaxFlow.setNone() # price self.obj1731.price.setValue(0) # Name self.obj1731.Name.setValue('') self.obj1731.Name.setNone() # ReqFlow self.obj1731.ReqFlow.setNone() self.obj1731.GGLabel.setValue(4) self.obj1731.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(280.0, 20.0, self.obj1731) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1731.graphObject_ = new_obj self.obj17310 = AttrCalc() self.obj17310.Copy = ATOM3Boolean() self.obj17310.Copy.setValue(('Copy from LHS', 1)) self.obj17310.Copy.config = 0 self.obj17310.Specify = ATOM3Constraint() self.obj17310.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1731.GGset2Any['MaxFlow'] = self.obj17310 self.obj17311 = AttrCalc() self.obj17311.Copy = ATOM3Boolean() self.obj17311.Copy.setValue(('Copy from LHS', 1)) self.obj17311.Copy.config = 0 self.obj17311.Specify = ATOM3Constraint() self.obj17311.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1731.GGset2Any['Name'] = self.obj17311 self.obj17312 = AttrCalc() self.obj17312.Copy = ATOM3Boolean() self.obj17312.Copy.setValue(('Copy from LHS', 1)) self.obj17312.Copy.config = 0 self.obj17312.Specify = ATOM3Constraint() self.obj17312.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1731.GGset2Any['ReqFlow'] = self.obj17312 # Add node to the root: self.RHS self.RHS.addNode(self.obj1731) self.obj1731.postAction(self.RHS.CREATE) self.obj1732 = metarial(parent) self.obj1732.preAction(self.RHS.CREATE) self.obj1732.isGraphObjectVisual = True if (hasattr(self.obj1732, '_setHierarchicalLink')): self.obj1732._setHierarchicalLink(False) # MaxFlow self.obj1732.MaxFlow.setNone() # price self.obj1732.price.setValue(0) # Name self.obj1732.Name.setValue('') self.obj1732.Name.setNone() # ReqFlow self.obj1732.ReqFlow.setNone() self.obj1732.GGLabel.setValue(6) self.obj1732.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(280.0, 240.0, self.obj1732) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1732.graphObject_ = new_obj self.obj17320 = AttrCalc() self.obj17320.Copy = ATOM3Boolean() self.obj17320.Copy.setValue(('Copy from LHS', 1)) self.obj17320.Copy.config = 0 self.obj17320.Specify = ATOM3Constraint() self.obj17320.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1732.GGset2Any['MaxFlow'] = self.obj17320 self.obj17321 = AttrCalc() self.obj17321.Copy = ATOM3Boolean() self.obj17321.Copy.setValue(('Copy from LHS', 1)) self.obj17321.Copy.config = 0 self.obj17321.Specify = ATOM3Constraint() self.obj17321.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1732.GGset2Any['Name'] = self.obj17321 self.obj17322 = AttrCalc() self.obj17322.Copy = ATOM3Boolean() self.obj17322.Copy.setValue(('Copy from LHS', 1)) self.obj17322.Copy.config = 0 self.obj17322.Specify = ATOM3Constraint() self.obj17322.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1732.GGset2Any['ReqFlow'] = self.obj17322 # Add node to the root: self.RHS self.RHS.addNode(self.obj1732) self.obj1732.postAction(self.RHS.CREATE) self.obj1733 = operatingUnit(parent) self.obj1733.preAction(self.RHS.CREATE) self.obj1733.isGraphObjectVisual = True if (hasattr(self.obj1733, '_setHierarchicalLink')): self.obj1733._setHierarchicalLink(False) # OperCostProp self.obj1733.OperCostProp.setNone() # name self.obj1733.name.setValue('') self.obj1733.name.setNone() # OperCostFix self.obj1733.OperCostFix.setNone() self.obj1733.GGLabel.setValue(5) self.obj1733.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(280.0, 140.0, self.obj1733) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1733.graphObject_ = new_obj self.obj17330 = AttrCalc() self.obj17330.Copy = ATOM3Boolean() self.obj17330.Copy.setValue(('Copy from LHS', 1)) self.obj17330.Copy.config = 0 self.obj17330.Specify = ATOM3Constraint() self.obj17330.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1733.GGset2Any['OperCostProp'] = self.obj17330 self.obj17331 = AttrCalc() self.obj17331.Copy = ATOM3Boolean() self.obj17331.Copy.setValue(('Copy from LHS', 1)) self.obj17331.Copy.config = 0 self.obj17331.Specify = ATOM3Constraint() self.obj17331.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1733.GGset2Any['name'] = self.obj17331 self.obj17332 = AttrCalc() self.obj17332.Copy = ATOM3Boolean() self.obj17332.Copy.setValue(('Copy from LHS', 1)) self.obj17332.Copy.config = 0 self.obj17332.Specify = ATOM3Constraint() self.obj17332.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1733.GGset2Any['OperCostFix'] = self.obj17332 # Add node to the root: self.RHS self.RHS.addNode(self.obj1733) self.obj1733.postAction(self.RHS.CREATE) self.obj1734 = intoMaterial(parent) self.obj1734.preAction(self.RHS.CREATE) self.obj1734.isGraphObjectVisual = True if (hasattr(self.obj1734, '_setHierarchicalLink')): self.obj1734._setHierarchicalLink(False) # rate self.obj1734.rate.setValue(0.0) self.obj1734.GGLabel.setValue(10) self.obj1734.graphClass_ = graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(315.25, 202.5, self.obj1734) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1734.graphObject_ = new_obj self.obj17340 = AttrCalc() self.obj17340.Copy = ATOM3Boolean() self.obj17340.Copy.setValue(('Copy from LHS', 0)) self.obj17340.Copy.config = 0 self.obj17340.Specify = ATOM3Constraint() self.obj17340.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(3)).rate.getValue()\n\n\n\n\n\n\n\n\n\n' )) self.obj1734.GGset2Any['rate'] = self.obj17340 # Add node to the root: self.RHS self.RHS.addNode(self.obj1734) self.obj1734.postAction(self.RHS.CREATE) self.obj1735 = fromMaterial(parent) self.obj1735.preAction(self.RHS.CREATE) self.obj1735.isGraphObjectVisual = True if (hasattr(self.obj1735, '_setHierarchicalLink')): self.obj1735._setHierarchicalLink(False) # rate self.obj1735.rate.setNone() self.obj1735.GGLabel.setValue(8) self.obj1735.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(323.0, 83.0, self.obj1735) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1735.graphObject_ = new_obj self.obj17350 = AttrCalc() self.obj17350.Copy = ATOM3Boolean() self.obj17350.Copy.setValue(('Copy from LHS', 1)) self.obj17350.Copy.config = 0 self.obj17350.Specify = ATOM3Constraint() self.obj17350.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1735.GGset2Any['rate'] = self.obj17350 # Add node to the root: self.RHS self.RHS.addNode(self.obj1735) self.obj1735.postAction(self.RHS.CREATE) self.obj1736 = Goal(parent) self.obj1736.preAction(self.RHS.CREATE) self.obj1736.isGraphObjectVisual = True if (hasattr(self.obj1736, '_setHierarchicalLink')): self.obj1736._setHierarchicalLink(False) # name self.obj1736.name.setValue('') self.obj1736.name.setNone() self.obj1736.GGLabel.setValue(2) self.obj1736.graphClass_ = graph_Goal if parent.genGraphics: new_obj = graph_Goal(60.0, 220.0, self.obj1736) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1736.graphObject_ = new_obj self.obj17360 = AttrCalc() self.obj17360.Copy = ATOM3Boolean() self.obj17360.Copy.setValue(('Copy from LHS', 1)) self.obj17360.Copy.config = 0 self.obj17360.Specify = ATOM3Constraint() self.obj17360.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1736.GGset2Any['name'] = self.obj17360 # Add node to the root: self.RHS self.RHS.addNode(self.obj1736) self.obj1736.postAction(self.RHS.CREATE) self.obj1737 = Role(parent) self.obj1737.preAction(self.RHS.CREATE) self.obj1737.isGraphObjectVisual = True if (hasattr(self.obj1737, '_setHierarchicalLink')): self.obj1737._setHierarchicalLink(False) # name self.obj1737.name.setValue('') self.obj1737.name.setNone() self.obj1737.GGLabel.setValue(1) self.obj1737.graphClass_ = graph_Role if parent.genGraphics: new_obj = graph_Role(60.0, 40.0, self.obj1737) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1737.graphObject_ = new_obj self.obj17370 = AttrCalc() self.obj17370.Copy = ATOM3Boolean() self.obj17370.Copy.setValue(('Copy from LHS', 1)) self.obj17370.Copy.config = 0 self.obj17370.Specify = ATOM3Constraint() self.obj17370.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1737.GGset2Any['name'] = self.obj17370 # Add node to the root: self.RHS self.RHS.addNode(self.obj1737) self.obj1737.postAction(self.RHS.CREATE) self.obj1738 = achieve(parent) self.obj1738.preAction(self.RHS.CREATE) self.obj1738.isGraphObjectVisual = True if (hasattr(self.obj1738, '_setHierarchicalLink')): self.obj1738._setHierarchicalLink(False) # rate self.obj1738.rate.setNone() self.obj1738.GGLabel.setValue(3) self.obj1738.graphClass_ = graph_achieve if parent.genGraphics: new_obj = graph_achieve(93.5, 143.5, self.obj1738) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1738.graphObject_ = new_obj self.obj17380 = AttrCalc() self.obj17380.Copy = ATOM3Boolean() self.obj17380.Copy.setValue(('Copy from LHS', 1)) self.obj17380.Copy.config = 0 self.obj17380.Specify = ATOM3Constraint() self.obj17380.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1738.GGset2Any['rate'] = self.obj17380 # Add node to the root: self.RHS self.RHS.addNode(self.obj1738) self.obj1738.postAction(self.RHS.CREATE) self.obj1739 = GenericGraphEdge(parent) self.obj1739.preAction(self.RHS.CREATE) self.obj1739.isGraphObjectVisual = True if (hasattr(self.obj1739, '_setHierarchicalLink')): self.obj1739._setHierarchicalLink(False) self.obj1739.GGLabel.setValue(7) self.obj1739.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(215.0, 41.5, self.obj1739) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1739.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1739) self.obj1739.postAction(self.RHS.CREATE) self.obj1740 = GenericGraphEdge(parent) self.obj1740.preAction(self.RHS.CREATE) self.obj1740.isGraphObjectVisual = True if (hasattr(self.obj1740, '_setHierarchicalLink')): self.obj1740._setHierarchicalLink(False) self.obj1740.GGLabel.setValue(9) self.obj1740.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(185.0, 276.0, self.obj1740) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1740.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1740) self.obj1740.postAction(self.RHS.CREATE) self.obj1731.out_connections_.append(self.obj1735) self.obj1735.in_connections_.append(self.obj1731) self.obj1731.graphObject_.pendingConnections.append( (self.obj1731.graphObject_.tag, self.obj1735.graphObject_.tag, [284.0, 69.0, 323.0, 83.0], 2, 0)) self.obj1733.out_connections_.append(self.obj1734) self.obj1734.in_connections_.append(self.obj1733) self.obj1733.graphObject_.pendingConnections.append( (self.obj1733.graphObject_.tag, self.obj1734.graphObject_.tag, [333.0, 148.0, 332.0, 167.0, 371.25, 179.5], 2, True)) self.obj1734.out_connections_.append(self.obj1732) self.obj1732.in_connections_.append(self.obj1734) self.obj1734.graphObject_.pendingConnections.append( (self.obj1734.graphObject_.tag, self.obj1732.graphObject_.tag, [326.0, 250.0, 354.5, 215.0, 371.25, 179.5], 2, True)) self.obj1735.out_connections_.append(self.obj1733) self.obj1733.in_connections_.append(self.obj1735) self.obj1735.graphObject_.pendingConnections.append( (self.obj1735.graphObject_.tag, self.obj1733.graphObject_.tag, [333.0, 148.0, 352.0, 90.0], 2, 0)) self.obj1736.out_connections_.append(self.obj1740) self.obj1740.in_connections_.append(self.obj1736) self.obj1736.graphObject_.pendingConnections.append( (self.obj1736.graphObject_.tag, self.obj1740.graphObject_.tag, [94.0, 270.0, 185.0, 276.0], 2, 0)) self.obj1737.out_connections_.append(self.obj1738) self.obj1738.in_connections_.append(self.obj1737) self.obj1737.graphObject_.pendingConnections.append( (self.obj1737.graphObject_.tag, self.obj1738.graphObject_.tag, [91.0, 85.0, 93.5, 143.5], 2, 0)) self.obj1737.out_connections_.append(self.obj1739) self.obj1739.in_connections_.append(self.obj1737) self.obj1737.graphObject_.pendingConnections.append( (self.obj1737.graphObject_.tag, self.obj1739.graphObject_.tag, [91.0, 40.0, 215.0, 41.5], 2, 0)) self.obj1738.out_connections_.append(self.obj1736) self.obj1736.in_connections_.append(self.obj1738) self.obj1738.graphObject_.pendingConnections.append( (self.obj1738.graphObject_.tag, self.obj1736.graphObject_.tag, [93.0, 221.0, 93.5, 143.5], 2, 0)) self.obj1739.out_connections_.append(self.obj1731) self.obj1731.in_connections_.append(self.obj1739) self.obj1739.graphObject_.pendingConnections.append( (self.obj1739.graphObject_.tag, self.obj1731.graphObject_.tag, [266.0, 62.0, 215.0, 41.5], 2, 0)) self.obj1740.out_connections_.append(self.obj1732) self.obj1732.in_connections_.append(self.obj1740) self.obj1740.graphObject_.pendingConnections.append( (self.obj1740.graphObject_.tag, self.obj1732.graphObject_.tag, [286.0, 282.0, 185.0, 276.0], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 17) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.LHS.merge(ASG_omacs(parent)) self.obj1696=CapableOf(parent) self.obj1696.preAction( self.LHS.CREATE ) self.obj1696.isGraphObjectVisual = True if(hasattr(self.obj1696, '_setHierarchicalLink')): self.obj1696._setHierarchicalLink(False) # rate self.obj1696.rate.setNone() self.obj1696.GGLabel.setValue(4) self.obj1696.graphClass_= graph_CapableOf if parent.genGraphics: new_obj = graph_CapableOf(250.75,110.75,self.obj1696) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1696.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1696) self.obj1696.postAction( self.LHS.CREATE ) self.obj1697=Goal(parent) self.obj1697.preAction( self.LHS.CREATE ) self.obj1697.isGraphObjectVisual = True if(hasattr(self.obj1697, '_setHierarchicalLink')): self.obj1697._setHierarchicalLink(False) # name self.obj1697.name.setValue('') self.obj1697.name.setNone() self.obj1697.GGLabel.setValue(3) self.obj1697.graphClass_= graph_Goal if parent.genGraphics: new_obj = graph_Goal(100.0,240.0,self.obj1697) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1697.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1697) self.obj1697.postAction( self.LHS.CREATE ) self.obj1698=Agent(parent) self.obj1698.preAction( self.LHS.CREATE ) self.obj1698.isGraphObjectVisual = True if(hasattr(self.obj1698, '_setHierarchicalLink')): self.obj1698._setHierarchicalLink(False) # price self.obj1698.price.setNone() # name self.obj1698.name.setValue('') self.obj1698.name.setNone() self.obj1698.GGLabel.setValue(1) self.obj1698.graphClass_= graph_Agent if parent.genGraphics: new_obj = graph_Agent(80.0,40.0,self.obj1698) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1698.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1698) self.obj1698.postAction( self.LHS.CREATE ) self.obj1699=Role(parent) self.obj1699.preAction( self.LHS.CREATE ) self.obj1699.isGraphObjectVisual = True if(hasattr(self.obj1699, '_setHierarchicalLink')): self.obj1699._setHierarchicalLink(False) # name self.obj1699.name.setValue('') self.obj1699.name.setNone() self.obj1699.GGLabel.setValue(2) self.obj1699.graphClass_= graph_Role if parent.genGraphics: new_obj = graph_Role(280.0,140.0,self.obj1699) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1699.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1699) self.obj1699.postAction( self.LHS.CREATE ) self.obj1700=achieve(parent) self.obj1700.preAction( self.LHS.CREATE ) self.obj1700.isGraphObjectVisual = True if(hasattr(self.obj1700, '_setHierarchicalLink')): self.obj1700._setHierarchicalLink(False) # rate self.obj1700.rate.setNone() self.obj1700.GGLabel.setValue(5) self.obj1700.graphClass_= graph_achieve if parent.genGraphics: new_obj = graph_achieve(258.5,259.0,self.obj1700) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1700.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1700) self.obj1700.postAction( self.LHS.CREATE ) self.obj1696.out_connections_.append(self.obj1699) self.obj1699.in_connections_.append(self.obj1696) self.obj1696.graphObject_.pendingConnections.append((self.obj1696.graphObject_.tag, self.obj1699.graphObject_.tag, [304.0, 141.0, 300.5, 120.5, 250.75, 110.75], 2, True)) self.obj1698.out_connections_.append(self.obj1696) self.obj1696.in_connections_.append(self.obj1698) self.obj1698.graphObject_.pendingConnections.append((self.obj1698.graphObject_.tag, self.obj1696.graphObject_.tag, [105.0, 102.0, 201.0, 101.0, 250.75, 110.75], 2, True)) self.obj1699.out_connections_.append(self.obj1700) self.obj1700.in_connections_.append(self.obj1699) self.obj1699.graphObject_.pendingConnections.append((self.obj1699.graphObject_.tag, self.obj1700.graphObject_.tag, [304.0, 186.0, 303.5, 233.0, 258.5, 259.0], 2, True)) self.obj1700.out_connections_.append(self.obj1697) self.obj1697.in_connections_.append(self.obj1700) self.obj1700.graphObject_.pendingConnections.append((self.obj1700.graphObject_.tag, self.obj1697.graphObject_.tag, [124.0, 290.0, 213.5, 285.0, 258.5, 259.0], 2, True)) self.RHS = ASG_pns(parent) self.RHS.merge(ASG_omacs(parent)) self.RHS.merge(ASG_GenericGraph(parent)) self.obj1704=metarial(parent) self.obj1704.preAction( self.RHS.CREATE ) self.obj1704.isGraphObjectVisual = True if(hasattr(self.obj1704, '_setHierarchicalLink')): self.obj1704._setHierarchicalLink(False) # MaxFlow self.obj1704.MaxFlow.setValue(999999) # price self.obj1704.price.setValue(0) # Name self.obj1704.Name.setValue('') self.obj1704.Name.setNone() # ReqFlow self.obj1704.ReqFlow.setValue(0) self.obj1704.GGLabel.setValue(8) self.obj1704.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(400.0,80.0,self.obj1704) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1704.graphObject_ = new_obj self.obj17040= AttrCalc() self.obj17040.Copy=ATOM3Boolean() self.obj17040.Copy.setValue(('Copy from LHS', 1)) self.obj17040.Copy.config = 0 self.obj17040.Specify=ATOM3Constraint() self.obj17040.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1704.GGset2Any['MaxFlow']= self.obj17040 self.obj17041= AttrCalc() self.obj17041.Copy=ATOM3Boolean() self.obj17041.Copy.setValue(('Copy from LHS', 0)) self.obj17041.Copy.config = 0 self.obj17041.Specify=ATOM3Constraint() self.obj17041.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(1)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(3)).name.getValue()\n\n')) self.obj1704.GGset2Any['Name']= self.obj17041 self.obj17042= AttrCalc() self.obj17042.Copy=ATOM3Boolean() self.obj17042.Copy.setValue(('Copy from LHS', 1)) self.obj17042.Copy.config = 0 self.obj17042.Specify=ATOM3Constraint() self.obj17042.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1704.GGset2Any['ReqFlow']= self.obj17042 # Add node to the root: self.RHS self.RHS.addNode(self.obj1704) self.obj1704.postAction( self.RHS.CREATE ) self.obj1705=operatingUnit(parent) self.obj1705.preAction( self.RHS.CREATE ) self.obj1705.isGraphObjectVisual = True if(hasattr(self.obj1705, '_setHierarchicalLink')): self.obj1705._setHierarchicalLink(False) # OperCostProp self.obj1705.OperCostProp.setValue(0.0) # name self.obj1705.name.setValue('') self.obj1705.name.setNone() # OperCostFix self.obj1705.OperCostFix.setValue(0.0) self.obj1705.GGLabel.setValue(7) self.obj1705.graphClass_= graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(400.0,240.0,self.obj1705) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1705.graphObject_ = new_obj self.obj17050= AttrCalc() self.obj17050.Copy=ATOM3Boolean() self.obj17050.Copy.setValue(('Copy from LHS', 0)) self.obj17050.Copy.config = 0 self.obj17050.Specify=ATOM3Constraint() self.obj17050.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(5)).rate.getValue()\n')) self.obj1705.GGset2Any['OperCostProp']= self.obj17050 self.obj17051= AttrCalc() self.obj17051.Copy=ATOM3Boolean() self.obj17051.Copy.setValue(('Copy from LHS', 0)) self.obj17051.Copy.config = 0 self.obj17051.Specify=ATOM3Constraint() self.obj17051.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(1)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(3)).name.getValue()\n\n\n\n\n\n\n')) self.obj1705.GGset2Any['name']= self.obj17051 self.obj17052= AttrCalc() self.obj17052.Copy=ATOM3Boolean() self.obj17052.Copy.setValue(('Copy from LHS', 0)) self.obj17052.Copy.config = 0 self.obj17052.Specify=ATOM3Constraint() self.obj17052.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return 2.0\n')) self.obj1705.GGset2Any['OperCostFix']= self.obj17052 # Add node to the root: self.RHS self.RHS.addNode(self.obj1705) self.obj1705.postAction( self.RHS.CREATE ) self.obj1706=fromMaterial(parent) self.obj1706.preAction( self.RHS.CREATE ) self.obj1706.isGraphObjectVisual = True if(hasattr(self.obj1706, '_setHierarchicalLink')): self.obj1706._setHierarchicalLink(False) # rate self.obj1706.rate.setValue(1.0) self.obj1706.GGLabel.setValue(9) self.obj1706.graphClass_= graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(422.0,190.0,self.obj1706) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1706.graphObject_ = new_obj self.obj17060= AttrCalc() self.obj17060.Copy=ATOM3Boolean() self.obj17060.Copy.setValue(('Copy from LHS', 0)) self.obj17060.Copy.config = 0 self.obj17060.Specify=ATOM3Constraint() self.obj17060.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1706.GGset2Any['rate']= self.obj17060 # Add node to the root: self.RHS self.RHS.addNode(self.obj1706) self.obj1706.postAction( self.RHS.CREATE ) self.obj1707=CapableOf(parent) self.obj1707.preAction( self.RHS.CREATE ) self.obj1707.isGraphObjectVisual = True if(hasattr(self.obj1707, '_setHierarchicalLink')): self.obj1707._setHierarchicalLink(False) # rate self.obj1707.rate.setNone() self.obj1707.GGLabel.setValue(4) self.obj1707.graphClass_= graph_CapableOf if parent.genGraphics: new_obj = graph_CapableOf(250.75,110.75,self.obj1707) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1707.graphObject_ = new_obj self.obj17070= AttrCalc() self.obj17070.Copy=ATOM3Boolean() self.obj17070.Copy.setValue(('Copy from LHS', 1)) self.obj17070.Copy.config = 0 self.obj17070.Specify=ATOM3Constraint() self.obj17070.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1707.GGset2Any['rate']= self.obj17070 # Add node to the root: self.RHS self.RHS.addNode(self.obj1707) self.obj1707.postAction( self.RHS.CREATE ) self.obj1708=Goal(parent) self.obj1708.preAction( self.RHS.CREATE ) self.obj1708.isGraphObjectVisual = True if(hasattr(self.obj1708, '_setHierarchicalLink')): self.obj1708._setHierarchicalLink(False) # name self.obj1708.name.setValue('') self.obj1708.name.setNone() self.obj1708.GGLabel.setValue(3) self.obj1708.graphClass_= graph_Goal if parent.genGraphics: new_obj = graph_Goal(100.0,240.0,self.obj1708) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1708.graphObject_ = new_obj self.obj17080= AttrCalc() self.obj17080.Copy=ATOM3Boolean() self.obj17080.Copy.setValue(('Copy from LHS', 1)) self.obj17080.Copy.config = 0 self.obj17080.Specify=ATOM3Constraint() self.obj17080.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1708.GGset2Any['name']= self.obj17080 # Add node to the root: self.RHS self.RHS.addNode(self.obj1708) self.obj1708.postAction( self.RHS.CREATE ) self.obj1709=Agent(parent) self.obj1709.preAction( self.RHS.CREATE ) self.obj1709.isGraphObjectVisual = True if(hasattr(self.obj1709, '_setHierarchicalLink')): self.obj1709._setHierarchicalLink(False) # price self.obj1709.price.setNone() # name self.obj1709.name.setValue('') self.obj1709.name.setNone() self.obj1709.GGLabel.setValue(1) self.obj1709.graphClass_= graph_Agent if parent.genGraphics: new_obj = graph_Agent(80.0,40.0,self.obj1709) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1709.graphObject_ = new_obj self.obj17090= AttrCalc() self.obj17090.Copy=ATOM3Boolean() self.obj17090.Copy.setValue(('Copy from LHS', 1)) self.obj17090.Copy.config = 0 self.obj17090.Specify=ATOM3Constraint() self.obj17090.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1709.GGset2Any['price']= self.obj17090 self.obj17091= AttrCalc() self.obj17091.Copy=ATOM3Boolean() self.obj17091.Copy.setValue(('Copy from LHS', 1)) self.obj17091.Copy.config = 0 self.obj17091.Specify=ATOM3Constraint() self.obj17091.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1709.GGset2Any['name']= self.obj17091 # Add node to the root: self.RHS self.RHS.addNode(self.obj1709) self.obj1709.postAction( self.RHS.CREATE ) self.obj1710=Role(parent) self.obj1710.preAction( self.RHS.CREATE ) self.obj1710.isGraphObjectVisual = True if(hasattr(self.obj1710, '_setHierarchicalLink')): self.obj1710._setHierarchicalLink(False) # name self.obj1710.name.setValue('') self.obj1710.name.setNone() self.obj1710.GGLabel.setValue(2) self.obj1710.graphClass_= graph_Role if parent.genGraphics: new_obj = graph_Role(280.0,140.0,self.obj1710) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1710.graphObject_ = new_obj self.obj17100= AttrCalc() self.obj17100.Copy=ATOM3Boolean() self.obj17100.Copy.setValue(('Copy from LHS', 1)) self.obj17100.Copy.config = 0 self.obj17100.Specify=ATOM3Constraint() self.obj17100.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1710.GGset2Any['name']= self.obj17100 # Add node to the root: self.RHS self.RHS.addNode(self.obj1710) self.obj1710.postAction( self.RHS.CREATE ) self.obj1711=achieve(parent) self.obj1711.preAction( self.RHS.CREATE ) self.obj1711.isGraphObjectVisual = True if(hasattr(self.obj1711, '_setHierarchicalLink')): self.obj1711._setHierarchicalLink(False) # rate self.obj1711.rate.setNone() self.obj1711.GGLabel.setValue(5) self.obj1711.graphClass_= graph_achieve if parent.genGraphics: new_obj = graph_achieve(258.5,259.0,self.obj1711) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1711.graphObject_ = new_obj self.obj17110= AttrCalc() self.obj17110.Copy=ATOM3Boolean() self.obj17110.Copy.setValue(('Copy from LHS', 1)) self.obj17110.Copy.config = 0 self.obj17110.Specify=ATOM3Constraint() self.obj17110.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1711.GGset2Any['rate']= self.obj17110 # Add node to the root: self.RHS self.RHS.addNode(self.obj1711) self.obj1711.postAction( self.RHS.CREATE ) self.obj1712=GenericGraphEdge(parent) self.obj1712.preAction( self.RHS.CREATE ) self.obj1712.isGraphObjectVisual = True if(hasattr(self.obj1712, '_setHierarchicalLink')): self.obj1712._setHierarchicalLink(False) self.obj1712.GGLabel.setValue(10) self.obj1712.graphClass_= graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(358.5,131.0,self.obj1712) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1712.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1712) self.obj1712.postAction( self.RHS.CREATE ) self.obj1704.out_connections_.append(self.obj1706) self.obj1706.in_connections_.append(self.obj1704) self.obj1704.graphObject_.pendingConnections.append((self.obj1704.graphObject_.tag, self.obj1706.graphObject_.tag, [424.0, 129.0, 422.0, 190.0], 0, True)) self.obj1706.out_connections_.append(self.obj1705) self.obj1705.in_connections_.append(self.obj1706) self.obj1706.graphObject_.pendingConnections.append((self.obj1706.graphObject_.tag, self.obj1705.graphObject_.tag, [420.0, 251.0, 422.0, 190.0], 0, True)) self.obj1707.out_connections_.append(self.obj1710) self.obj1710.in_connections_.append(self.obj1707) self.obj1707.graphObject_.pendingConnections.append((self.obj1707.graphObject_.tag, self.obj1710.graphObject_.tag, [311.0, 140.0, 250.75, 110.75], 2, 0)) self.obj1709.out_connections_.append(self.obj1707) self.obj1707.in_connections_.append(self.obj1709) self.obj1709.graphObject_.pendingConnections.append((self.obj1709.graphObject_.tag, self.obj1707.graphObject_.tag, [117.0, 102.0, 250.75, 110.75], 2, 0)) self.obj1710.out_connections_.append(self.obj1711) self.obj1711.in_connections_.append(self.obj1710) self.obj1710.graphObject_.pendingConnections.append((self.obj1710.graphObject_.tag, self.obj1711.graphObject_.tag, [311.0, 185.0, 258.5, 259.0], 2, 0)) self.obj1710.out_connections_.append(self.obj1712) self.obj1712.in_connections_.append(self.obj1710) self.obj1710.graphObject_.pendingConnections.append((self.obj1710.graphObject_.tag, self.obj1712.graphObject_.tag, [311.0, 140.0, 358.5, 131.0], 0, True)) self.obj1711.out_connections_.append(self.obj1708) self.obj1708.in_connections_.append(self.obj1711) self.obj1711.graphObject_.pendingConnections.append((self.obj1711.graphObject_.tag, self.obj1708.graphObject_.tag, [134.0, 290.0, 258.5, 259.0], 2, 0)) self.obj1712.out_connections_.append(self.obj1704) self.obj1704.in_connections_.append(self.obj1712) self.obj1712.graphObject_.pendingConnections.append((self.obj1712.graphObject_.tag, self.obj1704.graphObject_.tag, [406.0, 122.0, 358.5, 131.0], 0, True))
def __init__(self, parent): GGrule.__init__(self, 12) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.LHS.merge(ASG_omacs(parent)) self.LHS.merge(ASG_GenericGraph(parent)) self.obj1651 = rawMaterial(parent) self.obj1651.preAction(self.LHS.CREATE) self.obj1651.isGraphObjectVisual = True if (hasattr(self.obj1651, '_setHierarchicalLink')): self.obj1651._setHierarchicalLink(False) # MaxFlow self.obj1651.MaxFlow.setValue(999999) # price self.obj1651.price.setValue(0) # Name self.obj1651.Name.setValue('') self.obj1651.Name.setNone() # ReqFlow self.obj1651.ReqFlow.setValue(0) self.obj1651.GGLabel.setValue(3) self.obj1651.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(220.0, 20.0, self.obj1651) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1651.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1651) self.obj1651.postAction(self.LHS.CREATE) self.obj1652 = operatingUnit(parent) self.obj1652.preAction(self.LHS.CREATE) self.obj1652.isGraphObjectVisual = True if (hasattr(self.obj1652, '_setHierarchicalLink')): self.obj1652._setHierarchicalLink(False) # OperCostProp self.obj1652.OperCostProp.setValue(0.0) # name self.obj1652.name.setValue('') self.obj1652.name.setNone() # OperCostFix self.obj1652.OperCostFix.setValue(0.0) self.obj1652.GGLabel.setValue(2) self.obj1652.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(260.0, 160.0, self.obj1652) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1652.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1652) self.obj1652.postAction(self.LHS.CREATE) self.obj1653 = Agent(parent) self.obj1653.preAction(self.LHS.CREATE) self.obj1653.isGraphObjectVisual = True if (hasattr(self.obj1653, '_setHierarchicalLink')): self.obj1653._setHierarchicalLink(False) # price self.obj1653.price.setNone() # name self.obj1653.name.setValue('') self.obj1653.name.setNone() self.obj1653.GGLabel.setValue(1) self.obj1653.graphClass_ = graph_Agent if parent.genGraphics: new_obj = graph_Agent(80.0, 120.0, self.obj1653) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1653.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1653) self.obj1653.postAction(self.LHS.CREATE) self.obj1654 = GenericGraphEdge(parent) self.obj1654.preAction(self.LHS.CREATE) self.obj1654.isGraphObjectVisual = True if (hasattr(self.obj1654, '_setHierarchicalLink')): self.obj1654._setHierarchicalLink(False) self.obj1654.GGLabel.setValue(4) self.obj1654.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(181.75, 114.0, self.obj1654) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1654.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1654) self.obj1654.postAction(self.LHS.CREATE) self.obj1655 = GenericGraphEdge(parent) self.obj1655.preAction(self.LHS.CREATE) self.obj1655.isGraphObjectVisual = True if (hasattr(self.obj1655, '_setHierarchicalLink')): self.obj1655._setHierarchicalLink(False) self.obj1655.GGLabel.setValue(5) self.obj1655.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(229.25, 150.25, self.obj1655) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1655.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1655) self.obj1655.postAction(self.LHS.CREATE) self.obj1653.out_connections_.append(self.obj1654) self.obj1654.in_connections_.append(self.obj1653) self.obj1653.graphObject_.pendingConnections.append( (self.obj1653.graphObject_.tag, self.obj1654.graphObject_.tag, [105.0, 182.0, 147.0, 140.5, 181.75, 114.0], 2, True)) self.obj1653.out_connections_.append(self.obj1655) self.obj1655.in_connections_.append(self.obj1653) self.obj1653.graphObject_.pendingConnections.append( (self.obj1653.graphObject_.tag, self.obj1655.graphObject_.tag, [105.0, 182.0, 185.5, 153.0, 229.25, 150.25], 2, True)) self.obj1654.out_connections_.append(self.obj1651) self.obj1651.in_connections_.append(self.obj1654) self.obj1654.graphObject_.pendingConnections.append( (self.obj1654.graphObject_.tag, self.obj1651.graphObject_.tag, [244.0, 76.0, 216.5, 87.5, 181.75, 114.0], 2, True)) self.obj1655.out_connections_.append(self.obj1652) self.obj1652.in_connections_.append(self.obj1655) self.obj1655.graphObject_.pendingConnections.append( (self.obj1655.graphObject_.tag, self.obj1652.graphObject_.tag, [280.0, 171.0, 273.0, 147.5, 229.25, 150.25], 2, True)) self.RHS = ASG_pns(parent) self.RHS.merge(ASG_omacs(parent)) self.RHS.merge(ASG_GenericGraph(parent)) self.obj1659 = rawMaterial(parent) self.obj1659.preAction(self.RHS.CREATE) self.obj1659.isGraphObjectVisual = True if (hasattr(self.obj1659, '_setHierarchicalLink')): self.obj1659._setHierarchicalLink(False) # MaxFlow self.obj1659.MaxFlow.setValue(999999) # price self.obj1659.price.setValue(0) # Name self.obj1659.Name.setValue('') self.obj1659.Name.setNone() # ReqFlow self.obj1659.ReqFlow.setValue(0) self.obj1659.GGLabel.setValue(3) self.obj1659.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(220.0, 20.0, self.obj1659) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1659.graphObject_ = new_obj self.obj16590 = AttrCalc() self.obj16590.Copy = ATOM3Boolean() self.obj16590.Copy.setValue(('Copy from LHS', 1)) self.obj16590.Copy.config = 0 self.obj16590.Specify = ATOM3Constraint() self.obj16590.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1659.GGset2Any['MaxFlow'] = self.obj16590 self.obj16591 = AttrCalc() self.obj16591.Copy = ATOM3Boolean() self.obj16591.Copy.setValue(('Copy from LHS', 1)) self.obj16591.Copy.config = 0 self.obj16591.Specify = ATOM3Constraint() self.obj16591.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1659.GGset2Any['Name'] = self.obj16591 self.obj16592 = AttrCalc() self.obj16592.Copy = ATOM3Boolean() self.obj16592.Copy.setValue(('Copy from LHS', 1)) self.obj16592.Copy.config = 0 self.obj16592.Specify = ATOM3Constraint() self.obj16592.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1659.GGset2Any['ReqFlow'] = self.obj16592 # Add node to the root: self.RHS self.RHS.addNode(self.obj1659) self.obj1659.postAction(self.RHS.CREATE) self.obj1660 = operatingUnit(parent) self.obj1660.preAction(self.RHS.CREATE) self.obj1660.isGraphObjectVisual = True if (hasattr(self.obj1660, '_setHierarchicalLink')): self.obj1660._setHierarchicalLink(False) # OperCostProp self.obj1660.OperCostProp.setValue(0.0) # name self.obj1660.name.setValue('') self.obj1660.name.setNone() # OperCostFix self.obj1660.OperCostFix.setValue(0.0) self.obj1660.GGLabel.setValue(2) self.obj1660.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(260.0, 160.0, self.obj1660) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1660.graphObject_ = new_obj self.obj16600 = AttrCalc() self.obj16600.Copy = ATOM3Boolean() self.obj16600.Copy.setValue(('Copy from LHS', 1)) self.obj16600.Copy.config = 0 self.obj16600.Specify = ATOM3Constraint() self.obj16600.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1660.GGset2Any['OperCostProp'] = self.obj16600 self.obj16601 = AttrCalc() self.obj16601.Copy = ATOM3Boolean() self.obj16601.Copy.setValue(('Copy from LHS', 1)) self.obj16601.Copy.config = 0 self.obj16601.Specify = ATOM3Constraint() self.obj16601.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1660.GGset2Any['name'] = self.obj16601 self.obj16602 = AttrCalc() self.obj16602.Copy = ATOM3Boolean() self.obj16602.Copy.setValue(('Copy from LHS', 1)) self.obj16602.Copy.config = 0 self.obj16602.Specify = ATOM3Constraint() self.obj16602.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1660.GGset2Any['OperCostFix'] = self.obj16602 # Add node to the root: self.RHS self.RHS.addNode(self.obj1660) self.obj1660.postAction(self.RHS.CREATE) self.obj1661 = fromRaw(parent) self.obj1661.preAction(self.RHS.CREATE) self.obj1661.isGraphObjectVisual = True if (hasattr(self.obj1661, '_setHierarchicalLink')): self.obj1661._setHierarchicalLink(False) # rate self.obj1661.rate.setValue(1.0) self.obj1661.GGLabel.setValue(7) self.obj1661.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(262.0, 115.5, self.obj1661) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1661.graphObject_ = new_obj self.obj16610 = AttrCalc() self.obj16610.Copy = ATOM3Boolean() self.obj16610.Copy.setValue(('Copy from LHS', 0)) self.obj16610.Copy.config = 0 self.obj16610.Specify = ATOM3Constraint() self.obj16610.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1661.GGset2Any['rate'] = self.obj16610 # Add node to the root: self.RHS self.RHS.addNode(self.obj1661) self.obj1661.postAction(self.RHS.CREATE) self.obj1662 = Agent(parent) self.obj1662.preAction(self.RHS.CREATE) self.obj1662.isGraphObjectVisual = True if (hasattr(self.obj1662, '_setHierarchicalLink')): self.obj1662._setHierarchicalLink(False) # price self.obj1662.price.setNone() # name self.obj1662.name.setValue('') self.obj1662.name.setNone() self.obj1662.GGLabel.setValue(1) self.obj1662.graphClass_ = graph_Agent if parent.genGraphics: new_obj = graph_Agent(80.0, 120.0, self.obj1662) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1662.graphObject_ = new_obj self.obj16620 = AttrCalc() self.obj16620.Copy = ATOM3Boolean() self.obj16620.Copy.setValue(('Copy from LHS', 1)) self.obj16620.Copy.config = 0 self.obj16620.Specify = ATOM3Constraint() self.obj16620.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1662.GGset2Any['price'] = self.obj16620 self.obj16621 = AttrCalc() self.obj16621.Copy = ATOM3Boolean() self.obj16621.Copy.setValue(('Copy from LHS', 1)) self.obj16621.Copy.config = 0 self.obj16621.Specify = ATOM3Constraint() self.obj16621.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1662.GGset2Any['name'] = self.obj16621 # Add node to the root: self.RHS self.RHS.addNode(self.obj1662) self.obj1662.postAction(self.RHS.CREATE) self.obj1663 = GenericGraphEdge(parent) self.obj1663.preAction(self.RHS.CREATE) self.obj1663.isGraphObjectVisual = True if (hasattr(self.obj1663, '_setHierarchicalLink')): self.obj1663._setHierarchicalLink(False) self.obj1663.GGLabel.setValue(4) self.obj1663.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(181.75, 114.0, self.obj1663) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1663.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1663) self.obj1663.postAction(self.RHS.CREATE) self.obj1664 = GenericGraphEdge(parent) self.obj1664.preAction(self.RHS.CREATE) self.obj1664.isGraphObjectVisual = True if (hasattr(self.obj1664, '_setHierarchicalLink')): self.obj1664._setHierarchicalLink(False) self.obj1664.GGLabel.setValue(5) self.obj1664.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(229.25, 150.25, self.obj1664) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1664.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1664) self.obj1664.postAction(self.RHS.CREATE) self.obj1659.out_connections_.append(self.obj1661) self.obj1661.in_connections_.append(self.obj1659) self.obj1659.graphObject_.pendingConnections.append( (self.obj1659.graphObject_.tag, self.obj1661.graphObject_.tag, [244.0, 70.0, 262.0, 115.5], 0, True)) self.obj1661.out_connections_.append(self.obj1660) self.obj1660.in_connections_.append(self.obj1661) self.obj1661.graphObject_.pendingConnections.append( (self.obj1661.graphObject_.tag, self.obj1660.graphObject_.tag, [280.0, 161.0, 262.0, 115.5], 0, True)) self.obj1662.out_connections_.append(self.obj1663) self.obj1663.in_connections_.append(self.obj1662) self.obj1662.graphObject_.pendingConnections.append( (self.obj1662.graphObject_.tag, self.obj1663.graphObject_.tag, [117.0, 182.0, 181.75, 114.0], 2, 0)) self.obj1662.out_connections_.append(self.obj1664) self.obj1664.in_connections_.append(self.obj1662) self.obj1662.graphObject_.pendingConnections.append( (self.obj1662.graphObject_.tag, self.obj1664.graphObject_.tag, [117.0, 182.0, 229.25, 150.25], 2, 0)) self.obj1663.out_connections_.append(self.obj1659) self.obj1659.in_connections_.append(self.obj1663) self.obj1663.graphObject_.pendingConnections.append( (self.obj1663.graphObject_.tag, self.obj1659.graphObject_.tag, [244.0, 70.0, 181.75, 114.0], 2, 0)) self.obj1664.out_connections_.append(self.obj1660) self.obj1660.in_connections_.append(self.obj1664) self.obj1664.graphObject_.pendingConnections.append( (self.obj1664.graphObject_.tag, self.obj1660.graphObject_.tag, [280.0, 161.0, 229.25, 150.25], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 26) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.LHS.merge(ASG_omacs(parent)) self.LHS.merge(ASG_GenericGraph(parent)) self.obj1826 = rawMaterial(parent) self.obj1826.preAction(self.LHS.CREATE) self.obj1826.isGraphObjectVisual = True if (hasattr(self.obj1826, '_setHierarchicalLink')): self.obj1826._setHierarchicalLink(False) # MaxFlow self.obj1826.MaxFlow.setNone() # price self.obj1826.price.setNone() # Name self.obj1826.Name.setValue('') self.obj1826.Name.setNone() # ReqFlow self.obj1826.ReqFlow.setNone() self.obj1826.GGLabel.setValue(2) self.obj1826.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(260.0, 40.0, self.obj1826) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1826.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1826) self.obj1826.postAction(self.LHS.CREATE) self.obj1827 = operatingUnit(parent) self.obj1827.preAction(self.LHS.CREATE) self.obj1827.isGraphObjectVisual = True if (hasattr(self.obj1827, '_setHierarchicalLink')): self.obj1827._setHierarchicalLink(False) # OperCostProp self.obj1827.OperCostProp.setNone() # name self.obj1827.name.setValue('') self.obj1827.name.setNone() # OperCostFix self.obj1827.OperCostFix.setNone() self.obj1827.GGLabel.setValue(3) self.obj1827.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(280.0, 140.0, self.obj1827) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1827.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1827) self.obj1827.postAction(self.LHS.CREATE) self.obj1828 = fromRaw(parent) self.obj1828.preAction(self.LHS.CREATE) self.obj1828.isGraphObjectVisual = True if (hasattr(self.obj1828, '_setHierarchicalLink')): self.obj1828._setHierarchicalLink(False) # rate self.obj1828.rate.setNone() self.obj1828.GGLabel.setValue(5) self.obj1828.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(292.0, 123.5, self.obj1828) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1828.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1828) self.obj1828.postAction(self.LHS.CREATE) self.obj1829 = Agent(parent) self.obj1829.preAction(self.LHS.CREATE) self.obj1829.isGraphObjectVisual = True if (hasattr(self.obj1829, '_setHierarchicalLink')): self.obj1829._setHierarchicalLink(False) # price self.obj1829.price.setNone() # name self.obj1829.name.setValue('') self.obj1829.name.setNone() self.obj1829.GGLabel.setValue(1) self.obj1829.graphClass_ = graph_Agent if parent.genGraphics: new_obj = graph_Agent(60.0, 60.0, self.obj1829) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1829.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1829) self.obj1829.postAction(self.LHS.CREATE) self.obj1830 = GenericGraphEdge(parent) self.obj1830.preAction(self.LHS.CREATE) self.obj1830.isGraphObjectVisual = True if (hasattr(self.obj1830, '_setHierarchicalLink')): self.obj1830._setHierarchicalLink(False) self.obj1830.GGLabel.setValue(4) self.obj1830.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(184.5, 109.0, self.obj1830) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1830.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1830) self.obj1830.postAction(self.LHS.CREATE) self.obj1831 = GenericGraphEdge(parent) self.obj1831.preAction(self.LHS.CREATE) self.obj1831.isGraphObjectVisual = True if (hasattr(self.obj1831, '_setHierarchicalLink')): self.obj1831._setHierarchicalLink(False) self.obj1831.GGLabel.setValue(6) self.obj1831.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(159.0, 150.5, self.obj1831) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1831.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1831) self.obj1831.postAction(self.LHS.CREATE) self.obj1826.out_connections_.append(self.obj1828) self.obj1828.in_connections_.append(self.obj1826) self.obj1826.graphObject_.pendingConnections.append( (self.obj1826.graphObject_.tag, self.obj1828.graphObject_.tag, [284.0, 96.0, 292.0, 123.5], 0, True)) self.obj1828.out_connections_.append(self.obj1827) self.obj1827.in_connections_.append(self.obj1828) self.obj1828.graphObject_.pendingConnections.append( (self.obj1828.graphObject_.tag, self.obj1827.graphObject_.tag, [300.0, 151.0, 292.0, 123.5], 0, True)) self.obj1829.out_connections_.append(self.obj1830) self.obj1830.in_connections_.append(self.obj1829) self.obj1829.graphObject_.pendingConnections.append( (self.obj1829.graphObject_.tag, self.obj1830.graphObject_.tag, [85.0, 122.0, 184.5, 109.0], 0, True)) self.obj1829.out_connections_.append(self.obj1831) self.obj1831.in_connections_.append(self.obj1829) self.obj1829.graphObject_.pendingConnections.append( (self.obj1829.graphObject_.tag, self.obj1831.graphObject_.tag, [85.0, 122.0, 105.5, 141.5, 159.0, 150.5], 2, True)) self.obj1830.out_connections_.append(self.obj1826) self.obj1826.in_connections_.append(self.obj1830) self.obj1830.graphObject_.pendingConnections.append( (self.obj1830.graphObject_.tag, self.obj1826.graphObject_.tag, [284.0, 96.0, 184.5, 109.0], 0, True)) self.obj1831.out_connections_.append(self.obj1827) self.obj1827.in_connections_.append(self.obj1831) self.obj1831.graphObject_.pendingConnections.append( (self.obj1831.graphObject_.tag, self.obj1827.graphObject_.tag, [299.0, 158.0, 212.5, 159.5, 159.0, 150.5], 2, True)) self.RHS = ASG_pns(parent) self.obj1833 = rawMaterial(parent) self.obj1833.preAction(self.RHS.CREATE) self.obj1833.isGraphObjectVisual = True if (hasattr(self.obj1833, '_setHierarchicalLink')): self.obj1833._setHierarchicalLink(False) # MaxFlow self.obj1833.MaxFlow.setValue(999999) # price self.obj1833.price.setValue(0) # Name self.obj1833.Name.setValue('') self.obj1833.Name.setNone() # ReqFlow self.obj1833.ReqFlow.setValue(0) self.obj1833.GGLabel.setValue(2) self.obj1833.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(160.0, 40.0, self.obj1833) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['Text Scale'] = 1.0 new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1833.graphObject_ = new_obj self.obj18330 = AttrCalc() self.obj18330.Copy = ATOM3Boolean() self.obj18330.Copy.setValue(('Copy from LHS', 1)) self.obj18330.Copy.config = 0 self.obj18330.Specify = ATOM3Constraint() self.obj18330.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1833.GGset2Any['MaxFlow'] = self.obj18330 self.obj18331 = AttrCalc() self.obj18331.Copy = ATOM3Boolean() self.obj18331.Copy.setValue(('Copy from LHS', 0)) self.obj18331.Copy.config = 0 self.obj18331.Specify = ATOM3Constraint() self.obj18331.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(1)).price.getValue()\n' )) self.obj1833.GGset2Any['price'] = self.obj18331 self.obj18332 = AttrCalc() self.obj18332.Copy = ATOM3Boolean() self.obj18332.Copy.setValue(('Copy from LHS', 1)) self.obj18332.Copy.config = 0 self.obj18332.Specify = ATOM3Constraint() self.obj18332.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1833.GGset2Any['Name'] = self.obj18332 self.obj18333 = AttrCalc() self.obj18333.Copy = ATOM3Boolean() self.obj18333.Copy.setValue(('Copy from LHS', 1)) self.obj18333.Copy.config = 0 self.obj18333.Specify = ATOM3Constraint() self.obj18333.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1833.GGset2Any['ReqFlow'] = self.obj18333 # Add node to the root: self.RHS self.RHS.addNode(self.obj1833) self.obj1833.postAction(self.RHS.CREATE) self.obj1834 = operatingUnit(parent) self.obj1834.preAction(self.RHS.CREATE) self.obj1834.isGraphObjectVisual = True if (hasattr(self.obj1834, '_setHierarchicalLink')): self.obj1834._setHierarchicalLink(False) # OperCostProp self.obj1834.OperCostProp.setValue(0.0) # name self.obj1834.name.setValue('') self.obj1834.name.setNone() # OperCostFix self.obj1834.OperCostFix.setValue(0.0) self.obj1834.GGLabel.setValue(3) self.obj1834.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(120.0, 160.0, self.obj1834) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1834.graphObject_ = new_obj self.obj18340 = AttrCalc() self.obj18340.Copy = ATOM3Boolean() self.obj18340.Copy.setValue(('Copy from LHS', 1)) self.obj18340.Copy.config = 0 self.obj18340.Specify = ATOM3Constraint() self.obj18340.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1834.GGset2Any['OperCostProp'] = self.obj18340 self.obj18341 = AttrCalc() self.obj18341.Copy = ATOM3Boolean() self.obj18341.Copy.setValue(('Copy from LHS', 1)) self.obj18341.Copy.config = 0 self.obj18341.Specify = ATOM3Constraint() self.obj18341.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1834.GGset2Any['name'] = self.obj18341 self.obj18342 = AttrCalc() self.obj18342.Copy = ATOM3Boolean() self.obj18342.Copy.setValue(('Copy from LHS', 1)) self.obj18342.Copy.config = 0 self.obj18342.Specify = ATOM3Constraint() self.obj18342.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1834.GGset2Any['OperCostFix'] = self.obj18342 # Add node to the root: self.RHS self.RHS.addNode(self.obj1834) self.obj1834.postAction(self.RHS.CREATE) self.obj1835 = fromRaw(parent) self.obj1835.preAction(self.RHS.CREATE) self.obj1835.isGraphObjectVisual = True if (hasattr(self.obj1835, '_setHierarchicalLink')): self.obj1835._setHierarchicalLink(False) # rate self.obj1835.rate.setValue(0.0) self.obj1835.GGLabel.setValue(5) self.obj1835.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(177.0, 133.5, self.obj1835) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1835.graphObject_ = new_obj self.obj18350 = AttrCalc() self.obj18350.Copy = ATOM3Boolean() self.obj18350.Copy.setValue(('Copy from LHS', 1)) self.obj18350.Copy.config = 0 self.obj18350.Specify = ATOM3Constraint() self.obj18350.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1835.GGset2Any['rate'] = self.obj18350 # Add node to the root: self.RHS self.RHS.addNode(self.obj1835) self.obj1835.postAction(self.RHS.CREATE) self.obj1833.out_connections_.append(self.obj1835) self.obj1835.in_connections_.append(self.obj1833) self.obj1833.graphObject_.pendingConnections.append( (self.obj1833.graphObject_.tag, self.obj1835.graphObject_.tag, [184.0, 96.0, 177.0, 133.5], 0, True)) self.obj1835.out_connections_.append(self.obj1834) self.obj1834.in_connections_.append(self.obj1835) self.obj1835.graphObject_.pendingConnections.append( (self.obj1835.graphObject_.tag, self.obj1834.graphObject_.tag, [170.0, 171.0, 177.0, 133.5], 0, True))
def pnsEx2_MDL(self, rootNode, pnsRootNode=None): # --- Generating attributes code for ASG pns --- if (pnsRootNode): # author pnsRootNode.author.setValue('Annonymous') # description pnsRootNode.description.setValue('\n') pnsRootNode.description.setHeight(15) # name pnsRootNode.name.setValue('') pnsRootNode.name.setNone() # --- ASG attributes over --- self.obj2050 = rawMaterial(self) self.obj2050.isGraphObjectVisual = True if (hasattr(self.obj2050, '_setHierarchicalLink')): self.obj2050._setHierarchicalLink(False) # MaxFlow self.obj2050.MaxFlow.setValue(999999) # price self.obj2050.price.setValue(5) # Name self.obj2050.Name.setValue('A1') # ReqFlow self.obj2050.ReqFlow.setValue(0) self.obj2050.graphClass_ = graph_rawMaterial if self.genGraphics: new_obj = graph_rawMaterial(412, 0, self.obj2050) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("rawMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2050.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2050) self.globalAndLocalPostcondition(self.obj2050, rootNode) self.obj2050.postAction(rootNode.CREATE) self.obj2051 = rawMaterial(self) self.obj2051.isGraphObjectVisual = True if (hasattr(self.obj2051, '_setHierarchicalLink')): self.obj2051._setHierarchicalLink(False) # MaxFlow self.obj2051.MaxFlow.setValue(999999) # price self.obj2051.price.setValue(5) # Name self.obj2051.Name.setValue('A2') # ReqFlow self.obj2051.ReqFlow.setValue(0) self.obj2051.graphClass_ = graph_rawMaterial if self.genGraphics: new_obj = graph_rawMaterial(0, 0, self.obj2051) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("rawMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2051.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2051) self.globalAndLocalPostcondition(self.obj2051, rootNode) self.obj2051.postAction(rootNode.CREATE) self.obj2052 = operatingUnit(self) self.obj2052.isGraphObjectVisual = True if (hasattr(self.obj2052, '_setHierarchicalLink')): self.obj2052._setHierarchicalLink(False) # OperCostProp self.obj2052.OperCostProp.setValue(0.5) # name self.obj2052.name.setValue('A1 R1') # OperCostFix self.obj2052.OperCostFix.setValue(0.0) self.obj2052.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(412, 108, self.obj2052) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2052.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2052) self.globalAndLocalPostcondition(self.obj2052, rootNode) self.obj2052.postAction(rootNode.CREATE) self.obj2053 = operatingUnit(self) self.obj2053.isGraphObjectVisual = True if (hasattr(self.obj2053, '_setHierarchicalLink')): self.obj2053._setHierarchicalLink(False) # OperCostProp self.obj2053.OperCostProp.setValue(0.25) # name self.obj2053.name.setValue('A2 R2') # OperCostFix self.obj2053.OperCostFix.setValue(0.0) self.obj2053.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(0, 108, self.obj2053) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2053.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2053) self.globalAndLocalPostcondition(self.obj2053, rootNode) self.obj2053.postAction(rootNode.CREATE) self.obj2054 = operatingUnit(self) self.obj2054.isGraphObjectVisual = True if (hasattr(self.obj2054, '_setHierarchicalLink')): self.obj2054._setHierarchicalLink(False) # OperCostProp self.obj2054.OperCostProp.setValue(1.0) # name self.obj2054.name.setValue('G1 OAF') # OperCostFix self.obj2054.OperCostFix.setValue(2.0) self.obj2054.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(412, 450, self.obj2054) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2054.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2054) self.globalAndLocalPostcondition(self.obj2054, rootNode) self.obj2054.postAction(rootNode.CREATE) self.obj2055 = operatingUnit(self) self.obj2055.isGraphObjectVisual = True if (hasattr(self.obj2055, '_setHierarchicalLink')): self.obj2055._setHierarchicalLink(False) # OperCostProp self.obj2055.OperCostProp.setValue(1.0) # name self.obj2055.name.setValue('G2 OAF') # OperCostFix self.obj2055.OperCostFix.setValue(2.0) self.obj2055.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(206, 450, self.obj2055) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2055.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2055) self.globalAndLocalPostcondition(self.obj2055, rootNode) self.obj2055.postAction(rootNode.CREATE) self.obj2056 = operatingUnit(self) self.obj2056.isGraphObjectVisual = True if (hasattr(self.obj2056, '_setHierarchicalLink')): self.obj2056._setHierarchicalLink(False) # OperCostProp self.obj2056.OperCostProp.setValue(0.11) # name self.obj2056.name.setValue('A1 R1 G1') # OperCostFix self.obj2056.OperCostFix.setValue(2.0) self.obj2056.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(412, 279, self.obj2056) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2056.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2056) self.globalAndLocalPostcondition(self.obj2056, rootNode) self.obj2056.postAction(rootNode.CREATE) self.obj2057 = operatingUnit(self) self.obj2057.isGraphObjectVisual = True if (hasattr(self.obj2057, '_setHierarchicalLink')): self.obj2057._setHierarchicalLink(False) # OperCostProp self.obj2057.OperCostProp.setValue(0.12) # name self.obj2057.name.setValue('A1 R1 G2') # OperCostFix self.obj2057.OperCostFix.setValue(2.0) self.obj2057.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(206, 279, self.obj2057) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2057.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2057) self.globalAndLocalPostcondition(self.obj2057, rootNode) self.obj2057.postAction(rootNode.CREATE) self.obj2058 = operatingUnit(self) self.obj2058.isGraphObjectVisual = True if (hasattr(self.obj2058, '_setHierarchicalLink')): self.obj2058._setHierarchicalLink(False) # OperCostProp self.obj2058.OperCostProp.setValue(0.22) # name self.obj2058.name.setValue('A2 R2 G2') # OperCostFix self.obj2058.OperCostFix.setValue(2.0) self.obj2058.graphClass_ = graph_operatingUnit if self.genGraphics: new_obj = graph_operatingUnit(0, 279, self.obj2058) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("operatingUnit", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2058.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2058) self.globalAndLocalPostcondition(self.obj2058, rootNode) self.obj2058.postAction(rootNode.CREATE) self.obj2059 = metarial(self) self.obj2059.isGraphObjectVisual = True if (hasattr(self.obj2059, '_setHierarchicalLink')): self.obj2059._setHierarchicalLink(False) # MaxFlow self.obj2059.MaxFlow.setValue(999999) # price self.obj2059.price.setValue(0) # Name self.obj2059.Name.setValue('G1') # ReqFlow self.obj2059.ReqFlow.setValue(0) self.obj2059.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(412, 350, self.obj2059) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2059.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2059) self.globalAndLocalPostcondition(self.obj2059, rootNode) self.obj2059.postAction(rootNode.CREATE) self.obj2060 = metarial(self) self.obj2060.isGraphObjectVisual = True if (hasattr(self.obj2060, '_setHierarchicalLink')): self.obj2060._setHierarchicalLink(False) # MaxFlow self.obj2060.MaxFlow.setValue(999999) # price self.obj2060.price.setValue(0) # Name self.obj2060.Name.setValue('G2') # ReqFlow self.obj2060.ReqFlow.setValue(0) self.obj2060.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(206, 350, self.obj2060) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2060.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2060) self.globalAndLocalPostcondition(self.obj2060, rootNode) self.obj2060.postAction(rootNode.CREATE) self.obj2061 = metarial(self) self.obj2061.isGraphObjectVisual = True if (hasattr(self.obj2061, '_setHierarchicalLink')): self.obj2061._setHierarchicalLink(False) # MaxFlow self.obj2061.MaxFlow.setValue(999999) # price self.obj2061.price.setValue(0) # Name self.obj2061.Name.setValue('A1 R1 G1') # ReqFlow self.obj2061.ReqFlow.setValue(0) self.obj2061.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(412, 179, self.obj2061) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2061.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2061) self.globalAndLocalPostcondition(self.obj2061, rootNode) self.obj2061.postAction(rootNode.CREATE) self.obj2062 = metarial(self) self.obj2062.isGraphObjectVisual = True if (hasattr(self.obj2062, '_setHierarchicalLink')): self.obj2062._setHierarchicalLink(False) # MaxFlow self.obj2062.MaxFlow.setValue(999999) # price self.obj2062.price.setValue(0) # Name self.obj2062.Name.setValue('A1 R1 G2') # ReqFlow self.obj2062.ReqFlow.setValue(0) self.obj2062.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(206, 179, self.obj2062) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2062.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2062) self.globalAndLocalPostcondition(self.obj2062, rootNode) self.obj2062.postAction(rootNode.CREATE) self.obj2063 = metarial(self) self.obj2063.isGraphObjectVisual = True if (hasattr(self.obj2063, '_setHierarchicalLink')): self.obj2063._setHierarchicalLink(False) # MaxFlow self.obj2063.MaxFlow.setValue(999999) # price self.obj2063.price.setValue(0) # Name self.obj2063.Name.setValue('A2 R2 G2') # ReqFlow self.obj2063.ReqFlow.setValue(0) self.obj2063.graphClass_ = graph_metarial if self.genGraphics: new_obj = graph_metarial(0, 179, self.obj2063) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("metarial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2063.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2063) self.globalAndLocalPostcondition(self.obj2063, rootNode) self.obj2063.postAction(rootNode.CREATE) self.obj2064 = product(self) self.obj2064.isGraphObjectVisual = True if (hasattr(self.obj2064, '_setHierarchicalLink')): self.obj2064._setHierarchicalLink(False) # MaxFlow self.obj2064.MaxFlow.setValue(999999) # price self.obj2064.price.setValue(0) # Name self.obj2064.Name.setValue('OAF') # ReqFlow self.obj2064.ReqFlow.setValue(0) self.obj2064.graphClass_ = graph_product if self.genGraphics: new_obj = graph_product(412, 521, self.obj2064) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("product", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2064.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2064) self.globalAndLocalPostcondition(self.obj2064, rootNode) self.obj2064.postAction(rootNode.CREATE) self.obj2065 = fromMaterial(self) self.obj2065.isGraphObjectVisual = True if (hasattr(self.obj2065, '_setHierarchicalLink')): self.obj2065._setHierarchicalLink(False) # rate self.obj2065.rate.setValue(1.0) self.obj2065.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(443.97925309, 430.64382278, self.obj2065) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2065.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2065) self.globalAndLocalPostcondition(self.obj2065, rootNode) self.obj2065.postAction(rootNode.CREATE) self.obj2066 = fromMaterial(self) self.obj2066.isGraphObjectVisual = True if (hasattr(self.obj2066, '_setHierarchicalLink')): self.obj2066._setHierarchicalLink(False) # rate self.obj2066.rate.setValue(1.0) self.obj2066.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(237.97925309, 430.64382278, self.obj2066) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2066.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2066) self.globalAndLocalPostcondition(self.obj2066, rootNode) self.obj2066.postAction(rootNode.CREATE) self.obj2067 = fromMaterial(self) self.obj2067.isGraphObjectVisual = True if (hasattr(self.obj2067, '_setHierarchicalLink')): self.obj2067._setHierarchicalLink(False) # rate self.obj2067.rate.setValue(1.0) self.obj2067.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(463.682773237, 256.50121981, self.obj2067) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2067.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2067) self.globalAndLocalPostcondition(self.obj2067, rootNode) self.obj2067.postAction(rootNode.CREATE) self.obj2068 = fromMaterial(self) self.obj2068.isGraphObjectVisual = True if (hasattr(self.obj2068, '_setHierarchicalLink')): self.obj2068._setHierarchicalLink(False) # rate self.obj2068.rate.setValue(1.0) self.obj2068.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(257.682773237, 256.50121981, self.obj2068) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2068.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2068) self.globalAndLocalPostcondition(self.obj2068, rootNode) self.obj2068.postAction(rootNode.CREATE) self.obj2069 = fromMaterial(self) self.obj2069.isGraphObjectVisual = True if (hasattr(self.obj2069, '_setHierarchicalLink')): self.obj2069._setHierarchicalLink(False) # rate self.obj2069.rate.setValue(1.0) self.obj2069.graphClass_ = graph_fromMaterial if self.genGraphics: new_obj = graph_fromMaterial(51.6827732371, 256.50121981, self.obj2069) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2069.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2069) self.globalAndLocalPostcondition(self.obj2069, rootNode) self.obj2069.postAction(rootNode.CREATE) self.obj2070 = intoProduct(self) self.obj2070.isGraphObjectVisual = True if (hasattr(self.obj2070, '_setHierarchicalLink')): self.obj2070._setHierarchicalLink(False) # rate self.obj2070.rate.setValue(1.0) self.obj2070.graphClass_ = graph_intoProduct if self.genGraphics: new_obj = graph_intoProduct(443.936529683, 493.375109847, self.obj2070) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoProduct", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2070.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2070) self.globalAndLocalPostcondition(self.obj2070, rootNode) self.obj2070.postAction(rootNode.CREATE) self.obj2071 = intoProduct(self) self.obj2071.isGraphObjectVisual = True if (hasattr(self.obj2071, '_setHierarchicalLink')): self.obj2071._setHierarchicalLink(False) # rate self.obj2071.rate.setValue(1.0) self.obj2071.graphClass_ = graph_intoProduct if self.genGraphics: new_obj = graph_intoProduct(350.853713603, 484.915829787, self.obj2071) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoProduct", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2071.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2071) self.globalAndLocalPostcondition(self.obj2071, rootNode) self.obj2071.postAction(rootNode.CREATE) self.obj2072 = fromRaw(self) self.obj2072.isGraphObjectVisual = True if (hasattr(self.obj2072, '_setHierarchicalLink')): self.obj2072._setHierarchicalLink(False) # rate self.obj2072.rate.setValue(1.0) self.obj2072.graphClass_ = graph_fromRaw if self.genGraphics: new_obj = graph_fromRaw(443.979904526, 88.1336447318, self.obj2072) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromRaw", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2072.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2072) self.globalAndLocalPostcondition(self.obj2072, rootNode) self.obj2072.postAction(rootNode.CREATE) self.obj2073 = fromRaw(self) self.obj2073.isGraphObjectVisual = True if (hasattr(self.obj2073, '_setHierarchicalLink')): self.obj2073._setHierarchicalLink(False) # rate self.obj2073.rate.setValue(1.0) self.obj2073.graphClass_ = graph_fromRaw if self.genGraphics: new_obj = graph_fromRaw(31.9799045263, 88.1336447318, self.obj2073) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("fromRaw", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2073.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2073) self.globalAndLocalPostcondition(self.obj2073, rootNode) self.obj2073.postAction(rootNode.CREATE) self.obj2074 = intoMaterial(self) self.obj2074.isGraphObjectVisual = True if (hasattr(self.obj2074, '_setHierarchicalLink')): self.obj2074._setHierarchicalLink(False) # rate self.obj2074.rate.setValue(0.11) self.obj2074.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(444.407115796, 321.140199793, self.obj2074) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2074.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2074) self.globalAndLocalPostcondition(self.obj2074, rootNode) self.obj2074.postAction(rootNode.CREATE) self.obj2075 = intoMaterial(self) self.obj2075.isGraphObjectVisual = True if (hasattr(self.obj2075, '_setHierarchicalLink')): self.obj2075._setHierarchicalLink(False) # rate self.obj2075.rate.setValue(0.12) self.obj2075.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(238.407115796, 321.140199793, self.obj2075) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2075.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2075) self.globalAndLocalPostcondition(self.obj2075, rootNode) self.obj2075.postAction(rootNode.CREATE) self.obj2076 = intoMaterial(self) self.obj2076.isGraphObjectVisual = True if (hasattr(self.obj2076, '_setHierarchicalLink')): self.obj2076._setHierarchicalLink(False) # rate self.obj2076.rate.setValue(0.22) self.obj2076.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(137.852377142, 316.57866424, self.obj2076) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2076.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2076) self.globalAndLocalPostcondition(self.obj2076, rootNode) self.obj2076.postAction(rootNode.CREATE) self.obj2077 = intoMaterial(self) self.obj2077.isGraphObjectVisual = True if (hasattr(self.obj2077, '_setHierarchicalLink')): self.obj2077._setHierarchicalLink(False) # rate self.obj2077.rate.setValue(0.5) self.obj2077.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(448.986832981, 148.33772234, self.obj2077) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2077.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2077) self.globalAndLocalPostcondition(self.obj2077, rootNode) self.obj2077.postAction(rootNode.CREATE) self.obj2078 = intoMaterial(self) self.obj2078.isGraphObjectVisual = True if (hasattr(self.obj2078, '_setHierarchicalLink')): self.obj2078._setHierarchicalLink(False) # rate self.obj2078.rate.setValue(0.5) self.obj2078.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(349.992999454, 166.870109648, self.obj2078) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2078.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2078) self.globalAndLocalPostcondition(self.obj2078, rootNode) self.obj2078.postAction(rootNode.CREATE) self.obj2079 = intoMaterial(self) self.obj2079.isGraphObjectVisual = True if (hasattr(self.obj2079, '_setHierarchicalLink')): self.obj2079._setHierarchicalLink(False) # rate self.obj2079.rate.setValue(0.25) self.obj2079.graphClass_ = graph_intoMaterial if self.genGraphics: new_obj = graph_intoMaterial(36.9868329805, 148.33772234, self.obj2079) new_obj.DrawObject(self.UMLmodel) self.UMLmodel.addtag_withtag("intoMaterial", new_obj.tag) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj2079.graphObject_ = new_obj # Add node to the root: rootNode rootNode.addNode(self.obj2079) self.globalAndLocalPostcondition(self.obj2079, rootNode) self.obj2079.postAction(rootNode.CREATE) # Connections for obj2050 (graphObject_: Obj1645) of type rawMaterial self.drawConnections((self.obj2050, self.obj2072, [ 436.0, 56.0, 444.9799045262882, 72.38364473182781, 443.9799045262882, 88.13364473182781 ], "true", 3)) # Connections for obj2051 (graphObject_: Obj1646) of type rawMaterial self.drawConnections((self.obj2051, self.obj2073, [ 24.0, 56.0, 32.97990452628816, 72.38364473182781, 31.97990452628816, 88.13364473182781 ], "true", 3)) # Connections for obj2052 (graphObject_: Obj1647) named A1 R1 self.drawConnections((self.obj2052, self.obj2077, [ 431.0, 126.0, 444.73683298050514, 135.58772233983163, 448.98683298050514, 148.33772233983163 ], "true", 3), (self.obj2052, self.obj2078, [ 431.0, 126.0, 392.2429994544884, 151.1201096477546, 349.9929994544884, 166.8701096477546 ], "true", 3)) # Connections for obj2053 (graphObject_: Obj1648) named A2 R2 self.drawConnections((self.obj2053, self.obj2079, [ 19.0, 126.0, 32.73683298050514, 135.58772233983163, 36.98683298050514, 148.33772233983163 ], "true", 3)) # Connections for obj2054 (graphObject_: Obj1649) named G1 OAF self.drawConnections((self.obj2054, self.obj2070, [ 431.0, 468.0, 442.43652968314956, 480.12510984719063, 443.93652968314956, 493.37510984719063 ], "true", 3)) # Connections for obj2055 (graphObject_: Obj1650) named G2 OAF self.drawConnections((self.obj2055, self.obj2071, [ 259.0, 468.0, 306.353713602772, 471.6658297869167, 350.853713602772, 484.9158297869167 ], "true", 3)) # Connections for obj2056 (graphObject_: Obj1651) named A1 R1 G1 self.drawConnections((self.obj2056, self.obj2074, [ 431.0, 297.0, 442.6571157960441, 308.39019979269983, 444.4071157960441, 321.14019979269983 ], "true", 3)) # Connections for obj2057 (graphObject_: Obj1652) named A1 R1 G2 self.drawConnections((self.obj2057, self.obj2075, [ 225.0, 297.0, 236.65711579604408, 308.39019979269983, 238.40711579604408, 321.14019979269983 ], "true", 3)) # Connections for obj2058 (graphObject_: Obj1653) named A2 R2 G2 self.drawConnections((self.obj2058, self.obj2076, [ 53.0, 297.0, 97.10237714155916, 302.078664240101, 137.85237714155915, 316.578664240101 ], "true", 3)) # Connections for obj2059 (graphObject_: Obj1654) of type metarial self.drawConnections((self.obj2059, self.obj2065, [ 436.0, 399.0, 444.97925308968456, 415.14382277997964, 443.97925308968456, 430.64382277997964 ], "true", 3)) # Connections for obj2060 (graphObject_: Obj1655) of type metarial self.drawConnections((self.obj2060, self.obj2066, [ 230.0, 399.0, 238.9792530896846, 415.14382277997964, 237.9792530896846, 430.64382277997964 ], "true", 3)) # Connections for obj2061 (graphObject_: Obj1656) of type metarial self.drawConnections((self.obj2061, self.obj2067, [ 446.0, 228.0, 459.68277323709356, 241.0012198097823, 463.68277323709356, 256.5012198097823 ], "true", 3)) # Connections for obj2062 (graphObject_: Obj1657) of type metarial self.drawConnections((self.obj2062, self.obj2068, [ 240.0, 228.0, 253.68277323709358, 241.0012198097823, 257.68277323709356, 256.5012198097823 ], "true", 3)) # Connections for obj2063 (graphObject_: Obj1658) of type metarial self.drawConnections((self.obj2063, self.obj2069, [ 34.0, 228.0, 47.68277323709358, 241.0012198097823, 51.68277323709358, 256.5012198097823 ], "true", 3)) # Connections for obj2064 (graphObject_: Obj1659) of type product self.drawConnections() # Connections for obj2065 (graphObject_: Obj1660) of type fromMaterial self.drawConnections((self.obj2065, self.obj2054, [ 443.97925308968456, 430.64382277997964, 442.97925308968456, 446.14382277997964, 432.0, 461.0 ], "true", 3)) # Connections for obj2066 (graphObject_: Obj1662) of type fromMaterial self.drawConnections((self.obj2066, self.obj2055, [ 237.9792530896846, 430.64382277997964, 236.9792530896846, 446.14382277997964, 226.0, 461.0 ], "true", 3)) # Connections for obj2067 (graphObject_: Obj1664) of type fromMaterial self.drawConnections((self.obj2067, self.obj2056, [ 463.68277323709356, 256.5012198097823, 467.68277323709356, 272.0012198097823, 462.0, 290.0 ], "true", 3)) # Connections for obj2068 (graphObject_: Obj1666) of type fromMaterial self.drawConnections((self.obj2068, self.obj2057, [ 257.68277323709356, 256.5012198097823, 261.68277323709356, 272.0012198097823, 256.0, 290.0 ], "true", 3)) # Connections for obj2069 (graphObject_: Obj1668) of type fromMaterial self.drawConnections((self.obj2069, self.obj2058, [ 51.68277323709358, 256.5012198097823, 55.68277323709358, 272.0012198097823, 50.0, 290.0 ], "true", 3)) # Connections for obj2070 (graphObject_: Obj1670) of type intoProduct self.drawConnections((self.obj2070, self.obj2064, [ 443.93652968314956, 493.37510984719063, 445.43652968314956, 506.62510984719063, 437.0, 521.0 ], "true", 3)) # Connections for obj2071 (graphObject_: Obj1672) of type intoProduct self.drawConnections((self.obj2071, self.obj2064, [ 350.853713602772, 484.9158297869167, 395.353713602772, 498.1658297869167, 437.0, 521.0 ], "true", 3)) # Connections for obj2072 (graphObject_: Obj1674) of type fromRaw self.drawConnections((self.obj2072, self.obj2052, [ 443.9799045262882, 88.13364473182781, 442.9799045262882, 103.88364473182781, 432.0, 119.0 ], "true", 3)) # Connections for obj2073 (graphObject_: Obj1676) of type fromRaw self.drawConnections((self.obj2073, self.obj2053, [ 31.97990452628816, 88.13364473182781, 30.97990452628816, 103.88364473182781, 20.0, 119.0 ], "true", 3)) # Connections for obj2074 (graphObject_: Obj1678) of type intoMaterial self.drawConnections((self.obj2074, self.obj2059, [ 444.4071157960441, 321.14019979269983, 446.1571157960441, 333.89019979269983, 438.0, 348.0 ], "true", 3)) # Connections for obj2075 (graphObject_: Obj1680) of type intoMaterial self.drawConnections((self.obj2075, self.obj2060, [ 238.40711579604408, 321.14019979269983, 240.15711579604408, 333.89019979269983, 232.0, 348.0 ], "true", 3)) # Connections for obj2076 (graphObject_: Obj1682) of type intoMaterial self.drawConnections((self.obj2076, self.obj2060, [ 137.85237714155915, 316.578664240101, 178.60237714155915, 331.078664240101, 216.0, 355.0 ], "true", 3)) # Connections for obj2077 (graphObject_: Obj1684) of type intoMaterial self.drawConnections((self.obj2077, self.obj2061, [ 448.98683298050514, 148.33772233983163, 453.23683298050514, 161.08772233983163, 448.0, 177.0 ], "true", 3)) # Connections for obj2078 (graphObject_: Obj1686) of type intoMaterial self.drawConnections((self.obj2078, self.obj2062, [ 349.9929994544884, 166.8701096477546, 307.7429994544884, 182.6201096477546, 262.0, 189.0 ], "true", 3)) # Connections for obj2079 (graphObject_: Obj1688) of type intoMaterial self.drawConnections((self.obj2079, self.obj2063, [ 36.98683298050514, 148.33772233983163, 41.23683298050514, 161.08772233983163, 36.0, 177.0 ], "true", 3))
def __init__(self, parent): GGrule.__init__(self, 7) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.obj976 = metarial(parent) self.obj976.preAction(self.LHS.CREATE) self.obj976.isGraphObjectVisual = True if (hasattr(self.obj976, '_setHierarchicalLink')): self.obj976._setHierarchicalLink(False) # MaxFlow self.obj976.MaxFlow.setNone() # price self.obj976.price.setNone() # Name self.obj976.Name.setValue('') self.obj976.Name.setNone() # ReqFlow self.obj976.ReqFlow.setNone() self.obj976.GGLabel.setValue(1) self.obj976.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(200.0, 20.0, self.obj976) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj976.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj976) self.obj976.postAction(self.LHS.CREATE) self.obj977 = operatingUnit(parent) self.obj977.preAction(self.LHS.CREATE) self.obj977.isGraphObjectVisual = True if (hasattr(self.obj977, '_setHierarchicalLink')): self.obj977._setHierarchicalLink(False) # OperCostProp self.obj977.OperCostProp.setNone() # name self.obj977.name.setValue('') self.obj977.name.setNone() # OperCostFix self.obj977.OperCostFix.setNone() self.obj977.GGLabel.setValue(2) self.obj977.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(220.0, 160.0, self.obj977) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj977.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj977) self.obj977.postAction(self.LHS.CREATE) self.obj978 = fromMaterial(parent) self.obj978.preAction(self.LHS.CREATE) self.obj978.isGraphObjectVisual = True if (hasattr(self.obj978, '_setHierarchicalLink')): self.obj978._setHierarchicalLink(False) # rate self.obj978.rate.setNone() self.obj978.GGLabel.setValue(3) self.obj978.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(232.0, 120.0, self.obj978) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj978.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj978) self.obj978.postAction(self.LHS.CREATE) self.obj976.out_connections_.append(self.obj978) self.obj978.in_connections_.append(self.obj976) self.obj976.graphObject_.pendingConnections.append( (self.obj976.graphObject_.tag, self.obj978.graphObject_.tag, [224.0, 69.0, 232.0, 120.0], 0, True)) self.obj978.out_connections_.append(self.obj977) self.obj977.in_connections_.append(self.obj978) self.obj978.graphObject_.pendingConnections.append( (self.obj978.graphObject_.tag, self.obj977.graphObject_.tag, [240.0, 171.0, 232.0, 120.0], 0, True)) self.RHS = ASG_pns(parent) self.obj980 = metarial(parent) self.obj980.preAction(self.RHS.CREATE) self.obj980.isGraphObjectVisual = True if (hasattr(self.obj980, '_setHierarchicalLink')): self.obj980._setHierarchicalLink(False) # MaxFlow self.obj980.MaxFlow.setNone() # price self.obj980.price.setNone() # Name self.obj980.Name.setValue('') self.obj980.Name.setNone() # ReqFlow self.obj980.ReqFlow.setNone() self.obj980.GGLabel.setValue(1) self.obj980.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(200.0, 20.0, self.obj980) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj980.graphObject_ = new_obj self.obj9800 = AttrCalc() self.obj9800.Copy = ATOM3Boolean() self.obj9800.Copy.setValue(('Copy from LHS', 1)) self.obj9800.Copy.config = 0 self.obj9800.Specify = ATOM3Constraint() self.obj9800.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj980.GGset2Any['MaxFlow'] = self.obj9800 self.obj9801 = AttrCalc() self.obj9801.Copy = ATOM3Boolean() self.obj9801.Copy.setValue(('Copy from LHS', 1)) self.obj9801.Copy.config = 0 self.obj9801.Specify = ATOM3Constraint() self.obj9801.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj980.GGset2Any['price'] = self.obj9801 self.obj9802 = AttrCalc() self.obj9802.Copy = ATOM3Boolean() self.obj9802.Copy.setValue(('Copy from LHS', 1)) self.obj9802.Copy.config = 0 self.obj9802.Specify = ATOM3Constraint() self.obj9802.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj980.GGset2Any['Name'] = self.obj9802 self.obj9803 = AttrCalc() self.obj9803.Copy = ATOM3Boolean() self.obj9803.Copy.setValue(('Copy from LHS', 1)) self.obj9803.Copy.config = 0 self.obj9803.Specify = ATOM3Constraint() self.obj9803.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj980.GGset2Any['ReqFlow'] = self.obj9803 # Add node to the root: self.RHS self.RHS.addNode(self.obj980) self.obj980.postAction(self.RHS.CREATE) self.obj981 = operatingUnit(parent) self.obj981.preAction(self.RHS.CREATE) self.obj981.isGraphObjectVisual = True if (hasattr(self.obj981, '_setHierarchicalLink')): self.obj981._setHierarchicalLink(False) # OperCostProp self.obj981.OperCostProp.setNone() # name self.obj981.name.setValue('') self.obj981.name.setNone() # OperCostFix self.obj981.OperCostFix.setNone() self.obj981.GGLabel.setValue(2) self.obj981.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(220.0, 160.0, self.obj981) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj981.graphObject_ = new_obj self.obj9810 = AttrCalc() self.obj9810.Copy = ATOM3Boolean() self.obj9810.Copy.setValue(('Copy from LHS', 1)) self.obj9810.Copy.config = 0 self.obj9810.Specify = ATOM3Constraint() self.obj9810.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj981.GGset2Any['OperCostProp'] = self.obj9810 self.obj9811 = AttrCalc() self.obj9811.Copy = ATOM3Boolean() self.obj9811.Copy.setValue(('Copy from LHS', 1)) self.obj9811.Copy.config = 0 self.obj9811.Specify = ATOM3Constraint() self.obj9811.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj981.GGset2Any['name'] = self.obj9811 self.obj9812 = AttrCalc() self.obj9812.Copy = ATOM3Boolean() self.obj9812.Copy.setValue(('Copy from LHS', 1)) self.obj9812.Copy.config = 0 self.obj9812.Specify = ATOM3Constraint() self.obj9812.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj981.GGset2Any['OperCostFix'] = self.obj9812 # Add node to the root: self.RHS self.RHS.addNode(self.obj981) self.obj981.postAction(self.RHS.CREATE) self.obj982 = fromMaterial(parent) self.obj982.preAction(self.RHS.CREATE) self.obj982.isGraphObjectVisual = True if (hasattr(self.obj982, '_setHierarchicalLink')): self.obj982._setHierarchicalLink(False) # rate self.obj982.rate.setNone() self.obj982.GGLabel.setValue(3) self.obj982.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(232.0, 120.0, self.obj982) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj982.graphObject_ = new_obj self.obj9820 = AttrCalc() self.obj9820.Copy = ATOM3Boolean() self.obj9820.Copy.setValue(('Copy from LHS', 1)) self.obj9820.Copy.config = 0 self.obj9820.Specify = ATOM3Constraint() self.obj9820.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj982.GGset2Any['rate'] = self.obj9820 # Add node to the root: self.RHS self.RHS.addNode(self.obj982) self.obj982.postAction(self.RHS.CREATE) self.obj980.out_connections_.append(self.obj982) self.obj982.in_connections_.append(self.obj980) self.obj980.graphObject_.pendingConnections.append( (self.obj980.graphObject_.tag, self.obj982.graphObject_.tag, [224.0, 69.0, 232.0, 120.0], 2, 0)) self.obj982.out_connections_.append(self.obj981) self.obj981.in_connections_.append(self.obj982) self.obj982.graphObject_.pendingConnections.append( (self.obj982.graphObject_.tag, self.obj981.graphObject_.tag, [270.0, 161.0, 232.0, 120.0], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 1) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.obj107=rawMaterial(parent) self.obj107.preAction( self.LHS.CREATE ) self.obj107.isGraphObjectVisual = True if(hasattr(self.obj107, '_setHierarchicalLink')): self.obj107._setHierarchicalLink(False) # MaxFlow self.obj107.MaxFlow.setNone() # price self.obj107.price.setNone() # Name self.obj107.Name.setValue('') self.obj107.Name.setNone() # ReqFlow self.obj107.ReqFlow.setNone() self.obj107.GGLabel.setValue(1) self.obj107.graphClass_= graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(60.0,20.0,self.obj107) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj107.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj107) self.obj107.postAction( self.LHS.CREATE ) self.obj108=metarial(parent) self.obj108.preAction( self.LHS.CREATE ) self.obj108.isGraphObjectVisual = True if(hasattr(self.obj108, '_setHierarchicalLink')): self.obj108._setHierarchicalLink(False) # MaxFlow self.obj108.MaxFlow.setNone() # price self.obj108.price.setNone() # Name self.obj108.Name.setValue('') self.obj108.Name.setNone() # ReqFlow self.obj108.ReqFlow.setNone() self.obj108.GGLabel.setValue(4) self.obj108.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(360.0,160.0,self.obj108) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj108.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj108) self.obj108.postAction( self.LHS.CREATE ) self.obj109=operatingUnit(parent) self.obj109.preAction( self.LHS.CREATE ) self.obj109.isGraphObjectVisual = True if(hasattr(self.obj109, '_setHierarchicalLink')): self.obj109._setHierarchicalLink(False) # OperCostProp self.obj109.OperCostProp.setNone() # name self.obj109.name.setValue('') self.obj109.name.setNone() # OperCostFix self.obj109.OperCostFix.setNone() self.obj109.GGLabel.setValue(2) self.obj109.graphClass_= graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(180.0,120.0,self.obj109) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj109.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj109) self.obj109.postAction( self.LHS.CREATE ) self.obj110=fromRaw(parent) self.obj110.preAction( self.LHS.CREATE ) self.obj110.isGraphObjectVisual = True if(hasattr(self.obj110, '_setHierarchicalLink')): self.obj110._setHierarchicalLink(False) # rate self.obj110.rate.setNone() self.obj110.GGLabel.setValue(3) self.obj110.graphClass_= graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(135.5,78.0,self.obj110) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj110.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj110) self.obj110.postAction( self.LHS.CREATE ) self.obj111=intoMaterial(parent) self.obj111.preAction( self.LHS.CREATE ) self.obj111.isGraphObjectVisual = True if(hasattr(self.obj111, '_setHierarchicalLink')): self.obj111._setHierarchicalLink(False) # rate self.obj111.rate.setNone() self.obj111.GGLabel.setValue(5) self.obj111.graphClass_= graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(291.5,140.5,self.obj111) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj111.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj111) self.obj111.postAction( self.LHS.CREATE ) self.obj107.out_connections_.append(self.obj110) self.obj110.in_connections_.append(self.obj107) self.obj107.graphObject_.pendingConnections.append((self.obj107.graphObject_.tag, self.obj110.graphObject_.tag, [84.0, 76.0, 84.0, 118.0, 135.5, 78.0], 2, True)) self.obj109.out_connections_.append(self.obj111) self.obj111.in_connections_.append(self.obj109) self.obj109.graphObject_.pendingConnections.append((self.obj109.graphObject_.tag, self.obj111.graphObject_.tag, [233.0, 138.0, 212.0, 177.0, 291.5, 140.5], 2, True)) self.obj110.out_connections_.append(self.obj109) self.obj109.in_connections_.append(self.obj110) self.obj110.graphObject_.pendingConnections.append((self.obj110.graphObject_.tag, self.obj109.graphObject_.tag, [200.0, 131.0, 187.0, 38.0, 135.5, 78.0], 2, True)) self.obj111.out_connections_.append(self.obj108) self.obj108.in_connections_.append(self.obj111) self.obj111.graphObject_.pendingConnections.append((self.obj111.graphObject_.tag, self.obj108.graphObject_.tag, [386.0, 158.0, 371.0, 104.0, 291.5, 140.5], 2, True)) self.RHS = ASG_pns(parent) self.obj113=rawMaterial(parent) self.obj113.preAction( self.RHS.CREATE ) self.obj113.isGraphObjectVisual = True if(hasattr(self.obj113, '_setHierarchicalLink')): self.obj113._setHierarchicalLink(False) # MaxFlow self.obj113.MaxFlow.setNone() # price self.obj113.price.setNone() # Name self.obj113.Name.setValue('') self.obj113.Name.setNone() # ReqFlow self.obj113.ReqFlow.setNone() self.obj113.GGLabel.setValue(1) self.obj113.graphClass_= graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(60.0,20.0,self.obj113) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj113.graphObject_ = new_obj self.obj1130= AttrCalc() self.obj1130.Copy=ATOM3Boolean() self.obj1130.Copy.setValue(('Copy from LHS', 1)) self.obj1130.Copy.config = 0 self.obj1130.Specify=ATOM3Constraint() self.obj1130.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj113.GGset2Any['MaxFlow']= self.obj1130 self.obj1131= AttrCalc() self.obj1131.Copy=ATOM3Boolean() self.obj1131.Copy.setValue(('Copy from LHS', 1)) self.obj1131.Copy.config = 0 self.obj1131.Specify=ATOM3Constraint() self.obj1131.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj113.GGset2Any['price']= self.obj1131 self.obj1132= AttrCalc() self.obj1132.Copy=ATOM3Boolean() self.obj1132.Copy.setValue(('Copy from LHS', 1)) self.obj1132.Copy.config = 0 self.obj1132.Specify=ATOM3Constraint() self.obj1132.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj113.GGset2Any['Name']= self.obj1132 self.obj1133= AttrCalc() self.obj1133.Copy=ATOM3Boolean() self.obj1133.Copy.setValue(('Copy from LHS', 1)) self.obj1133.Copy.config = 0 self.obj1133.Specify=ATOM3Constraint() self.obj1133.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj113.GGset2Any['ReqFlow']= self.obj1133 # Add node to the root: self.RHS self.RHS.addNode(self.obj113) self.obj113.postAction( self.RHS.CREATE ) self.obj114=metarial(parent) self.obj114.preAction( self.RHS.CREATE ) self.obj114.isGraphObjectVisual = True if(hasattr(self.obj114, '_setHierarchicalLink')): self.obj114._setHierarchicalLink(False) # MaxFlow self.obj114.MaxFlow.setNone() # price self.obj114.price.setNone() # Name self.obj114.Name.setValue('') self.obj114.Name.setNone() # ReqFlow self.obj114.ReqFlow.setNone() self.obj114.GGLabel.setValue(4) self.obj114.graphClass_= graph_metarial if parent.genGraphics: new_obj = graph_metarial(360.0,160.0,self.obj114) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj114.graphObject_ = new_obj self.obj1140= AttrCalc() self.obj1140.Copy=ATOM3Boolean() self.obj1140.Copy.setValue(('Copy from LHS', 1)) self.obj1140.Copy.config = 0 self.obj1140.Specify=ATOM3Constraint() self.obj1140.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj114.GGset2Any['MaxFlow']= self.obj1140 self.obj1141= AttrCalc() self.obj1141.Copy=ATOM3Boolean() self.obj1141.Copy.setValue(('Copy from LHS', 1)) self.obj1141.Copy.config = 0 self.obj1141.Specify=ATOM3Constraint() self.obj1141.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj114.GGset2Any['price']= self.obj1141 self.obj1142= AttrCalc() self.obj1142.Copy=ATOM3Boolean() self.obj1142.Copy.setValue(('Copy from LHS', 1)) self.obj1142.Copy.config = 0 self.obj1142.Specify=ATOM3Constraint() self.obj1142.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj114.GGset2Any['Name']= self.obj1142 self.obj1143= AttrCalc() self.obj1143.Copy=ATOM3Boolean() self.obj1143.Copy.setValue(('Copy from LHS', 1)) self.obj1143.Copy.config = 0 self.obj1143.Specify=ATOM3Constraint() self.obj1143.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj114.GGset2Any['ReqFlow']= self.obj1143 # Add node to the root: self.RHS self.RHS.addNode(self.obj114) self.obj114.postAction( self.RHS.CREATE ) self.obj115=operatingUnit(parent) self.obj115.preAction( self.RHS.CREATE ) self.obj115.isGraphObjectVisual = True if(hasattr(self.obj115, '_setHierarchicalLink')): self.obj115._setHierarchicalLink(False) # OperCostProp self.obj115.OperCostProp.setNone() # name self.obj115.name.setValue('') self.obj115.name.setNone() # OperCostFix self.obj115.OperCostFix.setNone() self.obj115.GGLabel.setValue(2) self.obj115.graphClass_= graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(160.0,100.0,self.obj115) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj115.graphObject_ = new_obj self.obj1150= AttrCalc() self.obj1150.Copy=ATOM3Boolean() self.obj1150.Copy.setValue(('Copy from LHS', 1)) self.obj1150.Copy.config = 0 self.obj1150.Specify=ATOM3Constraint() self.obj1150.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj115.GGset2Any['OperCostProp']= self.obj1150 self.obj1151= AttrCalc() self.obj1151.Copy=ATOM3Boolean() self.obj1151.Copy.setValue(('Copy from LHS', 1)) self.obj1151.Copy.config = 0 self.obj1151.Specify=ATOM3Constraint() self.obj1151.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj115.GGset2Any['name']= self.obj1151 self.obj1152= AttrCalc() self.obj1152.Copy=ATOM3Boolean() self.obj1152.Copy.setValue(('Copy from LHS', 1)) self.obj1152.Copy.config = 0 self.obj1152.Specify=ATOM3Constraint() self.obj1152.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj115.GGset2Any['OperCostFix']= self.obj1152 # Add node to the root: self.RHS self.RHS.addNode(self.obj115) self.obj115.postAction( self.RHS.CREATE ) self.obj116=fromRaw(parent) self.obj116.preAction( self.RHS.CREATE ) self.obj116.isGraphObjectVisual = True if(hasattr(self.obj116, '_setHierarchicalLink')): self.obj116._setHierarchicalLink(False) # rate self.obj116.rate.setNone() self.obj116.GGLabel.setValue(3) self.obj116.graphClass_= graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(135.5,78.0,self.obj116) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj116.graphObject_ = new_obj self.obj1160= AttrCalc() self.obj1160.Copy=ATOM3Boolean() self.obj1160.Copy.setValue(('Copy from LHS', 1)) self.obj1160.Copy.config = 0 self.obj1160.Specify=ATOM3Constraint() self.obj1160.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj116.GGset2Any['rate']= self.obj1160 # Add node to the root: self.RHS self.RHS.addNode(self.obj116) self.obj116.postAction( self.RHS.CREATE ) self.obj117=intoMaterial(parent) self.obj117.preAction( self.RHS.CREATE ) self.obj117.isGraphObjectVisual = True if(hasattr(self.obj117, '_setHierarchicalLink')): self.obj117._setHierarchicalLink(False) # rate self.obj117.rate.setNone() self.obj117.GGLabel.setValue(5) self.obj117.graphClass_= graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(291.5,140.5,self.obj117) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj117.graphObject_ = new_obj self.obj1170= AttrCalc() self.obj1170.Copy=ATOM3Boolean() self.obj1170.Copy.setValue(('Copy from LHS', 1)) self.obj1170.Copy.config = 0 self.obj1170.Specify=ATOM3Constraint() self.obj1170.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj117.GGset2Any['rate']= self.obj1170 # Add node to the root: self.RHS self.RHS.addNode(self.obj117) self.obj117.postAction( self.RHS.CREATE ) self.obj113.out_connections_.append(self.obj116) self.obj116.in_connections_.append(self.obj113) self.obj113.graphObject_.pendingConnections.append((self.obj113.graphObject_.tag, self.obj116.graphObject_.tag, [84.0, 70.0, 135.5, 78.0], 2, 0)) self.obj115.out_connections_.append(self.obj117) self.obj117.in_connections_.append(self.obj115) self.obj115.graphObject_.pendingConnections.append((self.obj115.graphObject_.tag, self.obj117.graphObject_.tag, [213.0, 108.0, 291.5, 140.5], 2, 0)) self.obj116.out_connections_.append(self.obj115) self.obj115.in_connections_.append(self.obj116) self.obj116.graphObject_.pendingConnections.append((self.obj116.graphObject_.tag, self.obj115.graphObject_.tag, [210.0, 101.0, 135.5, 78.0], 2, 0)) self.obj117.out_connections_.append(self.obj114) self.obj114.in_connections_.append(self.obj117) self.obj117.graphObject_.pendingConnections.append((self.obj117.graphObject_.tag, self.obj114.graphObject_.tag, [370.0, 165.0, 291.5, 140.5], 2, 0))
def __init__(self, parent): GGrule.__init__(self, 21) self.TimeDelay = ATOM3Integer(2) self.exactMatch = 1 self.LHS = ASG_pns(parent) self.LHS.merge(ASG_omacs(parent)) self.LHS.merge(ASG_GenericGraph(parent)) self.obj1747 = rawMaterial(parent) self.obj1747.preAction(self.LHS.CREATE) self.obj1747.isGraphObjectVisual = True if (hasattr(self.obj1747, '_setHierarchicalLink')): self.obj1747._setHierarchicalLink(False) # MaxFlow self.obj1747.MaxFlow.setNone() # price self.obj1747.price.setValue(0) # Name self.obj1747.Name.setValue('') self.obj1747.Name.setNone() # ReqFlow self.obj1747.ReqFlow.setNone() self.obj1747.GGLabel.setValue(6) self.obj1747.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(240.0, 0.0, self.obj1747) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1747.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1747) self.obj1747.postAction(self.LHS.CREATE) self.obj1748 = metarial(parent) self.obj1748.preAction(self.LHS.CREATE) self.obj1748.isGraphObjectVisual = True if (hasattr(self.obj1748, '_setHierarchicalLink')): self.obj1748._setHierarchicalLink(False) # MaxFlow self.obj1748.MaxFlow.setNone() # price self.obj1748.price.setValue(0) # Name self.obj1748.Name.setValue('') self.obj1748.Name.setNone() # ReqFlow self.obj1748.ReqFlow.setNone() self.obj1748.GGLabel.setValue(11) self.obj1748.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(260.0, 200.0, self.obj1748) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1748.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1748) self.obj1748.postAction(self.LHS.CREATE) self.obj1749 = operatingUnit(parent) self.obj1749.preAction(self.LHS.CREATE) self.obj1749.isGraphObjectVisual = True if (hasattr(self.obj1749, '_setHierarchicalLink')): self.obj1749._setHierarchicalLink(False) # OperCostProp self.obj1749.OperCostProp.setNone() # name self.obj1749.name.setValue('') self.obj1749.name.setNone() # OperCostFix self.obj1749.OperCostFix.setNone() self.obj1749.GGLabel.setValue(7) self.obj1749.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(280.0, 100.0, self.obj1749) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1749.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1749) self.obj1749.postAction(self.LHS.CREATE) self.obj1750 = operatingUnit(parent) self.obj1750.preAction(self.LHS.CREATE) self.obj1750.isGraphObjectVisual = True if (hasattr(self.obj1750, '_setHierarchicalLink')): self.obj1750._setHierarchicalLink(False) # OperCostProp self.obj1750.OperCostProp.setNone() # name self.obj1750.name.setValue('') self.obj1750.name.setNone() # OperCostFix self.obj1750.OperCostFix.setNone() self.obj1750.GGLabel.setValue(12) self.obj1750.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(360.0, 260.0, self.obj1750) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1750.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1750) self.obj1750.postAction(self.LHS.CREATE) self.obj1751 = fromRaw(parent) self.obj1751.preAction(self.LHS.CREATE) self.obj1751.isGraphObjectVisual = True if (hasattr(self.obj1751, '_setHierarchicalLink')): self.obj1751._setHierarchicalLink(False) # rate self.obj1751.rate.setNone() self.obj1751.GGLabel.setValue(8) self.obj1751.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(311.5, 63.25, self.obj1751) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1751.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1751) self.obj1751.postAction(self.LHS.CREATE) self.obj1752 = fromMaterial(parent) self.obj1752.preAction(self.LHS.CREATE) self.obj1752.isGraphObjectVisual = True if (hasattr(self.obj1752, '_setHierarchicalLink')): self.obj1752._setHierarchicalLink(False) # rate self.obj1752.rate.setNone() self.obj1752.GGLabel.setValue(14) self.obj1752.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(379.5, 235.25, self.obj1752) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1752.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1752) self.obj1752.postAction(self.LHS.CREATE) self.obj1753 = CapableOf(parent) self.obj1753.preAction(self.LHS.CREATE) self.obj1753.isGraphObjectVisual = True if (hasattr(self.obj1753, '_setHierarchicalLink')): self.obj1753._setHierarchicalLink(False) # rate self.obj1753.rate.setNone() self.obj1753.GGLabel.setValue(3) self.obj1753.graphClass_ = graph_CapableOf if parent.genGraphics: new_obj = graph_CapableOf(84.5, 131.5, self.obj1753) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1753.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1753) self.obj1753.postAction(self.LHS.CREATE) self.obj1754 = Agent(parent) self.obj1754.preAction(self.LHS.CREATE) self.obj1754.isGraphObjectVisual = True if (hasattr(self.obj1754, '_setHierarchicalLink')): self.obj1754._setHierarchicalLink(False) # price self.obj1754.price.setNone() # name self.obj1754.name.setValue('') self.obj1754.name.setNone() self.obj1754.GGLabel.setValue(1) self.obj1754.graphClass_ = graph_Agent if parent.genGraphics: new_obj = graph_Agent(60.0, 20.0, self.obj1754) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1754.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1754) self.obj1754.postAction(self.LHS.CREATE) self.obj1755 = Role(parent) self.obj1755.preAction(self.LHS.CREATE) self.obj1755.isGraphObjectVisual = True if (hasattr(self.obj1755, '_setHierarchicalLink')): self.obj1755._setHierarchicalLink(False) # name self.obj1755.name.setValue('') self.obj1755.name.setNone() self.obj1755.GGLabel.setValue(2) self.obj1755.graphClass_ = graph_Role if parent.genGraphics: new_obj = graph_Role(60.0, 180.0, self.obj1755) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1755.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1755) self.obj1755.postAction(self.LHS.CREATE) self.obj1756 = GenericGraphEdge(parent) self.obj1756.preAction(self.LHS.CREATE) self.obj1756.isGraphObjectVisual = True if (hasattr(self.obj1756, '_setHierarchicalLink')): self.obj1756._setHierarchicalLink(False) self.obj1756.GGLabel.setValue(15) self.obj1756.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(174.5, 69.0, self.obj1756) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1756.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1756) self.obj1756.postAction(self.LHS.CREATE) self.obj1757 = GenericGraphEdge(parent) self.obj1757.preAction(self.LHS.CREATE) self.obj1757.isGraphObjectVisual = True if (hasattr(self.obj1757, '_setHierarchicalLink')): self.obj1757._setHierarchicalLink(False) self.obj1757.GGLabel.setValue(10) self.obj1757.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(245.75, 97.25, self.obj1757) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1757.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1757) self.obj1757.postAction(self.LHS.CREATE) self.obj1758 = GenericGraphEdge(parent) self.obj1758.preAction(self.LHS.CREATE) self.obj1758.isGraphObjectVisual = True if (hasattr(self.obj1758, '_setHierarchicalLink')): self.obj1758._setHierarchicalLink(False) self.obj1758.GGLabel.setValue(13) self.obj1758.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(175.0, 234.0, self.obj1758) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1758.graphObject_ = new_obj # Add node to the root: self.LHS self.LHS.addNode(self.obj1758) self.obj1758.postAction(self.LHS.CREATE) self.obj1747.out_connections_.append(self.obj1751) self.obj1751.in_connections_.append(self.obj1747) self.obj1747.graphObject_.pendingConnections.append( (self.obj1747.graphObject_.tag, self.obj1751.graphObject_.tag, [264.0, 56.0, 295.0, 49.5, 311.5, 63.25], 2, True)) self.obj1748.out_connections_.append(self.obj1752) self.obj1752.in_connections_.append(self.obj1748) self.obj1748.graphObject_.pendingConnections.append( (self.obj1748.graphObject_.tag, self.obj1752.graphObject_.tag, [306.0, 210.0, 353.5, 220.0, 379.5, 235.25], 2, True)) self.obj1751.out_connections_.append(self.obj1749) self.obj1749.in_connections_.append(self.obj1751) self.obj1751.graphObject_.pendingConnections.append( (self.obj1751.graphObject_.tag, self.obj1749.graphObject_.tag, [330.0, 111.0, 328.0, 77.0, 311.5, 63.25], 2, True)) self.obj1752.out_connections_.append(self.obj1750) self.obj1750.in_connections_.append(self.obj1752) self.obj1752.graphObject_.pendingConnections.append( (self.obj1752.graphObject_.tag, self.obj1750.graphObject_.tag, [410.0, 271.0, 405.5, 250.5, 379.5, 235.25], 2, True)) self.obj1753.out_connections_.append(self.obj1755) self.obj1755.in_connections_.append(self.obj1753) self.obj1753.graphObject_.pendingConnections.append( (self.obj1753.graphObject_.tag, self.obj1755.graphObject_.tag, [84.0, 181.0, 84.5, 131.5], 0, True)) self.obj1754.out_connections_.append(self.obj1753) self.obj1753.in_connections_.append(self.obj1754) self.obj1754.graphObject_.pendingConnections.append( (self.obj1754.graphObject_.tag, self.obj1753.graphObject_.tag, [85.0, 82.0, 84.5, 131.5], 0, True)) self.obj1754.out_connections_.append(self.obj1756) self.obj1756.in_connections_.append(self.obj1754) self.obj1754.graphObject_.pendingConnections.append( (self.obj1754.graphObject_.tag, self.obj1756.graphObject_.tag, [85.0, 82.0, 174.5, 69.0], 0, True)) self.obj1754.out_connections_.append(self.obj1757) self.obj1757.in_connections_.append(self.obj1754) self.obj1754.graphObject_.pendingConnections.append( (self.obj1754.graphObject_.tag, self.obj1757.graphObject_.tag, [85.0, 82.0, 192.0, 90.0, 245.75, 97.25], 2, True)) self.obj1755.out_connections_.append(self.obj1758) self.obj1758.in_connections_.append(self.obj1755) self.obj1755.graphObject_.pendingConnections.append( (self.obj1755.graphObject_.tag, self.obj1758.graphObject_.tag, [84.0, 226.0, 175.0, 234.0], 0, True)) self.obj1756.out_connections_.append(self.obj1747) self.obj1747.in_connections_.append(self.obj1756) self.obj1756.graphObject_.pendingConnections.append( (self.obj1756.graphObject_.tag, self.obj1747.graphObject_.tag, [264.0, 56.0, 174.5, 69.0], 0, True)) self.obj1757.out_connections_.append(self.obj1749) self.obj1749.in_connections_.append(self.obj1757) self.obj1757.graphObject_.pendingConnections.append( (self.obj1757.graphObject_.tag, self.obj1749.graphObject_.tag, [300.0, 111.0, 299.5, 104.5, 245.75, 97.25], 2, True)) self.obj1758.out_connections_.append(self.obj1748) self.obj1748.in_connections_.append(self.obj1758) self.obj1758.graphObject_.pendingConnections.append( (self.obj1758.graphObject_.tag, self.obj1748.graphObject_.tag, [266.0, 242.0, 175.0, 234.0], 0, True)) self.RHS = ASG_pns(parent) self.RHS.merge(ASG_omacs(parent)) self.RHS.merge(ASG_GenericGraph(parent)) self.obj1762 = rawMaterial(parent) self.obj1762.preAction(self.RHS.CREATE) self.obj1762.isGraphObjectVisual = True if (hasattr(self.obj1762, '_setHierarchicalLink')): self.obj1762._setHierarchicalLink(False) # MaxFlow self.obj1762.MaxFlow.setNone() # price self.obj1762.price.setValue(0) # Name self.obj1762.Name.setValue('') self.obj1762.Name.setNone() # ReqFlow self.obj1762.ReqFlow.setNone() self.obj1762.GGLabel.setValue(6) self.obj1762.graphClass_ = graph_rawMaterial if parent.genGraphics: new_obj = graph_rawMaterial(240.0, 0.0, self.obj1762) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1762.graphObject_ = new_obj self.obj17620 = AttrCalc() self.obj17620.Copy = ATOM3Boolean() self.obj17620.Copy.setValue(('Copy from LHS', 1)) self.obj17620.Copy.config = 0 self.obj17620.Specify = ATOM3Constraint() self.obj17620.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1762.GGset2Any['MaxFlow'] = self.obj17620 self.obj17621 = AttrCalc() self.obj17621.Copy = ATOM3Boolean() self.obj17621.Copy.setValue(('Copy from LHS', 1)) self.obj17621.Copy.config = 0 self.obj17621.Specify = ATOM3Constraint() self.obj17621.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1762.GGset2Any['Name'] = self.obj17621 self.obj17622 = AttrCalc() self.obj17622.Copy = ATOM3Boolean() self.obj17622.Copy.setValue(('Copy from LHS', 1)) self.obj17622.Copy.config = 0 self.obj17622.Specify = ATOM3Constraint() self.obj17622.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1762.GGset2Any['ReqFlow'] = self.obj17622 # Add node to the root: self.RHS self.RHS.addNode(self.obj1762) self.obj1762.postAction(self.RHS.CREATE) self.obj1763 = metarial(parent) self.obj1763.preAction(self.RHS.CREATE) self.obj1763.isGraphObjectVisual = True if (hasattr(self.obj1763, '_setHierarchicalLink')): self.obj1763._setHierarchicalLink(False) # MaxFlow self.obj1763.MaxFlow.setNone() # price self.obj1763.price.setValue(0) # Name self.obj1763.Name.setValue('') self.obj1763.Name.setNone() # ReqFlow self.obj1763.ReqFlow.setNone() self.obj1763.GGLabel.setValue(11) self.obj1763.graphClass_ = graph_metarial if parent.genGraphics: new_obj = graph_metarial(260.0, 200.0, self.obj1763) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1763.graphObject_ = new_obj self.obj17630 = AttrCalc() self.obj17630.Copy = ATOM3Boolean() self.obj17630.Copy.setValue(('Copy from LHS', 1)) self.obj17630.Copy.config = 0 self.obj17630.Specify = ATOM3Constraint() self.obj17630.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1763.GGset2Any['MaxFlow'] = self.obj17630 self.obj17631 = AttrCalc() self.obj17631.Copy = ATOM3Boolean() self.obj17631.Copy.setValue(('Copy from LHS', 1)) self.obj17631.Copy.config = 0 self.obj17631.Specify = ATOM3Constraint() self.obj17631.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1763.GGset2Any['Name'] = self.obj17631 self.obj17632 = AttrCalc() self.obj17632.Copy = ATOM3Boolean() self.obj17632.Copy.setValue(('Copy from LHS', 1)) self.obj17632.Copy.config = 0 self.obj17632.Specify = ATOM3Constraint() self.obj17632.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1763.GGset2Any['ReqFlow'] = self.obj17632 # Add node to the root: self.RHS self.RHS.addNode(self.obj1763) self.obj1763.postAction(self.RHS.CREATE) self.obj1764 = operatingUnit(parent) self.obj1764.preAction(self.RHS.CREATE) self.obj1764.isGraphObjectVisual = True if (hasattr(self.obj1764, '_setHierarchicalLink')): self.obj1764._setHierarchicalLink(False) # OperCostProp self.obj1764.OperCostProp.setNone() # name self.obj1764.name.setValue('') self.obj1764.name.setNone() # OperCostFix self.obj1764.OperCostFix.setNone() self.obj1764.GGLabel.setValue(7) self.obj1764.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(280.0, 100.0, self.obj1764) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1764.graphObject_ = new_obj self.obj17640 = AttrCalc() self.obj17640.Copy = ATOM3Boolean() self.obj17640.Copy.setValue(('Copy from LHS', 1)) self.obj17640.Copy.config = 0 self.obj17640.Specify = ATOM3Constraint() self.obj17640.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1764.GGset2Any['OperCostProp'] = self.obj17640 self.obj17641 = AttrCalc() self.obj17641.Copy = ATOM3Boolean() self.obj17641.Copy.setValue(('Copy from LHS', 1)) self.obj17641.Copy.config = 0 self.obj17641.Specify = ATOM3Constraint() self.obj17641.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1764.GGset2Any['name'] = self.obj17641 self.obj17642 = AttrCalc() self.obj17642.Copy = ATOM3Boolean() self.obj17642.Copy.setValue(('Copy from LHS', 1)) self.obj17642.Copy.config = 0 self.obj17642.Specify = ATOM3Constraint() self.obj17642.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1764.GGset2Any['OperCostFix'] = self.obj17642 # Add node to the root: self.RHS self.RHS.addNode(self.obj1764) self.obj1764.postAction(self.RHS.CREATE) self.obj1765 = operatingUnit(parent) self.obj1765.preAction(self.RHS.CREATE) self.obj1765.isGraphObjectVisual = True if (hasattr(self.obj1765, '_setHierarchicalLink')): self.obj1765._setHierarchicalLink(False) # OperCostProp self.obj1765.OperCostProp.setNone() # name self.obj1765.name.setValue('') self.obj1765.name.setNone() # OperCostFix self.obj1765.OperCostFix.setNone() self.obj1765.GGLabel.setValue(12) self.obj1765.graphClass_ = graph_operatingUnit if parent.genGraphics: new_obj = graph_operatingUnit(360.0, 260.0, self.obj1765) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1765.graphObject_ = new_obj self.obj17650 = AttrCalc() self.obj17650.Copy = ATOM3Boolean() self.obj17650.Copy.setValue(('Copy from LHS', 1)) self.obj17650.Copy.config = 0 self.obj17650.Specify = ATOM3Constraint() self.obj17650.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1765.GGset2Any['OperCostProp'] = self.obj17650 self.obj17651 = AttrCalc() self.obj17651.Copy = ATOM3Boolean() self.obj17651.Copy.setValue(('Copy from LHS', 1)) self.obj17651.Copy.config = 0 self.obj17651.Specify = ATOM3Constraint() self.obj17651.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1765.GGset2Any['name'] = self.obj17651 self.obj17652 = AttrCalc() self.obj17652.Copy = ATOM3Boolean() self.obj17652.Copy.setValue(('Copy from LHS', 1)) self.obj17652.Copy.config = 0 self.obj17652.Specify = ATOM3Constraint() self.obj17652.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1765.GGset2Any['OperCostFix'] = self.obj17652 # Add node to the root: self.RHS self.RHS.addNode(self.obj1765) self.obj1765.postAction(self.RHS.CREATE) self.obj1766 = fromRaw(parent) self.obj1766.preAction(self.RHS.CREATE) self.obj1766.isGraphObjectVisual = True if (hasattr(self.obj1766, '_setHierarchicalLink')): self.obj1766._setHierarchicalLink(False) # rate self.obj1766.rate.setNone() self.obj1766.GGLabel.setValue(8) self.obj1766.graphClass_ = graph_fromRaw if parent.genGraphics: new_obj = graph_fromRaw(311.5, 63.25, self.obj1766) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1766.graphObject_ = new_obj self.obj17660 = AttrCalc() self.obj17660.Copy = ATOM3Boolean() self.obj17660.Copy.setValue(('Copy from LHS', 1)) self.obj17660.Copy.config = 0 self.obj17660.Specify = ATOM3Constraint() self.obj17660.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1766.GGset2Any['rate'] = self.obj17660 # Add node to the root: self.RHS self.RHS.addNode(self.obj1766) self.obj1766.postAction(self.RHS.CREATE) self.obj1767 = intoMaterial(parent) self.obj1767.preAction(self.RHS.CREATE) self.obj1767.isGraphObjectVisual = True if (hasattr(self.obj1767, '_setHierarchicalLink')): self.obj1767._setHierarchicalLink(False) # rate self.obj1767.rate.setValue(0.0) self.obj1767.GGLabel.setValue(17) self.obj1767.graphClass_ = graph_intoMaterial if parent.genGraphics: new_obj = graph_intoMaterial(324.25, 167.5, self.obj1767) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1767.graphObject_ = new_obj self.obj17670 = AttrCalc() self.obj17670.Copy = ATOM3Boolean() self.obj17670.Copy.setValue(('Copy from LHS', 0)) self.obj17670.Copy.config = 0 self.obj17670.Specify = ATOM3Constraint() self.obj17670.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'a = self.getMatched ( graphID , self.LHS.nodeWithLabel(1) ).name.getValue()\nb = self.getMatched ( graphID , self.LHS.nodeWithLabel(2) ).name.getValue()\nreturn self.graphRewritingSystem.Dictag[ a ][b]\n\n' )) self.obj1767.GGset2Any['rate'] = self.obj17670 # Add node to the root: self.RHS self.RHS.addNode(self.obj1767) self.obj1767.postAction(self.RHS.CREATE) self.obj1768 = fromMaterial(parent) self.obj1768.preAction(self.RHS.CREATE) self.obj1768.isGraphObjectVisual = True if (hasattr(self.obj1768, '_setHierarchicalLink')): self.obj1768._setHierarchicalLink(False) # rate self.obj1768.rate.setNone() self.obj1768.GGLabel.setValue(14) self.obj1768.graphClass_ = graph_fromMaterial if parent.genGraphics: new_obj = graph_fromMaterial(379.5, 235.25, self.obj1768) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1768.graphObject_ = new_obj self.obj17680 = AttrCalc() self.obj17680.Copy = ATOM3Boolean() self.obj17680.Copy.setValue(('Copy from LHS', 1)) self.obj17680.Copy.config = 0 self.obj17680.Specify = ATOM3Constraint() self.obj17680.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1768.GGset2Any['rate'] = self.obj17680 # Add node to the root: self.RHS self.RHS.addNode(self.obj1768) self.obj1768.postAction(self.RHS.CREATE) self.obj1769 = CapableOf(parent) self.obj1769.preAction(self.RHS.CREATE) self.obj1769.isGraphObjectVisual = True if (hasattr(self.obj1769, '_setHierarchicalLink')): self.obj1769._setHierarchicalLink(False) # rate self.obj1769.rate.setNone() self.obj1769.GGLabel.setValue(3) self.obj1769.graphClass_ = graph_CapableOf if parent.genGraphics: new_obj = graph_CapableOf(84.5, 131.5, self.obj1769) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1769.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1769) self.obj1769.postAction(self.RHS.CREATE) self.obj1770 = Agent(parent) self.obj1770.preAction(self.RHS.CREATE) self.obj1770.isGraphObjectVisual = True if (hasattr(self.obj1770, '_setHierarchicalLink')): self.obj1770._setHierarchicalLink(False) # price self.obj1770.price.setNone() # name self.obj1770.name.setValue('') self.obj1770.name.setNone() self.obj1770.GGLabel.setValue(1) self.obj1770.graphClass_ = graph_Agent if parent.genGraphics: new_obj = graph_Agent(60.0, 20.0, self.obj1770) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1770.graphObject_ = new_obj self.obj17700 = AttrCalc() self.obj17700.Copy = ATOM3Boolean() self.obj17700.Copy.setValue(('Copy from LHS', 1)) self.obj17700.Copy.config = 0 self.obj17700.Specify = ATOM3Constraint() self.obj17700.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1770.GGset2Any['price'] = self.obj17700 self.obj17701 = AttrCalc() self.obj17701.Copy = ATOM3Boolean() self.obj17701.Copy.setValue(('Copy from LHS', 1)) self.obj17701.Copy.config = 0 self.obj17701.Specify = ATOM3Constraint() self.obj17701.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1770.GGset2Any['name'] = self.obj17701 # Add node to the root: self.RHS self.RHS.addNode(self.obj1770) self.obj1770.postAction(self.RHS.CREATE) self.obj1771 = Role(parent) self.obj1771.preAction(self.RHS.CREATE) self.obj1771.isGraphObjectVisual = True if (hasattr(self.obj1771, '_setHierarchicalLink')): self.obj1771._setHierarchicalLink(False) # name self.obj1771.name.setValue('') self.obj1771.name.setNone() self.obj1771.GGLabel.setValue(2) self.obj1771.graphClass_ = graph_Role if parent.genGraphics: new_obj = graph_Role(60.0, 180.0, self.obj1771) new_obj.layConstraints = dict() # Graphical Layout Constraints new_obj.layConstraints['scale'] = [1.0, 1.0] else: new_obj = None self.obj1771.graphObject_ = new_obj self.obj17710 = AttrCalc() self.obj17710.Copy = ATOM3Boolean() self.obj17710.Copy.setValue(('Copy from LHS', 1)) self.obj17710.Copy.config = 0 self.obj17710.Specify = ATOM3Constraint() self.obj17710.Specify.setValue( ('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), ([ 'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE' ], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None)) self.obj1771.GGset2Any['name'] = self.obj17710 # Add node to the root: self.RHS self.RHS.addNode(self.obj1771) self.obj1771.postAction(self.RHS.CREATE) self.obj1772 = GenericGraphEdge(parent) self.obj1772.preAction(self.RHS.CREATE) self.obj1772.isGraphObjectVisual = True if (hasattr(self.obj1772, '_setHierarchicalLink')): self.obj1772._setHierarchicalLink(False) self.obj1772.GGLabel.setValue(15) self.obj1772.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(174.5, 69.0, self.obj1772) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1772.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1772) self.obj1772.postAction(self.RHS.CREATE) self.obj1773 = GenericGraphEdge(parent) self.obj1773.preAction(self.RHS.CREATE) self.obj1773.isGraphObjectVisual = True if (hasattr(self.obj1773, '_setHierarchicalLink')): self.obj1773._setHierarchicalLink(False) self.obj1773.GGLabel.setValue(10) self.obj1773.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(245.75, 97.25, self.obj1773) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1773.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1773) self.obj1773.postAction(self.RHS.CREATE) self.obj1774 = GenericGraphEdge(parent) self.obj1774.preAction(self.RHS.CREATE) self.obj1774.isGraphObjectVisual = True if (hasattr(self.obj1774, '_setHierarchicalLink')): self.obj1774._setHierarchicalLink(False) self.obj1774.GGLabel.setValue(13) self.obj1774.graphClass_ = graph_GenericGraphEdge if parent.genGraphics: new_obj = graph_GenericGraphEdge(175.0, 234.0, self.obj1774) new_obj.layConstraints = dict() # Graphical Layout Constraints else: new_obj = None self.obj1774.graphObject_ = new_obj # Add node to the root: self.RHS self.RHS.addNode(self.obj1774) self.obj1774.postAction(self.RHS.CREATE) self.obj1762.out_connections_.append(self.obj1766) self.obj1766.in_connections_.append(self.obj1762) self.obj1762.graphObject_.pendingConnections.append( (self.obj1762.graphObject_.tag, self.obj1766.graphObject_.tag, [264.0, 50.0, 311.5, 63.25], 2, 0)) self.obj1763.out_connections_.append(self.obj1768) self.obj1768.in_connections_.append(self.obj1763) self.obj1763.graphObject_.pendingConnections.append( (self.obj1763.graphObject_.tag, self.obj1768.graphObject_.tag, [306.0, 210.0, 379.5, 235.25], 2, 0)) self.obj1764.out_connections_.append(self.obj1767) self.obj1767.in_connections_.append(self.obj1764) self.obj1764.graphObject_.pendingConnections.append( (self.obj1764.graphObject_.tag, self.obj1767.graphObject_.tag, [333.0, 108.0, 331.0, 142.0, 324.25, 167.5], 2, True)) self.obj1766.out_connections_.append(self.obj1764) self.obj1764.in_connections_.append(self.obj1766) self.obj1766.graphObject_.pendingConnections.append( (self.obj1766.graphObject_.tag, self.obj1764.graphObject_.tag, [330.0, 101.0, 311.5, 63.25], 2, 0)) self.obj1767.out_connections_.append(self.obj1763) self.obj1763.in_connections_.append(self.obj1767) self.obj1767.graphObject_.pendingConnections.append( (self.obj1767.graphObject_.tag, self.obj1763.graphObject_.tag, [306.0, 210.0, 317.5, 193.0, 324.25, 167.5], 2, True)) self.obj1768.out_connections_.append(self.obj1765) self.obj1765.in_connections_.append(self.obj1768) self.obj1768.graphObject_.pendingConnections.append( (self.obj1768.graphObject_.tag, self.obj1765.graphObject_.tag, [413.0, 268.0, 379.5, 235.25], 2, 0)) self.obj1769.out_connections_.append(self.obj1771) self.obj1771.in_connections_.append(self.obj1769) self.obj1769.graphObject_.pendingConnections.append( (self.obj1769.graphObject_.tag, self.obj1771.graphObject_.tag, [91.0, 180.0, 84.5, 131.5], 2, 0)) self.obj1770.out_connections_.append(self.obj1769) self.obj1769.in_connections_.append(self.obj1770) self.obj1770.graphObject_.pendingConnections.append( (self.obj1770.graphObject_.tag, self.obj1769.graphObject_.tag, [97.0, 82.0, 84.5, 131.5], 2, 0)) self.obj1770.out_connections_.append(self.obj1772) self.obj1772.in_connections_.append(self.obj1770) self.obj1770.graphObject_.pendingConnections.append( (self.obj1770.graphObject_.tag, self.obj1772.graphObject_.tag, [97.0, 82.0, 174.5, 69.0], 2, 0)) self.obj1770.out_connections_.append(self.obj1773) self.obj1773.in_connections_.append(self.obj1770) self.obj1770.graphObject_.pendingConnections.append( (self.obj1770.graphObject_.tag, self.obj1773.graphObject_.tag, [97.0, 82.0, 245.75, 97.25], 2, 0)) self.obj1771.out_connections_.append(self.obj1774) self.obj1774.in_connections_.append(self.obj1771) self.obj1771.graphObject_.pendingConnections.append( (self.obj1771.graphObject_.tag, self.obj1774.graphObject_.tag, [91.0, 225.0, 175.0, 234.0], 2, 0)) self.obj1772.out_connections_.append(self.obj1762) self.obj1762.in_connections_.append(self.obj1772) self.obj1772.graphObject_.pendingConnections.append( (self.obj1772.graphObject_.tag, self.obj1762.graphObject_.tag, [264.0, 50.0, 174.5, 69.0], 2, 0)) self.obj1773.out_connections_.append(self.obj1764) self.obj1764.in_connections_.append(self.obj1773) self.obj1773.graphObject_.pendingConnections.append( (self.obj1773.graphObject_.tag, self.obj1764.graphObject_.tag, [300.0, 101.0, 245.75, 97.25], 2, 0)) self.obj1774.out_connections_.append(self.obj1763) self.obj1763.in_connections_.append(self.obj1774) self.obj1774.graphObject_.pendingConnections.append( (self.obj1774.graphObject_.tag, self.obj1763.graphObject_.tag, [266.0, 242.0, 175.0, 234.0], 2, 0))