'''
-----------------------------------------------------------------------------
 Heat transfer analysis of a symmetric model of a three dimensional single
 edged notch specimen modeled using heat transfer elements (DC3D20).
 The *.odb file generated from this analysis is used for fracture
 analysis of the specimen.
-----------------------------------------------------------------------------
'''

from abaqus import *
import testUtils
testUtils.setBackwardCompatibility()
from abaqusConstants import *

import part, material, section, assembly, step, interaction
import regionToolset, displayGroupMdbToolset as dgm, mesh, load, job 

#----------------------------------------------------------------------------

# Create a model

Mdb()
modelName = '3DSingleEdgedThermMesh2'
myModel = mdb.Model(name=modelName)
    
# Create a new viewport in which to display the model
# and the results of the analysis.

myViewport = session.Viewport(name=modelName)
myViewport.makeCurrent()
myViewport.maximize()
    
#---------------------------------------------------------------------------

# Create a part

# Create a sketch for the base feature

mySketch = myModel.Sketch(name='plateProfile',sheetSize=200.0)
mySketch.sketchOptions.setValues(viewStyle=AXISYM)
mySketch.setPrimaryObject(option=STANDALONE)

mySketch.rectangle(point1=(-10.0, 0.0), point2=(10.0, 40.0))

myPlate = myModel.Part(name='Plate', 
    dimensionality=THREE_D, type=DEFORMABLE_BODY)
myPlate.BaseSolidExtrude(sketch=mySketch, depth=1.0)
mySketch.unsetPrimaryObject()
del myModel.sketches['plateProfile']

myViewport.setValues(displayedObject=myPlate)

# Partition the edge for the crack

pickedEdge = myPlate.edges.findAt((1,0,0))
myPlate.PartitionEdgeByParam(edges=pickedEdge, parameter=0.5)

# Partition the plate

face1 = myPlate.faces.findAt((0,20,1))
edge1 = myPlate.edges.findAt((10.,20.,1.))
t = myPlate.MakeSketchTransform(sketchPlane=face1,
    sketchUpEdge=edge1, sketchPlaneSide=SIDE1,
    origin=(0.0,20.0,1.0))

mySketch = myModel.Sketch(name='partitionProfile',
    sheetSize=89.46, gridSpacing=2.23, transform=t)
mySketch.setPrimaryObject(option=SUPERIMPOSE)
myPlate.projectReferencesOntoSketch(sketch=mySketch,
    filter=COPLANAR_EDGES)
mySketch.sketchOptions.setValues(gridOrigin=(0.0, -20.0))
mySketch.ArcByCenterEnds(center=(0.0,-20.0), point1=(0.28,-20.0),
    point2=(-0.28,-20.0), direction=COUNTERCLOCKWISE)
mySketch.Line(point1=(10.0,-10.0), point2=(-10.0,-10.0))
mySketch.Line(point1=(0.0,-20.0), point2=(10.0,-10.0))
mySketch.Line(point1=(0.0,-20.0), point2=(-10.0,-10.0))

pickedFaces = myPlate.faces.findAt((0,20,1))
myPlate.PartitionFaceBySketch(sketchUpEdge=edge1,
    faces=pickedFaces, sketch=mySketch)
mySketch.unsetPrimaryObject()
del myModel.sketches['partitionProfile']

# Extrude the partitions created above to partition
# the entire part

pickedCells = myPlate.cells
e1 = myPlate.edges.findAt((0.258686,0.107151,1.))
e2 = myPlate.edges.findAt((0.,0.280,1.))
e3 = myPlate.edges.findAt((-0.258686,0.107151,1.))
sPath = myPlate.edges.findAt((10,0,0.25))
pickedEdges =(e1,e2,e3)
myPlate.PartitionCellBySweepEdge(sweepPath=sPath, cells=pickedCells, 
    edges=pickedEdges)

pickedCells = myPlate.cells
e1 = myPlate.edges.findAt((0.098995,0.098995,1.))
e2 = myPlate.edges.findAt((5.098995,5.098995,1.))
e3 = myPlate.edges.findAt((0.,10.,1.))
e4 = myPlate.edges.findAt((-5.098995,5.098995,1.))
e5 = myPlate.edges.findAt((-0.098995,0.098995,1.))
pickedEdges = (e1,e2,e3,e4,e5)
sPath = myPlate.edges.findAt((10,0,0.25))
myPlate.PartitionCellBySweepEdge(sweepPath=sPath, cells=pickedCells, 
    edges=pickedEdges)

