def saveVTK(nstep, pd):
if pd.initialTransient:
return
procID = MPI.COMM_WORLD.Get_rank()
writer2 = exporters.VTKWriterA(pd.geomFields,pd.fluidMeshes,
fileBaseOutput + "elecfield-" + str(nstep) + "_proc"+str(procID) + ".vtk",
"fix-fix beam",
False,0)
writer2.init()
writer2.writeScalarField(pd.elecFields.potential,"potential")
writer2.writeVectorField(pd.elecFields.electric_field,"potentialgradient")
writer2.writeVectorField(pd.flowFields.velocity,"velocity")
writer2.writeScalarField(pd.flowFields.pressure, "pressure")
writer2.finish()
writer3 = exporters.VTKWriterA(pd.geomFields,pd.solidBoundaryMeshes,
fileBaseOutput+ "beamBoundary-" + str(nstep) + "_proc" + str(procID) + ".vtk",
"beam Boundary",
False,0,True)
writer3.init()
writer3.writeVectorField(pd.flowFields.velocity,"velocity")
writer3.writeVectorField(pd.flowFields.force,"flow_force")
writer3.writeVectorField(pd.elecFields.force,"elec_force")
writer3.finish()
def saveBeamBoundaryVTK(n):
writer3 = exporters.VTKWriterA(geomFields, solidBoundaryMeshes,
outDir + "beamBoundary-" + str(n) + ".vtk",
"beam Boundary", False, 0, True)
writer3.init()
writer3.finish()
def saveBeamVTK(n):
writer = exporters.VTKWriterA(geomFields, solidMeshes,
outDir + "beam-" + str(n) + ".vtk",
"gen5_beam", False, 0)
writer.init()
writer.writeVectorField(plateFields.deformation, "deformation")
writer.finish()
def saveFluidVTK(n):
writer = exporters.VTKWriterA(geomFields, fluidMeshes,
fileBase + "fluid-" + str(n) + ".vtk",
"fluid", False, 0)
writer.init()
writer.writeVectorField(flowFields.velocity, "velocity")
writer.writeScalarField(flowFields.pressure, "pressure")
writer.finish()
def saveFluidVTK(n):
writer = exporters.VTKWriterA(geomFields, fluidMeshesOrig,
outDir + "fluid-" + str(n) + ".vtk",
"gen5_fluid", False, 0)
writer.init()
writer.writeScalarField(elecFields.potential, "potential")
writer.writeVectorField(elecFields.electric_field, "potentialgradient")
writer.finish()
def saveVTK(n):
writer = exporters.VTKWriterA(geomFields,fluidMeshes,
fileBase + "elecfield-" + str(n) + ".vtk",
"frogleg",
False,0)
writer.init()
writer.writeScalarField(elecFields.potential,"potential")
writer.writeVectorField(elecFields.electric_field,"potentialgradient")
writer.finish()
writer1 = exporters.VTKWriterA(geomFields,solidMeshes,
fileBase + "deformation-" + str(n) + ".vtk",
"frogleg",
False,0)
writer1.init()
writer1.writeVectorField(plateFields.deformation,"deformation")
writer1.finish()
def savevtk(n):
writer = exporters.VTKWriterA(geomFields,meshes,"Couette"+string.zfill(str(n+1),5)+"_"+string.zfill(MPI.COMM_WORLD.Get_rank(),3)+".vtk","fix-fix beam",False,0)
writer.init()
writer.writeVectorField(geomFields.coordinate,"coordinates")
writer.writeScalarField(macroFields.density,"density")
writer.writeVectorField(macroFields.velocity,"velocity")
writer.writeScalarField(macroFields.pressure,"pressure")
writer.writeScalarField(macroFields.temperature,"temperature")
writer.finish()
def saveVTK(n):
writer1 = exporters.VTKWriterA(
geomFields, solidMeshes,
fileBase_output + "deformation-" + str(n) + ".vtk", "frogleg", False,
0)
writer1.init()
writer1.writeVectorField(plateFields.deformation, "deformation")
writer1.finish()
def advanceUnsteady(smodel, emodel, elecFields, geomFields, meshes,
numTimeSteps, numIterPerTimeStep):
for t in range(0, numTimeSteps):
speciesFields = smodel.getSpeciesFields(0)
filename = 'TimeStep_Species'
filename += ` t `
filename += '.vtk'
writer = exporters.VTKWriterA(geomFields, meshes_case, filename,
"TestBV", False, 0)
writer.init()
writer.writeScalarField(speciesFields.massFraction, "MassFraction")
writer.finish()
filename2 = 'TimeStep_Electric'
filename2 += ` t `
filename2 += '.vtk'
writer2 = exporters.VTKWriterA(geomFields, meshes_case, filename2,
"TestBV", False, 0)
writer2.init()
writer2.writeScalarField(elecFields.potential, "sConc")
writer2.finish()
for i in range(0, numIterPerTimeStep):
# set the species concentrations for the species of interest (Lithium)
elecFields.speciesConcentration = speciesFields.massFraction
#print "POTENTIAL MODEL"
emodel.advance(50)
#set the potential for all species
for j in range(0, nSpecies):
sFields = smodel.getSpeciesFields(j)
sFields.elecPotential = elecFields.potential
#print "SPECIES MODEL"
smodel.advance(50)
print 'advancing to time step %i' % t
smodel.updateTime()
def saveVTK(nstep, pd):
if pd.initialTransient:
return
writer2 = exporters.VTKWriterA(pd.geomFields, pd.macroFields,
pd.fluidMeshes,
"elecfield-" + str(nstep) + ".vtk",
"fix-fix beam", False, 0)
writer2.init()
writer2.writeVectorField()
writer2.finish()
def saveVTK(n):
writer = exporters.VTKWriterA(
geomFields, fluidMeshes,
fileBase_output + "elecfield-" + str(n) + ".vtk", "frogleg", False, 0)
writer.init()
writer.writeScalarField(elecFields.potential, "potential")
writer.writeVectorField(elecFields.electric_field, "potentialgradient")
writer.writeVectorField(flowFields.velocity, "velocity")
writer.writeScalarField(flowFields.pressure, "pressure")
writer.finish()
writer3 = exporters.VTKWriterA(
geomFields, solidBoundaryMeshes,
fileBase_output + "beamBoundary-" + str(n) + ".vtk", "beam Boundary",
False, 0, True)
writer3.init()
#writer3.writeVectorField(flowFields.velocity,"velocity")
#writer3.writeVectorField(flowFields.force,"flow_force")
#writer3.writeVectorField(elecFields.force,"elec_force")
writer3.finish()
def saveBeamVTK(self, n):
geomFields = self.sim.geomFields
solidMeshes = self.sim.solidMeshes
plateFields = self.sim.plateFields
writer = exporters.VTKWriterA(
geomFields, solidMeshes,
self.outputDir + "beam-" + str(n) + ".vtk", "gen5_beam", False, 0)
writer.init()
writer.writeVectorField(plateFields.deformation, "deformation")
writer.writeScalarField(plateFields.force, "force")
writer.finish()
def saveVTK(nstep, pd):
if pd.initialTransient:
return
writer = exporters.VTKWriterA(
pd.geomFields, pd.solidMeshes,
fileBaseOutput + "beam-deformation-" + str(nstep) + ".vtk",
"fix-fix beam", False, 0)
writer.init()
writer.writeVectorField(pd.structureFields.deformation, "deformation")
#writer.writeScalarField(pd.structureFields.sigmaXX,"sigmaXX")
#writer.writeScalarField(pd.structureFields.sigmaXY,"sigmaXY")
#writer.writeScalarField(pd.structureFields.sigmaYY,"sigmaYY")
writer.finish()
def saveBeamBoundaryVTK(self, n):
geomFields = self.sim.geomFields
solidBoundaryMeshes = self.sim.solidBoundaryMeshes
writer3 = exporters.VTKWriterA(
geomFields, solidBoundaryMeshes,
self.outputDir + "beamBoundary-" + str(n) + ".vtk",
"beam Boundary", False, 0, True)
writer3.init()
#writer3.writeVectorField(flowFields.velocity,"velocity")
#writer3.writeVectorField(flowFields.force,"flow_force")
#writer3.writeVectorField(elecFields.force,"elec_force")
writer3.finish()
def saveFluidVTK(self, n):
geomFields = self.sim.geomFields
fluidMeshes = self.sim.fluidMeshes
elecFields = self.sim.elecFields
if self.sim.enableFlowModel:
flowFields = self.sim.flowFields
writer = exporters.VTKWriterA(
geomFields, fluidMeshes,
self.outputDir + "fluid-" + str(n) + ".vtk", "gen5_fluid", False,
0)
writer.init()
writer.writeScalarField(elecFields.potential, "potential")
writer.writeVectorField(elecFields.electric_field, "potentialgradient")
if self.sim.enableFlowModel:
writer.writeVectorField(flowFields.velocity, "velocity")
writer.writeScalarField(flowFields.pressure, "pressure")
writer.finish()
def advanceUnsteady(smodel, geomFields, meshes, numTimeSteps,
numIterPerTimeStep):
for i in range(0, numTimeSteps):
speciesFields = smodel.getSpeciesFields(0)
filename = 'TimeStep_Species'
filename += ` i `
filename += '.vtk'
print filename
writer = exporters.VTKWriterA(geomFields, meshes, filename,
"TestSpecies", False, 0)
writer.init()
writer.writeScalarField(speciesFields.massFraction, "MassFraction")
writer.finish()
smodel.advance(numIterPerTimeStep)
print 'advancing to time step %i' % i
smodel.updateTime()
# Set solver options
toptions = tmodel.getOptions()
toptions.transient = False
toptions.enthalpyModel = False
toptions.polynomialCp = False
#toptions['latentHeat'] = latentHeat
#toptions['solidTemp'] = solidTemp
#toptions['liquidTemp'] = liquidTemp
#toptions.cpFile = specificHeatFile
toptions.setVar('initialTemperature', 298.0)
pc = fvmbaseExt.AMG()
pc.verbosity = 0
defSolver = fvmbaseExt.BCGStab()
defSolver.preconditioner = pc
defSolver.relativeTolerance = 1.e-10
defSolver.absoluteTolerance = 1.e-10
defSolver.nMaxIteractions = 1000
defSolver.verbosity = 0
toptions.linearSolver = defSolver
tmodel.init()
tmodel.advance(100)
writer = exporters.VTKWriterA(geomFields,meshes,"adaptive_test.vtk",
"TestTemperature",False,0)
writer.init()
writer.writeScalarField(thermalFields.temperature, "Temperature")
#writer.writeScalarField(thermalFields.meltFrac, "MeltFraction")
#writer.writeScalarField(thermalFields.conductivity, "Conductivity")
writer.finish()
def solveModels(self, appliedVoltage):
print "--Solving Models--"
maxdeformation = []
numIterations = 200
globalTime = 0
globalCount = 0
timeStep = 2e-7
saveFrequency = 2
initialTransient = False
probeIndex = 3240
pc = fvmbaseExt.AMG()
pc.verbosity = 0
defSolver = fvmbaseExt.BCGStab()
defSolver.preconditioner = pc
defSolver.relativeTolerance = 1e-6
defSolver.absoluteTolerance = 1.e-15
defSolver.nMaxIterations = 50000
defSolver.verbosity = 1
poptions = self.pmodel.getOptions()
poptions.deformationLinearSolver = defSolver
poptions.deformationTolerance = 1.0e-3
poptions.setVar("deformationURF", 1.0)
poptions.printNormalizedResiduals = True
poptions.timeDiscretizationOrder = 2
poptions.transient = False
poptions.scf = 5. / 6.
poptions.setVar('timeStep', timeStep)
### elec solver ###
epc = fvmbaseExt.AMG()
epc.verbosity = 0
elecSolver = fvmbaseExt.BCGStab()
elecSolver.preconditioner = epc
elecSolver.relativeTolerance = 1e-3
elecSolver.nMaxIterations = 1000
elecSolver.maxCoarseLevels = 20
elecSolver.verbosity = 0
eoptions = self.emodel.getOptions()
eoptions.electrostaticsLinearSolver = elecSolver
eoptions.electrostaticsTolerance = 0.5e-5
eoptions.electrostatics_enable = 1
eoptions.chargetransport_enable = 0
eoptions.tunneling = 0
eoptions.ibm_enable = 1
eoptions.transient_enable = False
eoptions.printNormalizedResiduals = True
### initialize models and run ###
self.pmodel.init()
self.emodel.init()
self.dmodel.init()
ibManager = fvmbaseExt.IBManager(self.geomFields,
self.solidBoundaryMeshes[0],
self.fluidMeshes)
for Voltage in appliedVoltage:
for mesh in self.solidBoundaryMeshes:
faces = mesh.getFaces()
areaMag = self.geomFields.areaMag[faces]
faceCount = faces.getCount()
pot = areaMag.newSizedClone(faceCount)
pota = pot.asNumPyArray()
pota[:] = appliedVoltage
self.elecFields.potential[faces] = pot
sbMeshFaces = self.solidBoundaryMeshes[0].getFaces()
ibManager.fluidNeighborsPerIBFace = 4
ibManager.solidNeighborsPerIBFace = 4
ibManager.fluidNeighborsPerSolidFace = 6
t1 = time.time()
#--------------Timestep Loop --------------------------#
for n in range(0, numIterations):
# checkMarking(globalCount)
# --------------- update IBM -------------------------#
print "*** update IBM at globalCount %i ***" % globalCount
ibManager.update()
self.fluidMetricsCalculator.computeIBInterpolationMatrices(
sbMeshFaces)
self.fluidMetricsCalculator.computeSolidInterpolationMatrices(
sbMeshFaces)
#------------solve electrostatics--------#
print "*** solving electric model at globalCount %i ***" % globalCount
for i in range(0, 20):
self.emodel.computeIBFacePotential(sbMeshFaces)
self.emodel.advance(1)
self.emodel.computeSolidSurfaceForcePerUnitArea(
sbMeshFaces)
#saveVTK(n)
#------------update force on beam ----------#
print "*** update force at globalCount %i ***" % globalCount
sbElecForce = self.elecFields.force[sbMeshFaces].asNumPyArray()
solidMesh = self.solidMeshes[0]
solidCells = solidMesh.getCells()
nCells = solidCells.getCount()
nSelfCells = solidCells.getSelfCount()
nSBFaces = sbMeshFaces.getCount()
if (nSBFaces != 2 * nSelfCells + (nCells - nSelfCells)):
print "the extruded solid boundary mesh has wrong face numbers!"
force = self.plateFields.force[solidCells].asNumPyArray()
thickness = self.plateFields.thickness[
solidCells].asNumPyArray()
force[:] = 0.
### Need to correct~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
thickness[:] = self.beam_thickness
# force on interior cells
for c in range(0, nSelfCells):
botFaceIndex = c
topFaceIndex = c + nSelfCells
force[c] = sbElecForce[botFaceIndex][2] + sbElecForce[
topFaceIndex][2]
# force on boundary cells
for c in range(nSelfCells, nCells):
force[c] = sbElecForce[nSelfCells + c][2]
#pdb.set_trace()
#------------solve structure-------------#
print "*** solving structure model at globalCount %i ***" % globalCount
self.pmodel.advance(1)
self.dmodel.calculateNodeDisplacement()
self.dmodel.deformPlate()
self.solidMetricsCalculator.recalculate_deform()
#------------update solid boundary mesh---------------#
#solidBoundaryMeshes = [m.extrude(1, beam_thickness, True) for m in solidMeshes]
sbNodes = self.solidBoundaryMeshes[0].getNodes()
nSBNodes = sbNodes.getCount()
nodes = self.solidMeshes[0].getNodes()
if nSBNodes != nodes.getCount() * 2:
print "the extruded solid mesh has wrong node number!"
nodeCoord = self.geomFields.coordinate[nodes].asNumPyArray()
bNodeCoord = self.geomFields.coordinate[sbNodes].asNumPyArray()
bMeshCoord = self.solidBoundaryMeshes[0].getNodeCoordinates(
).asNumPyArray()
self.deformation = self.geomFields.nodeDisplacement[
nodes].asNumPyArray()
#pdb.set_trace()
for sbn in range(0, nSBNodes / 2):
bNodeCoord[sbn][
2] = -self.beam_thickness / 2 + nodeCoord[sbn][2]
bMeshCoord[sbn][
2] = -self.beam_thickness / 2 + nodeCoord[sbn][2]
for sbn in range(nSBNodes / 2, nSBNodes):
bNodeCoord[sbn][2] = self.beam_thickness / 2 + nodeCoord[
sbn - nSBNodes / 2][2]
bMeshCoord[sbn][2] = self.beam_thickness / 2 + nodeCoord[
sbn - nSBNodes / 2][2]
#pdb.set_trace()
#solidBoundaryMetricsCalculator = models.MeshMetricsCalculatorA(geomFields,solidBoundaryMeshes)
#solidBoundaryMetricsCalculator.init()
self.solidBoundaryMetricsCalculator.recalculate_deform()
cell = self.solidMeshes[0].getCells()
deform = self.plateFields.deformation[cell].asNumPyArray()
def_min = deform.min(axis=0)
def_min_z = def_min[2]
maxdeformation.append(def_min_z)
if (n != 0):
if ((maxdeformation[n] - maxdeformation[n - 1]) /
maxdeformation[n] < 1e-3):
print "Convergence reached"
break
# -----------------update time --------------------------#
globalTime += timeStep
globalCount += 1
#self.pmodel.updateTime()
#saveVTK(n)
#writeTrace(
if (n % saveFrequency == 0):
writer = exporters.VTKWriterA(
self.geomFields, self.fluidMeshes,
"elecfield-" + str(n) + ".vtk", "fix-fix beam", False,
0)
writer.init()
writer.writeScalarField(self.elecFields.potential,
"potential")
writer.writeVectorField(self.elecFields.electric_field,
"potentialgradient")
writer.finish()
writer1 = exporters.VTKWriterA(
self.geomFields, self.solidMeshes,
"structural-" + str(n) + ".vtk", "Disk", False, 0)
writer1.init()
writer1.writeVectorField(self.plateFields.deformation,
"Deformation")
writer1.finish()
t2 = time.time()
print '\nsolution time = %f' % (t2 - t1)
return maxdeformation[n]
print "POTENTIAL MODEL"
emodel.advance(50)
#set the potential for all species
for j in range(0, nSpecies):
sFields = smodel.getSpeciesFields(j)
sFields.elecPotential = elecFields.potential
print "SPECIES MODEL"
smodel.advance(26)
mesh = meshes[1]
massFlux = smodel.getMassFluxIntegral(mesh, 6, 0)
print massFlux
mesh = meshes[0]
massFlux2 = smodel.getMassFluxIntegral(mesh, 5, 0)
print massFlux2
writer = exporters.VTKWriterA(geomFields, meshes_case, "testSpeciesModel.vtk",
"TestSpecies", False, 0)
writer.init()
writer.writeScalarField(speciesFields.massFraction, "MassFraction")
writer.finish()
writer3 = exporters.VTKWriterA(geomFields, meshes_case,
"testElectricModel.vtk", "TestSpecies", False,
0)
writer3.init()
writer3.writeScalarField(elecFields.potential, "sConc")
writer3.finish()
def advanceUnsteady(smodel, emodel, elecFields, geomFields, meshes,
numTimeSteps, numIterPerTimeStep, TimestepTolerance):
outputFile = open('./outputFile.txt', 'w++')
outputFile.write('TimeStep(' + str(timeStep) +
'seconds) ConvergenceTime(s) Iterations(Max=' +
str(numIterPerTimeStep) + ') FinalResidual FluxBalance\n')
outputFile.close()
for t in range(1, (numTimeSteps + 1)):
TimestepStart = time.clock()
for i in range(0, numIterPerTimeStep):
# set the species concentrations for the species of interest (Lithium)
elecFields.speciesConcentration = speciesFields.massFraction
emodel.advance(20)
#set the potential and mass fraction that the potentail model saw, for all species
for j in range(0, nSpecies):
sFields = smodel.getSpeciesFields(j)
sFields.elecPotential = elecFields.potential
sFields.massFractionElectricModel = sFields.massFraction ###
smodel.advance(1)
#exit if residual is NAN or less than Tolerance
if (not (smodel.getMassFractionResidual(0) > TimestepTolerance)):
#exit only if minimum number of iterations have been run
#and flux balance has been reached
FluxBalance = smodel.getMassFluxIntegral(
meshes[1], 17, 0) + smodel.getMassFluxIntegral(
meshes[0], 16, 0)
if (((i + 2) > MinimumIterationsPerTimeStep) &
(abs(FluxBalance) < FluxBalanceTolerance)):
break
#exit immediately if residual is NAN, regardless of iteration count
if ((not (smodel.getMassFractionResidual(0) <= TimestepTolerance))
&
(not (smodel.getMassFractionResidual(0) > TimestepTolerance))):
break
#print flux balances
print "Fluxes:"
mesh = meshes[1] #anode
massFlux1 = smodel.getMassFluxIntegral(mesh, 11, 0)
massFlux2 = smodel.getMassFluxIntegral(mesh, 17, 0)
print massFlux1
print massFlux2
mesh = meshes[0] #cathode
massFlux3 = smodel.getMassFluxIntegral(mesh, 9, 0)
massFlux4 = smodel.getMassFluxIntegral(mesh, 16, 0)
print massFlux3
print massFlux4
TimestepEnd = time.clock()
outputFile = open('./outputFile.txt', 'a')
outputFile.write(
str(t) + ' ' + str(TimestepEnd - TimestepStart) + ' ' +
str(i + 1) + ' ' + str(smodel.getMassFractionResidual(0)) + ' ' +
str(massFlux2 + massFlux4) + '\n')
outputFile.close()
if ((not (smodel.getMassFractionResidual(0) <= TimestepTolerance)) &
(not (smodel.getMassFractionResidual(0) > TimestepTolerance))):
# current residual must be NAN, so end simualation and do not write to .vtk file
break
filename = 'TimeStep_Species' + ` t ` + '.vtk'
writer = exporters.VTKWriterA(geomFields, meshes_case, filename,
"TestBV", False, 0)
writer.init()
writer.writeScalarField((smodel.getSpeciesFields(0)).massFraction,
"LiConc")
writer.finish()
filename2 = 'TimeStep_Electric' + ` t ` + '.vtk'
writer2 = exporters.VTKWriterA(geomFields, meshes_case, filename2,
"TestBV", False, 0)
writer2.init()
writer2.writeScalarField(elecFields.potential, "ElecPotential")
writer2.finish()
print "#############################################################"
print 'Finished time step %i in %i iterations and %f seconds' % (t, (
i + 1), (TimestepEnd - TimestepStart))
print "#############################################################"
smodel.updateTime()
def RunSim(xmax,ymax,zmax,imax,jmax,kmax,old_values,laser_file):
#pdb.set_trace()
mesh = generateBoxMesh(xmax, ymax, zmax, imax, jmax, kmax)
meshes = (mesh,)
geomFields = models.GeomFields('geom')
metricsCalculator = models.MeshMetricsCalculatorA(geomFields,meshes)
metricsCalculator.init()
thermalFields = models.ThermalFields('temperature')
tmodel = models.ThermalModelA(geomFields,thermalFields,meshes)
bcmap = tmodel.getBCMap()
vcmap = tmodel.getVCMap()
global time
global numTimeSteps
global curr_cycle
global v_laser
global laser_pos
global laser_pos_next
global int_time
vcZone = vcmap[mesh.getID()]
# Set boundary conditions and material properties
vcZone['thermalConductivity'] = thermalConductivity
vcZone['density'] = density
# vcZone['specificHeat'] = 1546
xmin_id = 1
xmax_id = 2
ymin_id = 3
ymax_id = 4
zmin_id = 5
zmax_id = 6
bc_xmin = bcmap[xmin_id]
bc_xmax = bcmap[xmax_id]
bc_ymin = bcmap[ymin_id]
bc_ymax = bcmap[ymax_id]
bc_zmin = bcmap[zmin_id]
bc_zmax = bcmap[zmax_id]
bc_zmax.bcType = 'Mixed'
bc_zmax.setVar('farFieldTemperature',initTemp)
bc_zmax.setVar('surfaceEmissivity',-1.0)
bc_zmax.setVar('convectiveCoefficient',-30)
bc_zmin.bcType = 'Convective'
bc_zmin.setVar('farFieldTemperature',initTemp)
bc_zmin.setVar('convectiveCoefficient',-1332)
# bc_zmin.setVar('specifiedHeatFlux',0)
bc_ymin.bcType = 'SpecifiedTemperature'
bc_ymin.setVar('specifiedTemperature',298.0)
bc_ymax.bcType = 'SpecifiedTemperature'
bc_ymax.setVar('specifiedTemperature',298.0)
bc_xmin.bcType = 'SpecifiedTemperature'
bc_xmin.setVar('specifiedTemperature',298.0)
bc_xmax.bcType = 'SpecifiedTemperature'
bc_xmax.setVar('specifiedTemperature',298.0)
# Set solver options
toptions = tmodel.getOptions()
toptions.transient = True
toptions.enthalpyModel = True
toptions.polynomialCp = True
toptions['latentHeat'] = latentHeat
toptions['solidTemp'] = solidTemp
toptions['liquidTemp'] = liquidTemp
toptions.cpFile = specificHeatFile
toptions.setVar('initialTemperature', initTemp)
pc = fvmbaseExt.AMG()
pc.verbosity = 0
defSolver = fvmbaseExt.BCGStab()
defSolver.preconditioner = pc
defSolver.relativeTolerance = 1.e-10
defSolver.absoluteTolerance = 1.e-10
defSolver.nMaxIteractions = 1000
defSolver.verbosity = 0
toptions.linearSolver = defSolver
tmodel.init()
cells = mesh.getCells()
ncells = cells.getSelfCount()
old_ncells, old_temp, old_tempN1, old_enth, old_enthN1, old_enthInv, old_dHdT, old_meltFrac = old_values
temp = thermalFields.temperature
tempN1 = thermalFields.temperatureN1
enth = thermalFields.enthalpy
enthN1 = thermalFields.enthalpyN1
enthInv = thermalFields.enthalpyInverse
dHdT = thermalFields.dHdT
meltFrac = thermalFields.meltFrac
temp = temp[cells].asNumPyArray()
tempN1 = tempN1[cells].asNumPyArray()
enth = enth[cells].asNumPyArray()
enthN1 = enthN1[cells].asNumPyArray()
enthInv = enthInv[cells].asNumPyArray()
dHdT = dHdT[cells].asNumPyArray()
meltFrac = meltFrac[cells].asNumPyArray()
##recover data from previous mesh if it exists
if(old_ncells != 0):
for c in range(old_ncells):
temp[c] = old_temp[c]
tempN1[c] = old_tempN1[c]
enth[c] = old_enth[c]
enthN1[c] = old_enthN1[c]
enthInv[c] = old_enthInv[c]
dHdT[c] = old_dHdT[c]
meltFrac[c] = old_meltFrac[c]
nodes=mesh.getCellNodes()
NodeCoord=mesh.getNodeCoordinates().asNumPyArray()
CellCoord=geomFields.coordinate[cells].asNumPyArray()
laser_width = 3*laser_diam/4/2.146
laser_path = open(laser_file,'r')
if (curr_cycle == -1):
curr_cycle = 1
line = laser_path.readline()
words = line.split()
if(time != float(words[0])):
raise NameError('Time does not match start time in laser_file')
laser_pos.x = float(words[1])
laser_pos.y = float(words[2])
laser_power = float(words[3])
line = laser_path.readline()
words = line.split()
int_time = float(words[0])-time
v_laser = [(float(words[1])-laser_pos.x)/int_time,(float(words[2])-laser_pos.y)/int_time]
laser_power_next = float(words[3])
else:
line = laser_path.readline()
words = line.split()
laser_power = float(words[3])
if (float(words[0]) > time):
raise NameError('Current time not within laser_file for restart')
else:
while(True):
line = laser_path.readline()
words = line.split()
if (float(words[0]) > time):
int_time = float(words[0])-time
v_laser = [(float(words[1])-laser_pos.x)/int_time,(float(words[2])-laser_pos.y)/int_time]
laser_power_next = float(words[3])
break
else:
laser_power = float(words[3])
f = open('laser_position','a')
f.write(str(time) + ' ' + str(numTimeSteps) + ' ' + str(laser_pos.x) + ' ' + str(laser_pos.y) + '\n')
MeltFracField = thermalFields.meltFrac
meltFracArray = MeltFracField[cells].asNumPyArray()
for c in range(ncells):
lim = getNodeCoords(c,CellCoord,NodeCoord,nodes)
if(lim[0] >= 0.01) and (lim[1] <= 0.09) and (lim[2] >= 0.01) and (lim[3] <= 0.09) and (lim[5] <= 0.0001):
meltFracArray[c] = 1.0
else:
meltFracArray[c] = 0.0
while(True):
#find the timestep.
if (int_time <= maxTimeStep):
timeStep = int_time
else:
timeStep = maxTimeStep
laser_pos_next.x = laser_pos.x+v_laser[0]*timeStep
laser_pos_next.y = laser_pos.y+v_laser[1]*timeStep
int_time = int_time - timeStep
toptions.setVar('timeStep',timeStep)
print "Current Time: " + str(time)
print "Time Step: " + str(timeStep)
laser_rect = getLaserRect(laser_pos,laser_pos_next,v_laser,laser_width)
SourceField = thermalFields.source
sourceArray = SourceField[cells].asNumPyArray()
CondField = thermalFields.conductivity
condArray = CondField[cells].asNumPyArray()
TempField = thermalFields.temperature
tempArray = TempField[cells].asNumPyArray()
MeltFracField = thermalFields.meltFrac
meltFracArray = MeltFracField[cells].asNumPyArray()
for c in range(ncells):
#set source term
lim = getNodeCoords(c,CellCoord,NodeCoord,nodes)
if ((lim[5]-zlen) < -1/beta*math.log(0.01*beta/(1-R))):
source = 0
elif (cellLaserOverlap(lim,laser_pos,laser_pos_next,laser_width,
laser_rect)):
ts = getTimes(lim,laser_pos,laser_width,v_laser,timeStep)
if (len(ts) == 2):
source = GaussLegendreQuadrature(laserSource,xs,Ws,ts[0],ts[1],lim,laser_pos,laser_power,v_laser)/timeStep
elif (len(ts) == 0):
source = 0.0
else:
raise NameError('Bad number of solutions to laser overlap cell ' + str(c))
else:
source = 0
sourceArray[c] = source
##Set conductivity based on previous temperature
solidCond = condFunction(tempArray[c])
condArray[c] = condMeltFunction(solidCond,meltFracArray[c])
tmodel.advance(maxIterPerTimeStep)
##Picard iterate out any temperature dependent conductivity
picardIters = 1
urf = 0.9
while(picardIters < 200):
for c in range(ncells):
solidCond = condFunction(tempArray[c])
if((meltFracArray[c] >= 1.0) or (tempArray[c] >= liquidTemp)):
condArray[c] = (1.0-urf)*condArray[c] + urf*solidCond
else:
condArray[c] = (1.0-urf)*condArray[c] + urf*condMeltFunction(solidCond,
max(meltFracArray[c],(tempArray[c]-solidTemp)/
(liquidTemp-solidTemp)))
picardIters = picardIters + 1
prev_temp = np.copy(tempArray)
tmodel.advance(maxIterPerTimeStep)
err_norm = np.linalg.norm(prev_temp-tempArray)/np.linalg.norm(tempArray)
print err_norm
if (err_norm < 1e-4*urf):
break
if (picardIters == 20):
print 'Picard Iterations did not converge after 20 iterations. Decreasing urf to 0.8'
urf = 0.8
if (picardIters == 60):
print 'Picard Iterations did not converge after 60 iterations. Decreasing urf to 0.7'
urf = 0.7
if (picardIters == 120):
print 'Picard Iterations did not converge after 120 iterations. Decreasing urf to 0.6'
urf = 0.6
else:
raise NameError('Picard iterations did not converge after 200 iterations')
##Update time
tmodel.updateTime()
time = time + timeStep
# Update laser position
laser_pos.x = laser_pos_next.x
laser_pos.y = laser_pos_next.y
f.write(str(time) + ' ' + str(numTimeSteps) + ' ' + str(laser_pos.x) + ' ' + str(laser_pos.y) + '\n')
# Output data for current timestep
if((numTimeSteps % outFreq) == 0):
filename = outfilebase + '_' + str(numTimeSteps) + '.vtk'
writer = exporters.VTKWriterA(geomFields,meshes,filename,
"TestTemperature",False,0)
writer.init()
writer.writeScalarField(thermalFields.temperature, "Temperature")
writer.writeScalarField(thermalFields.meltFrac, "MeltFraction")
#writer.writeScalarField(thermalFields.conductivity, "Conductivity")
writer.finish()
write_restart_file((ncells, temp, tempN1, enth, enthN1, enthInv, dHdT, meltFrac))
numTimeSteps = numTimeSteps + 1
if(int_time == 0.0):
laser_power = laser_power_next
line = laser_path.readline()
if (line == ''):
break
else:
words = line.split()
if (len(words) == 0):
break
else:
int_time = float(words[0])-time
v_laser = [(float(words[1])-laser_pos.x)/int_time,(float(words[2])-laser_pos.y)/int_time]
laser_power_next = float(words[3])
f.close()
return_temp = np.copy(temp)
return_tempN1 = np.copy(tempN1)
return_enth = np.copy(enth)
return_enthN1 = np.copy(enthN1)
return_enthInv = np.copy(enthInv)
return_dHdT = np.copy(dHdT)
return_meltFrac = np.copy(meltFrac)
return (ncells, return_temp, return_tempN1, return_enth,
return_enthN1, return_enthInv, return_dHdT, return_meltFrac)
print "Knudsen Number:", Kn
print " "
#initialize
pmodel.init()
#initialize the boundary conditions
pmodel.callBoundaryConditions()
#iterate (argument is the max number of iterations)
pmodel.advance(100)
###################################################
#The simulation is finished, the rest is just post#
#processing #
###################################################
writer = exporters.VTKWriterA(geomFields, meshes, "temperatureProfile.vtk",
"Phonon Transport", False, 0)
writer.init()
writer.writeScalarField(pmacro.temperature, "Temperature")
writer.writeVectorField(pmacro.heatFlux, "HeatFlux")
writer.finish()
topflux = pmodel.HeatFluxIntegral(meshes[0], 5) + pmodel.HeatFluxIntegral(
meshes[1], 8)
botflux = pmodel.HeatFluxIntegral(meshes[0], 7) + pmodel.HeatFluxIntegral(
meshes[1], 10)
leftflux = pmodel.HeatFluxIntegral(meshes[1], 9)
rightflux = pmodel.HeatFluxIntegral(meshes[0], 6)
ballistic = Cp * vg * (T_2 - T_1) / 4. * L_side
print " "
print "=================================="
i + 1), (TimestepEnd - TimestepStart))
print "#############################################################"
smodel.updateTime()
# initialize
emodel.init()
smodel.init()
# initialize potential model to match with species model at time 0
speciesFields = smodel.getSpeciesFields(0)
elecFields.speciesConcentration = speciesFields.massFraction
emodel.advance(200)
# write initial conditons
writer = exporters.VTKWriterA(geomFields, meshes_case, 'TimeStep_Species0.vtk',
"TestBV", False, 0)
writer.init()
writer.writeScalarField((smodel.getSpeciesFields(0)).massFraction, "LiConc")
writer.finish()
writer2 = exporters.VTKWriterA(geomFields, meshes_case,
'TimeStep_Electric0.vtk', "TestBV", False, 0)
writer2.init()
writer2.writeScalarField(elecFields.potential, "ElecPotential")
writer2.finish()
# solve coupled system
advanceUnsteady(smodel, emodel, elecFields, geomFields, meshes, numTimeSteps,
numIterPerTimeStep, TimestepTolerance)
'''
mesh = meshes[1]
massFlux = smodel.getMassFluxIntegral(mesh,6,0)
rho[c] = vof[c] * rhoH20 + (1.0 - vof[c]) * rhoAir
rhoPrev[c] = vof[c] * rhoH20 + (1.0 - vof[c]) * rhoAir
mu[c] = vof[c] * muH20 + (1.0 - vof[c]) * muAir
source[c] = grav * rho[c]
fg = mesh.getInteriorFaceGroup()
faces = fg.site
faceCells = mesh.getAllFaceCells()
nFaces = faces.getCount()
faceArea = geomFields.area[faces].asNumPyArray()
V = flowFields.velocity[cells].asNumPyArray()
#massFlux = flowFields.massFlux[faces].asNumPyArray()
flux = thermalFields.convectionFlux[faces].asNumPyArray()
writer = exporters.VTKWriterA(geomFields, meshes,
"flow-" + str(numTimeSteps) + ".vtk",
"FlowField", False, 0)
writer.init()
writer.writeScalarField(flowFields.pressure, "Pressure")
writer.writeScalarField(thermalFields.temperature, "VOF")
writer.writeScalarField(flowFields.density, "Density")
writer.writeScalarField(flowFields.viscosity, "Viscosity")
writer.writeVectorField(flowFields.velocity, "Velocity")
writer.finish()
pdb.set_trace()
while (numTimeSteps < 10):
for j in range(300):
#solve for flow field
flowConverged = fmodel.advance(1)
writer = exporters.VTKWriterA(geomFields, meshes,
solver = fvmbaseExt.AMG()
solver.relativeTolerance = 1e-14 #solver tolerance
solver.absoluteTolerance = 1e-16 #solver tolerance
solver.nMaxIterations = 100
solver.maxCoarseLevels = 30
solver.verbosity = 0
soptions.linearSolver = solver
# model tolerances are only needed for non-linear or unstructured problems
#soptions.relativeTolerance=1e-16
#soptions.absoluteTolerance=1e-16
#smodel.printBCs()
smodel.init()
smodel.advance(1)
mesh = meshes[1]
heatFlux = smodel.getMassFluxIntegral(mesh, 6, 0)
print heatFlux
mesh = meshes[0]
heatFlux2 = smodel.getMassFluxIntegral(mesh, 5, 0)
print heatFlux2
speciesFields = smodel.getSpeciesFields(0)
writer = exporters.VTKWriterA(geomFields, meshes, "testSpeciesModel.vtk",
"TestSpecies", False, 0)
writer.init()
writer.writeScalarField(speciesFields.massFraction, "MassFraction")
writer.finish()
#Mesh 1
wall3 = (cmodel.HeatFluxIntegral(meshes[1], 3)) * eVtoJoule
wall13 = (cmodel.HeatFluxIntegral(meshes[1], 13)) * eVtoJoule
wall8 = (cmodel.HeatFluxIntegral(meshes[1], 8)) * eVtoJoule
wall11 = (cmodel.HeatFluxIntegral(meshes[1], 11)) * eVtoJoule
print "Solution Time: ", t
meshlist0 = fvmbaseExt.MeshList()
meshlist0.push_back(meshes[0])
meshlist1 = fvmbaseExt.MeshList()
meshlist1.push_back(meshes[1])
name_file = "FabMesh"
writer0 = exporters.VTKWriterA(geomFields, meshlist0, name_file + '0' + '.vtk',
"Phonon Transport", False, 0)
writer0.init()
writer0.writeScalarField(pmacro.temperature, "Temperature")
for mode in range(4):
writer0.writeScalarField(pmacro.getModeTemp(0, mode),
"Mode" + str(mode) + "Mesh" + str(0))
writer0.finish()
writer1 = exporters.VTKWriterA(geomFields, meshlist1, name_file + '1' + '.vtk',
"Phonon Transport", False, 0)
writer1.init()
writer1.writeScalarField(pmacro.temperature, "Temperature")
for mode in range(4):
writer1.writeScalarField(pmacro.getModeTemp(1, mode),
def solveModels(self, appliedVoltage):
maxdeformation = []
ibManager = fvmbaseExt.IBManager(self.geomFields,
self.solidBoundaryMeshes[0],
self.fluidMeshes)
for mesh in self.solidBoundaryMeshes:
faces = mesh.getFaces()
areaMag = self.geomFields.areaMag[faces]
faceCount = faces.getCount()
pot = areaMag.newSizedClone(faceCount)
pota = pot.asNumPyArray()
pota[:] = appliedVoltage
self.elecFields.potential[faces] = pot
sbMeshFaces = self.solidBoundaryMeshes[0].getFaces()
ibManager.fluidNeighborsPerIBFace = 6
ibManager.solidNeighborsPerIBFace = 4
ibManager.fluidNeighborsPerSolidFace = 5
t1 = time.time()
traceFile = open(("tracefile-%e.dat" % appliedVoltage), "w")
#--------------Timestep Loop --------------------------#
for n in range(0, self.numIterations):
# checkMarking(globalCount)
# --------------- update IBM -------------------------#
print "*** update IBM at globalCount %i ***" % self.globalCount
ibManager.update()
self.fluidMetricsCalculator.computeIBInterpolationMatrices(
sbMeshFaces)
self.fluidMetricsCalculator.computeSolidInterpolationMatrices(
sbMeshFaces)
#------------solve electrostatics--------#
print "*** solving electric model at globalCount %i ***" % self.globalCount
for i in range(0, 20):
self.emodel.computeIBFacePotential(sbMeshFaces)
if (self.emodel.advance(1)):
break
self.emodel.computeSolidSurfaceForcePerUnitArea(sbMeshFaces)
#------------update force on beam ----------#
print "*** update force at globalCount %i ***" % self.globalCount
sbElecForce = self.elecFields.force[sbMeshFaces].asNumPyArray()
solidMesh = self.solidMeshes[0]
solidCells = solidMesh.getCells()
nCells = solidCells.getCount()
nSelfCells = solidCells.getSelfCount()
nSBFaces = sbMeshFaces.getCount()
if (nSBFaces != 2 * nSelfCells + (nCells - nSelfCells)):
print "the extruded solid boundary mesh has wrong face numbers!"
force = self.plateFields.force[solidCells].asNumPyArray()
thickness = self.plateFields.thickness[solidCells].asNumPyArray()
force[:] = 0.
### Need to correct~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
thickness[:] = self.beam_thickness
# force on interior cells
for c in range(0, nSelfCells):
botFaceIndex = c
topFaceIndex = c + nSelfCells
force[c] = sbElecForce[botFaceIndex][2] + sbElecForce[
topFaceIndex][2]
# force on boundary cells
for c in range(nSelfCells, nCells):
force[c] = sbElecForce[nSelfCells + c][2]
#pdb.set_trace()
#------------solve structure-------------#
print "*** solving structure model at globalCount %i ***" % self.globalCount
self.pmodel.advance(1)
self.dmodel.calculateNodeDisplacement()
self.dmodel.deformPlate()
self.solidMetricsCalculator.recalculate_deform()
#------------update solid boundary mesh---------------#
#solidBoundaryMeshes = [m.extrude(1, beam_thickness, True) for m in solidMeshes]
sbNodes = self.solidBoundaryMeshes[0].getNodes()
nSBNodes = sbNodes.getCount()
nodes = self.solidMeshes[0].getNodes()
if nSBNodes != nodes.getCount() * 2:
print "the extruded solid mesh has wrong node number!"
nodeCoord = self.geomFields.coordinate[nodes].asNumPyArray()
bNodeCoord = self.geomFields.coordinate[sbNodes].asNumPyArray()
bMeshCoord = self.solidBoundaryMeshes[0].getNodeCoordinates(
).asNumPyArray()
self.deformation = self.geomFields.nodeDisplacement[
nodes].asNumPyArray()
for sbn in range(0, nSBNodes / 2):
bNodeCoord[sbn][
2] = -self.beam_thickness / 2 + nodeCoord[sbn][2]
bMeshCoord[sbn][
2] = -self.beam_thickness / 2 + nodeCoord[sbn][2]
for sbn in range(nSBNodes / 2, nSBNodes):
bNodeCoord[sbn][2] = self.beam_thickness / 2 + nodeCoord[
sbn - nSBNodes / 2][2]
bMeshCoord[sbn][2] = self.beam_thickness / 2 + nodeCoord[
sbn - nSBNodes / 2][2]
self.solidBoundaryMetricsCalculator.recalculate_deform()
cell = self.solidMeshes[0].getCells()
deform = self.plateFields.deformation[cell].asNumPyArray()
temp = np.array(deform[:])
val = 0.e0
for i in range(len(temp)):
temp2 = temp[i]
if (temp2[2] < val):
val = temp2[2]
maxdeformation.append(val)
traceFile.write("%i %e\n" % (n, maxdeformation[n]))
traceFile.flush()
# -----------------update time --------------------------#
self.globalTime += self.timeStep
self.globalCount += 1
if (n % self.saveFrequency == 0 and self.saveVTKstate):
writer = exporters.VTKWriterA(
self.geomFields, self.fluidMeshes, "elecfield-" +
str(appliedVoltage) + "V-" + str(n) + ".vtk",
"fix-fix beam", False, 0)
writer.init()
writer.writeScalarField(self.elecFields.potential, "potential")
writer.writeVectorField(self.elecFields.electric_field,
"potentialgradient")
writer.finish()
writer1 = exporters.VTKWriterA(
self.geomFields, self.solidMeshes, "structural-" +
str(appliedVoltage) + "V-" + str(n) + ".vtk", "Disk",
False, 0)
writer1.init()
writer1.writeVectorField(self.plateFields.deformation,
"Deformation")
writer1.finish()
if (abs(maxdeformation[n]) > self.Gap):
traceFile.write("Pull In")
traceFile.flush()
maxdeformation[n] = -self.Gap
break
if (n != 0):
print abs((maxdeformation[n] - maxdeformation[n - 1]) /
maxdeformation[n])
if (abs((maxdeformation[n] - maxdeformation[n - 1]) /
maxdeformation[n]) < 1e-3):
print "Convergence reached"
break
t2 = time.time()
print '\nsolution time = %f' % (t2 - t1)
traceFile.close()
return maxdeformation[n]
print "Wall 7: ", wall7
print "Balance: ", (wall4 + wall5 + wall6 + wall7)
print "Ballistic Ratio: ", wall4 / BallisticRate
print "Thermal Conductivity: ", thcon
print "Total Solution Time:", t
print ""
print "Mesh file: " + filename
print "Scaling: " + str(scale)
print "BZ file: " + BZfile + BZdisc
print "Max Levels: ", copts.maxLevels
K_space.findKnStats(scale)
name_file = KnName + '_' + str(copts.maxLevels) + 'levs'
writer = exporters.VTKWriterA(geomFields, meshes, name_file + '.vtk',
"Phonon Transport", False, 0)
writer.init()
writer.writeScalarField(pmacro.temperature, "Temperature")
#f copts.withNormal==1:
# writer.writeVectorField(pmacro.lam,"Lambda")
writer.finish()
resFile = open(name_file + '.res', 'w')
resFile.write("Final Residual: " + str(resid) + "\n")
resFile.write("Iteration Count: " + str(iteration) + "\n")
resFile.write("Total Solution Time: " + str(t) + "\n")
resFile.write("Max Levels: " + str(copts.maxLevels) + "\n")
resFile.write("Initial Guess: " + str(Tinit) + "\n")
resFile.write("Wall 4: " + str(wall4) + "\n")
resFile.write("Wall 5: " + str(wall5) + "\n")
