Changeset 22901


Ignore:
Timestamp:
07/04/18 22:41:56 (7 years ago)
Author:
dlcheng
Message:

CHG (JS): Finalizing BAMG JS Integration. Adding additional js implementations of Matlab functionality (elementwise arithmetic, col indexing).

Location:
issm/trunk-jpl/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/m/array/arrayoperations.js

    r22896 r22901  
    4848        return sum;
    4949} //}}}
    50 
    51 function ArrayAdd(array1, array2){ //{{{
    52     if(array1.length!=array2.length)throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!");
    53 
    54     //do the subtraction:
    55     var result = array1.slice();
    56     for(var i = 0; i < array1.length; i++){
    57         result[i] = array1[i] + array2[i];
    58     }
    59     return result;
    60 
    61 } //}}}
    62 function ArraySubtract(array1, array2){ //{{{
    63     if(array1.length!=array2.length)throw Error("ArraySubtract error message: arrays provided as arguments are not of the same length!");
    64 
    65     //do the subtraction:
    66     var result = array1.slice();
    67     for(var i = 0; i < array1.length; i++){
    68         result[i] = array1[i] - array2[i];
    69     }
    70     return result;
    71 
    72 } //}}}
    73 function ArrayMultiply(array1, array2){ //{{{
    74     if(array1.length!=array2.length)throw Error("ArrayMultiply error message: arrays provided as arguments are not of the same length!");
    75 
    76     //do the subtraction:
    77     var result = array1.slice();
    78     for(var i = 0; i < array1.length; i++){
    79         result[i] = array1[i] * array2[i];
    80     }
    81     return result;
    82 
     50function ArrayAdd(){ //{{{
     51    //Takes in any number of scalars or arrays, and calculates the sum. Scalars are treated as similar length arrays of the scalar.
     52    //Determine reference array and size
     53    var size, arg;
     54        for (var a = 0; a < arguments.length; a++) {
     55        arg = arguments[a];
     56        if (arg instanceof Array) {
     57            size = arg.length;
     58            break;
     59        }
     60    }
     61        //check internal consistency of arrays provided!:
     62        for (var a = 0; a < arguments.length; a++) {
     63        arg = arguments[a];
     64        if (arg instanceof Array && arg.length != size) {
     65            throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!");
     66        } else if (!(arg instanceof Array) && typeof arg != 'number') {
     67            throw Error("ArrayAdd error message: arguments provided are not of the type Array or Number!");
     68        }
     69        }
     70        //do the result:
     71        var result = NewArrayFill(size, 0);
     72        for (var a = 0; a < arguments.length; a++) {
     73                arg = arguments[a];
     74        if (arg instanceof Array) {
     75            for(var i = 0; i < result.length; i++){
     76                result[i] -= arg[i];
     77            }
     78        } else if (typeof arg != 'number') {
     79            for(var i = 0; i < result.length; i++){
     80                result[i] += arg;
     81            }
     82        }
     83        }
     84        return result;
     85} //}}}
     86function ArraySubtract(){ //{{{
     87    //Takes in any number of scalars or arrays, and calculates the subtraction. Scalars are treated as similar length arrays of the scalar.
     88    //Determine reference array and size
     89    var size, array, arg;
     90        for (var a = 0; a < arguments.length; a++) {
     91        arg = arguments[a];
     92        if (arg instanceof Array) {
     93            size = arg.length;
     94            array = arg;
     95            break;
     96        }
     97    }
     98        //check internal consistency of arrays provided!:
     99        for (var a = 0; a < arguments.length; a++) {
     100        arg = arguments[a];
     101        if (arg instanceof Array && arg.length != size) {
     102            throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!");
     103        } else if (!(arg instanceof Array) && typeof arg != 'number') {
     104            throw Error("ArrayAdd error message: arguments provided are not of the type Array or Number!");
     105        }
     106        }
     107        //calculate the result, using the first argument to initialize:
     108        var result = array.slice(0);
     109        for (var a = 0; a < arguments.length; a++) {
     110                arg = arguments[a];
     111        if (arg instanceof Array) {
     112            for(var i = 0; i < result.length; i++){
     113                result[i] -= arg[i];
     114            }
     115        } else if (typeof arg != 'number') {
     116            for(var i = 0; i < result.length; i++){
     117                result[i] -= arg;
     118            }
     119        }
     120        }
     121        return result;
     122} //}}}
     123function ArrayMultiply(){ //{{{
     124    //Takes in any number of scalars or arrays, and calculates the product. Scalars are treated as similar length arrays of the scalar.
     125    //Determine reference array and size
     126    var size, arg;
     127        for (var a = 0; a < arguments.length; a++) {
     128        arg = arguments[a];
     129        if (arg instanceof Array) {
     130            size = arg.length;
     131            break;
     132        }
     133    }
     134        //check internal consistency of arrays provided!:
     135        for (var a = 0; a < arguments.length; a++) {
     136        arg = arguments[a];
     137        if (arg instanceof Array && arg.length != size) {
     138            throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!");
     139        } else if (!(arg instanceof Array) && typeof arg != 'number') {
     140            throw Error("ArrayAdd error message: arguments provided are not of the type Array or Number!");
     141        }
     142        }
     143        //do the result:
     144        var result = NewArrayFill(size, 0);
     145        for (var a = 0; a < arguments.length; a++) {
     146                arg = arguments[a];
     147        if (arg instanceof Array) {
     148            for(var i = 0; i < result.length; i++){
     149                result[i] *= arg[i];
     150            }
     151        } else if (typeof arg != 'number') {
     152            for(var i = 0; i < result.length; i++){
     153                result[i] *= arg;
     154            }
     155        }
     156        }
     157        return result;
    83158} //}}}
    84159function ArrayDivide(array1, array2){ //{{{
    85     if(array1.length!=array2.length)throw Error("ArrayDivide error message: arrays provided as arguments are not of the same length!");
    86 
    87     //do the subtraction:
    88     var result = array1.slice();
    89     for(var i = 0; i < array1.length; i++){
    90         result[i] = array1[i] / array2[i];
    91     }
    92     return result;
    93 
     160    //Takes in any number of scalars or arrays, and calculates the quotient. Scalars are treated as similar length arrays of the scalar.
     161    //Determine reference array and size
     162    var size, array, arg;
     163        for (var a = 0; a < arguments.length; a++) {
     164        arg = arguments[a];
     165        if (arg instanceof Array) {
     166            size = arg.length;
     167            array = arg;
     168            break;
     169        }
     170    }
     171        //check internal consistency of arrays provided!:
     172        for (var a = 0; a < arguments.length; a++) {
     173        arg = arguments[a];
     174        if (arg instanceof Array && arg.length != size) {
     175            throw Error("ArrayAdd error message: arrays provided as arguments are not of the same length!");
     176        } else if (!(arg instanceof Array) && typeof arg != 'number') {
     177            throw Error("ArrayAdd error message: arguments provided are not of the type Array or Number!");
     178        }
     179        }
     180        //calculate the result, using the first argument to initialize:
     181        var result = array.slice(0);
     182        for (var a = 0; a < arguments.length; a++) {
     183                arg = arguments[a];
     184        if (arg instanceof Array) {
     185            for(var i = 0; i < result.length; i++){
     186                result[i] /= arg[i];
     187            }
     188        } else if (typeof arg != 'number') {
     189            for(var i = 0; i < result.length; i++){
     190                result[i] /= arg;
     191            }
     192        }
     193        }
     194        return result;
    94195} //}}}
    95196function ArrayMean(array){ //{{{
    … …  
    206307        return c;
    207308} //}}}
     309function ArrayCol(matrix, cols) { //{{{
     310    var column = [];
     311    if (cols instanceof Array) {
     312        for (var i = 0; i < matrix.length; i++){
     313            var row = [];
     314            for (var j = cols[0]; j <= cols[1]; j++){
     315                row.push(matrix[i][j]);
     316            }
     317            column.push(row);
     318        }
     319
     320    } else if (typeof cols == 'number') {
     321        for (var i = 0; i < matrix.length; i++){
     322            column.push(matrix[i][cols]);
     323        }
     324    } else {
     325        throw new Error("ArrayCol error: cols must be a single integer or an array with 2 integers!");
     326    }
     327   return column;
     328} //}}}
    208329function ListToMatrix(list, elementsPerSubArray) { //{{{
    209330        var matrix = [], i, k;

  • issm/trunk-jpl/src/m/classes/bamggeom.js

    r22877 r22901  
    55
    66function bamggeom(){
    7     //methods
    8     this.setdefaultparameters = function(){// {{{
    9     }// }}}
     7        //methods
     8        this.constructor = function(args) {// {{{
     9                //BAMGGEOM - constructor for bamggeom object
     10                //
     11                //   Usage:
     12                //      bamggeom = bamggeom(varargin)
     13
     14                //initialize list
     15        switch (args.length) {
     16            case 0:
     17                                //if no input arguments, create a default object
     18                break;
     19            case 1:
     20                var object = args[0];
     21                for (var field in object) {
     22                    if (object.hasOwnProperty(field)) {
     23                        this.field = object.field;
     24                    }
     25                }
     26                break;
     27            default:
     28                                throw Error('bamggeom constructor error message: unknown type of constructor call');
     29        }
     30        }// }}}
    1031    this.disp= function(){// {{{
    1132        disp(sprintf('\n%s = \n', 'bamggeom'));
    … …  
    2445    this.SubDomains         = [];
    2546
    26     this.setdefaultparameters();
     47        this.constructor(arguments);
    2748    //}}}
    2849}

  • issm/trunk-jpl/src/m/classes/bamgmesh.js

    r22877 r22901  
    55
    66function bamgmesh(){
    7     //methods
    8     this.setdefaultparameters = function(){// {{{
    9     }// }}}
     7        //methods
     8        this.constructor = function(args) {// {{{
     9                //BAMGMESH - constructor for bamgmesh object
     10                //
     11                //   Usage:
     12                //      bamgmesh = bamgmesh(varargin)
     13
     14                //initialize list
     15        switch (args.length) {
     16            case 0:
     17                                //if no input arguments, create a default object
     18                break;
     19            case 1:
     20                var object = args[0];
     21                for (var field in object) {
     22                    if (object.hasOwnProperty(field)) {
     23                        this.field = object.field;
     24                    }
     25                }
     26                break;
     27            default:
     28                                throw Error('bamggeom constructor error message: unknown type of constructor call');
     29        }
     30        }// }}}
    1031    this.disp= function(){// {{{
    1132        disp(sprintf('\n%s = \n', 'bamgmesh'));
    … …  
    3253    this.PreviousNumbering          = [];
    3354
    34     this.setdefaultparameters();
     55        this.constructor(arguments);
    3556    //}}}
    3657}

  • issm/trunk-jpl/src/m/mesh/bamg.js

    r22896 r22901  
    237237        }
    238238        if (options.getfieldvalue('Markers',[]).length == bamg_geometry.Edges.length) {
    239                 console.log('BAMG Markers not implemented yet.');
    240             //bamg_geometry.Edges(:,3)=options.getfieldvalue('Markers');
     239            var markers = options.getfieldvalue('Markers');
     240            for (var i = 0; i < markers.length; i++) {
     241                bamg_geometry.Edges[i][2] = markers[i];
     242            }
    241243        }
    242244        /*
    … …  
    399401
    400402            //recover RequiredVertices
    401             requiredvertices= options.getfieldvalue('RequiredVertices'); //for some reason, it is of class "single"
    402             if (requiredvertices[0].length==2) {
     403            requiredvertices = options.getfieldvalue('RequiredVertices'); //for some reason, it is of class "single"
     404            if (requiredvertices[0].length == 2) {
    403405                 requiredvertices=[requiredvertices 4.*ones(size(requiredvertices,1),1)];
    404406            }   
    … …  
    416418
    417419        }
     420        */
    418421
    419422        //Deal with RequiredEdges
    420         if (options.getfieldvalue('NoBoundaryRefinment',0)==1) {
    421             bamg_geometry.RequiredEdges=[1:size(bamg_geometry.Edges,1)]';
     423        if (options.getfieldvalue('NoBoundaryRefinment', 0) == 1) {
     424            bamg_geometry.RequiredEdges = ArrayTranspose(ArrayRange(1, bamg_geometry.Edges.length));
    422425        }
    423426
    424427        //process geom
    425428        //bamg_geometry=processgeometry(bamg_geometry,options.getfieldvalue('tol',NaN),domain[0]);
    426         */
    427 
    428     } /*else if ((typeof md.private.bamg === 'object') && ('geometry' in md.private.bamg)) {
    429         bamg_geometry=bamggeom(md.private.bamg.geometry);
     429
     430    } else if ((typeof md.priv.bamg === 'object') && ('geometry' in md.priv.bamg)) {
     431        bamg_geometry = new bamggeom(md.priv.bamg.geometry);
    430432    } else {
    431433        //do nothing...
    … …  
    433435    //}}}
    434436    // Bamg Mesh parameters {{{
    435     if (!options.exist('domain') && md.mesh.numberofvertices!=0 && md.mesh.elementtype()=='Tria') {
    436 
    437         if ((typeof md.private.bamg === 'object') && ('mesh' in md.private.bamg)) {
    438             bamg_mesh=bamgmesh(md.private.bamg.mesh);
     437    if (!options.exist('domain') && md.mesh.numberofvertices != 0 && md.mesh.elementtype() == 'Tria') {
     438
     439        if ((typeof md.priv.bamg === 'object') && ('mesh' in md.priv.bamg)) {
     440            bamg_mesh = new bamgmesh(md.priv.bamg.mesh);
    439441        } else {
    440             bamg_mesh.Vertices=[md.mesh.x md.mesh.y ones(md.mesh.numberofvertices,1)];
    441             bamg_mesh.Triangles=[md.mesh.elements ones(md.mesh.numberofelements,1)];
     442            for (var i = 0; i < md.mesh.numberofvertices; i++) {
     443                bamg_mesh.Vertices.push([md.mesh.x[i], md.mesh.y.y[i], 1]);
     444            }
     445            for (var i = 0; i < md.mesh.numberofelements; i++) {
     446                bamg_mesh.Triangles.push([md.mesh.elements[i][0], md.mesh.elements[i][1], md.mesh.elements[i][2], 1]);
     447            }
    442448        }
    443449
    … …  
    445451            console.log('bamg error message: rifts not supported yet. Do meshprocessrift AFTER bamg');
    446452        }
    447     }*/
     453    }
    448454    //}}}
    449455    // Bamg Options {{{
    … …  
    480486    var bamgmesh_out=return_array[0];
    481487    var bamggeom_out=return_array[1];
    482 //
    483 //    if (options.getfieldvalue('vertical',0)) {
    484 //        md.mesh=mesh2dvertical();
    485 //        md.mesh.x=bamgmesh_out.Vertices(:,1);
    486 //        md.mesh.y=bamgmesh_out.Vertices(:,2);
    487 //        md.mesh.elements=bamgmesh_out.Triangles(:,1:3);
    488 //        md.mesh.edges=bamgmesh_out.IssmEdges;
    489 //        md.mesh.segments=bamgmesh_out.IssmSegments(:,1:3);
    490 //        md.mesh.segmentmarkers=bamgmesh_out.IssmSegments(:,4);
    491 //
    492 //        //Fill in rest of fields:
    493 //        md.mesh.numberofelements=size(md.mesh.elements,1);
    494 //        md.mesh.numberofvertices=length(md.mesh.x);
    495 //        md.mesh.numberofedges=size(md.mesh.edges,1);
    496 //        md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    497 //
    498 //        //Now, build the connectivity tables for this mesh.
    499 //        md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    500 //
    501 //    } else if options.getfieldvalue('3dsurface',0) {
    502 //       
    503 //        md.mesh=mesh3dsurface();
    504 //        md.mesh.x=bamgmesh_out.Vertices(:,1);
    505 //        md.mesh.y=bamgmesh_out.Vertices(:,2);
    506 //        md.mesh.z=md.mesh.x; md.mesh.z(:)=0;
    507 //        md.mesh.elements=bamgmesh_out.Triangles(:,1:3);
    508 //        md.mesh.edges=bamgmesh_out.IssmEdges;
    509 //        md.mesh.segments=bamgmesh_out.IssmSegments(:,1:3);
    510 //        md.mesh.segmentmarkers=bamgmesh_out.IssmSegments(:,4);
    511 //
    512 //        //Fill in rest of fields:
    513 //        md.mesh.numberofelements=size(md.mesh.elements,1);
    514 //        md.mesh.numberofvertices=length(md.mesh.x);
    515 //        md.mesh.numberofedges=size(md.mesh.edges,1);
    516 //        md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    517 //
    518 //    } else {
    519 //        md.mesh=mesh2d();
    520 //        md.mesh.x=bamgmesh_out.Vertices(:,1);
    521 //        md.mesh.y=bamgmesh_out.Vertices(:,2);
    522 //        md.mesh.elements=bamgmesh_out.Triangles(:,1:3);
    523 //        md.mesh.edges=bamgmesh_out.IssmEdges;
    524 //        md.mesh.segments=bamgmesh_out.IssmSegments(:,1:3);
    525 //        md.mesh.segmentmarkers=bamgmesh_out.IssmSegments(:,4);
    526 //
    527 //        //Fill in rest of fields:
    528 //        md.mesh.numberofelements=size(md.mesh.elements,1);
    529 //        md.mesh.numberofvertices=length(md.mesh.x);
    530 //        md.mesh.numberofedges=size(md.mesh.edges,1);
    531 //        md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    532 //    }
    533 //
    534 //    //Bamg private fields
    535 //    md.private.bamg=struct();
    536 //    md.private.bamg.mesh=bamgmesh(bamgmesh_out);
    537 //    md.private.bamg.geometry=bamggeom(bamggeom_out);
    538 //    md.mesh.elementconnectivity=md.private.bamg.mesh.ElementConnectivity;
    539 //    md.mesh.elementconnectivity(find(isnan(md.mesh.elementconnectivity)))=0;
    540 //
    541 //    //Check for orphan
    542 //    if ArrayAny(!ismember(1:md.mesh.numberofvertices,sort(unique(reshape(md.mesh.elements,3*md.mesh.numberofelements,1)))))
    543 //        console.log('Output mesh has orphans. Check your Domain and/or RequiredVertices');
    544 //    }
    545 //    }
    546 //
    547 //    function geom=processgeometry(geom,tol,outline) // {{{
    548 //
     488
     489    if (options.getfieldvalue('vertical', 0) != 0) {
     490        md.mesh                     = new mesh2dvertical();
     491        md.mesh.x                   = ArrayCol(bamgmesh_out.Vertices, 0);
     492        md.mesh.y                   = ArrayCol(bamgmesh_out.Vertices, 1);
     493        md.mesh.elements            = ArrayCol(bamgmesh_out.Triangles, [0, 2]);
     494        md.mesh.edges               = bamgmesh_out.IssmEdges;
     495        md.mesh.segments            = ArrayCol(bamgmesh_out.IssmSegments, [0, 2]);
     496        md.mesh.segmentmarkers      = ArrayCol(bamgmesh_out.IssmSegments, 3);
     497
     498        //Fill in rest of fields:
     499        md.mesh.numberofelements    = md.mesh.elements.length;
     500        md.mesh.numberofvertices    = md.mesh.x.length;
     501        md.mesh.numberofedges       = md.mesh.edges.length;
     502        for (var i = 0; i < md.mesh.segments.length; i++) {
     503            md.mesh.vertexonboundary[md.mesh.segments[i][0]] = 1;
     504            md.mesh.vertexonboundary[md.mesh.segments[i][1]] = 1;
     505        }
     506    } else if (options.getfieldvalue('3dsurface', 0) != 0) {
     507        md.mesh                     = new mesh3dsurface();
     508        md.mesh.x                   = ArrayCol(bamgmesh_out.Vertices, 0);
     509        md.mesh.y                   = ArrayCol(bamgmesh_out.Vertices, 1);
     510        md.mesh.z                   = NewArrayFill(md.mesh.x.length, 0);
     511        md.mesh.elements            = ArrayCol(bamgmesh_out.Triangles, [0, 2]);
     512        md.mesh.edges               = bamgmesh_out.IssmEdges;
     513        md.mesh.segments            = ArrayCol(bamgmesh_out.IssmSegments, [0, 2]);
     514        md.mesh.segmentmarkers      = ArrayCol(bamgmesh_out.IssmSegments, 3);
     515
     516        //Fill in rest of fields:
     517        md.mesh.numberofelements    = md.mesh.elements.length;
     518        md.mesh.numberofvertices    = md.mesh.x.length;
     519        md.mesh.numberofedges       = md.mesh.edges.length;
     520        for (var i = 0; i < md.mesh.segments.length; i++) {
     521            md.mesh.vertexonboundary[md.mesh.segments[i][0]] = 1;
     522            md.mesh.vertexonboundary[md.mesh.segments[i][1]] = 1;
     523        }
     524    } else {
     525        md.mesh                     = new mesh2d();
     526        md.mesh.x                   = ArrayCol(bamgmesh_out.Vertices, 0);
     527        md.mesh.y                   = ArrayCol(bamgmesh_out.Vertices, 1);
     528        md.mesh.elements            = ArrayCol(bamgmesh_out.Triangles, [0, 2]);
     529        md.mesh.edges               = bamgmesh_out.IssmEdges;
     530        md.mesh.segments            = ArrayCol(bamgmesh_out.IssmSegments, [0, 2]);
     531        md.mesh.segmentmarkers      = ArrayCol(bamgmesh_out.IssmSegments, 3);
     532
     533        //Fill in rest of fields:
     534        md.mesh.numberofelements    = md.mesh.elements.length;
     535        md.mesh.numberofvertices    = md.mesh.x.length;
     536        md.mesh.numberofedges       = md.mesh.edges.length;
     537        md.mesh.vertexonboundary    = NewArrayFill(md.mesh.numberofvertices, 0);
     538        for (var i = 0; i < md.mesh.segments.length; i++) {
     539            md.mesh.vertexonboundary[md.mesh.segments[i][0]] = 1;
     540            md.mesh.vertexonboundary[md.mesh.segments[i][1]] = 1;
     541        }
     542    }
     543
     544    //Bamg private fields
     545    md.priv.bamg                 = [];
     546    md.priv.bamg.mesh            = new bamgmesh(bamgmesh_out);
     547    md.priv.bamg.geometry        = new bamggeom(bamggeom_out);
     548    md.mesh.elementconnectivity  = md.priv.bamg.mesh.ElementConnectivity;
     549    for (var i = 0; i < md.mesh.elementconnectivity.length; i++) {
     550        if (isNaN(md.mesh.elementconnectivity[i])) {
     551            md.mesh.elementconnectivity[i] = 0;
     552        }
     553    }
     554
     555    //Check for orphan
     556    for (var i = 0; i < md.mesh.numberofelements; i++) {
     557        for (var j = 0; j < 3; j++) {
     558            if (md.mesh.elements[i][j] > md.mesh.numberofvertices) {
     559                console.log('Output mesh has orphans. Check your Domain and/or RequiredVertices');
     560                break;
     561            }
     562        }
     563    }
     564}
     565
     566function processgeometry(geom,tol,outline){ // {{{
     567
    549568//    //Deal with edges
    550569//    disp('Checking Edge crossing...');

  • issm/trunk-jpl/src/wrappers/BamgMesher/BamgMesher.js

    r22896 r22901  
    2323        var ptr = Module.getValue(pptr,'i32');
    2424        return Module.HEAPU32.slice(ptr / 4, ptr / 4 + nods);
     25}
     26function size2d(array) {
     27    // If array = Array(0), size2d(array) == [0, 1]
     28    // If array = [1, 2, 3] size2d(array) == [3, 1]
     29    // If array = [[1, 2, 3], [2, 3, 4]], size2d(array) == [2, 3]
     30    var size0 = array.length;
     31    var size1 = 1;
     32    if (array[0] instanceof Array) {
     33        size1 = array[0].length;
     34    }
     35    //if (array[0] != undefined && array[0].length != undefined) {
     36    //    size1 = array[0].length;
     37    //}
     38    return [size0, size1];
    2539}
    2640function BamgMesher(bamgmesh_in, bamggeom_in, bamgopts) {
    … …  
    4155    //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.
    4256        //input
    43     var pVerticesSize_mesh_in               = intsToHeap([bamgmesh_in.Vertices.length, bamgmesh_in.Vertices[0] != undefined ? bamgmesh_in.Vertices[0].length : 1]);
     57    var pVerticesSize_mesh_in               = intsToHeap(size2d(bamgmesh_in.Vertices));
    4458    var pVertices_mesh_in                   = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.Vertices));
    45     var pEdgesSize_mesh_in                  = intsToHeap([bamgmesh_in.Edges.length, bamgmesh_in.Edges[0] != undefined ? bamgmesh_in.Edges[0].length : 1]);
     59    var pEdgesSize_mesh_in                  = intsToHeap(size2d(bamgmesh_in.Edges));
    4660    var pEdges_mesh_in                      = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.Edges));
    47     var pTrianglesSize_mesh_in              = intsToHeap([bamgmesh_in.Triangles.length, bamgmesh_in.Triangles[0] != undefined ? bamgmesh_in.Triangles[0].length : 1]);
     61    var pTrianglesSize_mesh_in              = intsToHeap(size2d(bamgmesh_in.Triangles));
    4862    var pTriangles_mesh_in                  = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.Triangles));
    49     var pCrackedEdgesSize_mesh_in           = intsToHeap([bamgmesh_in.CrackedEdges.length, bamgmesh_in.CrackedEdges[0] != undefined ? bamgmesh_in.CrackedEdges[0].length : 1]);
     63    var pCrackedEdgesSize_mesh_in           = intsToHeap(size2d(bamgmesh_in.CrackedEdges));
    5064    var pCrackedEdges_mesh_in               = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.CrackedEdges));
    51     var pVerticesOnGeomEdgeSize_mesh_in     = intsToHeap([bamgmesh_in.VerticesOnGeomEdge.length, bamgmesh_in.VerticesOnGeomEdge[0] != undefined ? bamgmesh_in.VerticesOnGeomEdge[0].length : 1]);
     65    var pVerticesOnGeomEdgeSize_mesh_in     = intsToHeap(size2d(bamgmesh_in.VerticesOnGeomEdge));
    5266    var pVerticesOnGeomEdge_mesh_in         = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.VerticesOnGeomEdge));
    53     var pVerticesOnGeomVertexSize_mesh_in   = intsToHeap([bamgmesh_in.VerticesOnGeomVertex.length, bamgmesh_in.VerticesOnGeomVertex[0] != undefined ? bamgmesh_in.VerticesOnGeomVertex[0].length : 1]);
     67    var pVerticesOnGeomVertexSize_mesh_in   = intsToHeap(size2d(bamgmesh_in.VerticesOnGeomVertex));
    5468    var pVerticesOnGeomVertex_mesh_in       = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.VerticesOnGeomVertex));
    55     var pEdgesOnGeomEdgeSize_mesh_in        = intsToHeap([bamgmesh_in.EdgesOnGeomEdge.length, bamgmesh_in.EdgesOnGeomEdge[0] != undefined ? bamgmesh_in.EdgesOnGeomEdge[0].length : 1]);
     69    var pEdgesOnGeomEdgeSize_mesh_in        = intsToHeap(size2d(bamgmesh_in.EdgesOnGeomEdge));
    5670    var pEdgesOnGeomEdge_mesh_in            = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.EdgesOnGeomEdge));
    57     var pIssmSegmentsSize_mesh_in           = intsToHeap([bamgmesh_in.IssmSegments.length, bamgmesh_in.IssmSegments[0] != undefined ? bamgmesh_in.IssmSegments[0].length : 1]);
     71    var pIssmSegmentsSize_mesh_in           = intsToHeap(size2d(bamgmesh_in.IssmSegments));
    5872    var pIssmSegments_mesh_in               = doublesToHeap(Array.prototype.concat.apply([], bamgmesh_in.IssmSegments));
    5973
    60     var pVerticesSize_geom_in               = intsToHeap([bamggeom_in.Vertices.length, bamggeom_in.Vertices[0] != undefined ? bamggeom_in.Vertices[0].length : 1]);
     74    var pVerticesSize_geom_in               = intsToHeap(size2d(bamggeom_in.Vertices));
    6175    var pVertices_geom_in                   = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.Vertices));
    62     var pEdgesSize_geom_in                  = intsToHeap([bamggeom_in.Edges.length, bamggeom_in.Edges[0] != undefined ? bamggeom_in.Edges[0].length : 1]);
     76    var pEdgesSize_geom_in                  = intsToHeap(size2d(bamggeom_in.Edges));
    6377    var pEdges_geom_in                      = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.Edges));
    64     var pCornersSize_geom_in                = intsToHeap([bamggeom_in.Corners.length, bamggeom_in.Corners[0] != undefined ? bamggeom_in.Corners[0].length : 1]);
     78    var pCornersSize_geom_in                = intsToHeap(size2d(bamggeom_in.Corners));
    6579    var pCorners_geom_in                    = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.Corners));
    66     var pRequiredVerticesSize_geom_in       = intsToHeap([bamggeom_in.RequiredVertices.length, bamggeom_in.RequiredVertices[0] != undefined ? bamggeom_in.RequiredVertices[0].length : 1]);
     80    var pRequiredVerticesSize_geom_in       = intsToHeap(size2d(bamggeom_in.RequiredVertices));
    6781    var pRequiredVertices_geom_in           = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.RequiredVertices));
    68     var pRequiredEdgesSize_geom_in          = intsToHeap([bamggeom_in.RequiredEdges.length, bamggeom_in.RequiredEdges[0] != undefined ? bamggeom_in.RequiredEdges[0].length : 1]);
     82    var pRequiredEdgesSize_geom_in          = intsToHeap(size2d(bamggeom_in.RequiredEdges));
    6983    var pRequiredEdges_geom_in              = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.RequiredEdges));
    70     var pCrackedEdgesSize_geom_in           = intsToHeap([bamggeom_in.CrackedEdges.length, bamggeom_in.CrackedEdges[0] != undefined ? bamggeom_in.CrackedEdges[0].length : 1]);
     84    var pCrackedEdgesSize_geom_in           = intsToHeap(size2d(bamggeom_in.CrackedEdges));
    7185    var pCrackedEdges_geom_in               = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.CrackedEdges));
    72     var pSubDomainsSize_geom_in             = intsToHeap([bamggeom_in.SubDomains.length, bamggeom_in.SubDomains[0] != undefined ? bamggeom_in.SubDomains[0].length : 1]);
     86    var pSubDomainsSize_geom_in             = intsToHeap(size2d(bamggeom_in.SubDomains));
    7387    var pSubDomains_geom_in                 = doublesToHeap(Array.prototype.concat.apply([], bamggeom_in.SubDomains));
    7488
    … …  
    92106    var hmin                                = bamgopts.hmin;
    93107    var hmax                                = bamgopts.hmax;
    94     var phminVerticesSize                   = intsToHeap([bamgopts.hminVertices.length, bamgopts.hminVertices[0] != undefined ? bamgopts.hminVertices[0].length : 1]);
     108    var phminVerticesSize                   = intsToHeap(size2d(bamgopts.hminVertices));
    95109    var phminVertices                       = doublesToHeap(Array.prototype.concat.apply([], bamgopts.hminVertices));
    96     var phmaxVerticesSize                   = intsToHeap([bamgopts.hmaxVertices.length, bamgopts.hmaxVertices[0] != undefined ? bamgopts.hmaxVertices[0].length : 1]);
     110    var phmaxVerticesSize                   = intsToHeap(size2d(bamgopts.hmaxVertices));
    97111    var phmaxVertices                       = doublesToHeap(Array.prototype.concat.apply([], bamgopts.hmaxVertices));
    98     var phVerticesSize                      = intsToHeap([bamgopts.hVertices.length, bamgopts.hVertices[0] != undefined ? bamgopts.hVertices[0].length : 1]);
     112    var phVerticesSize                      = intsToHeap(size2d(bamgopts.hVertices));
    99113    var phVertices                          = doublesToHeap(Array.prototype.concat.apply([], bamgopts.hVertices));
    100     var pmetricSize                         = intsToHeap([bamgopts.metric.length, bamgopts.metric[0] != undefined ? bamgopts.metric[0].length : 1]);
     114    var pmetricSize                         = intsToHeap(size2d(bamgopts.metric));
    101115    var pmetric                             = doublesToHeap(Array.prototype.concat.apply([], bamgopts.metric));
    102     var pfieldSize                          = intsToHeap([bamgopts.field.length, bamgopts.field[0] != undefined ? bamgopts.field[0].length : 1]);
     116    var pfieldSize                          = intsToHeap(size2d(bamgopts.field));
    103117    var pfield                              = doublesToHeap(Array.prototype.concat.apply([], bamgopts.field));
    104     var perrSize                            = intsToHeap([bamgopts.err.length, bamgopts.err[0] != undefined ? bamgopts.err[0].length : 1]);
     118    var perrSize                            = intsToHeap(size2d(bamgopts.err));
    105119    var perr                                = doublesToHeap(Array.prototype.concat.apply([], bamgopts.err));
    106120       
Note: See TracChangeset for help on using the changeset viewer.