# Create a set for the entire part

pickedCells = myPlate.cells
myPlate.Set(cells=pickedCells, name='fullPart')

#---------------------------------------------------------------------------

# Assign material properties

# Create linear elastic material

myModel.Material(name='HEAT')
myModel.materials['HEAT'].Conductivity(table=((0.0007872,),))
myModel.materials['HEAT'].Density(table=((0.2829,),))
myModel.materials['HEAT'].SpecificHeat(table=((0.1431,),))

myModel.HomogeneousSolidSection(name='solidHomogeneous', 
    material='HEAT', thickness=1.0)

region = myPlate.sets['fullPart']

# Assign the above section to the part

myPlate.SectionAssignment(region=region, sectionName='solidHomogeneous')

#---------------------------------------------------------------------------

# Create an assembly

myAssembly = myModel.rootAssembly
myViewport.setValues(displayedObject=myAssembly)
myAssembly.DatumCsysByDefault(CARTESIAN)
myAssembly.Instance(name='myPlate-1', part=myPlate, dependent=OFF)
myPlateInstance = myAssembly.instances['myPlate-1']

# Create a set for the entire instance

faces1 = myPlateInstance.faces
myAssembly.Set(faces=faces1, name='All')

# Create a set for the left faces

faces1 = myPlateInstance.faces.findAt(((-10.,5,0.5),),
    ((-10.,25,0.5),),)
myAssembly.Set(faces=faces1, name='leftFaces')

# Create a set for the right faces

faces1 = myPlateInstance.faces.findAt(((10.,5,0.5),),
    ((10.,25,0.5),),)
myAssembly.Set(faces=faces1, name='rightFaces')

#---------------------------------------------------------------------------

# Create a step for performing a heat transfer analysis

myModel.HeatTransferStep(name='Step-1', previous='Initial',
    description='Heat transfer analysis step', response=STEADY_STATE,
    amplitude=RAMP)

# Create a history output for the temperature
myModel.HistoryOutputRequest(name='H-Output-1', createStepName='Step-1', variables=PRESELECT)

regionDef = myAssembly.sets['All']
myModel.historyOutputRequests['H-Output-1'].setValues(variables=('NT', ),
    region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE)

#---------------------------------------------------------------------------

# Create loads and boundary conditions 

# Assign boundary conditions

region = myAssembly.sets['leftFaces']
myModel.TemperatureBC(name='leftFaceTemp', createStepName='Step-1', 
    region=region, fixed=OFF, distributionType=UNIFORM, magnitude=1000.0)

region = myAssembly.sets['rightFaces']
myModel.TemperatureBC(name='rightFaceTemp', createStepName='Step-1',
    region=region, fixed=OFF, distributionType=UNIFORM, magnitude=-1000.0)

#---------------------------------------------------------------------------

# Create a mesh

# Assign meshing controls to different regions

pickedRegions = myPlateInstance.cells.findAt(((0.,0.140,0.500),),
    ((0.140,0.,0.500),), ((-0.140,0.,0.500),),)
myAssembly.setMeshControls(regions=pickedRegions,
    elemShape=WEDGE, technique=SWEEP)

pickedRegions = myPlateInstance.cells.findAt(((0.,25.,0.500),),
    ((0.,5.14,0.500),), ((-10.,5.,0.500),), ((10.,5.,0.500),),)
myAssembly.setMeshControls(regions=pickedRegions,
    elemShape=HEX, technique=STRUCTURED)

# Seed all the edges

pickedEdges = myPlateInstance.edges.findAt(((0.098995,0.098995,1.),),
    ((0.098995,0.098995,0.),), ((-0.098995,0.098995,0.),),
    ((-0.098995,0.098995,1.),), ((0.140,0.,0.),),
    ((0.140,0.,1.),), ((-0.140,0.,0.),), ((-0.140,0.,1.),),)
myAssembly.seedEdgeByNumber(edges=pickedEdges,
    number=1, constraint=FIXED)

