def construct_mesh(input, filename, verbose=False): """ The following function is taking parsed values from the XML to: - build model grids & meshes, - initialise Finite Volume discretisation, - define the partitioning when parallelisation is enable. """ rank = mpi.COMM_WORLD.rank size = mpi.COMM_WORLD.size comm = mpi.COMM_WORLD cumflex = None flex = None wave = None tinFlex = None strata = None mapero = None # Get DEM regular grid and create Badlands TIN. recGrid = raster2TIN.raster2TIN(filename, areaDelFactor=input.Afactor) fixIDs = recGrid.boundsPt + recGrid.edgesPt force = forceSim.forceSim( input.seafile, input.seapos, input.rainMap, input.rainTime, input.rainVal, input.orographic, input.orographiclin, input.rbgd, input.rmin, input.rmax, input.rzmax, input.windx, input.windy, input.tauc, input.tauf, input.nm, input.cw, input.hw, input.ortime, input.tectFile, input.tectTime, recGrid.regX, recGrid.regY, input.riverPos, input.riverTime, input.riverQws, input.riverRck, input.riverNb, input.rockNb, input.tDisplay) if input.disp3d: force.time3d = input.time3d if input.merge3d == 0. or input.merge3d > recGrid.resEdges: force.merge3d = input.Afactor * recGrid.resEdges * 0.5 else: force.merge3d = input.merge3d # Partition the TIN walltime = time.clock() FVmesh = FVmethod.FVmethod(recGrid.tinMesh['vertices'], recGrid.tinMesh['triangles'], recGrid.tinMesh['edges']) # Perform partitioning by equivalent domain splitting partitionIDs, RowProc, ColProc = partitionTIN.simple( recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1]) FVmesh.partIDs = partitionIDs # Get each partition global node ID inGIDs = np.where(partitionIDs == rank)[0] # Build Finite Volume discretisation # Define overlapping partitions lGIDs, localTIN = partitionTIN.overlap(recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1], RowProc, ColProc, 2 * recGrid.resEdges, verbose) # Set parameters of the finite volume mesh tMesh = FVmethod.FVmethod(localTIN['vertices'], localTIN['triangles'], localTIN['edges']) if rank == 0 and size > 1 and verbose: print " - partition TIN amongst processors and create local TINs", time.clock( ) - walltime # Define Finite Volume parameters walltime = time.clock() totPts = len(recGrid.tinMesh['vertices'][:, 0]) FVmesh.neighbours = np.zeros((totPts, 20), dtype=np.int32, order='F') FVmesh.neighbours.fill(-2) FVmesh.edge_length = np.zeros((totPts, 20), dtype=np.float, order='F') FVmesh.vor_edges = np.zeros((totPts, 20), dtype=np.float, order='F') FVmesh.control_volumes = np.zeros(totPts, dtype=np.float) # Compute Finite Volume parameters tGIDs, tNgbh, tEdgs, tVors, tVols = tMesh.construct_FV( inGIDs, lGIDs, totPts, recGrid.resEdges * input.Afactor, verbose) FVmesh.neighbours[tGIDs, :tMesh.maxNgbh] = tNgbh FVmesh.edge_length[tGIDs, :tMesh.maxNgbh] = tEdgs FVmesh.vor_edges[tGIDs, :tMesh.maxNgbh] = tVors FVmesh.control_volumes[tGIDs] = tVols if rank == 0 and verbose: print " - FV mesh ", time.clock() - walltime # Define TIN parameters if input.flexure: elevation, cumdiff, cumhill, cumflex, inIDs, parentIDs = _define_TINparams( totPts, input, FVmesh, recGrid, verbose) else: elevation, cumdiff, cumhill, inIDs, parentIDs = _define_TINparams( totPts, input, FVmesh, recGrid, verbose) # Build stratigraphic and erodibility meshes if input.laytime > 0 and input.erolays >= 0: strata, mapero = _build_strateroMesh(input, FVmesh, recGrid, cumdiff, rank, verbose) elif input.laytime > 0: strata = _build_strateroMesh(input, FVmesh, recGrid, cumdiff, rank, verbose) elif input.erolays >= 0: mapero = _build_strateroMesh(input, FVmesh, recGrid, cumdiff, rank, verbose) # Set default to no rain force.update_force_TIN(FVmesh.node_coords[:, :2]) # Flexural isostasy initialisation if input.flexure: flex, tinFlex, cumflex = _init_flexure(FVmesh, input, recGrid, force, elevation, cumdiff, cumflex, totPts, rank, verbose) # Wave grid initialisation if input.waveOn: wave = _init_wave(input, recGrid, force, rank, verbose) # Stratigraphic TIN initialisation if input.rockNb > 0: layNb = int((input.tEnd - input.tStart) / input.laytime) + 2 bPts = recGrid.boundsPt ePts = recGrid.edgesPt if input.restart: straTIN = stratiWedge.stratiWedge( layNb, input.initlayers, FVmesh.node_coords[:, :2], bPts, ePts, input.layersData, input.actlay, input.outDir, input.strath5file, input.rockNb, recGrid.regX, recGrid.regY, elevation, input.rockCk, cumdiff, input.rfolder, input.rstep) else: straTIN = stratiWedge.stratiWedge( layNb, input.initlayers, FVmesh.node_coords[:, :2], bPts, ePts, input.layersData, input.actlay, input.outDir, input.strath5file, input.rockNb, recGrid.regX, recGrid.regY, elevation, input.rockCk) else: straTIN = None # Stratigraphic grid in case of carbonate and/or pelagic growth functions if input.carbonate or input.pelagic: layNb = int((input.tEnd - input.tStart) / input.tDisplay) + 2 bPts = recGrid.boundsPt ePts = recGrid.edgesPt if input.restart: carbTIN = carbMesh.carbMesh(layNb, input.initlayers, FVmesh.node_coords[:, :2], bPts, ePts, input.layersData, input.outDir, input.strath5file, recGrid.regX, recGrid.regY, elevation, input.rfolder, input.rstep) else: carbTIN = carbMesh.carbMesh(layNb, input.initlayers, FVmesh.node_coords[:, :2], bPts, ePts, input.layersData, input.outDir, input.strath5file, recGrid.regX, recGrid.regY, elevation) else: carbTIN = None return recGrid, FVmesh, force, tMesh, lGIDs, fixIDs, \ inIDs, parentIDs, inGIDs, totPts, elevation, cumdiff, \ cumhill, cumflex, strata, mapero, tinFlex, flex, wave, \ straTIN, carbTIN
def reconstruct_mesh(recGrid, input, verbose=False): """ The following function is used after 3D displacements to: - rebuild model grids & meshes, - reinitialise Finite Volume discretisation, - redefine the partitioning when parallelisation is enable. """ rank = mpi.COMM_WORLD.rank size = mpi.COMM_WORLD.size comm = mpi.COMM_WORLD walltime = time.clock() FVmesh = FVmethod.FVmethod(recGrid.tinMesh['vertices'], recGrid.tinMesh['triangles'], recGrid.tinMesh['edges']) # Perform partitioning by equivalent domain splitting partitionIDs, RowProc, ColProc = partitionTIN.simple( recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1]) FVmesh.partIDs = partitionIDs # Get each partition global node ID inGIDs = np.where(partitionIDs == rank)[0] if rank == 0 and verbose: print " - partition TIN amongst processors ", time.clock() - walltime # Define overlapping partitions walltime = time.clock() lGIDs, localTIN = partitionTIN.overlap(recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1], RowProc, ColProc, 2 * recGrid.resEdges, verbose) # Set parameters of the finite volume mesh tMesh = FVmethod.FVmethod(localTIN['vertices'], localTIN['triangles'], localTIN['edges']) # Define Finite Volume parameters totPts = len(recGrid.tinMesh['vertices'][:, 0]) FVmesh.neighbours = np.zeros((totPts, 20), dtype=np.int32, order='F') FVmesh.neighbours.fill(-2) FVmesh.edge_length = np.zeros((totPts, 20), dtype=np.float, order='F') FVmesh.vor_edges = np.zeros((totPts, 20), dtype=np.float, order='F') FVmesh.control_volumes = np.zeros(totPts, dtype=np.float) # Compute Finite Volume parameters tGIDs, tNgbh, tEdgs, tVors, tVols = tMesh.construct_FV( inGIDs, lGIDs, totPts, recGrid.resEdges * input.Afactor, verbose) FVmesh.neighbours[tGIDs, :tMesh.maxNgbh] = tNgbh FVmesh.edge_length[tGIDs, :tMesh.maxNgbh] = tEdgs FVmesh.vor_edges[tGIDs, :tMesh.maxNgbh] = tVors FVmesh.control_volumes[tGIDs] = tVols if rank == 0 and verbose: print " - reconstructed FV mesh ", time.clock() - walltime inIDs = np.where(FVmesh.partIDs[recGrid.boundsPt:] == rank)[0] inIDs += recGrid.boundsPt elevationTIN.assign_parameter_pit(FVmesh.neighbours, FVmesh.control_volumes, input.diffnb, input.diffprop, recGrid.boundsPt, input.fillmax) return FVmesh, tMesh, lGIDs, inIDs, inGIDs, totPts
def load_dem(self, filename, verbose=False): """ Load a DEM input file. """ # 1. Get DEM regular grid and create Badlands TIN. recGrid = raster2TIN.raster2TIN(filename, areaDelFactor=self.input.Afactor) self.fixIDs = recGrid.boundsPt + recGrid.edgesPt force = forceSim.forceSim( self.input.seafile, self.input.seapos, self.input.rainMap, self.input.rainTime, self.input.rainVal, self.input.orographic, self.input.rbgd, self.input.rmin, self.input.rmax, self.input.windx, self.input.windy, self.input.tauc, self.input.tauf, self.input.nm, self.input.cw, self.input.hw, self.input.ortime, self.input.tectFile, self.input.tectTime, recGrid.regX, recGrid.regY, self.input.tDisplay) if self.input.disp3d: force.time3d = self.input.time3d if self.input.merge3d == 0. or self.input.merge3d > recGrid.resEdges: force.merge3d = self.input.Afactor * recGrid.resEdges * 0.5 else: force.merge3d = self.input.merge3d # 2. Partition the TIN walltime = time.clock() FVmesh = FVmethod.FVmethod(recGrid.tinMesh['vertices'], recGrid.tinMesh['triangles'], recGrid.tinMesh['edges']) # Perform partitioning by equivalent domain splitting partitionIDs, RowProc, ColProc = partitionTIN.simple( recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1]) FVmesh.partIDs = partitionIDs # Get each partition global node ID inGIDs = np.where(partitionIDs == self._rank)[0] if self._rank == 0 and self._size > 1 and verbose: print " - partition TIN amongst processors ", time.clock( ) - walltime # 3. Build Finite Volume discretisation # Define overlapping partitions allIDs, localTIN = partitionTIN.overlap( recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1], RowProc, ColProc, 2 * recGrid.resEdges, verbose) # Set parameters of the finite volume mesh tMesh = FVmethod.FVmethod(localTIN['vertices'], localTIN['triangles'], localTIN['edges']) walltime = time.clock() # Define Finite Volume parameters totPts = len(recGrid.tinMesh['vertices'][:, 0]) FVmesh.neighbours = np.zeros((totPts, 20), dtype=np.int32, order='F') FVmesh.neighbours.fill(-2) FVmesh.edge_length = np.zeros((totPts, 20), dtype=np.float) FVmesh.vor_edges = np.zeros((totPts, 20), dtype=np.float) FVmesh.control_volumes = np.zeros(totPts, dtype=np.float) # Compute Finite Volume parameters tGIDs, tNgbh, tEdgs, tVors, tVols = tMesh.construct_FV( inGIDs, allIDs, totPts, recGrid.resEdges * self.input.Afactor, verbose) FVmesh.neighbours[tGIDs, :tMesh.maxNgbh] = tNgbh FVmesh.edge_length[tGIDs, :tMesh.maxNgbh] = tEdgs FVmesh.vor_edges[tGIDs, :tMesh.maxNgbh] = tVors FVmesh.control_volumes[tGIDs] = tVols if self._rank == 0 and verbose: print " - FV mesh ", time.clock() - walltime # 4. Interpolate elevation walltime = time.clock() inIDs = np.where(FVmesh.partIDs[recGrid.boundsPt:] == self._rank)[0] inIDs += recGrid.boundsPt local_elev = np.zeros(totPts) local_elev.fill(-1.e6) if self.input.restart: local_cum = np.zeros(totPts) local_cum.fill(-1.e6) if self.input.flexure: local_cumflex = np.zeros(totPts) local_cumflex.fill(-1.e6) local_elev[inIDs], local_cum[inIDs], local_cumflex[ inIDs] = recGrid.load_hdf5_flex( self.input.rfolder, self.input.rstep, FVmesh.node_coords[inIDs, :2]) else: local_elev[inIDs], local_cum[inIDs] = recGrid.load_hdf5( self.input.rfolder, self.input.rstep, FVmesh.node_coords[inIDs, :2]) self._comm.Allreduce(mpi.IN_PLACE, local_elev, op=mpi.MAX) self._comm.Allreduce(mpi.IN_PLACE, local_cum, op=mpi.MAX) self.cumdiff = local_cum self.cumdiff[:recGrid.boundsPt] = 0. if self.input.flexure: self._comm.Allreduce(mpi.IN_PLACE, local_cumflex, op=mpi.MAX) self.cumflex = local_cumflex self.cumflex[:recGrid.boundsPt] = 0. else: local_elev[inIDs] = elevationTIN.getElevation( recGrid.regX, recGrid.regY, recGrid.regZ, FVmesh.node_coords[inIDs, :2]) self._comm.Allreduce(mpi.IN_PLACE, local_elev, op=mpi.MAX) self.cumdiff = np.zeros(totPts) if self.input.flexure: self.cumflex = np.zeros(totPts) elevation = elevationTIN.update_border_elevation( local_elev, FVmesh.neighbours, FVmesh.edge_length, recGrid.boundsPt, btype=self.input.btype) # Set default to no rain force.update_force_TIN(FVmesh.node_coords[:, :2]) self.rain = np.zeros(totPts, dtype=float) # Define variables self.hillslope = diffLinear() self.hillslope.CDaerial = self.input.CDa self.hillslope.CDmarine = self.input.CDm self.flow = flowNetwork() self.flow.erodibility = self.input.SPLero self.flow.m = self.input.SPLm self.flow.n = self.input.SPLn self.flow.mindt = self.input.minDT self.flow.bedrock = self.input.bedrock self.flow.alluvial = self.input.alluvial self.flow.esmooth = self.input.esmooth self.flow.dsmooth = self.input.dsmooth self.flow.xycoords = FVmesh.node_coords[:, :2] self.flow.spl = self.input.spl self.flow.capacity = self.input.capacity self.flow.filter = self.input.filter self.flow.depo = self.input.depo if self._rank == 0 and verbose: print " - interpolate elevation on grid ", time.clock() - walltime # Flexural isostasy initialisation if self.input.flexure: walltime = time.clock() nx = self.input.fnx ny = self.input.fny if nx == 0: nx = recGrid.nx if ny == 0: ny = recGrid.ny if self.input.elasticH is None: elasticT = str(self.input.elasticGrid) else: elasticT = self.input.elasticH self.flex = isoFlex.isoFlex() self.flex.buildGrid(nx, ny, self.input.youngMod, self.input.dmantle, self.input.dsediment, elasticT, self.input.flexbounds, FVmesh.node_coords[:, :2]) self.tinFlex = np.zeros(totPts, dtype=float) force.getSea(self.tNow) self.tinFlex = self.flex.get_flexure(elevation, self.cumdiff, force.sealevel, recGrid.boundsPt, initFlex=True) self.tinFlex = force.disp_border(self.tinFlex, FVmesh.neighbours, FVmesh.edge_length, recGrid.boundsPt) self.cumflex += self.tinFlex if self._rank == 0: print " - Compute flexural isostasy ", time.clock( ) - walltime # Save state for subsequent calls # TODO: there is a lot of stuff here. Can we reduce it? self.recGrid = recGrid self.elevation = elevation self.FVmesh = FVmesh self.allIDs = allIDs self.inIDs = inIDs self.inGIDs = inGIDs self.tMesh = tMesh self.force = force self.totPts = totPts
def rebuildMesh(self, verbose=False): """ Build TIN after 3D displacements. """ # Build the Finite Volume representation self.fixIDs = self.recGrid.boundsPt + self.recGrid.edgesPt walltime = time.clock() FVmesh = FVmethod.FVmethod(self.recGrid.tinMesh['vertices'], self.recGrid.tinMesh['triangles'], self.recGrid.tinMesh['edges']) # Perform partitioning by equivalent domain splitting partitionIDs, RowProc, ColProc = partitionTIN.simple( self.recGrid.tinMesh['vertices'][:, 0], self.recGrid.tinMesh['vertices'][:, 1]) FVmesh.partIDs = partitionIDs # Get each partition global node ID inGIDs = np.where(partitionIDs == self._rank)[0] if self._rank == 0 and verbose: print " - partition TIN amongst processors ", time.clock( ) - walltime # Define overlapping partitions allIDs, localTIN = partitionTIN.overlap( self.recGrid.tinMesh['vertices'][:, 0], self.recGrid.tinMesh['vertices'][:, 1], RowProc, ColProc, 2 * self.recGrid.resEdges, verbose) # Set parameters of the finite volume mesh tMesh = FVmethod.FVmethod(localTIN['vertices'], localTIN['triangles'], localTIN['edges']) walltime = time.clock() # Define Finite Volume parameters totPts = len(self.recGrid.tinMesh['vertices'][:, 0]) FVmesh.neighbours = np.zeros((totPts, 20), dtype=np.int32) FVmesh.neighbours.fill(-2) FVmesh.edge_length = np.zeros((totPts, 20), dtype=np.float) FVmesh.vor_edges = np.zeros((totPts, 20), dtype=np.float) FVmesh.control_volumes = np.zeros(totPts, dtype=np.float) # Compute Finite Volume parameters tGIDs, tNgbh, tEdgs, tVors, tVols = tMesh.construct_FV( inGIDs, allIDs, totPts, self.recGrid.resEdges * self.input.Afactor, verbose) FVmesh.neighbours[tGIDs, :tMesh.maxNgbh] = tNgbh FVmesh.edge_length[tGIDs, :tMesh.maxNgbh] = tEdgs FVmesh.vor_edges[tGIDs, :tMesh.maxNgbh] = tVors FVmesh.control_volumes[tGIDs] = tVols if self._rank == 0 and verbose: print " - FV mesh ", time.clock() - walltime inIDs = np.where( FVmesh.partIDs[self.recGrid.boundsPt:] == self._rank)[0] inIDs += self.recGrid.boundsPt # Set default with no rain self.force.update_force_TIN(FVmesh.node_coords[:, :2]) self.rain = np.zeros(totPts, dtype=float) self.rain[inIDs] = self.force.get_Rain(self.tNow, self.elevation, inIDs) # Update flexural isostasy if self.input.flexure: self.tinFlex = np.zeros(totPts, dtype=float) self.flex.update_flexure_parameters(FVmesh.node_coords[:, :2]) # Save state for subsequent calls # TODO: there is a lot of stuff here. Can we reduce it? self.flow.xycoords = FVmesh.node_coords[:, :2] self.FVmesh = FVmesh self.allIDs = allIDs self.inIDs = inIDs self.inGIDs = inGIDs self.tMesh = tMesh self.totPts = totPts
def construct_mesh(input, filename, verbose=False): """ The following function is taking parsed values from the XML to: - build model grids & meshes, - initialise Finite Volume discretisation, - define the partitioning when parallelisation is enable. """ rank = mpi.COMM_WORLD.rank size = mpi.COMM_WORLD.size comm = mpi.COMM_WORLD cumflex = None flex = None tinFlex = None strata = None mapero = None # Get DEM regular grid and create Badlands TIN. recGrid = raster2TIN.raster2TIN(filename, areaDelFactor=input.Afactor) fixIDs = recGrid.boundsPt + recGrid.edgesPt force = forceSim.forceSim(input.seafile, input.seapos, input.rainMap, input.rainTime, input.rainVal, input.orographic, input.rbgd, input.rmin, input.rmax , input.windx, input.windy, input.tauc, input.tauf, input.nm, input.cw, input.hw, input.ortime, input.tectFile, input.tectTime, recGrid.regX, recGrid.regY, input.riverPos, input.riverTime, input.riverQws, input.riverWidth, input.riverNb, input.tDisplay) if input.disp3d: force.time3d = input.time3d if input.merge3d == 0. or input.merge3d > recGrid.resEdges: force.merge3d = input.Afactor * recGrid.resEdges * 0.5 else: force.merge3d = input.merge3d # Partition the TIN walltime = time.clock() FVmesh = FVmethod.FVmethod(recGrid.tinMesh['vertices'], recGrid.tinMesh['triangles'], recGrid.tinMesh['edges']) # Perform partitioning by equivalent domain splitting partitionIDs, RowProc, ColProc = partitionTIN.simple(recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1]) FVmesh.partIDs = partitionIDs # Get each partition global node ID inGIDs = np.where(partitionIDs == rank)[0] # Build Finite Volume discretisation # Define overlapping partitions lGIDs, localTIN = partitionTIN.overlap(recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1], RowProc, ColProc, 2*recGrid.resEdges, verbose) # Set parameters of the finite volume mesh tMesh = FVmethod.FVmethod(localTIN['vertices'], localTIN['triangles'], localTIN['edges']) if rank == 0 and size > 1 and verbose: print " - partition TIN amongst processors and create local TINs", time.clock() - walltime # Define Finite Volume parameters walltime = time.clock() totPts = len(recGrid.tinMesh['vertices'][:, 0]) FVmesh.neighbours = np.zeros((totPts, 20), dtype=np.int32, order='F') FVmesh.neighbours.fill(-2) FVmesh.edge_length = np.zeros((totPts, 20), dtype=np.float) FVmesh.vor_edges = np.zeros((totPts, 20), dtype=np.float) FVmesh.control_volumes = np.zeros(totPts, dtype=np.float) # Compute Finite Volume parameters tGIDs, tNgbh, tEdgs, tVors, tVols = tMesh.construct_FV(inGIDs, lGIDs, totPts, recGrid.resEdges*input.Afactor, verbose) FVmesh.neighbours[tGIDs,:tMesh.maxNgbh] = tNgbh FVmesh.edge_length[tGIDs,:tMesh.maxNgbh] = tEdgs FVmesh.vor_edges[tGIDs,:tMesh.maxNgbh] = tVors FVmesh.control_volumes[tGIDs] = tVols if rank == 0 and verbose: print " - FV mesh ", time.clock() - walltime # Define TIN parameters if input.flexure: elevation, cumdiff, cumflex, inIDs = _define_TINparams(totPts, input, FVmesh, recGrid, verbose) else: elevation, cumdiff, inIDs = _define_TINparams(totPts, input, FVmesh, recGrid, verbose) # Build stratigraphic and erodibility meshes if input.laytime > 0 and input.erolays >= 0: strata, mapero = _build_strateroMesh(input, FVmesh, recGrid, cumdiff, rank, verbose) elif input.laytime > 0: strata = _build_strateroMesh(input, FVmesh, recGrid, cumdiff, rank, verbose) elif input.erolays >= 0: mapero = _build_strateroMesh(input, FVmesh, recGrid, cumdiff, rank, verbose) # Set default to no rain force.update_force_TIN(FVmesh.node_coords[:,:2]) # Flexural isostasy initialisation if input.flexure: flex, tinFlex, cumflex = _init_flexure(FVmesh, input, recGrid, force, elevation, cumdiff, cumflex, totPts, rank, verbose) return recGrid, FVmesh, force, tMesh, lGIDs, fixIDs, \ inIDs, inGIDs, totPts, elevation, cumdiff, \ cumflex, strata, mapero, tinFlex, flex
def reconstruct_mesh(recGrid, input, verbose=False): """ The following function is used after 3D displacements to: - rebuild model grids & meshes, - reinitialise Finite Volume discretisation, - redefine the partitioning when parallelisation is enable. """ rank = mpi.COMM_WORLD.rank size = mpi.COMM_WORLD.size comm = mpi.COMM_WORLD walltime = time.clock() FVmesh = FVmethod.FVmethod(recGrid.tinMesh['vertices'], recGrid.tinMesh['triangles'], recGrid.tinMesh['edges']) # Perform partitioning by equivalent domain splitting partitionIDs, RowProc, ColProc = partitionTIN.simple(recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1]) FVmesh.partIDs = partitionIDs # Get each partition global node ID inGIDs = np.where(partitionIDs == rank)[0] if rank == 0 and verbose: print " - partition TIN amongst processors ", time.clock() - walltime # Define overlapping partitions walltime = time.clock() lGIDs, localTIN = partitionTIN.overlap(recGrid.tinMesh['vertices'][:, 0], recGrid.tinMesh['vertices'][:, 1], RowProc, ColProc, 2*recGrid.resEdges, verbose) # Set parameters of the finite volume mesh tMesh = FVmethod.FVmethod(localTIN['vertices'], localTIN['triangles'], localTIN['edges']) # Define Finite Volume parameters totPts = len(recGrid.tinMesh['vertices'][:, 0]) FVmesh.neighbours = np.zeros((totPts, 20), dtype=np.int32) FVmesh.neighbours.fill(-2) FVmesh.edge_length = np.zeros((totPts, 20), dtype=np.float) FVmesh.vor_edges = np.zeros((totPts, 20), dtype=np.float) FVmesh.control_volumes = np.zeros(totPts, dtype=np.float) # Compute Finite Volume parameters tGIDs, tNgbh, tEdgs, tVors, tVols = tMesh.construct_FV(inGIDs, lGIDs, totPts, recGrid.resEdges*input.Afactor, verbose) FVmesh.neighbours[tGIDs,:tMesh.maxNgbh] = tNgbh FVmesh.edge_length[tGIDs,:tMesh.maxNgbh] = tEdgs FVmesh.vor_edges[tGIDs,:tMesh.maxNgbh] = tVors FVmesh.control_volumes[tGIDs] = tVols if rank == 0 and verbose: print " - reconstructed FV mesh ", time.clock() - walltime inIDs = np.where(FVmesh.partIDs[recGrid.boundsPt:] == rank)[0] inIDs += recGrid.boundsPt elevationTIN.assign_parameter_pit(FVmesh.neighbours, recGrid.boundsPt, input.fillmax) return FVmesh, tMesh, lGIDs, inIDs, inGIDs, totPts