/// <summary> /// Creates a new instance of the <see cref="MetisOptions"/> class with default graph partitioning options. /// </summary> public static MetisOptions GraphPartitionDefault() { var opt = new MetisOptions(); opt.Partitioning = PartitioningType.KWAY; opt.Objective = ObjectiveType.CUT; opt.Coarsening = CoarseningType.SHEM; opt.InitialPartitioning = InitialPartitioningType.GROW; opt.Refinement = RefinementType.GREEDY; opt.No2Hop = false; opt.MinConnect = false; opt.Contiguous = false; opt.Cuts = 1; opt.Seperators = 1; opt.Iterations = 10; opt.Seed = -1; opt.DebugLevel = DebugLevel.NONE; opt.UFactor = -1; return(opt); }
private MetisStatus Partition(int nparts, int[] part, MetisOptions options, bool kway) { int objval = 0; if (part == null || part.Length < this.nvtxs) { return(MetisStatus.ERROR_INPUT); } var handles = new List <GCHandle>(); // Pin array data. var p_part = InteropHelper.Pin(part, handles); var p_xadj = InteropHelper.Pin(xadj, handles); var p_adjncy = InteropHelper.Pin(adjncy, handles); var p_vwgt = InteropHelper.Pin(vwgt, handles); var p_ewgt = InteropHelper.Pin(adjwgt, handles); var p_vsize = InteropHelper.Pin(vsize, handles); var p_opts = options == null ? IntPtr.Zero : InteropHelper.Pin(options.raw, handles); int l_nv = nvtxs; int l_nw = ncon; int status = 0; try { if (kway) { status = NativeMethods.PartGraphKway(ref l_nv, ref l_nw, p_xadj, p_adjncy, p_vwgt, p_vsize, p_ewgt, ref nparts, IntPtr.Zero, IntPtr.Zero, p_opts, ref objval, p_part); } else { status = NativeMethods.PartGraphRecursive(ref l_nv, ref l_nw, p_xadj, p_adjncy, p_vwgt, p_vsize, p_ewgt, ref nparts, IntPtr.Zero, IntPtr.Zero, p_opts, ref objval, p_part); } } catch (Exception) { throw; } finally { InteropHelper.Free(handles); } return((MetisStatus)status); }
/// <summary> /// Computes fill reducing orderings of sparse matrices using the multilevel nested dissection algorithm. /// </summary> /// <param name="perm">Target array storing the fill-reducing permutaion (size nvtxs).</param> /// <param name="iperm">Target array storing the fill-reducing inverse permutaion (size nvtxs).</param> /// <param name="options">Partitioning options.</param> /// <returns></returns> public MetisStatus NestedDissection(int[] perm, int[] iperm, MetisOptions options = null) { if (perm.Length != nvtxs || iperm.Length != nvtxs) { return(MetisStatus.ERROR_INPUT); } var handles = new List <GCHandle>(); // Pin array data. var p_xadj = InteropHelper.Pin(xadj, handles); var p_adjncy = InteropHelper.Pin(adjncy, handles); var p_vwgt = InteropHelper.Pin(vwgt, handles); var p_opts = options == null ? IntPtr.Zero : InteropHelper.Pin(options.raw, handles); var p_perm = InteropHelper.Pin(perm, handles); var p_iperm = InteropHelper.Pin(iperm, handles); int l_nv = nvtxs; int status = 0; try { status = NativeMethods.NodeND(ref l_nv, p_xadj, p_adjncy, p_vwgt, p_opts, p_perm, p_iperm); } catch (Exception) { throw; } finally { InteropHelper.Free(handles); } return((MetisStatus)status); }
/// <summary> /// Creates a new instance of the <see cref="MetisOptions"/> class with default nested dissection ordering options. /// </summary> public static MetisOptions NestedDissectionDefault() { var opt = new MetisOptions(); opt.Coarsening = CoarseningType.SHEM; opt.InitialPartitioning = InitialPartitioningType.NODE; opt.Refinement = RefinementType.SEP2SIDED; opt.UFactor = 200; opt.PFactor = 0; opt.Compress = true; opt.ComponentOrder = false; opt.No2Hop = false; opt.Cuts = 1; opt.Seperators = 1; opt.Iterations = 10; opt.Seed = -1; opt.DebugLevel = DebugLevel.NONE; return(opt); }
/// <summary> /// Partition a graph into k parts using multilevel recursive bisection partitioning. /// </summary> /// <param name="k">The number of partitions.</param> /// <param name="part">Target array storing the partition of the graph (size nvtxs).</param> /// <param name="options">Partitioning options.</param> /// <returns></returns> public MetisStatus PartitionRecursive(int k, int[] part, MetisOptions options = null) { return(Partition(k, part, options, false)); }
/// <summary> /// Partition a graph into k parts using multilevel k-way partitioning. /// </summary> /// <param name="k">The number of partitions.</param> /// <param name="part">Target array storing the partition of the graph (size nvtxs).</param> /// <param name="options">Partitioning options.</param> /// <returns></returns> public MetisStatus PartitionKway(int k, int[] part, MetisOptions options = null) { return(Partition(k, part, options, true)); }
private MetisStatus Partition(int nparts, int[] epart, int[] npart, MetisOptions options, bool dual) { if (ne <= 0) { return(MetisStatus.ERROR_INPUT); } if (epart == null || epart.Length < ne) { return(MetisStatus.ERROR_INPUT); } if (npart == null || npart.Length < nn) { return(MetisStatus.ERROR_INPUT); } int objval = 0; int ncommon = 2; // for triangles float[] tpwgts = GetWeights(nparts, ncon); var handles = new List <GCHandle>(); // Pin array data and get pointers. var p_eptr = InteropHelper.Pin(eptr, handles); var p_eind = InteropHelper.Pin(eind, handles); var p_ewgt = InteropHelper.Pin(ewgt, handles); var p_tpwgts = InteropHelper.Pin(tpwgts, handles); var p_epart = InteropHelper.Pin(epart, handles); var p_npart = InteropHelper.Pin(npart, handles); var p_opts = options == null ? IntPtr.Zero : InteropHelper.Pin(options.raw, handles); int l_ne = ne; int l_nn = nn; int status = 0; try { if (dual) { status = NativeMethods.PartMeshDual(ref l_ne, ref l_nn, p_eptr, p_eind, p_ewgt, IntPtr.Zero, ref ncommon, ref nparts, p_tpwgts, p_opts, ref objval, p_epart, p_npart); } else { status = NativeMethods.PartMeshNodal(ref l_ne, ref l_nn, p_eptr, p_eind, IntPtr.Zero, IntPtr.Zero, ref nparts, p_tpwgts, p_opts, ref objval, p_epart, p_npart); } } catch (Exception) { throw; } finally { InteropHelper.Free(handles); } return((MetisStatus)status); }
/// <summary> /// Partition a mesh into k parts based on a partitioning of the mesh's nodal graph. /// </summary> /// <param name="k">The number of partitions.</param> /// <param name="epart">Target array storing the element partition (size ne).</param> /// <param name="npart">Target array storing the node partition (size nn).</param> /// <param name="options">Partitioning options.</param> /// <returns></returns> public MetisStatus PartitionNodal(int k, int[] epart, int[] npart, MetisOptions options = null) { return(Partition(k, epart, npart, options, false)); }