Changeset 17558


Ignore:
Timestamp:
03/27/14 08:34:27 (11 years ago)
Author:
Mathieu Morlighem
Message:

NEW: removed old mesh classes, use subclasses instead

Location:
issm/trunk-jpl/src/m
Files:
1 deleted
22 edited
1 moved

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/m/classes/mesh2d.py

    r17480 r17558  
    44from checkfield import checkfield
    55import MatlabFuncs as m
     6from WriteData import WriteData
    67
    78class mesh2d(object):
    … …  
    8586                md = checkfield(md,'fieldname','mesh.x','NaN',1,'size',[md.mesh.numberofvertices])
    8687                md = checkfield(md,'fieldname','mesh.y','NaN',1,'size',[md.mesh.numberofvertices])
    87                 md = checkfield(md,'fieldname','mesh.z','NaN',1,'size',[md.mesh.numberofvertices])
    8888                md = checkfield(md,'fieldname','mesh.elements','NaN',1,'>',0,'values',numpy.arange(1,md.mesh.numberofvertices+1))
    8989                md = checkfield(md,'fieldname','mesh.elements','size',[md.mesh.numberofelements,3])

  • issm/trunk-jpl/src/m/classes/mesh3dprisms.m

    r17556 r17558  
    4646                                case 0
    4747                                        obj=setdefaultparameters(obj);
     48                                case 1
     49                                        self=mesh3dprisms();
     50                                        object=varargin{1};
     51                                        fields=fieldnames(object);
     52                                        for i=1:length(fields)
     53                                                field=fields{i};
     54                                                if ismember(field,properties('mesh3dprisms')),
     55                                                        self.(field)=object.(field);
     56                                                end
     57                                        end
    4858                                otherwise
    4959                                        error('constructor not supported');

  • issm/trunk-jpl/src/m/classes/mesh3dprisms.py

    r17556 r17558  
    44from checkfield import *
    55from MatlabFuncs import *
     6from WriteData import WriteData
    67
    78class mesh3dprisms(object):

  • issm/trunk-jpl/src/m/classes/model.m

    r17523 r17558  
    110110                                md.surfaceforcings=SMB();
    111111                                md.surfaceforcings.mass_balance=mass_balance;
     112                        end
     113                        %2014 March 26th
     114                        if isa(md.mesh,'mesh'),
     115                                if(md.mesh.dimension==2),
     116                                        md.mesh=mesh2d(md.mesh);
     117                                else
     118                                        md.mesh=mesh3dprisms(md.mesh);
     119                                end
    112120                        end
    113121                end% }}}
    … …  
    143151
    144152                        %Check that the model is really a 3d model
    145                         if ~md.mesh.dimension==3,
     153                        if ~strcmp(md.mesh.meshtype(),'3D'),
    146154                                error('collapse error message: only 3d mesh can be collapsed')
    147155                        end
    … …  
    179187                        if ~isnan(md.gia.lithosphere_thickness), md.gia.lithosphere_thickness=project2d(md,md.gia.lithosphere_thickness,1); end
    180188
    181                         %bedinfo and surface info
    182                         md.mesh.elementonbed=ones(md.mesh.numberofelements2d,1);
    183                         md.mesh.elementonsurface=ones(md.mesh.numberofelements2d,1);
    184                         md.mesh.vertexonbed=ones(md.mesh.numberofvertices2d,1);
    185                         md.mesh.vertexonsurface=ones(md.mesh.numberofvertices2d,1);
    186 
    187189                        %elementstype
    188190                        if ~isnan(md.flowequation.element_equation)
    … …  
    237239
    238240                        %Initialize with the 2d mesh
     241                        md.mesh=mesh2d();
    239242                        md.mesh.x=md.mesh.x2d;
    240243                        md.mesh.y=md.mesh.y2d;
    … …  
    258261                        md.mesh.numberoflayers=0;
    259262
    260                         %Update mesh type
    261                         md.mesh.dimension=2;
    262263                end % }}}
    263264                function md2 = extract(md,area) % {{{
    … …  
    327328                        elements_2(:,2)=Pnode(elements_2(:,2));
    328329                        elements_2(:,3)=Pnode(elements_2(:,3));
    329                         if md1.mesh.dimension==3,
     330                        if isa(md1.mesh,'mesh3dprisms'),
    330331                                elements_2(:,4)=Pnode(elements_2(:,4));
    331332                                elements_2(:,5)=Pnode(elements_2(:,5));
    … …  
    383384
    384385                        %mesh.uppervertex mesh.lowervertex
    385                         if md1.mesh.dimension==3
     386                        if isa(md1.mesh,'mesh3dprisms'),
    386387                                md2.mesh.uppervertex=md1.mesh.uppervertex(pos_node);
    387388                                pos=find(~isnan(md2.mesh.uppervertex));
    … …  
    402403
    403404                        %Initial 2d mesh
    404                         if md1.mesh.dimension==3
     405                        if isa(md1.mesh,'mesh3dprisms'),
    405406                                flag_elem_2d=flag_elem(1:md1.mesh.numberofelements2d);
    406407                                pos_elem_2d=find(flag_elem_2d);
    … …  
    461462
    462463                        %recreate segments
    463                         if md1.mesh.dimension==2
     464                        if isa(md1.mesh,'mesh2d'),
    464465                                md2.mesh.vertexconnectivity=NodeConnectivity(md2.mesh.elements,md2.mesh.numberofvertices);
    465466                                md2.mesh.elementconnectivity=ElementConnectivity(md2.mesh.elements,md2.mesh.vertexconnectivity);
    … …  
    600601                                error('number of layers should be at least 2');
    601602                        end
    602                         if md.mesh.dimension==3,
     603                        if strcmp(md.mesh.meshtype(),'3D')
    603604                                error('Cannot extrude a 3d mesh (extrude cannot be called more than once)');
    604605                        end
    605606
    606607                        %Initialize with the 2d mesh
     608                        mesh2d = md.mesh;
     609                        md.mesh=mesh3dprisms();
     610                        md.mesh.x                           = mesh2d.x;
     611                        md.mesh.y                           = mesh2d.y;
     612                        md.mesh.elements                    = mesh2d.elements;
     613                        md.mesh.numberofelements            = mesh2d.numberofelements;
     614                        md.mesh.numberofvertices            = mesh2d.numberofvertices;
     615
     616                        md.mesh.lat                         = mesh2d.lat;
     617                        md.mesh.long                        = mesh2d.long;
     618                        md.mesh.hemisphere                  = mesh2d.hemisphere;
     619
     620                        md.mesh.vertexonboundary            = mesh2d.vertexonboundary;
     621                        md.mesh.vertexconnectivity          = mesh2d.vertexconnectivity;
     622                        md.mesh.elementconnectivity         = mesh2d.elementconnectivity;
     623                        md.mesh.average_vertex_connectivity = mesh2d.average_vertex_connectivity;
     624
     625                        md.mesh.extractedvertices           = mesh2d.extractedvertices;
     626                        md.mesh.extractedelements           = mesh2d.extractedelements;
     627
    607628                        x3d=[];
    608629                        y3d=[];
    … …  
    649670                        md.mesh.numberofelements2d=md.mesh.numberofelements;
    650671                        md.mesh.numberofvertices2d=md.mesh.numberofvertices;
    651 
    652                         %Update mesh type
    653                         md.mesh.dimension=3;
    654672
    655673                        %Build global 3d mesh
    … …  
    906924                        if isfield(structmd,'segments'), md.mesh.segments=structmd.segments; end
    907925                        if isfield(structmd,'segmentmarkers'), md.mesh.segmentmarkers=structmd.segmentmarkers; end
    908                         if isfield(structmd,'dim'), md.mesh.dimension=structmd.dim; end
    909926                        if isfield(structmd,'numlayers'), md.mesh.numberoflayers=structmd.numlayers; end
    910927                        if isfield(structmd,'numberofelements'), md.mesh.numberofelements=structmd.numberofelements; end
    … …  
    940957                        if isfield(structmd,'part'); md.qmu.partition=structmd.part; end
    941958
    942                         %Field changes
    943                         if (isfield(structmd,'type') & ischar(structmd.type)),
    944                                 if strcmpi(structmd.type,'2d'), md.mesh.dimension=2; end
    945                                 if strcmpi(structmd.type,'3d'), md.mesh.dimension=3; end
    946                         end
    947959                        if isnumeric(md.verbose),
    948960                                md.verbose=verbose;
    … …  
    10661078
    10671079                        %initialize subclasses
    1068                         md.mesh             = mesh();
     1080                        md.mesh             = mesh2d();
    10691081                        md.mask             = mask();
    10701082                        md.constants        = constants();

  • issm/trunk-jpl/src/m/classes/model.py

    r17488 r17558  
    44import sys
    55from mesh import mesh
     6from mesh3dprisms import mesh3dprisms
    67from mask import mask
    78from geometry import geometry
    … …  
    239240                elements_2[:,1]=Pnode[elements_2[:,1]-1]
    240241                elements_2[:,2]=Pnode[elements_2[:,2]-1]
    241                 if md1.mesh.dimension==3:
     242                if md1.mesh.__class__.__name__=='mesh3dprisms':
    242243                        elements_2[:,3]=Pnode[elements_2[:,3]-1]
    243244                        elements_2[:,4]=Pnode[elements_2[:,4]-1]
    … …  
    291292
    292293                #mesh.uppervertex mesh.lowervertex
    293                 if md1.mesh.dimension==3:
     294                if md1.mesh.__class__.__name__=='mesh3dprisms':
    294295                        md2.mesh.uppervertex=md1.mesh.uppervertex[pos_node]
    295296                        pos=numpy.nonzero(numpy.logical_not(md2.mesh.uppervertex==-1))[0]
    … …  
    309310
    310311                #Initial 2d mesh
    311                 if md1.mesh.dimension==3:
     312                if md1.mesh.__class__.__name__=='mesh3dprisms':
    312313                        flag_elem_2d=flag_elem[numpy.arange(0,md1.mesh.numberofelements2d)]
    313314                        pos_elem_2d=numpy.nonzero(flag_elem_2d)[0]
    … …  
    362363
    363364                #recreate segments
    364                 if md1.mesh.dimension==2:
     365                if md1.mesh.__class__.__name__=='mesh2d':
    365366                        [md2.mesh.vertexconnectivity]=NodeConnectivity(md2.mesh.elements,md2.mesh.numberofvertices)
    366367                        [md2.mesh.elementconnectivity]=ElementConnectivity(md2.mesh.elements,md2.mesh.vertexconnectivity)
    … …  
    498499                if numlayers<2:
    499500                        raise TypeError("number of layers should be at least 2")
    500                 if md.mesh.dimension==3:
     501                if md.mesh.__class__.__name__=='mesh3dprisms':
    501502                        raise TypeError("Cannot extrude a 3d mesh (extrude cannot be called more than once)")
    502503
    503504                #Initialize with the 2d mesh
     505                mesh2d = md.mesh
     506                md.mesh=mesh3dprisms()
     507                md.mesh.x                           = mesh2d.x
     508                md.mesh.y                           = mesh2d.y
     509                md.mesh.elements                    = mesh2d.elements
     510                md.mesh.numberofelements            = mesh2d.numberofelements
     511                md.mesh.numberofvertices            = mesh2d.numberofvertices
     512
     513                md.mesh.lat                         = mesh2d.lat
     514                md.mesh.long                        = mesh2d.long
     515                md.mesh.hemisphere                  = mesh2d.hemisphere
     516
     517                md.mesh.vertexonboundary            = mesh2d.vertexonboundary
     518                md.mesh.vertexconnectivity          = mesh2d.vertexconnectivity
     519                md.mesh.elementconnectivity         = mesh2d.elementconnectivity
     520                md.mesh.average_vertex_connectivity = mesh2d.average_vertex_connectivity
     521
     522                md.mesh.extractedvertices           = mesh2d.extractedvertices
     523                md.mesh.extractedelements           = mesh2d.extractedelements
     524
    504525                x3d=numpy.empty((0))
    505526                y3d=numpy.empty((0))
    … …  
    544565                md.mesh.numberofelements2d=md.mesh.numberofelements
    545566                md.mesh.numberofvertices2d=md.mesh.numberofvertices
    546 
    547                 #Update mesh type
    548                 md.mesh.dimension=3
    549567
    550568                #Build global 3d mesh

  • issm/trunk-jpl/src/m/classes/oldclasses/mesh.m

    r17553 r17558  
    1 %MESH class definition
    2 %
    3 %   Usage:
    4 %      mesh=mesh();
    5 
    61classdef mesh
    72        properties (SetAccess=public)
    … …  
    4641                extractedelements           = NaN
    4742        end
    48         methods (Static)
    49                 function obj = loadobj(obj) % {{{
    50                         % This function is directly called by matlab when a model object is
    51                         % loaded. Update old properties here
    52 
    53                         %2012 June 28th
    54                         if numel(obj.edges)>1 & any(isnan(obj.edges(:)))
    55                                 disp('Update model edges from previous version');
    56                                 obj.edges(isnan(obj.edges))=-1;
    57                         end
    58 
    59                 end% }}}
    60         end
    61         methods
    62                 function obj = mesh(varargin) % {{{
    63                         switch nargin
    64                                 case 0
    65                                         obj=setdefaultparameters(obj);
    66                                 otherwise
    67                                         error('constructor not supported');
    68                         end
    69                 end % }}}
    70                 function obj = setdefaultparameters(obj) % {{{
    71 
    72                         %the connectivity is the averaged number of nodes linked to a
    73                         %given node through an edge. This connectivity is used to initially
    74                         %allocate memory to the stiffness matrix. A value of 16 seems to
    75                         %give a good memory/time ration. This value can be checked in
    76                         %trunk/test/Miscellaneous/runme.m
    77                         obj.average_vertex_connectivity=25;
    78                 end % }}}
    79                 function md = checkconsistency(obj,md,solution,analyses) % {{{
    80 
    81                         md = checkfield(md,'fieldname','mesh.x','NaN',1,'size',[md.mesh.numberofvertices 1]);
    82                         md = checkfield(md,'fieldname','mesh.y','NaN',1,'size',[md.mesh.numberofvertices 1]);
    83                         md = checkfield(md,'fieldname','mesh.z','NaN',1,'size',[md.mesh.numberofvertices 1]);
    84                         md = checkfield(md,'fieldname','mesh.elements','NaN',1,'>',0,'values',1:md.mesh.numberofvertices);
    85                         if(md.mesh.dimension==2),
    86                                 md = checkfield(md,'fieldname','mesh.elements','size',[md.mesh.numberofelements 3]);
    87                         else
    88                                 md = checkfield(md,'fieldname','mesh.elements','size',[md.mesh.numberofelements 6]);
    89                         end
    90                         if any(~ismember(1:md.mesh.numberofvertices,sort(unique(md.mesh.elements(:)))));
    91                                 md = checkmessage(md,'orphan nodes have been found. Check the mesh outline');
    92                         end
    93                         md = checkfield(md,'fieldname','mesh.dimension','values',[2 3]);
    94                         md = checkfield(md,'fieldname','mesh.numberoflayers','>=',0);
    95                         md = checkfield(md,'fieldname','mesh.numberofelements','>',0);
    96                         md = checkfield(md,'fieldname','mesh.numberofvertices','>',0);
    97                         %no checks for numberofedges lat long and hemisphere
    98                         md = checkfield(md,'fieldname','mesh.elementonbed','size',[md.mesh.numberofelements 1],'values',[0 1]);
    99                         md = checkfield(md,'fieldname','mesh.elementonsurface','size',[md.mesh.numberofelements 1],'values',[0 1]);
    100                         md = checkfield(md,'fieldname','mesh.vertexonbed','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    101                         md = checkfield(md,'fieldname','mesh.vertexonsurface','size',[md.mesh.numberofvertices 1],'values',[0 1]);
    102                         if (md.mesh.dimension==3),
    103                                 md = checkfield(md,'fieldname','mesh.z','>=',md.geometry.bed-10^-10,'message','''mesh.z'' lower than bedrock');
    104                                 md = checkfield(md,'fieldname','mesh.z','<=',md.geometry.surface+10^-10,'message','''mesh.z'' higher than surface elevation');
    105                         end
    106                         if (md.mesh.dimension==2),
    107                                 md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',9,'message','''mesh.average_vertex_connectivity'' should be at least 9 in 2d');
    108                         else
    109                                 md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',24,'message','''mesh.average_vertex_connectivity'' should be at least 24 in 3d');
    110                         end
    111 
    112                         %Solution specific checks
    113                         switch(solution),
    114                                 case MasstransportSolutionEnum(),
    115                                         if md.masstransport.stabilization==3,
    116                                                 md = checkfield(md,'fieldname','mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes');
    117                                         end
    118                                 case BalancethicknessSolutionEnum(),
    119                                         if md.balancethickness.stabilization==3,
    120                                                 md = checkfield(md,'fieldname','mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes');
    121                                         end
    122                                 case TransientSolutionEnum(),
    123                                         if md.transient.ismasstransport & md.masstransport.stabilization==3,
    124                                                 md = checkfield(md,'fieldname','mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes');
    125                                         end
    126                                 case ThermalSolutionEnum(),
    127                                         md = checkfield(md,'fieldname','mesh.dimension','values',3,'message','thermal solution only supported on 3d meshes');
    128                         end
    129                 end % }}}
    130                 function disp(obj) % {{{
    131                         disp(sprintf('   Mesh:'));
    132 
    133                         if obj.dimension==3,
    134                                 disp(sprintf('\n      Elements and vertices of the original 2d mesh:'));
    135                                 fielddisplay(obj,'numberofelements2d','number of elements');
    136                                 fielddisplay(obj,'numberofvertices2d','number of vertices');
    137                                 fielddisplay(obj,'elements2d','vertex indices of the mesh elements');
    138                                 fielddisplay(obj,'x2d','vertices x coordinate [m]');
    139                                 fielddisplay(obj,'y2d','vertices y coordinate [m]');
    140 
    141                                 disp(sprintf('\n      Elements and vertices of the extruded 3d mesh:'));
    142                         else
    143                                 disp(sprintf('\n      Elements and vertices:'));
    144                         end
    145                         fielddisplay(obj,'numberofelements','number of elements');
    146                         fielddisplay(obj,'numberofvertices','number of vertices');
    147                         fielddisplay(obj,'elements','vertex indices of the mesh elements');
    148                         fielddisplay(obj,'x','vertices x coordinate [m]');
    149                         fielddisplay(obj,'y','vertices y coordinate [m]');
    150                         fielddisplay(obj,'z','vertices z coordinate [m]');
    151                         fielddisplay(obj,'edges','edges of the 2d mesh (vertex1 vertex2 element1 element2)');
    152                         fielddisplay(obj,'numberofedges','number of edges of the 2d mesh');
    153 
    154                         disp(sprintf('\n      Properties:'));
    155                         fielddisplay(obj,'dimension','mesh dimension');
    156                         fielddisplay(obj,'numberoflayers','number of extrusion layers');
    157                         fielddisplay(obj,'vertexonbed','lower vertices flags list');
    158                         fielddisplay(obj,'elementonbed','lower elements flags list');
    159                         fielddisplay(obj,'vertexonsurface','upper vertices flags list');
    160                         fielddisplay(obj,'elementonsurface','upper elements flags list');
    161                         fielddisplay(obj,'uppervertex','upper vertex list (NaN for vertex on the upper surface)');
    162                         fielddisplay(obj,'upperelements','upper element list (NaN for element on the upper layer)');
    163                         fielddisplay(obj,'lowervertex','lower vertex list (NaN for vertex on the lower surface)');
    164                         fielddisplay(obj,'lowerelements','lower element list (NaN for element on the lower layer');
    165                         fielddisplay(obj,'vertexonboundary','vertices on the boundary of the domain flag list');
    166 
    167                         fielddisplay(obj,'segments','edges on domain boundary (vertex1 vertex2 element)');
    168                         fielddisplay(obj,'segmentmarkers','number associated to each segment');
    169                         fielddisplay(obj,'vertexconnectivity','list of vertices connected to vertex_i');
    170                         fielddisplay(obj,'elementconnectivity','list of vertices connected to element_i');
    171                         fielddisplay(obj,'average_vertex_connectivity','average number of vertices connected to one vertex');
    172 
    173                         disp(sprintf('\n      Extracted model:'));
    174                         fielddisplay(obj,'extractedvertices','vertices extracted from the model');
    175                         fielddisplay(obj,'extractedelements','elements extracted from the model');
    176 
    177                         disp(sprintf('\n      Projection:'));
    178                         fielddisplay(obj,'lat','vertices latitude [degrees]');
    179                         fielddisplay(obj,'long','vertices longitude [degrees]');
    180                         fielddisplay(obj,'hemisphere','Indicate hemisphere ''n'' or ''s'' ');
    181                 end % }}}
    182                 function marshall(obj,md,fid) % {{{
    183                         WriteData(fid,'enum',MeshTypeEnum(),'data',StringToEnum(['Mesh' meshtype(obj)]),'format','Integer');
    184                         WriteData(fid,'object',obj,'fieldname','x','format','DoubleMat','mattype',1);
    185                         WriteData(fid,'object',obj,'fieldname','y','format','DoubleMat','mattype',1);
    186                         WriteData(fid,'object',obj,'fieldname','z','format','DoubleMat','mattype',1);
    187                         WriteData(fid,'object',obj,'fieldname','elements','format','DoubleMat','mattype',2);
    188                         WriteData(fid,'object',obj,'fieldname','numberoflayers','format','Integer');
    189                         WriteData(fid,'object',obj,'fieldname','numberofelements','format','Integer');
    190                         WriteData(fid,'object',obj,'fieldname','numberofvertices','format','Integer');
    191                         WriteData(fid,'object',obj,'fieldname','elementonbed','format','BooleanMat','mattype',2);
    192                         WriteData(fid,'object',obj,'fieldname','elementonsurface','format','BooleanMat','mattype',2);
    193                         WriteData(fid,'object',obj,'fieldname','vertexonbed','format','BooleanMat','mattype',1);
    194                         WriteData(fid,'object',obj,'fieldname','vertexonsurface','format','BooleanMat','mattype',1);
    195                         WriteData(fid,'object',obj,'fieldname','lowerelements','format','DoubleMat','mattype',2);
    196                         WriteData(fid,'object',obj,'fieldname','upperelements','format','DoubleMat','mattype',2);
    197                         WriteData(fid,'object',obj,'fieldname','average_vertex_connectivity','format','Integer');
    198                         WriteData(fid,'object',obj,'fieldname','elements2d','format','DoubleMat','mattype',3);
    199                         WriteData(fid,'object',obj,'fieldname','numberofvertices2d','format','Integer');
    200                         WriteData(fid,'object',obj,'fieldname','numberofelements2d','format','Integer');
    201                 end % }}}
    202                 function type = meshtype(obj) % {{{
    203                         if obj.dimension==2,
    204                                 type = '2Dhorizontal';
    205                         else
    206                                 type = '3D';
    207                         end
    208                 end % }}}
    209         end
    21043end

  • issm/trunk-jpl/src/m/mesh/argusmesh.m

    r9734 r17558  
    7777
    7878%Finally, use model constructor to build a complete model:
     79md.mesh=mesh2d();
    7980md.mesh.elements=elements;
    8081md.mesh.x=x;
    8182md.mesh.y=y;
    82 md.z=z;
    8383md.mesh.numberofvertices=size(md.mesh.x,1);
    8484md.mesh.numberofelements=size(md.mesh.elements,1);
    85 md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    86 md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    87 md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
    88 md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    89 md.mesh.dimension=2;
    9085md=addnote(md,notes);
    9186

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

    r16967 r17558  
    333333
    334334if getfieldvalue(options,'vertical',0),
    335         md.mesh=mesh2dvertical;
     335        md.mesh=mesh2dvertical();
    336336        md.mesh.x=bamgmesh_out.Vertices(:,1);
    337337        md.mesh.y=bamgmesh_out.Vertices(:,2);
    … …  
    350350        md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    351351else
    352         % plug results onto model
     352        md.mesh=mesh2d();
    353353        md.mesh.x=bamgmesh_out.Vertices(:,1);
    354354        md.mesh.y=bamgmesh_out.Vertices(:,2);
    … …  
    359359
    360360        %Fill in rest of fields:
    361         md.mesh.dimension=2;
    362361        md.mesh.numberofelements=size(md.mesh.elements,1);
    363362        md.mesh.numberofvertices=length(md.mesh.x);
    364363        md.mesh.numberofedges=size(md.mesh.edges,1);
    365         md.mesh.z=zeros(md.mesh.numberofvertices,1);
    366         md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    367         md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    368         md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
    369         md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    370364        md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    371365end
     366
     367%Bamg private fields
    372368md.private.bamg=struct();
    373369md.private.bamg.mesh=bamgmesh(bamgmesh_out);
    … …  
    375371md.mesh.elementconnectivity=md.private.bamg.mesh.ElementConnectivity;
    376372md.mesh.elementconnectivity(find(isnan(md.mesh.elementconnectivity)))=0;
    377 
    378373
    379374%Check for orphan

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

    r17480 r17558  
    11import os.path
    22import numpy
     3from mesh2d import mesh2d
    34from collections import OrderedDict
    45from pairoptions import pairoptions
    … …  
    320321        md.private.bamg['mesh']=bamgmesh(bamgmesh_out)
    321322        md.private.bamg['geometry']=bamggeom(bamggeom_out)
     323        md.mesh = mesh2d()
    322324        md.mesh.x=bamgmesh_out['Vertices'][:,0].copy()
    323325        md.mesh.y=bamgmesh_out['Vertices'][:,1].copy()
    … …  
    328330
    329331        #Fill in rest of fields:
    330         md.mesh.dimension=2
    331332        md.mesh.numberofelements=numpy.size(md.mesh.elements,axis=0)
    332333        md.mesh.numberofvertices=numpy.size(md.mesh.x)
    333334        md.mesh.numberofedges=numpy.size(md.mesh.edges,axis=0)
    334         md.mesh.z=numpy.zeros(md.mesh.numberofvertices)
    335         md.mesh.vertexonbed=numpy.ones(md.mesh.numberofvertices,bool)
    336         md.mesh.vertexonsurface=numpy.ones(md.mesh.numberofvertices,bool)
    337         md.mesh.elementonbed=numpy.ones(md.mesh.numberofelements,bool)
    338         md.mesh.elementonsurface=numpy.ones(md.mesh.numberofelements,bool)
    339335        md.mesh.vertexonboundary=numpy.zeros(md.mesh.numberofvertices,bool)
    340336        md.mesh.vertexonboundary[md.mesh.segments[:,0:2]-1]=True

  • issm/trunk-jpl/src/m/mesh/meshconvert.m

    r16281 r17558  
    3636
    3737%Fill in rest of fields:
    38 md.mesh.dimension        = 2;
    3938md.mesh.numberofelements = size(md.mesh.elements,1);
    4039md.mesh.numberofvertices = length(md.mesh.x);
    4140md.mesh.numberofedges    = size(md.mesh.edges,1);
    42 md.mesh.z                = zeros(md.mesh.numberofvertices,1);
    43 md.mesh.vertexonbed      = ones(md.mesh.numberofvertices,1);
    44 md.mesh.vertexonsurface  = ones(md.mesh.numberofvertices,1);
    45 md.mesh.elementonbed     = ones(md.mesh.numberofelements,1);
    46 md.mesh.elementonsurface = ones(md.mesh.numberofelements,1);
    4741md.mesh.vertexonboundary = zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2)) = 1;

  • issm/trunk-jpl/src/m/mesh/meshconvert.py

    r17497 r17558  
    22from collections import OrderedDict
    33from BamgConvertMesh import BamgConvertMesh
     4from mesh2d   import mesh2d
    45from bamgmesh import bamgmesh
    56from bamggeom import bamggeom
    … …  
    3334        md.private.bamg['mesh']     = bamgmesh(bamgmesh_out)
    3435        md.private.bamg['geometry'] = bamggeom(bamggeom_out)
     36        md.mesh                     = mesh2d()
    3537        md.mesh.x                   = bamgmesh_out['Vertices'][:,0].copy()
    3638        md.mesh.y                   = bamgmesh_out['Vertices'][:,1].copy()
    … …  
    4143
    4244        #Fill in rest of fields:
    43         md.mesh.dimension          = 2
    4445        md.mesh.numberofelements   = numpy.size(md.mesh.elements,axis=0)
    4546        md.mesh.numberofvertices   = numpy.size(md.mesh.x)
    4647        md.mesh.numberofedges      = numpy.size(md.mesh.edges,axis=0)
    47         md.mesh.z                  = numpy.zeros(md.mesh.numberofvertices)
    48         md.mesh.vertexonbed        = numpy.ones(md.mesh.numberofvertices,bool)
    49         md.mask.vertexonwater      = numpy.zeros(md.mesh.numberofvertices,bool)
    50         md.mesh.vertexonsurface    = numpy.ones(md.mesh.numberofvertices,bool)
    51         md.mesh.elementonbed       = numpy.ones(md.mesh.numberofelements,bool)
    52         md.mesh.elementonsurface   = numpy.ones(md.mesh.numberofelements,bool)
    5348        md.mesh.vertexonboundary   = numpy.zeros(md.mesh.numberofvertices,bool)
    5449        md.mesh.vertexonboundary[md.mesh.segments[:,0:2]-1] = True

  • issm/trunk-jpl/src/m/mesh/rifts/meshaddrifts.m

    r13730 r17558  
    8080%finish up "a la" mesh.h
    8181md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    82 md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    83 md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    84 md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
    85 md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    8682
    8783%Now, build the connectivity tables for this mesh.
    8884md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
    8985md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    90 
    91 %type of model
    92 md.mesh.dimension=2;

  • issm/trunk-jpl/src/m/mesh/rifts/meshprocessoutsiderifts.m

    r13806 r17558  
    8282md.mesh.numberofelements=length(md.mesh.elements);
    8383md.mesh.numberofvertices=length(md.mesh.x);
    84 md.mesh.z=zeros(md.mesh.numberofvertices,1);
    8584md.mesh.vertexonboundary=zeros(length(md.mesh.x),1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    86 md.flowequation.element_equation=3*ones(md.mesh.numberofelements,1);
    87 md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    88 md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    89 md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
    90 md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    9185end
    9286

  • issm/trunk-jpl/src/m/mesh/rifts/meshprocessoutsiderifts.py

    r17480 r17558  
    8080        md.mesh.numberofelements=numpy.size(md.mesh.elements,axis=0)
    8181        md.mesh.numberofvertices=numpy.size(md.mesh.x)
    82         md.mesh.z=numpy.zeros(md.mesh.numberofvertices)
    8382        md.mesh.vertexonboundary=numpy.zeros(numpy.size(md.mesh.x),bool)
    8483        md.mesh.vertexonboundary[md.mesh.segments[:,0:2]-1]=True
    8584        md.rifts.numrifts=length(md.rifts.riftstruct)
    86         md.flowequation.element_equation=3*numpy.ones(md.mesh.numberofelements,int)
    87         md.mesh.vertexonbed=numpy.ones(md.mesh.numberofvertices,bool)
    88         md.mesh.vertexonsurface=numpy.ones(md.mesh.numberofvertices,bool)
    89         md.mesh.elementonbed=numpy.ones(md.mesh.numberofelements,bool)
    90         md.mesh.elementonsurface=numpy.ones(md.mesh.numberofelements,bool)
    9185
    9286        return md

  • issm/trunk-jpl/src/m/mesh/rifts/meshprocessrifts.m

    r10992 r17558  
    3434md.mesh.numberofelements=length(md.mesh.elements);
    3535md.mesh.numberofvertices=length(md.mesh.x);
    36 md.mesh.z=zeros(md.mesh.numberofvertices,1);
    3736md.mesh.vertexonboundary=zeros(length(md.mesh.x),1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    38 md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    39 md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    40 md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
    41 md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    4237
    4338%get coordinates of rift tips

  • issm/trunk-jpl/src/m/mesh/rifts/meshprocessrifts.py

    r17497 r17558  
    3535        md.mesh.numberofelements=numpy.size(md.mesh.elements,axis=0)
    3636        md.mesh.numberofvertices=numpy.size(md.mesh.x)
    37         md.mesh.z=numpy.zeros(md.mesh.numberofvertices)
    3837        md.mesh.vertexonboundary=numpy.zeros(numpy.size(md.mesh.x),bool)
    3938        md.mesh.vertexonboundary[md.mesh.segments[:,0:2]-1]=True
    40         md.mesh.vertexonbed=numpy.ones(md.mesh.numberofvertices,bool)
    41         md.mesh.vertexonsurface=numpy.ones(md.mesh.numberofvertices,bool)
    42         md.mesh.elementonbed=numpy.ones(md.mesh.numberofelements,bool)
    43         md.mesh.elementonsurface=numpy.ones(md.mesh.numberofelements,bool)
    4439
    4540        #get coordinates of rift tips

  • issm/trunk-jpl/src/m/mesh/squaremesh.m

    r14092 r17558  
    5555
    5656%plug coordinates and nodes
     57md.mesh=mesh2d();
    5758md.mesh.x=x;
    5859md.mesh.y=y;
    59 md.mesh.z=zeros(nods,1);
    6060md.mesh.numberofvertices=nods;
    6161md.mesh.vertexonboundary=zeros(nods,1);md.mesh.vertexonboundary(segments(:,1:2))=1;
    62 md.mesh.vertexonbed=ones(nods,1);
    63 md.mesh.vertexonsurface=ones(nods,1);
    6462
    6563%plug elements
    … …  
    6765md.mesh.segments=segments;
    6866md.mesh.numberofelements=nel;
    69 md.mesh.elementonbed=ones(nel,1);
    70 md.mesh.elementonsurface=ones(nel,1);
    7167
    7268%Now, build the connectivity tables for this mesh.
    7369md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
    7470md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    75 
    76 %plug other field
    77 md.mesh.dimension=2;

  • issm/trunk-jpl/src/m/mesh/squaremesh.py

    r17497 r17558  
    5757
    5858        #plug coordinates and nodes
     59        md.mesh=mesh2d()
    5960        md.mesh.x=x
    6061        md.mesh.y=y
    61         md.mesh.z=numpy.zeros((nods))
    6262        md.mesh.numberofvertices=nods
    6363        md.mesh.vertexonboundary=numpy.zeros((nods),bool)
    6464        md.mesh.vertexonboundary[segments[:,0:2]-1]=True
    65         md.mesh.vertexonbed=numpy.ones((nods),bool)
    66         md.mesh.vertexonsurface=numpy.ones((nods),bool)
    6765
    6866        #plug elements
    … …  
    7068        md.mesh.segments=segments
    7169        md.mesh.numberofelements=nel
    72         md.mesh.elementonbed=numpy.ones((nel),bool)
    73         md.mesh.elementonsurface=numpy.ones((nel),bool)
    7470
    7571        #Now, build the connectivity tables for this mesh.
    … …  
    7773        [md.mesh.elementconnectivity]=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity)
    7874
    79         #plug other field
    80         md.mesh.dimension=2
    81 
    8275        return md
    83 

  • issm/trunk-jpl/src/m/mesh/triangle.m

    r17121 r17558  
    5959
    6060%plug into md
     61md.mesh=mesh2d();
    6162md.mesh.x=x;
    6263md.mesh.y=y;
    … …  
    6869md.mesh.numberofelements=size(md.mesh.elements,1);
    6970md.mesh.numberofvertices=length(md.mesh.x);
    70 md.mesh.z=zeros(md.mesh.numberofvertices,1);
    7171md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    72 md.mesh.vertexonbed=ones(md.mesh.numberofvertices,1);
    73 md.mesh.vertexonsurface=ones(md.mesh.numberofvertices,1);
    74 md.mesh.elementonbed=ones(md.mesh.numberofelements,1);
    75 md.mesh.elementonsurface=ones(md.mesh.numberofelements,1);
    7672
    7773%Now, build the connectivity tables for this mesh.
    7874md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices);
    7975md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity);
    80 
    81 %type of model
    82 md.mesh.dimension=2;

  • issm/trunk-jpl/src/m/mesh/triangle.py

    r17480 r17558  
    11import numpy
     2from mesh2d import mesh2d
    23from TriMesh import TriMesh
    34from NodeConnectivity import NodeConnectivity
    … …  
    4344
    4445        #Mesh using TriMesh
     46        md.mesh=mesh2d()
    4547        [md.mesh.elements,md.mesh.x,md.mesh.y,md.mesh.segments,md.mesh.segmentmarkers]=TriMesh(domainname,riftname,area)
    4648        md.mesh.elements=md.mesh.elements.astype(int)
    … …  
    5153        md.mesh.numberofelements = numpy.size(md.mesh.elements,axis=0)
    5254        md.mesh.numberofvertices = numpy.size(md.mesh.x)
    53         md.mesh.z = numpy.zeros(md.mesh.numberofvertices)
    5455        md.mesh.vertexonboundary = numpy.zeros(md.mesh.numberofvertices,bool)
    5556        md.mesh.vertexonboundary[md.mesh.segments[:,0:2]-1] = True
    56         md.mesh.vertexonbed = numpy.ones(md.mesh.numberofvertices,bool)
    57         md.mesh.vertexonsurface = numpy.ones(md.mesh.numberofvertices,bool)
    58         md.mesh.elementonbed = numpy.ones(md.mesh.numberofelements,bool)
    59         md.mesh.elementonsurface = numpy.ones(md.mesh.numberofelements,bool)
    6057
    6158        #Now, build the connectivity tables for this mesh.
    … …  
    6360        [md.mesh.elementconnectivity] = ElementConnectivity(md.mesh.elements, md.mesh.vertexconnectivity)
    6461
    65         #type of model
    66         md.mesh.dimension = 2.
    67 
    6862        return md
    69 

  • issm/trunk-jpl/src/m/mesh/triangle2dvertical.m

    r17121 r17558  
    4646
    4747%plug into md
    48 md.mesh=mesh2dvertical;
     48md.mesh=mesh2dvertical();
    4949md.mesh.x=x;
    5050md.mesh.z=z;

  • issm/trunk-jpl/src/m/parameterization/contourenvelope.m

    r15987 r17558  
    4242%get nodes inside profile
    4343mesh.elementconnectivity=md.mesh.elementconnectivity;
    44 if md.mesh.dimension==2;
     44if strcmp(md.mesh.meshtype(),'2Dhorizontal'),
    4545        mesh.elements=md.mesh.elements;
    4646        mesh.x=md.mesh.x;

  • issm/trunk-jpl/src/m/parameterization/contourenvelope.py

    r17497 r17558  
    4646        #get nodes inside profile
    4747        mesh.elementconnectivity=copy.deepcopy(md.mesh.elementconnectivity)
    48         if md.mesh.dimension==2:
     48        if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
    4949                mesh.elements=copy.deepcopy(md.mesh.elements)
    5050                mesh.x=copy.deepcopy(md.mesh.x)
Note: See TracChangeset for help on using the changeset viewer.