pickedEdges = myPlateInstance.edges.findAt(((-0.19799,0.19799,0.500),),
    ((0.19799,0.19799,0.500),), ((0.,0.,0.500),),
    ((0.280,0.,0.500),), ((-0.280,0.,0.500),),)
myAssembly.seedEdgeByNumber(edges=pickedEdges,
    number=1, constraint=FIXED)

pickedEdges = myPlateInstance.edges.findAt(((0.258686,0.107151,0.),),
    ((-0.258686,0.107151,0.),), ((0.258686,0.107151,1.),),
    ((-0.258686,0.107151,1.),),)
myAssembly.seedEdgeByNumber(edges=pickedEdges,
    number=3, constraint=FIXED)

pickedEdges = myPlateInstance.edges.findAt(((0.,0.280,0.),),
    ((0.,0.280,1.),),)
myAssembly.seedEdgeByNumber(edges=pickedEdges,
    number=6, constraint=FIXED)

pickedEdges = myPlateInstance.edges.findAt(((10.,5.,0.),),
    ((-10.,5.,0.),), ((10.,5.,1.),), ((-10.,5.,1.),),)
myAssembly.seedEdgeByNumber(edges=pickedEdges,
    number=3, constraint=FIXED)

pickedEdges = myPlateInstance.edges.findAt(((0.,10.,0.),),
    ((0.,10.,1.),),)
myAssembly.seedEdgeByNumber(edges=pickedEdges,
    number=6, constraint=FIXED)

pickedEdges1 = myPlateInstance.edges.findAt(((-2.033918,0.,1.),),
    ((-1.070671,1.070671,1.),), ((1.070671,1.070671,1.),),)
pickedEdges2 = myPlateInstance.edges.findAt(((2.141342,0.,1.),),)
myAssembly.seedEdgeByBias(end1Edges=pickedEdges1, end2Edges=pickedEdges2,
    ratio=4, number=5, constraint=FIXED)

pickedEdges1 = myPlateInstance.edges.findAt(((2.141844,0.,0.),),
    ((1.070671,1.070671,0.),),)
pickedEdges2 = myPlateInstance.edges.findAt(((-2.141342,0.,0.),),
    ((-1.070671,1.070671,0.),),)
myAssembly.seedEdgeByBias(end1Edges=pickedEdges1, end2Edges=pickedEdges2,
    ratio=4, number=5, constraint=FIXED)

pickedEdges2 = myPlateInstance.edges.findAt(((10.,13.668598,1.),),)
pickedEdges1 = myPlateInstance.edges.findAt(((10.,14.075607,0.),),)
myAssembly.seedEdgeByBias(end1Edges=pickedEdges1, end2Edges=pickedEdges2,
    ratio=3, number=3, constraint=FIXED)

pickedEdges1 = myPlateInstance.edges.findAt(((-10.,14.784095,1.),),)
pickedEdges2 = myPlateInstance.edges.findAt(((-10.,14.698612,0.),),)
myAssembly.seedEdgeByBias(end1Edges=pickedEdges1, end2Edges=pickedEdges2,
    ratio=3, number=3, constraint=FIXED)

pickedEdges = myPlateInstance.edges.findAt(((0.,40.,1.),),
    ((0.,40.,0.),),)
myAssembly.seedEdgeByNumber(edges=pickedEdges,
    number=6, constraint=FIXED)

elemType1 = mesh.ElemType(elemCode=DC3D20, elemLibrary=STANDARD)
elemType2 = mesh.ElemType(elemCode=DC3D15, elemLibrary=STANDARD)
elemType3 = mesh.ElemType(elemCode=DC3D10, elemLibrary=STANDARD)
cells1 = myPlateInstance.cells
pickedRegions =(cells1, )
myAssembly.setElementType(regions=pickedRegions,
    elemTypes=(elemType1,elemType2,elemType3))
partInstances =(myPlateInstance, )
myAssembly.generateMesh(regions=partInstances)

#---------------------------------------------------------------------------

# Create the job and submit it for analysis

myJob = mdb.Job(name=modelName, model=modelName,
    description='Heat transfer analysis')
mdb.saveAs(pathName=modelName)

#---------------------------------------------------------------------------







