#---Model-4--Dmin--t-- 5 5 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-005' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 5.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 10 10 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-010' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 10.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 15 15 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-015' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 15.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 20 20 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-020' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 20.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 25 25 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-025' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 25.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 30 30 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-030' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 30.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 35 35 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-035' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 35.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 40 40 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-040' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 40.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 45 45 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-045' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 45.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 50 50 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-050' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 50.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 55 55 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-055' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 55.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 60 60 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-060' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 60.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 65 65 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-065' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 65.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 70 70 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-070' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 70.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert# #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 75 75 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-075' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 75.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 80 80 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-080' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 80.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 85 85 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-085' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 85.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 90 90 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-090' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 90.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #------------------------------------------------------- #---Model-4--Dmin--t-- 95 95 from abaqus import * import testUtils testUtils.setBackwardCompatibility() from abaqusConstants import * mod_nam1 = 'Det_4_WCv_Lh_' mod_nam2 = 'Dmin_t-095' mod_nam = mod_nam1 + mod_nam2 # Create a model. myModel = mdb.Model(name = mod_nam) import sketch import part #------------------------------------------------------------------------------- #--------- Parameter Angabe -------------------------------------------- #------------------------------------------------------------------------------- height_body = 95.0 # : t (genannt 'tt' im Script) length_body = 440.0 #:D (genannt 'DD' im Script) pres = -1.0 #load Wert #------------------------------------------------------------------------------- #--------- Parameter rechnen -------------------------------------------- #------------------------------------------------------------------------------- tt = height_body DD = length_body Dh = DD/2 ac = 0.5 * log (tt) # crack length #--------------------- qq = ac # rechteck pp = qq * 2 rr = 0.9 * qq # Radius von dem kreis seedSize= (pp/8)*1.5 #---------ACHTUNG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** SKETCHING ************************************* #------------------------------------------------------------------------------- from sketch import * myModel=mdb.Model(name=mod_nam) s=myModel.ConstrainedSketch(name='Sketch L', sheetSize=6000.0) #----------------------- s.Line(point1=(0.0, 0.0), point2=(0.0, tt)) s.Line(point1=(0.0, tt), point2=(Dh, tt)) s.Line(point1=(0.0, 0.0), point2=(Dh, 0.0)) s.Line(point1=(Dh, 0.0), point2=(Dh, tt)) #------------------------------------------------------------------------------- #*********************** CREAT A PART ************************************* #------------------------------------------------------------------------------- myPart=myModel.Part(name='Plate', dimensionality=TWO_D_PLANAR, type=DEFORMABLE_BODY) myPart.BaseShell(sketch=s) p = mdb.models[mod_nam].parts['Plate'] session.viewports['Viewport: 1'].setValues(displayedObject=p) #------------------------------------------------------------------------------- #*********************** CREAT A MATERIAL ************************************* #------------------------------------------------------------------------------- import material mdb.models[mod_nam].Material(name='steel') mdb.models[mod_nam].materials['steel'].Elastic(table=((210000.0, 0.3), )) #------------------------------------------------------------------------------- #*********************** SECTION ************************************* #------------------------------------------------------------------------------- import section mdb.models[mod_nam].HomogeneousSolidSection(name='solid_plate', material='steel', thickness=1.0) #------------------------------------------------------------------------------- #************************ ASSIGNING SECTIONS *********************************** #------------------------------------------------------------------------------- plateRegion=(myPart.faces,) myPart.SectionAssignment(region=plateRegion, sectionName='solid_plate') #------------------------------------------------------------------------------- #*********************** ASSEMBLY ************************************* #------------------------------------------------------------------------------- import assembly myAssembly = myModel.rootAssembly myInstance = myAssembly.Instance(name='plateInstance', part=myPart, dependent=OFF) #------------------------------------------------------------------------------- #*********************** STEP ************************************* #------------------------------------------------------------------------------- import step #Create a static Step myModel.StaticStep(name='plateLoad', previous='Initial', timePeriod=1.0, initialInc=0.1, description='load the top of the Plate') #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #---------------------------------------------------------------------- #-------------Auflager------------------------------------------------------------------ #---------------------------------------------------------------------- import regionToolset #session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='Initial') a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((0.0, 0.0, 0.0,),), ((0.0, tt, 0,),), ) region = regionToolset.Region(vertices=verts1) mdb.models[mod_nam].DisplacementBC(name='Auflager', createStepName='Initial', region=region, u1=UNSET, u2=0.0, ur3=UNSET, amplitude=UNSET, distributionType=UNIFORM, localCsys=None) #####--------------!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- #*********************** LOAD ************************************* #------------------------------------------------------------------------------- import load #---------------------------------------------------------------------- #-------------Symmetrie------------------------------------------------------------------ #---------------------------------------------------------------------- rightEdgeCenter=(Dh, tt/2, 0.0) rightEdge = myInstance.edges.findAt((rightEdgeCenter,) ) # Create a boundary symetri at right side of Plate. rightRegion = (rightEdge,) myModel.XsymmBC(name='Right symetry', createStepName='plateLoad', region=rightRegion) #-------------------Load define------------------------------------------------- #********************* hier Load ist Horizontal ACHTUNG!!!!!!!!!!!!!!!!!!!!!!! #------------------------------------------------------------------------------- downEdgeCenter=(0.0, tt/2, 0.0) downEdge = myInstance.edges.findAt((downEdgeCenter,) ) endRegion = ((downEdge,SIDE1),) #endRegion = ((downEdge,),) mdb.models[mod_nam].Pressure(name='Horizontal Load', createStepName='plateLoad', region=endRegion, distributionType=UNIFORM, field='', magnitude=pres, amplitude=UNSET) #------------------------------------------------------------------------------- #*********************** PARTITION ************************************* #------------------------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces v1 = a.instances['plateInstance'].vertices #---Partition---vertikal-----:p1 pickedFaces = f1.findAt((1.0, 1.0, 0.0,)) a.PartitionFaceByShortestPath(point1=(Dh/2 +qq, 0.0, 0.0), point2=(Dh/2 +qq, tt, 0.0), faces=pickedFaces) a.PartitionFaceByShortestPath(point1=((Dh/2) -qq, 0.0, 0.0), point2=((Dh/2)-qq, tt, 0.0), faces=pickedFaces) #-------------------------------- pickedFace2 = f1.findAt( ((1.0, 1.0, 0.0,),), ((Dh/2, 1.0, 0,),), ((Dh-1.0, 1.0, 0,),), ) a.PartitionFaceByShortestPath(point1=(0.0, tt-pp ,0.0), point2=(Dh, tt-pp ,0.0), faces=pickedFace2) #---Partition---große und kleine Kreise im Rechteck-------:p11 import regionToolset session.viewports['Viewport: 1'].view.setValues(nearPlane=464.727, farPlane=477.822, width=26.716, height=29.1318, viewOffsetX=1.19752, viewOffsetY=29.1112) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces t = a.MakeSketchTransform(sketchPlane=f1[4], sketchPlaneSide=SIDE1, origin=( Dh/2, tt-qq, 0.0)) s1 = mdb.models[mod_nam].ConstrainedSketch( name='__profile__', sheetSize=12.01, gridSpacing=0.3, transform=t) g, v, d, c = s1.geometry, s1.vertices, s1.dimensions, s1.constraints s1.setPrimaryObject(option=SUPERIMPOSE) a = mdb.models[mod_nam].rootAssembly a.projectReferencesOntoSketch(sketch=s1, filter=COPLANAR_EDGES) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, 0.001)) s1.CircleByCenterPerimeter(center=(0.0, 0.0), point1=(0.0, rr)) a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedFaces = f1.getSequenceFromMask(mask=('[#10 ]', ), ) a.PartitionFaceBySketch(faces=pickedFaces, sketch=s1) s1.unsetPrimaryObject() del mdb.models[mod_nam].sketches['__profile__'] #---Partition---groß Kreis, klein Kreis und Rechteck----: #------------------------------- 1 pickedFace2 = f1.findAt( ((Dh/2+0.0005, tt-qq, 0.0,),), ((Dh/2+0.0015, tt-qq, 0.0,),), ((Dh/2+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 2 a.PartitionFaceByShortestPath(point1=(Dh/2-qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 3 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2, tt-pp, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #------------------------------- 4 pickedFace2 = f1.findAt( (((Dh/2)+0.0005, tt-qq, 0.0,),), (((Dh/2)+rr-0.0015, tt-qq, 0.0,),), (((Dh/2)+rr+0.0005, tt-qq, 0.0,),), ) a.PartitionFaceByShortestPath(point1=(Dh/2+qq, tt-qq, 0.0), point2=(Dh/2, tt-qq, 0.0), faces=pickedFace2) #--------End of Partition----------------------- #------------------------------------------------------------------------------- #***************** MESH and SEED ***************************************** #------------------------------------------------------------------------------- import mesh #-------------Erst SEED ! --SEED mit gleicher Abstand--------------------------- f1 = a.instances['plateInstance'].edges #-------SEED---die Radien des kleinen Kreises--------:s1------------------------ pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #1 ((Dh/2-0.0005, tt-qq, 0.0),), #2 ((Dh/2, tt-qq-0.0005, 0.0),), #3 ((Dh/2+0.0005, tt-qq, 0.0),), #4 ) a.seedEdgeByNumber(edges=pickedRegions, number=1) #durch 1 geteilt !!! #------SEED------die in dem Rechteck Strecken bis grosem Kreis----:s2------- pickedRegions = f1.findAt( ((Dh/2, tt-0.0005, 0.0),), #5 ((Dh/2-rr-0.0005, tt-qq, 0.0),), #6 ((Dh/2, tt-pp+0.0005, 0.0),), #7 ((Dh/2+qq-0.0005, tt-qq, 0.0),), #8 ) a.seedEdgeByNumber(edges=pickedRegions, number=2) # nur 2 Teile !! #------SEED---die Groß und klein Kreise-und die andere -in 5 teile unterteilt!!-----------:s3--------------- pickedRegions = f1.findAt( ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq+(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2-(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(0.001 * cos (45 * pi/180)), tt-qq-(0.001 * sin (45 * pi/180)), 0.0),),#10- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq+(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2+(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ((Dh/2-(rr * cos (45 * pi/180)), tt-qq-(rr * sin (45 * pi/180)), 0.0),),#13- ) a.seedEdgeByNumber(edges=pickedRegions, number=6) #------SEED------Rechteck----------------3 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh/2 + 0.1, tt, 0.0),), #17 ((Dh/2 - 0.1, tt, 0.0),), #18 ((Dh/2 + 0.1, tt-pp, 0.0),),#19 ((Dh/2 - 0.1, tt-pp, 0.0),),#20 ((Dh/2 + qq, tt-0.1, 0.0),),#21 ((Dh/2 - qq, tt-0.1, 0.0),),#22 ((Dh/2 + qq, tt-pp+0.1, 0.0),),#23 ((Dh/2 - qq, tt-pp+0.1, 0.0),),#24 ) a.seedEdgeByNumber(edges=pickedRegions, number=4) # #------SEED------Rechteck----------------6 teilig---------------------:s4------- pickedRegions = f1.findAt( ((Dh , tt-qq, 0.0),), #17 ((0.0, tt-qq, 0.0),), #18 ((Dh/2 , 0.0, 0.0),),#19 ) a.seedEdgeByNumber(edges=pickedRegions, number=8) # #------SEED---biased--die Radien vom großen Kreis--in 50 Teilen unterteilt--:s6- pickedRegions = f1.findAt( ((Dh/2 + 0.02, tt-qq , 0.0),), #26 ((Dh/2 , tt-qq+0.02, 0.0),), #27 ((Dh/2 -0.02 , tt-qq , 0.0),), #26 ((Dh/2 , tt-qq-0.02 , 0.0),), #27 ) a.seedEdgeByBias(end1Edges=pickedRegions, ratio=110.0, number=50) #------SEED-------------der Rest!! Alle mit gleichem Abstand--:s9--------------- pickedRegions = f1.findAt( ((1.0, tt, 0.0),), #17 ((1.0, tt-pp, 0.0),), #18 ((1.0, 0.0, 0.0),),#19 ((Dh-0.1, tt, 0.0),),#20 ((Dh-0.1, tt-pp, 0.0),), #21 ((Dh-0.1, 0.0, 0.0),), #22 ((0.0, 0.1, 0.0),),#23 ((Dh/2 - qq, 0.1, 0.0),),#23 ((Dh/2 + qq, 0.1, 0.0),),#23 ((Dh, 0.1, 0.0),),#23 ) a.seedEdgeBySize(edges=pickedRegions, size=seedSize) #------------------------------------------------------------------------------- #***************** CRACK ***************************************** #------------------------------------------------------------------------------- #----------------------------Crack-Assign- SEAM !!!!!!!!!!!!!!! import regionToolset a = mdb.models[mod_nam].rootAssembly pickedRegions = f1.findAt( ((Dh/2, tt-qq+0.0005, 0.0),), #17 ((Dh/2, tt-qq+0.1, 0.0),), #18 ((Dh/2, tt-0.001, 0.0),),#19 ) pickedRegions = regionToolset.Region(edges=pickedRegions) mdb.models[mod_nam].rootAssembly.engineeringFeatures.assignSeam( regions=pickedRegions) #-----------------------------Crack Definition a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt(((Dh/2, tt-qq, 0.0), ), ) crackFront = regionToolset.Region(vertices=verts1) a = mdb.models[mod_nam].rootAssembly v1 = a.instances['plateInstance'].vertices verts1 = v1.findAt( ((Dh/2, tt-qq, 0.0), ), ) crackTip = regionToolset.Region(vertices=verts1) a.engineeringFeatures.ContourIntegral(name='Crack-VERTICAL', symmetric=OFF, crackFront=crackFront, crackTip=crackTip, extensionDirectionMethod=CRACK_NORMAL, crackNormal=((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0)), midNodePosition=0.35, collapsedElementAtTip=SINGLE_NODE) session.viewports['Viewport: 1'].assemblyDisplay.setValues(interactions=OFF, constraints=OFF, connectors=OFF, engineeringFeatures=OFF, adaptiveMeshConstraints=ON) session.viewports['Viewport: 1'].assemblyDisplay.setValues(step='plateLoad') mdb.models[mod_nam].HistoryOutputRequest(name='H-Output_Krack_Vertikal', createStepName='plateLoad', frequency=LAST_INCREMENT, contourIntegral='Crack-VERTICAL', sectionPoints=DEFAULT, rebar=EXCLUDE, numberOfContours=53, contourType=K_FACTORS) #---Assign Mesh Control--entire-model assembly!!!-structured-quadratic------------------------------------------ f1 = a.instances['plateInstance'].faces a.setMeshControls(regions=f1, elemShape=QUAD, technique=STRUCTURED) elemType1 = mesh.ElemType(elemCode=CPS8R, elemLibrary=STANDARD) elemType2 = mesh.ElemType(elemCode=CPS6M, elemLibrary=STANDARD) pickedRegions =(f1, ) a.setElementType(regions=pickedRegions, elemTypes=(elemType1, elemType2)) #----Assign Mesh Control-----------Klein Kreis-----SWEEP---QUAD_DOMINATED------------------------------------------------ a = mdb.models[mod_nam].rootAssembly f1 = a.instances['plateInstance'].faces pickedRegions = f1.findAt( ((Dh/2 + 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq+0.0005, 0.0),), #1 ((Dh/2 + 0.0005, tt-qq-0.0005, 0.0),), #1 ((Dh/2 - 0.0005, tt-qq-0.0005, 0.0),), #1 ) a.setMeshControls(regions=pickedRegions, elemShape=QUAD_DOMINATED, technique=SWEEP) #---------- MESH -------------------------------------------------------------- a = mdb.models[mod_nam].rootAssembly partInstances =(a.instances['plateInstance'], ) a.generateMesh(regions=partInstances) #------------------------------------------------------------------------------- #***************** JOB ***************************************** #------------------------------------------------------------------------------- import job a = mdb.models[mod_nam].rootAssembly #1111111111111111111111111111 # Create an analysis job for the model and submit it. jobName = mod_nam myJob = mdb.Job(name=jobName, model= mod_nam , description='Plate Rechner') myJob.submit() myJob.waitForCompletion() #-------------------------------------------------------