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")