Index: /issm/trunk-jpl/src/m/array/arrayoperations.js =================================================================== --- /issm/trunk-jpl/src/m/array/arrayoperations.js (revision 22900) +++ /issm/trunk-jpl/src/m/array/arrayoperations.js (revision 22901) @@ -48,48 +48,149 @@ return sum; } //}}} - -function ArrayAdd(array1, array2){ //{{{ - if(array1.length!=array2.length)throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!"); - - //do the subtraction: - var result = array1.slice(); - for(var i = 0; i < array1.length; i++){ - result[i] = array1[i] + array2[i]; - } - return result; - -} //}}} -function ArraySubtract(array1, array2){ //{{{ - if(array1.length!=array2.length)throw Error("ArraySubtract error message: arrays provided as arguments are not of the same length!"); - - //do the subtraction: - var result = array1.slice(); - for(var i = 0; i < array1.length; i++){ - result[i] = array1[i] - array2[i]; - } - return result; - -} //}}} -function ArrayMultiply(array1, array2){ //{{{ - if(array1.length!=array2.length)throw Error("ArrayMultiply error message: arrays provided as arguments are not of the same length!"); - - //do the subtraction: - var result = array1.slice(); - for(var i = 0; i < array1.length; i++){ - result[i] = array1[i] * array2[i]; - } - return result; - +function ArrayAdd(){ //{{{ + //Takes in any number of scalars or arrays, and calculates the sum. Scalars are treated as similar length arrays of the scalar. + //Determine reference array and size + var size, arg; + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array) { + size = arg.length; + break; + } + } + //check internal consistency of arrays provided!: + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array && arg.length != size) { + throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!"); + } else if (!(arg instanceof Array) && typeof arg != 'number') { + throw Error("ArrayAdd error message: arguments provided are not of the type Array or Number!"); + } + } + //do the result: + var result = NewArrayFill(size, 0); + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array) { + for(var i = 0; i < result.length; i++){ + result[i] -= arg[i]; + } + } else if (typeof arg != 'number') { + for(var i = 0; i < result.length; i++){ + result[i] += arg; + } + } + } + return result; +} //}}} +function ArraySubtract(){ //{{{ + //Takes in any number of scalars or arrays, and calculates the subtraction. Scalars are treated as similar length arrays of the scalar. + //Determine reference array and size + var size, array, arg; + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array) { + size = arg.length; + array = arg; + break; + } + } + //check internal consistency of arrays provided!: + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array && arg.length != size) { + throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!"); + } else if (!(arg instanceof Array) && typeof arg != 'number') { + throw Error("ArrayAdd error message: arguments provided are not of the type Array or Number!"); + } + } + //calculate the result, using the first argument to initialize: + var result = array.slice(0); + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array) { + for(var i = 0; i < result.length; i++){ + result[i] -= arg[i]; + } + } else if (typeof arg != 'number') { + for(var i = 0; i < result.length; i++){ + result[i] -= arg; + } + } + } + return result; +} //}}} +function ArrayMultiply(){ //{{{ + //Takes in any number of scalars or arrays, and calculates the product. Scalars are treated as similar length arrays of the scalar. + //Determine reference array and size + var size, arg; + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array) { + size = arg.length; + break; + } + } + //check internal consistency of arrays provided!: + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array && arg.length != size) { + throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!"); + } else if (!(arg instanceof Array) && typeof arg != 'number') { + throw Error("ArrayAdd error message: arguments provided are not of the type Array or Number!"); + } + } + //do the result: + var result = NewArrayFill(size, 0); + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array) { + for(var i = 0; i < result.length; i++){ + result[i] *= arg[i]; + } + } else if (typeof arg != 'number') { + for(var i = 0; i < result.length; i++){ + result[i] *= arg; + } + } + } + return result; } //}}} function ArrayDivide(array1, array2){ //{{{ - if(array1.length!=array2.length)throw Error("ArrayDivide error message: arrays provided as arguments are not of the same length!"); - - //do the subtraction: - var result = array1.slice(); - for(var i = 0; i < array1.length; i++){ - result[i] = array1[i] / array2[i]; - } - return result; - + //Takes in any number of scalars or arrays, and calculates the quotient. Scalars are treated as similar length arrays of the scalar. + //Determine reference array and size + var size, array, arg; + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array) { + size = arg.length; + array = arg; + break; + } + } + //check internal consistency of arrays provided!: + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array && arg.length != size) { + throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!"); + } else if (!(arg instanceof Array) && typeof arg != 'number') { + throw Error("ArrayAdd error message: arguments provided are not of the type Array or Number!"); + } + } + //calculate the result, using the first argument to initialize: + var result = array.slice(0); + for (var a = 0; a < arguments.length; a++) { + arg = arguments[a]; + if (arg instanceof Array) { + for(var i = 0; i < result.length; i++){ + result[i] /= arg[i]; + } + } else if (typeof arg != 'number') { + for(var i = 0; i < result.length; i++){ + result[i] /= arg; + } + } + } + return result; } //}}} function ArrayMean(array){ //{{{ @@ -206,4 +307,24 @@ return c; } //}}} +function ArrayCol(matrix, cols) { //{{{ + var column = []; + if (cols instanceof Array) { + for (var i = 0; i < matrix.length; i++){ + var row = []; + for (var j = cols[0]; j <= cols[1]; j++){ + row.push(matrix[i][j]); + } + column.push(row); + } + + } else if (typeof cols == 'number') { + for (var i = 0; i < matrix.length; i++){ + column.push(matrix[i][cols]); + } + } else { + throw new Error("ArrayCol error: cols must be a single integer or an array with 2 integers!"); + } + return column; +} //}}} function ListToMatrix(list, elementsPerSubArray) { //{{{ var matrix = [], i, k; Index: /issm/trunk-jpl/src/m/classes/bamggeom.js =================================================================== --- /issm/trunk-jpl/src/m/classes/bamggeom.js (revision 22900) +++ /issm/trunk-jpl/src/m/classes/bamggeom.js (revision 22901) @@ -5,7 +5,28 @@ function bamggeom(){ - //methods - this.setdefaultparameters = function(){// {{{ - }// }}} + //methods + this.constructor = function(args) {// {{{ + //BAMGGEOM - constructor for bamggeom object + // + // Usage: + // bamggeom = bamggeom(varargin) + + //initialize list + switch (args.length) { + case 0: + //if no input arguments, create a default object + break; + case 1: + var object = args[0]; + for (var field in object) { + if (object.hasOwnProperty(field)) { + this.field = object.field; + } + } + break; + default: + throw Error('bamggeom constructor error message: unknown type of constructor call'); + } + }// }}} this.disp= function(){// {{{ disp(sprintf('\n%s = \n', 'bamggeom')); @@ -24,5 +45,5 @@ this.SubDomains = []; - this.setdefaultparameters(); + this.constructor(arguments); //}}} } Index: /issm/trunk-jpl/src/m/classes/bamgmesh.js =================================================================== --- /issm/trunk-jpl/src/m/classes/bamgmesh.js (revision 22900) +++ /issm/trunk-jpl/src/m/classes/bamgmesh.js (revision 22901) @@ -5,7 +5,28 @@ function bamgmesh(){ - //methods - this.setdefaultparameters = function(){// {{{ - }// }}} + //methods + this.constructor = function(args) {// {{{ + //BAMGMESH - constructor for bamgmesh object + // + // Usage: + // bamgmesh = bamgmesh(varargin) + + //initialize list + switch (args.length) { + case 0: + //if no input arguments, create a default object + break; + case 1: + var object = args[0]; + for (var field in object) { + if (object.hasOwnProperty(field)) { + this.field = object.field; + } + } + break; + default: + throw Error('bamggeom constructor error message: unknown type of constructor call'); + } + }// }}} this.disp= function(){// {{{ disp(sprintf('\n%s = \n', 'bamgmesh')); @@ -32,5 +53,5 @@ this.PreviousNumbering = []; - this.setdefaultparameters(); + this.constructor(arguments); //}}} } Index: /issm/trunk-jpl/src/m/mesh/bamg.js =================================================================== --- /issm/trunk-jpl/src/m/mesh/bamg.js (revision 22900) +++ /issm/trunk-jpl/src/m/mesh/bamg.js (revision 22901) @@ -237,6 +237,8 @@ } if (options.getfieldvalue('Markers',[]).length == bamg_geometry.Edges.length) { - console.log('BAMG Markers not implemented yet.'); - //bamg_geometry.Edges(:,3)=options.getfieldvalue('Markers'); + var markers = options.getfieldvalue('Markers'); + for (var i = 0; i < markers.length; i++) { + bamg_geometry.Edges[i][2] = markers[i]; + } } /* @@ -399,6 +401,6 @@ //recover RequiredVertices - requiredvertices= options.getfieldvalue('RequiredVertices'); //for some reason, it is of class "single" - if (requiredvertices[0].length==2) { + requiredvertices = options.getfieldvalue('RequiredVertices'); //for some reason, it is of class "single" + if (requiredvertices[0].length == 2) { requiredvertices=[requiredvertices 4.*ones(size(requiredvertices,1),1)]; } @@ -416,16 +418,16 @@ } + */ //Deal with RequiredEdges - if (options.getfieldvalue('NoBoundaryRefinment',0)==1) { - bamg_geometry.RequiredEdges=[1:size(bamg_geometry.Edges,1)]'; + if (options.getfieldvalue('NoBoundaryRefinment', 0) == 1) { + bamg_geometry.RequiredEdges = ArrayTranspose(ArrayRange(1, bamg_geometry.Edges.length)); } //process geom //bamg_geometry=processgeometry(bamg_geometry,options.getfieldvalue('tol',NaN),domain[0]); - */ - - } /*else if ((typeof md.private.bamg === 'object') && ('geometry' in md.private.bamg)) { - bamg_geometry=bamggeom(md.private.bamg.geometry); + + } else if ((typeof md.priv.bamg === 'object') && ('geometry' in md.priv.bamg)) { + bamg_geometry = new bamggeom(md.priv.bamg.geometry); } else { //do nothing... @@ -433,11 +435,15 @@ //}}} // Bamg Mesh parameters {{{ - if (!options.exist('domain') && md.mesh.numberofvertices!=0 && md.mesh.elementtype()=='Tria') { - - if ((typeof md.private.bamg === 'object') && ('mesh' in md.private.bamg)) { - bamg_mesh=bamgmesh(md.private.bamg.mesh); + if (!options.exist('domain') && md.mesh.numberofvertices != 0 && md.mesh.elementtype() == 'Tria') { + + if ((typeof md.priv.bamg === 'object') && ('mesh' in md.priv.bamg)) { + bamg_mesh = new bamgmesh(md.priv.bamg.mesh); } else { - bamg_mesh.Vertices=[md.mesh.x md.mesh.y ones(md.mesh.numberofvertices,1)]; - bamg_mesh.Triangles=[md.mesh.elements ones(md.mesh.numberofelements,1)]; + for (var i = 0; i < md.mesh.numberofvertices; i++) { + bamg_mesh.Vertices.push([md.mesh.x[i], md.mesh.y.y[i], 1]); + } + for (var i = 0; i < md.mesh.numberofelements; i++) { + bamg_mesh.Triangles.push([md.mesh.elements[i][0], md.mesh.elements[i][1], md.mesh.elements[i][2], 1]); + } } @@ -445,5 +451,5 @@ console.log('bamg error message: rifts not supported yet. Do meshprocessrift AFTER bamg'); } - }*/ + } //}}} // Bamg Options {{{ @@ -480,71 +486,84 @@ var bamgmesh_out=return_array[0]; var bamggeom_out=return_array[1]; -// -// if (options.getfieldvalue('vertical',0)) { -// md.mesh=mesh2dvertical(); -// md.mesh.x=bamgmesh_out.Vertices(:,1); -// md.mesh.y=bamgmesh_out.Vertices(:,2); -// md.mesh.elements=bamgmesh_out.Triangles(:,1:3); -// md.mesh.edges=bamgmesh_out.IssmEdges; -// md.mesh.segments=bamgmesh_out.IssmSegments(:,1:3); -// md.mesh.segmentmarkers=bamgmesh_out.IssmSegments(:,4); -// -// //Fill in rest of fields: -// md.mesh.numberofelements=size(md.mesh.elements,1); -// md.mesh.numberofvertices=length(md.mesh.x); -// md.mesh.numberofedges=size(md.mesh.edges,1); -// md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1; -// -// //Now, build the connectivity tables for this mesh. -// md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1; -// -// } else if options.getfieldvalue('3dsurface',0) { -// -// md.mesh=mesh3dsurface(); -// md.mesh.x=bamgmesh_out.Vertices(:,1); -// md.mesh.y=bamgmesh_out.Vertices(:,2); -// md.mesh.z=md.mesh.x; md.mesh.z(:)=0; -// md.mesh.elements=bamgmesh_out.Triangles(:,1:3); -// md.mesh.edges=bamgmesh_out.IssmEdges; -// md.mesh.segments=bamgmesh_out.IssmSegments(:,1:3); -// md.mesh.segmentmarkers=bamgmesh_out.IssmSegments(:,4); -// -// //Fill in rest of fields: -// md.mesh.numberofelements=size(md.mesh.elements,1); -// md.mesh.numberofvertices=length(md.mesh.x); -// md.mesh.numberofedges=size(md.mesh.edges,1); -// md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1; -// -// } else { -// md.mesh=mesh2d(); -// md.mesh.x=bamgmesh_out.Vertices(:,1); -// md.mesh.y=bamgmesh_out.Vertices(:,2); -// md.mesh.elements=bamgmesh_out.Triangles(:,1:3); -// md.mesh.edges=bamgmesh_out.IssmEdges; -// md.mesh.segments=bamgmesh_out.IssmSegments(:,1:3); -// md.mesh.segmentmarkers=bamgmesh_out.IssmSegments(:,4); -// -// //Fill in rest of fields: -// md.mesh.numberofelements=size(md.mesh.elements,1); -// md.mesh.numberofvertices=length(md.mesh.x); -// md.mesh.numberofedges=size(md.mesh.edges,1); -// md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1; -// } -// -// //Bamg private fields -// md.private.bamg=struct(); -// md.private.bamg.mesh=bamgmesh(bamgmesh_out); -// md.private.bamg.geometry=bamggeom(bamggeom_out); -// md.mesh.elementconnectivity=md.private.bamg.mesh.ElementConnectivity; -// md.mesh.elementconnectivity(find(isnan(md.mesh.elementconnectivity)))=0; -// -// //Check for orphan -// if ArrayAny(!ismember(1:md.mesh.numberofvertices,sort(unique(reshape(md.mesh.elements,3*md.mesh.numberofelements,1))))) -// console.log('Output mesh has orphans. Check your Domain and/or RequiredVertices'); -// } -// } -// -// function geom=processgeometry(geom,tol,outline) // {{{ -// + + if (options.getfieldvalue('vertical', 0) != 0) { + md.mesh = new mesh2dvertical(); + md.mesh.x = ArrayCol(bamgmesh_out.Vertices, 0); + md.mesh.y = ArrayCol(bamgmesh_out.Vertices, 1); + md.mesh.elements = ArrayCol(bamgmesh_out.Triangles, [0, 2]); + md.mesh.edges = bamgmesh_out.IssmEdges; + md.mesh.segments = ArrayCol(bamgmesh_out.IssmSegments, [0, 2]); + md.mesh.segmentmarkers = ArrayCol(bamgmesh_out.IssmSegments, 3); + + //Fill in rest of fields: + md.mesh.numberofelements = md.mesh.elements.length; + md.mesh.numberofvertices = md.mesh.x.length; + md.mesh.numberofedges = md.mesh.edges.length; + for (var i = 0; i < md.mesh.segments.length; i++) { + md.mesh.vertexonboundary[md.mesh.segments[i][0]] = 1; + md.mesh.vertexonboundary[md.mesh.segments[i][1]] = 1; + } + } else if (options.getfieldvalue('3dsurface', 0) != 0) { + md.mesh = new mesh3dsurface(); + md.mesh.x = ArrayCol(bamgmesh_out.Vertices, 0); + md.mesh.y = ArrayCol(bamgmesh_out.Vertices, 1); + md.mesh.z = NewArrayFill(md.mesh.x.length, 0); + md.mesh.elements = ArrayCol(bamgmesh_out.Triangles, [0, 2]); + md.mesh.edges = bamgmesh_out.IssmEdges; + md.mesh.segments = ArrayCol(bamgmesh_out.IssmSegments, [0, 2]); + md.mesh.segmentmarkers = ArrayCol(bamgmesh_out.IssmSegments, 3); + + //Fill in rest of fields: + md.mesh.numberofelements = md.mesh.elements.length; + md.mesh.numberofvertices = md.mesh.x.length; + md.mesh.numberofedges = md.mesh.edges.length; + for (var i = 0; i < md.mesh.segments.length; i++) { + md.mesh.vertexonboundary[md.mesh.segments[i][0]] = 1; + md.mesh.vertexonboundary[md.mesh.segments[i][1]] = 1; + } + } else { + md.mesh = new mesh2d(); + md.mesh.x = ArrayCol(bamgmesh_out.Vertices, 0); + md.mesh.y = ArrayCol(bamgmesh_out.Vertices, 1); + md.mesh.elements = ArrayCol(bamgmesh_out.Triangles, [0, 2]); + md.mesh.edges = bamgmesh_out.IssmEdges; + md.mesh.segments = ArrayCol(bamgmesh_out.IssmSegments, [0, 2]); + md.mesh.segmentmarkers = ArrayCol(bamgmesh_out.IssmSegments, 3); + + //Fill in rest of fields: + md.mesh.numberofelements = md.mesh.elements.length; + md.mesh.numberofvertices = md.mesh.x.length; + md.mesh.numberofedges = md.mesh.edges.length; + md.mesh.vertexonboundary = NewArrayFill(md.mesh.numberofvertices, 0); + for (var i = 0; i < md.mesh.segments.length; i++) { + md.mesh.vertexonboundary[md.mesh.segments[i][0]] = 1; + md.mesh.vertexonboundary[md.mesh.segments[i][1]] = 1; + } + } + + //Bamg private fields + md.priv.bamg = []; + md.priv.bamg.mesh = new bamgmesh(bamgmesh_out); + md.priv.bamg.geometry = new bamggeom(bamggeom_out); + md.mesh.elementconnectivity = md.priv.bamg.mesh.ElementConnectivity; + for (var i = 0; i < md.mesh.elementconnectivity.length; i++) { + if (isNaN(md.mesh.elementconnectivity[i])) { + md.mesh.elementconnectivity[i] = 0; + } + } + + //Check for orphan + for (var i = 0; i < md.mesh.numberofelements; i++) { + for (var j = 0; j < 3; j++) { + if (md.mesh.elements[i][j] > md.mesh.numberofvertices) { + console.log('Output mesh has orphans. Check your Domain and/or RequiredVertices'); + break; + } + } + } +} + +function processgeometry(geom,tol,outline){ // {{{ + // //Deal with edges // disp('Checking Edge crossing...'); Index: /issm/trunk-jpl/src/wrappers/BamgMesher/BamgMesher.js =================================================================== --- /issm/trunk-jpl/src/wrappers/BamgMesher/BamgMesher.js (revision 22900) +++ /issm/trunk-jpl/src/wrappers/BamgMesher/BamgMesher.js (revision 22901) @@ -23,4 +23,18 @@ var ptr = Module.getValue(pptr,'i32'); return Module.HEAPU32.slice(ptr / 4, ptr / 4 + nods); +} +function size2d(array) { + // If array = Array(0), size2d(array) == [0, 1] + // If array = [1, 2, 3] size2d(array) == [3, 1] + // If array = [[1, 2, 3], [2, 3, 4]], size2d(array) == [2, 3] + var size0 = array.length; + var size1 = 1; + if (array[0] instanceof Array) { + size1 = array[0].length; + } + //if (array[0] != undefined && array[0].length != undefined) { + // size1 = array[0].length; + //} + return [size0, size1]; } function BamgMesher(bamgmesh_in, bamggeom_in, bamgopts) { @@ -41,34 +55,34 @@ //For each property, calculate the size and fill with 0 if the 2nd dimension is undefined, then use the int size array to init the double array. //input - var pVerticesSize_mesh_in = intsToHeap([bamgmesh_in.Vertices.length, bamgmesh_in.Vertices[0] != undefined ? bamgmesh_in.Vertices[0].length : 1]); + var pVerticesSize_mesh_in = intsToHeap(size2d(bamgmesh_in.Vertices)); var pVertices_mesh_in = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.Vertices)); - var pEdgesSize_mesh_in = intsToHeap([bamgmesh_in.Edges.length, bamgmesh_in.Edges[0] != undefined ? bamgmesh_in.Edges[0].length : 1]); + var pEdgesSize_mesh_in = intsToHeap(size2d(bamgmesh_in.Edges)); var pEdges_mesh_in = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.Edges)); - var pTrianglesSize_mesh_in = intsToHeap([bamgmesh_in.Triangles.length, bamgmesh_in.Triangles[0] != undefined ? bamgmesh_in.Triangles[0].length : 1]); + var pTrianglesSize_mesh_in = intsToHeap(size2d(bamgmesh_in.Triangles)); var pTriangles_mesh_in = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.Triangles)); - var pCrackedEdgesSize_mesh_in = intsToHeap([bamgmesh_in.CrackedEdges.length, bamgmesh_in.CrackedEdges[0] != undefined ? bamgmesh_in.CrackedEdges[0].length : 1]); + var pCrackedEdgesSize_mesh_in = intsToHeap(size2d(bamgmesh_in.CrackedEdges)); var pCrackedEdges_mesh_in = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.CrackedEdges)); - var pVerticesOnGeomEdgeSize_mesh_in = intsToHeap([bamgmesh_in.VerticesOnGeomEdge.length, bamgmesh_in.VerticesOnGeomEdge[0] != undefined ? bamgmesh_in.VerticesOnGeomEdge[0].length : 1]); + var pVerticesOnGeomEdgeSize_mesh_in = intsToHeap(size2d(bamgmesh_in.VerticesOnGeomEdge)); var pVerticesOnGeomEdge_mesh_in = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.VerticesOnGeomEdge)); - var pVerticesOnGeomVertexSize_mesh_in = intsToHeap([bamgmesh_in.VerticesOnGeomVertex.length, bamgmesh_in.VerticesOnGeomVertex[0] != undefined ? bamgmesh_in.VerticesOnGeomVertex[0].length : 1]); + var pVerticesOnGeomVertexSize_mesh_in = intsToHeap(size2d(bamgmesh_in.VerticesOnGeomVertex)); var pVerticesOnGeomVertex_mesh_in = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.VerticesOnGeomVertex)); - var pEdgesOnGeomEdgeSize_mesh_in = intsToHeap([bamgmesh_in.EdgesOnGeomEdge.length, bamgmesh_in.EdgesOnGeomEdge[0] != undefined ? bamgmesh_in.EdgesOnGeomEdge[0].length : 1]); + var pEdgesOnGeomEdgeSize_mesh_in = intsToHeap(size2d(bamgmesh_in.EdgesOnGeomEdge)); var pEdgesOnGeomEdge_mesh_in = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.EdgesOnGeomEdge)); - var pIssmSegmentsSize_mesh_in = intsToHeap([bamgmesh_in.IssmSegments.length, bamgmesh_in.IssmSegments[0] != undefined ? bamgmesh_in.IssmSegments[0].length : 1]); + var pIssmSegmentsSize_mesh_in = intsToHeap(size2d(bamgmesh_in.IssmSegments)); var pIssmSegments_mesh_in = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.IssmSegments)); - var pVerticesSize_geom_in = intsToHeap([bamggeom_in.Vertices.length, bamggeom_in.Vertices[0] != undefined ? bamggeom_in.Vertices[0].length : 1]); + var pVerticesSize_geom_in = intsToHeap(size2d(bamggeom_in.Vertices)); var pVertices_geom_in = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.Vertices)); - var pEdgesSize_geom_in = intsToHeap([bamggeom_in.Edges.length, bamggeom_in.Edges[0] != undefined ? bamggeom_in.Edges[0].length : 1]); + var pEdgesSize_geom_in = intsToHeap(size2d(bamggeom_in.Edges)); var pEdges_geom_in = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.Edges)); - var pCornersSize_geom_in = intsToHeap([bamggeom_in.Corners.length, bamggeom_in.Corners[0] != undefined ? bamggeom_in.Corners[0].length : 1]); + var pCornersSize_geom_in = intsToHeap(size2d(bamggeom_in.Corners)); var pCorners_geom_in = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.Corners)); - var pRequiredVerticesSize_geom_in = intsToHeap([bamggeom_in.RequiredVertices.length, bamggeom_in.RequiredVertices[0] != undefined ? bamggeom_in.RequiredVertices[0].length : 1]); + var pRequiredVerticesSize_geom_in = intsToHeap(size2d(bamggeom_in.RequiredVertices)); var pRequiredVertices_geom_in = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.RequiredVertices)); - var pRequiredEdgesSize_geom_in = intsToHeap([bamggeom_in.RequiredEdges.length, bamggeom_in.RequiredEdges[0] != undefined ? bamggeom_in.RequiredEdges[0].length : 1]); + var pRequiredEdgesSize_geom_in = intsToHeap(size2d(bamggeom_in.RequiredEdges)); var pRequiredEdges_geom_in = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.RequiredEdges)); - var pCrackedEdgesSize_geom_in = intsToHeap([bamggeom_in.CrackedEdges.length, bamggeom_in.CrackedEdges[0] != undefined ? bamggeom_in.CrackedEdges[0].length : 1]); + var pCrackedEdgesSize_geom_in = intsToHeap(size2d(bamggeom_in.CrackedEdges)); var pCrackedEdges_geom_in = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.CrackedEdges)); - var pSubDomainsSize_geom_in = intsToHeap([bamggeom_in.SubDomains.length, bamggeom_in.SubDomains[0] != undefined ? bamggeom_in.SubDomains[0].length : 1]); + var pSubDomainsSize_geom_in = intsToHeap(size2d(bamggeom_in.SubDomains)); var pSubDomains_geom_in = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.SubDomains)); @@ -92,15 +106,15 @@ var hmin = bamgopts.hmin; var hmax = bamgopts.hmax; - var phminVerticesSize = intsToHeap([bamgopts.hminVertices.length, bamgopts.hminVertices[0] != undefined ? bamgopts.hminVertices[0].length : 1]); + var phminVerticesSize = intsToHeap(size2d(bamgopts.hminVertices)); var phminVertices = doublesToHeap(Array.prototype.concat.apply([], bamgopts.hminVertices)); - var phmaxVerticesSize = intsToHeap([bamgopts.hmaxVertices.length, bamgopts.hmaxVertices[0] != undefined ? bamgopts.hmaxVertices[0].length : 1]); + var phmaxVerticesSize = intsToHeap(size2d(bamgopts.hmaxVertices)); var phmaxVertices = doublesToHeap(Array.prototype.concat.apply([], bamgopts.hmaxVertices)); - var phVerticesSize = intsToHeap([bamgopts.hVertices.length, bamgopts.hVertices[0] != undefined ? bamgopts.hVertices[0].length : 1]); + var phVerticesSize = intsToHeap(size2d(bamgopts.hVertices)); var phVertices = doublesToHeap(Array.prototype.concat.apply([], bamgopts.hVertices)); - var pmetricSize = intsToHeap([bamgopts.metric.length, bamgopts.metric[0] != undefined ? bamgopts.metric[0].length : 1]); + var pmetricSize = intsToHeap(size2d(bamgopts.metric)); var pmetric = doublesToHeap(Array.prototype.concat.apply([], bamgopts.metric)); - var pfieldSize = intsToHeap([bamgopts.field.length, bamgopts.field[0] != undefined ? bamgopts.field[0].length : 1]); + var pfieldSize = intsToHeap(size2d(bamgopts.field)); var pfield = doublesToHeap(Array.prototype.concat.apply([], bamgopts.field)); - var perrSize = intsToHeap([bamgopts.err.length, bamgopts.err[0] != undefined ? bamgopts.err[0].length : 1]); + var perrSize = intsToHeap(size2d(bamgopts.err)); var perr = doublesToHeap(Array.prototype.concat.apply([], bamgopts.err));