Changeset 3446


Ignore:
Timestamp:
04/08/10 06:50:07 (15 years ago)
Author:
Eric.Larour
Message:

Massive debug

Location:
issm/trunk/src/c
Files:
3 added
1 deleted
70 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/ComputePressurex/ComputePressurex.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void    ComputePressurex( Vec* pp_g,DataSet* elements,DataSet* nodes,DataSet* loads, DataSet* materials,DataSet* parameters){
     12void    ComputePressurex( Vec* pp_g,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,DataSet* parameters){
    1313
    1414        int i;
    … …  
    2727
    2828        /*Get elements configured: */
    29         elements->Configure(elements,loads, nodes, materials,parameters);
    30         parameters->Configure(elements,loads, nodes, materials,parameters);
     29        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     30        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    3131
    3232        /*Call on dataset driver: */

  • issm/trunk/src/c/ComputePressurex/ComputePressurex.h

    r2333 r3446  
    99
    1010/* local prototypes: */
    11 void    ComputePressurex( Vec* pp_g,DataSet* elements,DataSet* nodes,DataSet* loads, DataSet* materials,  DataSet* parameters);
     11void    ComputePressurex( Vec* pp_g,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  DataSet* parameters);
    1212
    1313#endif  /* _COMPUTEPRESSUREX_H */

  • issm/trunk/src/c/ConfigureObjectsx/ConfigureObjectsx.cpp

    r3420 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 int     ConfigureObjectsx( DataSet* elements, DataSet* loads, DataSet* nodes,vertices, DataSet* materials,DataSet* parameters){
     12int     ConfigureObjectsx( DataSet* elements, DataSet* loads, DataSet* nodes, DataSet* vertices, DataSet* materials,DataSet* parameters){
    1313
    1414        int noerr=1;
    … …  
    2424        //_printf_("      Configuring nodes...\n");
    2525        nodes->Configure(elements,loads,nodes,vertices,materials,parameters);
    26         //_printf_("      Configuring vertices...\n");
    27         vertices->Configure(elements,loads,vertices,materials,parameters);
    2826        //_printf_("      Configuring parameters...\n");
    2927        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);

  • issm/trunk/src/c/CostFunctionx/CostFunctionx.cpp

    r3332 r3446  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void CostFunctionx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials,DataSet* parameters,
     13void CostFunctionx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,DataSet* parameters,
    1414                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type){
    1515
    … …  
    2323       
    2424        /*First, get elements and loads configured: */
    25         elements->Configure(elements,loads, nodes, materials,parameters);
    26         parameters->Configure(elements,loads, nodes, materials,parameters);
     25        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     26        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2727
    2828        /*If fit=3, compute Surface Area*/
    … …  
    3030        if (fit==3 && !inputs->IsPresent("surfacearea")){
    3131
    32                 SurfaceAreax(&S,elements,nodes,loads,materials,parameters,inputs,analysis_type,sub_analysis_type);
     32                SurfaceAreax(&S,elements,nodes,vertices,loads,materials,parameters,inputs,analysis_type,sub_analysis_type);
    3333                inputs->Add("surfacearea",S);
    3434        }

  • issm/trunk/src/c/CostFunctionx/CostFunctionx.h

    r3169 r3446  
    77
    88#include "../DataSet/DataSet.h"
     9#include "../objects/objects.h"
    910
    1011/* local prototypes: */
    11 void CostFunctionx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,
     12void CostFunctionx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,
    1213                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
    1314

  • issm/trunk/src/c/DataSet/DataSet.cpp

    r3420 r3446  
    16501650}
    16511651/*}}}*/
    1652 /*FUNCTION DataSet::UpdateNodePositions{{{1*/
    1653 void  DataSet::UpdateNodePositions(double* thickness,double* bed){
    1654 
    1655         vector<Object*>::iterator object;
    1656         Node* node=NULL;
    1657 
    1658         for ( object=objects.begin() ; object < objects.end(); object++ ){
    1659 
    1660                 if((*object)->Enum()==NodeEnum()){
    1661 
    1662                         node=(Node*)(*object);
    1663                         node->UpdateNodePosition(thickness,bed);
    1664                 }
    1665         }
    1666 }
    1667 /*}}}*/
     1652/*FUNCTION DataSet::UpdateVertexPositions{{{1*/
     1653void  DataSet::UpdateVertexPositions(double* thickness,double* bed){
     1654
     1655        vector<Object*>::iterator object;
     1656        Vertex* vertex=NULL;
     1657
     1658        for ( object=objects.begin() ; object < objects.end(); object++ ){
     1659
     1660                if((*object)->Enum()==VertexEnum()){
     1661
     1662                        vertex=(Vertex*)(*object);
     1663                        vertex->UpdatePosition(thickness,bed);
     1664                }
     1665        }
     1666}
     1667/*}}}*/

  • issm/trunk/src/c/DataSet/DataSet.h

    r3420 r3446  
    9494                int   FindResult(void* pvalue, char* name);
    9595                void  FieldExtrude(Vec field,double* field_serial,char* field_name, int collapse);
    96                 void  UpdateNodePositions(double* thickness,double* bed);
     96                void  UpdateVertexPositions(double* thickness,double* bed);
    9797                void  OutputRifts(Vec riftproperties);
    9898                /*}}}*/

  • issm/trunk/src/c/Dofx/Dofx.h

    r3417 r3446  
    77
    88#include "../DataSet/DataSet.h"
     9#include "../objects/objects.h"
    910
    1011/* local prototypes: */

  • issm/trunk/src/c/Dux/Dux.cpp

    r3332 r3446  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void Dux( Vec* pdu_g, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,
     13void Dux( Vec* pdu_g, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,
    1414                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type){
    1515
    … …  
    2525
    2626        /*First, get elements and loads configured: */
    27         elements->Configure(elements,loads, nodes, materials,parameters);
    28         parameters->Configure(elements,loads, nodes, materials,parameters);
     27        elements->Configure(elements,loads, nodes, vertices, materials,parameters);
     28        parameters->Configure(elements,loads, nodes, vertices, materials,parameters);
    2929
    3030        /*If fit=3, compute Surface Area*/
    … …  
    3232        if (fit==3 && !inputs->IsPresent("surfacearea")){
    3333
    34                 SurfaceAreax(&S,elements,nodes,loads,materials,parameters,inputs,analysis_type,sub_analysis_type);
     34                SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters,inputs,analysis_type,sub_analysis_type);
    3535                inputs->Add("surfacearea",S);
    3636        }

  • issm/trunk/src/c/Dux/Dux.h

    r2333 r3446  
    66#define _DUX_H
    77
     8#include "../objects/objects.h"
    89#include "../DataSet/DataSet.h"
    910
    1011/* local prototypes: */
    11 void Dux( Vec* pdu_g, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,
     12void Dux( Vec* pdu_g, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,
    1213                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
    1314

  • issm/trunk/src/c/FieldAverageOntoVerticesx/FieldAverageOntoVerticesx.cpp

    r3372 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void FieldAverageOntoVerticesx( Vec field, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,char* fieldname){
     12void FieldAverageOntoVerticesx( Vec field, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,char* fieldname){
    1313
    1414        double* field_serial=NULL;
    1515
    1616        /*First, get elements and nodes configured: */
    17         elements->Configure(elements,loads, nodes, materials,parameters);
    18         nodes->Configure(elements,loads, nodes, materials,parameters);
    19         parameters->Configure(elements,loads, nodes, materials,parameters);
     17        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     18        nodes->Configure(elements,loads, nodes,vertices, materials,parameters);
     19        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2020
    2121        /*Serialize field: */

  • issm/trunk/src/c/FieldAverageOntoVerticesx/FieldAverageOntoVerticesx.h

    r3372 r3446  
    99
    1010/* local prototypes: */
    11 void FieldAverageOntoVerticesx( Vec field, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,char* fieldname);
     11void FieldAverageOntoVerticesx( Vec field, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,char* fieldname);
    1212
    1313#endif  /* _FIELDDEPTHAVERAGEX_H */

  • issm/trunk/src/c/FieldDepthAveragex/FieldDepthAveragex.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void FieldDepthAveragex( Vec field, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,char* fieldname){
     12void FieldDepthAveragex( Vec field, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,char* fieldname){
    1313
    1414        double* field_serial=NULL;
    1515
    1616        /*First, get elements and nodes configured: */
    17         elements->Configure(elements,loads, nodes, materials,parameters);
    18         nodes->Configure(elements,loads, nodes, materials,parameters);
    19         parameters->Configure(elements,loads, nodes, materials,parameters);
     17        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     18        nodes->Configure(elements,loads, nodes,vertices, materials,parameters);
     19        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2020
    2121        /*Serialize field: */

  • issm/trunk/src/c/FieldDepthAveragex/FieldDepthAveragex.h

    r2333 r3446  
    99
    1010/* local prototypes: */
    11 void FieldDepthAveragex( Vec field, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,char* fieldname);
     11void FieldDepthAveragex( Vec field, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,char* fieldname);
    1212
    1313#endif  /* _FIELDDEPTHAVERAGEX_H */

  • issm/trunk/src/c/FieldExtrudex/FieldExtrudex.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void FieldExtrudex( Vec field, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,char* field_name,int collapse){
     12void FieldExtrudex( Vec field, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,char* field_name,int collapse){
    1313
    1414        double* field_serial=NULL;
    1515
    1616        /*First, get elements and nodes configured: */
    17         elements->Configure(elements,loads, nodes, materials,parameters);
    18         nodes->Configure(elements,loads, nodes, materials,parameters);
    19         parameters->Configure(elements,loads, nodes, materials,parameters);
     17        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     18        nodes->Configure(elements,loads, nodes,vertices, materials,parameters);
     19        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2020
    2121        /*Serialize field: */

  • issm/trunk/src/c/FieldExtrudex/FieldExtrudex.h

    r2333 r3446  
    99
    1010/* local prototypes: */
    11 void FieldExtrudex( Vec field, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,char* field_name, int collapse);
     11void FieldExtrudex( Vec field, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,char* field_name, int collapse);
    1212
    1313#endif  /* _FIELDEXTRUDEX_H */

  • issm/trunk/src/c/Gradjx/Gradjx.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void Gradjx( Vec* pgrad_g, int numberofnodes, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,
     12void Gradjx( Vec* pgrad_g, int numberofnodes, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,
    1313                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type,char* control_type){
    1414
    … …  
    1717
    1818        /*First, get elements and loads configured: */
    19         elements->Configure(elements,loads, nodes, materials,parameters);
    20         parameters->Configure(elements,loads, nodes, materials,parameters);
     19        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     20        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2121
    2222        /*Allocate grad_g: */

  • issm/trunk/src/c/Gradjx/Gradjx.h

    r2333 r3446  
    77
    88#include "../DataSet/DataSet.h"
     9#include "../objects/objects.h"
    910
    1011/* local prototypes: */
    11 void Gradjx( Vec* pgrad_g, int numberofnodes, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials,  DataSet* parameters,
     12void Gradjx( Vec* pgrad_g, int numberofnodes, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,  DataSet* parameters,
    1213                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type,char* control_type);
    1314

  • issm/trunk/src/c/Makefile.am

    r3417 r3446  
    270270                                        ./UpdateGeometryx/UpdateGeometryx.h\
    271271                                        ./UpdateGeometryx/UpdateGeometryx.cpp\
    272                                         ./UpdateNodePositionsx/UpdateNodePositionsx.h\
    273                                         ./UpdateNodePositionsx/UpdateNodePositionsx.cpp\
     272                                        ./UpdateVertexPositionsx/UpdateVertexPositionsx.h\
     273                                        ./UpdateVertexPositionsx/UpdateVertexPositionsx.cpp\
    274274                                        ./ConfigureObjectsx/ConfigureObjectsx.h\
    275275                                        ./ConfigureObjectsx/ConfigureObjectsx.cpp\
    … …  
    666666                                        ./UpdateGeometryx/UpdateGeometryx.h\
    667667                                        ./UpdateGeometryx/UpdateGeometryx.cpp\
    668                                         ./UpdateNodePositionsx/UpdateNodePositionsx.h\
    669                                         ./UpdateNodePositionsx/UpdateNodePositionsx.cpp\
     668                                        ./UpdateVertexPositionsx/UpdateVertexPositionsx.h\
     669                                        ./UpdateVertexPositionsx/UpdateVertexPositionsx.cpp\
    670670                                        ./ConfigureObjectsx/ConfigureObjectsx.h\
    671671                                        ./ConfigureObjectsx/ConfigureObjectsx.cpp\

  • issm/trunk/src/c/MassFluxx/MassFluxx.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials,DataSet* parameters,  double* segments,int num_segments,double* ug){
     12void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials,DataSet* parameters,  double* segments,int num_segments,double* ug){
    1313
    1414        int i,j;
    … …  
    2424
    2525        /*First, get elements and loads configured: */
    26         elements->Configure(elements,loads, nodes, materials,parameters);
    27         loads->Configure(elements, loads, nodes, materials,parameters);
    28         parameters->Configure(elements,loads, nodes, materials,parameters);
     26        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     27        loads->Configure(elements, loads, nodes,vertices, materials,parameters);
     28        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2929
    3030        /*Go through segments, and then elements, and figure out which elements belong to a segment.

  • issm/trunk/src/c/MassFluxx/MassFluxx.h

    r2333 r3446  
    1010
    1111/* local prototypes: */
    12 void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials, DataSet* parameters,double* segments,int num_segments,double* ug);
     12void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, DataSet* parameters,double* segments,int num_segments,double* ug);
    1313
    1414

  • issm/trunk/src/c/Misfitx/Misfitx.cpp

    r3332 r3446  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials,DataSet* parameters,
     13void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,DataSet* parameters,
    1414                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type){
    1515       
    … …  
    2323       
    2424        /*First, get elements and loads configured: */
    25         elements->Configure(elements,loads, nodes, materials,parameters);
    26         parameters->Configure(elements,loads, nodes, materials,parameters);
     25        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     26        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2727
    2828        /*If fit=3, compute Surface Area*/
    … …  
    3030        if (fit==3 && !inputs->IsPresent("surfacearea")){
    3131
    32                 SurfaceAreax(&S,elements,nodes,loads,materials,parameters,inputs,analysis_type,sub_analysis_type);
     32                SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters,inputs,analysis_type,sub_analysis_type);
    3333                inputs->Add("surfacearea",S);
    3434        }

  • issm/trunk/src/c/Misfitx/Misfitx.h

    r3169 r3446  
    77
    88#include "../DataSet/DataSet.h"
     9#include "../objects/objects.h"
    910
    1011/* local prototypes: */
    11 void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,
     12void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,
    1213                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
    1314

  • issm/trunk/src/c/ModelProcessorx/Balancedvelocities/CreateConstraintsBalancedvelocities.cpp

    r3439 r3446  
    4040        #ifdef _PARALLEL_
    4141        /*keep only this partition's nodes:*/
    42         if((iomodel->my_grids[i]==1)){
     42        if((iomodel->my_vertices[i]==1)){
    4343        #endif
    4444
    … …  
    5757
    5858        #ifdef _PARALLEL_
    59         } //if((my_grids[i]==1))
     59        } //if((my_vertices[i]==1))
    6060        #endif
    6161        }

  • issm/trunk/src/c/ModelProcessorx/DiagnosticHutter/CreateConstraintsDiagnosticHutter.cpp

    r3439 r3446  
    4848        #ifdef _PARALLEL_
    4949        /*keep only this partition's nodes:*/
    50         if((iomodel->my_grids[i])){
     50        if((iomodel->my_vertices[i])){
    5151        #endif
    5252
    … …  
    7373
    7474        #ifdef _PARALLEL_
    75         } //if((my_grids[i]))
     75        } //if((my_vertices[i]))
    7676        #endif
    7777        }

  • issm/trunk/src/c/ModelProcessorx/DiagnosticStokes/CreateConstraintsDiagnosticStokes.cpp

    r3439 r3446  
    4141        #ifdef _PARALLEL_
    4242        /*keep only this partition's nodes:*/
    43         if((iomodel->my_grids[i]==1)){
     43        if((iomodel->my_vertices[i]==1)){
    4444        #endif
    4545
    … …  
    7777
    7878        #ifdef _PARALLEL_
    79         } //if((my_grids[i]==1))
     79        } //if((my_vertices[i]==1))
    8080        #endif
    8181        }

  • issm/trunk/src/c/ModelProcessorx/DiagnosticStokes/CreateLoadsDiagnosticStokes.cpp

    r3442 r3446  
    8686        #ifdef _PARALLEL_
    8787        /*keep only this partition's nodes:*/
    88         if((iomodel->my_grids[i]==1)){
     88        if((iomodel->my_vertices[i]==1)){
    8989        #endif
    9090
    … …  
    103103                }
    104104        #ifdef _PARALLEL_
    105         } //if((iomodel->my_grids[i]==1))
     105        } //if((iomodel->my_vertices[i]==1))
    106106        #endif
    107107        }

  • issm/trunk/src/c/ModelProcessorx/IoModel.h

    r3417 r3446  
    180180        bool*   my_vertices;
    181181        bool*   my_nodes;
    182         double* my_bordervertices;
     182        bool*  my_bordervertices;
    183183        int*    penaltypartitioning;
    184184
    … …  
    273273       
    274274        /*partitioning: */
    275         void  Partitioning(bool** pmy_elements, bool** pmy_vertices, bool** pmy_nodes, double** pmy_bordervertices, IoModel* iomodel, ConstDataHandle iomodel_handle);
     275        void  Partitioning(bool** pmy_elements, bool** pmy_vertices, bool** pmy_nodes, bool** pmy_bordervertices, IoModel* iomodel, ConstDataHandle iomodel_handle);
    276276
    277277#endif  /* _IOMODEL_H */

  • issm/trunk/src/c/ModelProcessorx/Melting/CreateLoadsMelting.cpp

    r3439 r3446  
    5252        #ifdef _PARALLEL_
    5353        /*keep only this partition's nodes:*/
    54         if((iomodel->my_grids[i]==1)){
     54        if((iomodel->my_vertices[i]==1)){
    5555        #endif
    5656
    … …  
    7171                }
    7272        #ifdef _PARALLEL_
    73         } //if((iomodel->my_grids[i]==1))
     73        } //if((iomodel->my_vertices[i]==1))
    7474        #endif
    7575        }

  • issm/trunk/src/c/ModelProcessorx/Partitioning.cpp

    r3420 r3446  
    1515#include "../include/macros.h"
    1616#include "../include/typedefs.h"
     17#include "../MeshPartitionx/MeshPartitionx.h"
    1718
    1819void  DiscontinuousGalerkinPartitioning(bool** pmy_elements, bool** pmy_vertices, bool** pmy_nodes, bool** pmy_bordervertices, IoModel* iomodel, ConstDataHandle iomodel_handle);
    … …  
    135136                my_bordervertices=(bool*)xcalloc(iomodel->numberofvertices,sizeof(bool));
    136137                for(i=0;i<iomodel->numberofvertices;i++){
    137                         if(serial_bordervertices>1)my_bordervertices[i]=1;
     138                        if(serial_bordervertices[i]>1)my_bordervertices[i]=1;
    138139                }
    139140        #else

  • issm/trunk/src/c/ModelProcessorx/Prognostic/CreateConstraintsPrognostic.cpp

    r3439 r3446  
    4141        #ifdef _PARALLEL_
    4242        /*keep only this partition's nodes:*/
    43         if((iomodel->my_grids[i]==1)){
     43        if((iomodel->my_vertices[i]==1)){
    4444        #endif
    4545
    … …  
    5959
    6060        #ifdef _PARALLEL_
    61         } //if((my_grids[i]==1))
     61        } //if((my_vertices[i]==1))
    6262        #endif
    6363        }

  • issm/trunk/src/c/ModelProcessorx/Qmu/CreateParametersQmu.cpp

    r3436 r3446  
    2121        int      second_count;
    2222       
    23         int*     epart=NULL;
    2423        int*     part=NULL;
    2524        double*  dpart=NULL;
    26         int      elements_width;
    2725
    2826        char**  responsedescriptors=NULL;
    … …  
    173171
    174172
    175                 /*partition grids in iomodel->qmu_npart parts, unless a partition is already present: */
     173                /*partition vertices in iomodel->qmu_npart parts, unless a partition is already present: */
    176174                IoModelFetchData(&dpart,NULL,NULL,iomodel_handle,"part");
    177175
    178176                if(!dpart){
    179177
    180                         if(strcmp(iomodel->meshtype,"2d")==0){
    181                                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    182                                 elements_width=3; //tria elements
    183                         }
    184                         else{
    185                                 IoModelFetchData(&iomodel->elements2d,NULL,NULL,iomodel_handle,"elements2d");
    186                                 elements_width=6; //penta elements
    187                         }
    188 
    189                         MeshPartitionx(&epart, &part,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements, iomodel->numberofelements2d,iomodel->numberofvertices2d,iomodel->elements2d,iomodel->numlayers,elements_width, iomodel->meshtype,iomodel->qmu_npart);
     178                        /*Partition elements and vertices and nodes: */
     179                        Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
    190180
    191181                        dpart=(double*)xmalloc(iomodel->numberofvertices*sizeof(double));
    192                         for(i=0;i<iomodel->numberofvertices;i++)dpart[i]=part[i];
     182                        for(i=0;i<iomodel->numberofvertices;i++)dpart[i]=iomodel->my_vertices[i];
    193183                }
    194184
    … …  
    235225
    236226                                        /*Only if partitioning exist do we care about the segments: */
    237                                         if(iomodel->epart){
     227                                        if(iomodel->my_elements){
    238228
    239229                                                /*Use the element partitioning vector from the iomodel to down select qmu_mass_flux_segments to only segments that are relevant
    … …  
    241231                                                my_num_qmu_mass_flux_segments=0;
    242232                                                for(j=0;j<num_qmu_mass_flux_segments;j++){
    243                                                         if (  iomodel->epart[(int)(*(qmu_mass_flux_segments+5*j+4))-1]   == my_rank)my_num_qmu_mass_flux_segments++;
     233                                                        if (  iomodel->my_elements[(int)(*(qmu_mass_flux_segments+5*j+4))-1])my_num_qmu_mass_flux_segments++;
    244234                                                }
    245235
    … …  
    249239                                                        second_count=0;
    250240                                                        for(j=0;j<num_qmu_mass_flux_segments;j++){
    251                                                                 if (iomodel->epart[(int)*(qmu_mass_flux_segments+5*j+4)-1]==my_rank){
     241                                                                if (iomodel->my_elements[(int)*(qmu_mass_flux_segments+5*j+4)-1]){
    252242                                                                        for(k=0;k<5;k++)*(my_qmu_mass_flux_segments+5*second_count+k)=*(qmu_mass_flux_segments+5*j+k);
    253243                                                                        second_count++;
    … …  
    321311                xfree((void**)&iomodel->elements);
    322312                xfree((void**)&iomodel->elements2d);
    323                 xfree((void**)&epart);
    324313                xfree((void**)&part);
    325314                xfree((void**)&dpart);

  • issm/trunk/src/c/ModelProcessorx/Thermal/CreateConstraintsThermal.cpp

    r3439 r3446  
    4343        #ifdef _PARALLEL_
    4444        /*keep only this partition's nodes:*/
    45         if((iomodel->my_grids[i]==1)){
     45        if((iomodel->my_vertices[i]==1)){
    4646        #endif
    4747

  • issm/trunk/src/c/ModelProcessorx/Thermal/CreateLoadsThermal.cpp

    r3439 r3446  
    5353        #ifdef _PARALLEL_
    5454        /*keep only this partition's nodes:*/
    55         if((iomodel->my_grids[i]==1)){
     55        if((iomodel->my_vertices[i]==1)){
    5656        #endif
    5757
    … …  
    7272                }
    7373        #ifdef _PARALLEL_
    74         } //if((iomodel->my_grids[i]==1))
     74        } //if((iomodel->my_vertices[i]==1))
    7575        #endif
    7676        }

  • issm/trunk/src/c/PenaltyConstraintsx/PenaltyConstraintsx.cpp

    r3332 r3446  
    1111#include "../EnumDefinitions/EnumDefinitions.h"
    1212
    13 void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes,
     13void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices,
    1414                DataSet* loads,DataSet* materials,  DataSet* parameters,ParameterInputs* inputs,int analysis_type,int sub_analysis_type){
    1515
    … …  
    2828
    2929        /*First, get loads configured: */
    30         loads->Configure(elements, loads, nodes, materials,parameters);
     30        loads->Configure(elements, loads, nodes,vertices, materials,parameters);
    3131
    3232        /*Do we have penalties linked to rifts? In this case, run our special rifts penalty

  • issm/trunk/src/c/PenaltyConstraintsx/PenaltyConstraintsx.h

    r2333 r3446  
    1010
    1111/* local prototypes: */
    12 void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes,
     12void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices,
    1313                DataSet* loads,DataSet* materials,  DataSet* parameters,ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
    1414

  • issm/trunk/src/c/PenaltySystemMatricesx/PenaltySystemMatricesx.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void PenaltySystemMatricesx(Mat Kgg, Vec pg,double* pkmax,DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials, DataSet* parameters,
     12void PenaltySystemMatricesx(Mat Kgg, Vec pg,double* pkmax,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, DataSet* parameters,
    1313                int kflag,int pflag,ParameterInputs* inputs,int analysis_type,int sub_analysis_type){
    1414       
    … …  
    2020       
    2121        /*First, get elements and loads configured: */
    22         elements->Configure(elements,loads, nodes, materials,parameters);
    23         loads->Configure(elements, loads, nodes, materials,parameters);
    24         parameters->Configure(elements,loads, nodes, materials,parameters);
     22        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     23        loads->Configure(elements, loads, nodes,vertices, materials,parameters);
     24        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2525
    2626        /*Now, figure out maximum value of K_gg, so that we can penalize it correctly: */

  • issm/trunk/src/c/PenaltySystemMatricesx/PenaltySystemMatricesx.h

    r2333 r3446  
    1010
    1111/* local prototypes: */
    12 void PenaltySystemMatricesx(Mat Kgg, Vec pg,double* pkmax, DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials, DataSet* parameters,
     12void PenaltySystemMatricesx(Mat Kgg, Vec pg,double* pkmax, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, DataSet* parameters,
    1313                int kflag,int pflag,ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
    1414

  • issm/trunk/src/c/Qmux/DakotaResponses.cpp

    r3332 r3446  
    263263
    264264                        /*Compute misfit: */
    265                         Misfitx( &J, femmodel->elements,femmodel->nodes, femmodel->loads, femmodel->materials, femmodel->parameters,inputs,analysis_type,sub_analysis_type);
     265                        Misfitx( &J, femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,inputs,analysis_type,sub_analysis_type);
    266266                       
    267267
    … …  
    317317
    318318                        /*call mass flux module: */
    319                         MassFluxx(&mass_flux,femmodel->elements,femmodel->nodes,femmodel->loads,femmodel->materials,femmodel->parameters,segments,num_segments,ug_serial);
     319                        MassFluxx(&mass_flux,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,segments,num_segments,ug_serial);
    320320                       
    321321                        if(my_rank==0)responses[i]=mass_flux;

  • issm/trunk/src/c/Qmux/Qmux.h

    r3042 r3446  
    77
    88#include "../DataSet/DataSet.h"
     9#include "../objects/objects.h"
    910
    1011/* local prototypes: */

  • issm/trunk/src/c/SpcNodesx/SpcNodesx.h

    r2316 r3446  
    66#define _SPCNODESX_H
    77
     8#include "../objects/objects.h"
    89#include "../DataSet/DataSet.h"
    910#include "../toolkits/toolkits.h"
    1011
    1112/* local prototypes: */
    12 void    SpcNodesx( DofVec** pyg, DataSet* nodesin,DataSet* constraints);
     13void SpcNodesx( DofVec** pyg, DataSet* nodesin,DataSet* constraints);
    1314
    1415#endif  /* _SPCNODESX_H */

  • issm/trunk/src/c/SurfaceAreax/SurfaceAreax.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials,DataSet* parameters,
     12void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,DataSet* parameters,
    1313                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type){
    1414       
    … …  
    1818       
    1919        /*First, get elements and loads configured: */
    20         elements->Configure(elements,loads, nodes, materials,parameters);
    21         parameters->Configure(elements,loads, nodes, materials,parameters);
     20        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     21        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2222
    2323        /*Compute gradients: */

  • issm/trunk/src/c/SurfaceAreax/SurfaceAreax.h

    r3180 r3446  
    66#define _SURFACEAREAX_H
    77
     8#include "../objects/objects.h"
    89#include "../DataSet/DataSet.h"
    910
    1011/* local prototypes: */
    11 void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,
     12void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,
    1213                        ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
    1314

  • issm/trunk/src/c/SystemMatricesx/SystemMatricesx.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void SystemMatricesx(Mat* pKgg, Vec* ppg,DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials, DataSet* parameters,
     12void SystemMatricesx(Mat* pKgg, Vec* ppg,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, DataSet* parameters,
    1313                int kflag,int pflag,int connectivity,int numberofdofspernode,ParameterInputs* inputs,int analysis_type,int sub_analysis_type){
    1414       
    … …  
    2626
    2727        /*First, get elements and loads configured: */
    28         elements->Configure(elements,loads, nodes, materials,parameters);
    29         loads->Configure(elements, loads, nodes, materials,parameters);
    30         parameters->Configure(elements,loads, nodes, materials,parameters);
     28        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     29        loads->Configure(elements, loads, nodes,vertices, materials,parameters);
     30        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    3131
    3232        /*Get size of matrix: */

  • issm/trunk/src/c/SystemMatricesx/SystemMatricesx.h

    r2333 r3446  
    1010
    1111/* local prototypes: */
    12 void SystemMatricesx(Mat* pKgg, Vec* ppg,DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials, DataSet* parameters,
     12void SystemMatricesx(Mat* pKgg, Vec* ppg,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, DataSet* parameters,
    1313                int kflag,int pflag,int connectivity,int numberofdofspernode,ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
    1414

  • issm/trunk/src/c/UpdateFromInputsx/UpdateFromInputsx.cpp

    r3332 r3446  
    1010#include "../EnumDefinitions/EnumDefinitions.h"
    1111
    12 int UpdateFromInputsx( DataSet* elements,DataSet* nodes, DataSet* loads, DataSet* materials, DataSet* parameters,ParameterInputs* inputs) {
     12int UpdateFromInputsx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, DataSet* parameters,ParameterInputs* inputs) {
    1313
    1414        int noerr=1;
    … …  
    2020
    2121        /*First, get elements and loads configured: */
    22         elements->Configure(elements,loads, nodes, materials,parameters);
    23         loads->Configure(elements, loads, nodes, materials,parameters);
    24         nodes->Configure(elements, loads, nodes, materials,parameters);
    25         parameters->Configure(elements,loads, nodes, materials,parameters);
     22        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     23        loads->Configure(elements, loads, nodes,vertices, materials,parameters);
     24        nodes->Configure(elements, loads, nodes,vertices, materials,parameters);
     25        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    2626
    2727        /*Update elements, nodes, loads and materials from inputs: */

  • issm/trunk/src/c/UpdateFromInputsx/UpdateFromInputsx.h

    r2333 r3446  
    66#define _UPDATEFROMINPUTSXX_H
    77
     8#include "../objects/objects.h"
    89#include "../DataSet/DataSet.h"
    9 #include "../objects/ParameterInputs.h"
    1010
    1111/* local prototypes: */
    12 int             UpdateFromInputsx( DataSet* elements,DataSet* nodes,DataSet* loads, DataSet* materials,  DataSet* parameters,ParameterInputs* inputs);
     12int             UpdateFromInputsx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  DataSet* parameters,ParameterInputs* inputs);
    1313
    1414#endif  /* _UPDATEFROMINPUTSXX_H */

  • issm/trunk/src/c/UpdateGeometryx/UpdateGeometryx.cpp

    r3332 r3446  
    1212
    1313void UpdateGeometryx(Vec* poutthickness,Vec* poutbed,Vec* poutsurface,
    14                 DataSet* elements, DataSet* nodes,DataSet* loads, DataSet* materials, DataSet* parameters,
     14                DataSet* elements, DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials, DataSet* parameters,
    1515                Vec vec_newthickness,Vec vec_bed,Vec vec_surface){
    1616
    … …  
    4343
    4444        /*First, get elements and loads configured: */
    45         elements->Configure(elements,loads, nodes, materials,parameters);
    46         materials->Configure(elements, loads, nodes, materials,parameters);
    47         loads->Configure(elements, loads, nodes, materials,parameters);
    48         parameters->Configure(elements,loads, nodes, materials,parameters);
     45        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
     46        materials->Configure(elements, loads, nodes,vertices, materials,parameters);
     47        loads->Configure(elements, loads, nodes,vertices, materials,parameters);
     48        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    4949
    5050        /*Serialize inputs :*/

  • issm/trunk/src/c/UpdateGeometryx/UpdateGeometryx.h

    r2333 r3446  
    1111/* local prototypes: */
    1212void UpdateGeometryx(Vec* poutthickness,Vec* poutbed,Vec* poutsurface,
    13                 DataSet* elements, DataSet* nodes,DataSet* loads, DataSet* materials, DataSet* parameters,
     13                DataSet* elements, DataSet* nodes,DataSet* vertices,DataSet* loads, DataSet* materials, DataSet* parameters,
    1414                Vec newthickness,Vec bed,Vec surface);
    1515

  • issm/trunk/src/c/issm.h

    r3372 r3446  
    4141#include "./UpdateFromInputsx/UpdateFromInputsx.h"
    4242#include "./UpdateGeometryx/UpdateGeometryx.h"
    43 #include "./UpdateNodePositionsx/UpdateNodePositionsx.h"
     43#include "./UpdateVertexPositionsx/UpdateVertexPositionsx.h"
    4444#include "./PenaltySystemMatricesx/PenaltySystemMatricesx.h"
    4545#include "./Reducematrixfromgtofx/Reducematrixfromgtofx.h"

  • issm/trunk/src/c/objects/ElementProperties.cpp

    r3420 r3446  
    4444        this->thermal_steadystate=0;
    4545        return;
     46}
     47/*}}}*/
     48/*FUNCTION ElementProperties copy constructor {{{1*/
     49ElementProperties::ElementProperties(ElementProperties* in){
     50       
     51        int i;
     52
     53        this->numnodes=in->numnodes;
     54
     55        if(in->h){
     56                this->h=(double*)xmalloc(this->numnodes*sizeof(double));
     57                for(i=0;i<this->numnodes;i++)this->h[i]=in->h[i];
     58        }
     59        else this->h=NULL;
     60
     61        this->numnodes=in->numnodes;
     62        if(in->s){
     63                this->s=(double*)xmalloc(this->numnodes*sizeof(double));
     64                for(i=0;i<this->numnodes;i++)this->s[i]=in->s[i];
     65        }
     66        else this->s=NULL;
     67
     68
     69        this->numnodes=in->numnodes;
     70        if(in->b){
     71                this->b=(double*)xmalloc(this->numnodes*sizeof(double));
     72                for(i=0;i<this->numnodes;i++)this->b[i]=in->b[i];
     73        }
     74        else this->b=NULL;
     75
     76
     77        this->numnodes=in->numnodes;
     78        if(in->k){
     79                this->k=(double*)xmalloc(this->numnodes*sizeof(double));
     80                for(i=0;i<this->numnodes;i++)this->k[i]=in->k[i];
     81        }
     82        else this->k=NULL;
     83
     84
     85        this->numnodes=in->numnodes;
     86        if(in->melting){
     87                this->melting=(double*)xmalloc(this->numnodes*sizeof(double));
     88                for(i=0;i<this->numnodes;i++)this->melting[i]=in->melting[i];
     89        }
     90        else this->melting=NULL;
     91
     92
     93        this->numnodes=in->numnodes;
     94        if(in->accumulation){
     95                this->accumulation=(double*)xmalloc(this->numnodes*sizeof(double));
     96                for(i=0;i<this->numnodes;i++)this->accumulation[i]=in->accumulation[i];
     97        }
     98        else this->accumulation=NULL;
     99
     100
     101        this->numnodes=in->numnodes;
     102        if(in->geothermalflux){
     103                this->geothermalflux=(double*)xmalloc(this->numnodes*sizeof(double));
     104                for(i=0;i<this->numnodes;i++)this->geothermalflux[i]=in->geothermalflux[i];
     105        }
     106        else this->geothermalflux=NULL;
     107
     108
     109        this->friction_type=in->friction_type;
     110        this->p=in->p;
     111        this->q=in->q;
     112        this->shelf=in->shelf;
     113        this->onbed=in->onbed;
     114        this->onwater=in->onwater;
     115        this->onsurface=in->onsurface;
     116        this->collapse=in->collapse;
     117        this->thermal_steadystate=in->thermal_steadystate;
     118
    46119}
    47120/*}}}*/

  • issm/trunk/src/c/objects/Node.cpp

    r3442 r3446  
    278278}
    279279/*}}}*/
     280/*FUNCTION Node GetDof {{{2*/
     281int   Node::GetDof(int dofindex){
     282
     283        return indexing.doflist[dofindex];
     284
     285}
     286/*}}}*/
     287/*FUNCTION Node GetDofList1{{{2*/
     288int  Node::GetDofList1(void){
     289
     290        Vertex* vertex=NULL;
     291
     292        vertex=(Vertex*)this->hvertex.delivers();
     293
     294        return vertex->dof;
     295}
     296/*}}}*/
     297/*FUNCTION Node GetDofList{{{2*/
     298void  Node::GetDofList(int* outdoflist,int* pnumberofdofspernode){
     299
     300        int i;
     301        for(i=0;i<this->indexing.numberofdofs;i++){
     302                outdoflist[i]=indexing.doflist[i];
     303        }
     304        /*Assign output pointers:*/
     305        *pnumberofdofspernode=this->indexing.numberofdofs;
     306}
     307/*}}}*/
    280308/*FUNCTION Node GetId{{{2*/
    281309int    Node::GetId(void){ return id; }
    … …  
    728756}
    729757/*}}}*/
    730 /*FUNCTION Node GetDof {{{2*/
    731 int   Node::GetDof(int dofindex){
    732 
    733         return indexing.doflist[dofindex];
    734 
    735 }
    736 /*}}}*/
    737 /*FUNCTION Node GetDofList{{{2*/
    738 void  Node::GetDofList(int* outdoflist,int* pnumberofdofspernode){
    739 
    740         int i;
    741         for(i=0;i<this->indexing.numberofdofs;i++){
    742                 outdoflist[i]=indexing.doflist[i];
    743         }
    744         /*Assign output pointers:*/
    745         *pnumberofdofspernode=this->indexing.numberofdofs;
    746 }
    747 /*}}}*/
    748758/*FUNCTION Node GetNumberOfDofs{{{2*/
    749759int   Node::GetNumberOfDofs(){

  • issm/trunk/src/c/objects/Node.h

    r3439 r3446  
    9393                int   IsOnSheet();
    9494                void  FieldExtrude(Vec field,double* field_serial,char* field_name);
    95                 void  UpdateNodePosition(double* thickness,double* bed);
    9695                /*}}}*/
    9796};

  • issm/trunk/src/c/parallel/ControlInitialization.cpp

    r3332 r3446  
    8383        diagnostic_core_linear(&slopex,fem_sl,inputs,SlopecomputeAnalysisEnum(),BedXAnalysisEnum());
    8484        diagnostic_core_linear(&slopey,fem_sl,inputs,SlopecomputeAnalysisEnum(),BedYAnalysisEnum());
    85         FieldExtrudex( slopex, fem_sl->elements,fem_sl->nodes,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopex",0);
    86         FieldExtrudex( slopey, fem_sl->elements,fem_sl->nodes,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopey",0);
     85        FieldExtrudex( slopex, fem_sl->elements,fem_sl->nodes,fem_sl->vertices,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopex",0);
     86        FieldExtrudex( slopey, fem_sl->elements,fem_sl->nodes,fem_sl->vertices,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopey",0);
    8787
    8888        //Add in inputs
    … …  
    9797        diagnostic_core_nonlinear(&ug,NULL,NULL,NULL,fem_dh,inputs,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
    9898        if(verbose)_printf_("%s\n"," extruding horizontal velocities...");
    99         VecDuplicatePatch(&ug_horiz,ug); FieldExtrudex( ug_horiz,fem_dh->elements,fem_dh->nodes, fem_dh->loads,fem_dh-> materials,fem_dh->parameters,"velocity",1);
     99        VecDuplicatePatch(&ug_horiz,ug); FieldExtrudex( ug_horiz,fem_dh->elements,fem_dh->nodes, fem_dh->vertices,fem_dh->loads,fem_dh-> materials,fem_dh->parameters,"velocity",1);
    100100
    101101        //vertical velocity
    … …  
    113113        //Create 4d u_g
    114114        if(verbose)_printf_("%s\n"," computing pressure according to Pattyn...");
    115         ComputePressurex( &pg,fem_dh->elements, fem_dh->nodes, fem_dh->loads,  fem_dh->materials, fem_dh->parameters);
     115        ComputePressurex( &pg,fem_dh->elements, fem_dh->nodes, fem_dh->vertices,fem_dh->loads,  fem_dh->materials, fem_dh->parameters);
    116116        VecScale(pg,1.0/stokesreconditioning);
    117117        ug_stokes=NewVec(fem_ds->nodesets->GetGSize());

  • issm/trunk/src/c/parallel/OutputResults.cpp

    r3332 r3446  
    1212#include "../DataSet/DataSet.h"
    1313#include "../io/io.h"
     14#include "../objects/objects.h"
    1415
    1516void OutputResults(DataSet* results,char* filename){

  • issm/trunk/src/c/parallel/balancedthickness_core.cpp

    r3332 r3446  
    4444        _printf_("depth averaging velocity...\n");
    4545        u_g=inputs->Get("velocity",&dofs[0],2); //take (vx,vy) from inputs velocity
    46         FieldDepthAveragex( u_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"velocity");
     46        FieldDepthAveragex( u_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"velocity");
    4747        inputs->Add("velocity_average",u_g,2,numberofnodes);
    4848       
    … …  
    5151
    5252        _printf_("extrude computed thickness on all layers:\n");
    53         FieldExtrudex( h_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"thickness",0);
     53        FieldExtrudex( h_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"thickness",0);
    5454
    5555        /*Plug results into output dataset: */

  • issm/trunk/src/c/parallel/balancedvelocities_core.cpp

    r3332 r3446  
    4343        _printf_("depth averaging velocity...\n");
    4444        u_g=inputs->Get("velocity",&dofs[0],2); //take (vx,vy) from inputs velocity
    45         FieldDepthAveragex( u_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"velocity");
     45        FieldDepthAveragex( u_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"velocity");
    4646        inputs->Add("velocity_average",u_g,2,numberofnodes);
    4747       
    … …  
    5050
    5151        _printf_("extrude computed thickness on all layers:\n");
    52         FieldExtrudex( v_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"thickness",0);
     52        FieldExtrudex( v_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"thickness",0);
    5353
    5454        /*Plug results into output dataset: */

  • issm/trunk/src/c/parallel/control_core.cpp

    r3332 r3446  
    105105       
    106106                /*Update parameters: */
    107                 UpdateFromInputsx(fem_model->elements,fem_model->nodes,fem_model->loads, fem_model->materials,fem_model->parameters,inputs);
     107                UpdateFromInputsx(fem_model->elements,fem_model->nodes,fem_model->vertices,fem_model->loads, fem_model->materials,fem_model->parameters,inputs);
    108108
    109109                _printf_("%s\n","      computing gradJ...");

  • issm/trunk/src/c/parallel/diagnostic_core.cpp

    r3332 r3446  
    9696               
    9797                        if(verbose)_printf_("%s\n","extruding slopes in 3d...");
    98                         FieldExtrudex( slopex, fem_sl->elements,fem_sl->nodes,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopex",0);
    99                         FieldExtrudex( slopey, fem_sl->elements,fem_sl->nodes,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopex",0);
     98                        FieldExtrudex( slopex, fem_sl->elements,fem_sl->nodes,fem_sl->vertices,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopex",0);
     99                        FieldExtrudex( slopey, fem_sl->elements,fem_sl->nodes,fem_sl->vertices,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopex",0);
    100100                }
    101101
    … …  
    109109
    110110                if(verbose)_printf_("%s\n"," computing pressure according to MacAyeal...");
    111                 ComputePressurex( &pg,fem_dhu->elements,fem_dhu->nodes,fem_dhu->loads,fem_dhu->materials, fem_dhu->parameters);
     111                ComputePressurex( &pg,fem_dhu->elements,fem_dhu->nodes,fem_dhu->vertices,fem_dhu->loads,fem_dhu->materials, fem_dhu->parameters);
    112112
    113113                if(verbose)_printf_("%s\n"," update boundary conditions for macyeal pattyn using hutter results...");
    … …  
    127127                if(dim==2){
    128128                        if(verbose)_printf_("%s\n"," computing pressure according to MacAyeal...");
    129                         ComputePressurex( &pg,fem_dh->elements, fem_dh->nodes, fem_dh->loads,  fem_dh->materials, fem_dh->parameters);
     129                        ComputePressurex( &pg,fem_dh->elements, fem_dh->nodes, fem_dh->vertices,fem_dh->loads,  fem_dh->materials, fem_dh->parameters);
    130130                }
    131131
    … …  
    136136
    137137                if(verbose)_printf_("%s\n"," extruding horizontal velocities...");
    138                 VecDuplicatePatch(&ug_horiz,ug); FieldExtrudex( ug_horiz,fem_dh->elements,fem_dh->nodes, fem_dh->loads,fem_dh->materials,fem_dh->parameters,"velocity",1);
     138                VecDuplicatePatch(&ug_horiz,ug); FieldExtrudex( ug_horiz,fem_dh->elements,fem_dh->nodes, fem_dh->vertices,fem_dh->loads,fem_dh->materials,fem_dh->parameters,"velocity",1);
    139139
    140140                if(verbose)_printf_("%s\n"," computing vertical velocities...");
    … …  
    150150
    151151                if(verbose)_printf_("%s\n"," computing pressure according to Pattyn...");
    152                 ComputePressurex( &pg,fem_dh->elements, fem_dh->nodes, fem_dh->loads,  fem_dh->materials,fem_dh->parameters);
     152                ComputePressurex( &pg,fem_dh->elements, fem_dh->nodes, fem_dh->vertices,fem_dh->loads,  fem_dh->materials,fem_dh->parameters);
    153153               
    154154                if (isstokes){
    … …  
    160160                        diagnostic_core_linear(&slopex,fem_sl,inputs,SlopecomputeAnalysisEnum(),BedXAnalysisEnum());
    161161                        diagnostic_core_linear(&slopey,fem_sl,inputs,SlopecomputeAnalysisEnum(),BedYAnalysisEnum());
    162                         FieldExtrudex( slopex, fem_sl->elements,fem_sl->nodes,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopex",0);
    163                         FieldExtrudex( slopey, fem_sl->elements,fem_sl->nodes,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopey",0);
     162                        FieldExtrudex( slopex, fem_sl->elements,fem_sl->nodes,fem_sl->vertices,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopex",0);
     163                        FieldExtrudex( slopey, fem_sl->elements,fem_sl->nodes,fem_sl->vertices,fem_sl->loads,fem_sl->materials,fem_sl->parameters,"slopey",0);
    164164
    165165                        inputs->Add("bedslopex",slopex,numberofdofspernode_sl,numberofnodes);

  • issm/trunk/src/c/parallel/diagnostic_core_linear.cpp

    r3332 r3446  
    3434
    3535        /*Update parameters: */
    36         UpdateFromInputsx(fem->elements,fem->nodes,fem->loads, fem->materials,fem->parameters,inputs);
     36        UpdateFromInputsx(fem->elements,fem->nodes,fem->vertices,fem->loads, fem->materials,fem->parameters,inputs);
    3737               
    3838        //*Generate system matrices
    3939        if (verbose) _printf_("   Generating matrices\n");
    40         SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
     40        SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
    4141
    4242        if (verbose) _printf_("   Generating penalty matrices\n");
    43         //*Generate penalty system matrices
    44         PenaltySystemMatricesx(Kgg, pg,NULL,fem->elements,fem->nodes,fem->loads,fem->materials,fem->parameters,kflag,pflag,inputs,analysis_type,sub_analysis_type);
     43                //*Generate penalty system matrices
     44                PenaltySystemMatricesx(Kgg, pg,NULL,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag,inputs,analysis_type,sub_analysis_type);
    4545
    4646        /*!Reduce matrix from g to f size:*/

  • issm/trunk/src/c/parallel/diagnostic_core_nonlinear.cpp

    r3332 r3446  
    8080
    8181                /*Update parameters: */
    82                 UpdateFromInputsx(fem->elements,fem->nodes,loads, fem->materials,fem->parameters,inputs);
     82                UpdateFromInputsx(fem->elements,fem->nodes,fem->vertices,loads, fem->materials,fem->parameters,inputs);
    8383
    8484                if (verbose) _printf_("   Generating matrices\n");
    8585                //*Generate system matrices
    86                 SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
     86                SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->vertices,loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
    8787
    8888                if (verbose) _printf_("   Generating penalty matrices\n");
    8989                //*Generate penalty system matrices
    90                 PenaltySystemMatricesx(Kgg, pg,NULL,fem->elements,fem->nodes,loads,fem->materials,fem->parameters,kflag,pflag,inputs,analysis_type,sub_analysis_type);
     90                PenaltySystemMatricesx(Kgg, pg,NULL,fem->elements,fem->nodes,fem->vertices,loads,fem->materials,fem->parameters,kflag,pflag,inputs,analysis_type,sub_analysis_type);
    9191
    9292                if (verbose) _printf_("   reducing matrix from g to f set\n");
    … …  
    117117                if (old_ug) inputs->Add("old_velocity",old_ug,numberofdofspernode,numberofnodes);
    118118                inputs->Add("velocity",ug,numberofdofspernode,numberofnodes);
    119                 PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, fem->elements,fem->nodes,loads,fem->materials,fem->parameters,inputs,analysis_type,sub_analysis_type);
     119                PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, fem->elements,fem->nodes,fem->vertices,loads,fem->materials,fem->parameters,inputs,analysis_type,sub_analysis_type);
    120120
    121121                //if(verbose)_printf_("   number of unstable constraints: %i\n",num_unstable_constraints);
    … …  
    156156                kflag=1; pflag=0; //stiffness generation only
    157157       
    158                 SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
     158                SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->vertices,loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
    159159                Reducematrixfromgtofx(&Kff,&Kfs,Kgg,fem->Gmn,fem->nodesets);
    160160                MatFree(&Kgg);VecFree(&pg);

  • issm/trunk/src/c/parallel/gradjcompute_core.cpp

    r3332 r3446  
    6767
    6868        _printf_("%s\n","      buid Du, difference between observed velocity and model velocity:");
    69         Dux( &du_g, femmodel->elements,femmodel->nodes,femmodel->loads,femmodel->materials,femmodel->parameters,inputs,analysis_type,sub_analysis_type);
     69        Dux( &du_g, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,inputs,analysis_type,sub_analysis_type);
    7070
    7171        _printf_("%s\n","      reduce adjoint load from g-set to f-set:");
    … …  
    8585        inputs->Add("adjoint",lambda_g_double,numberofdofspernode,numberofnodes);
    8686
    87         Gradjx( &grad_g, numberofnodes,femmodel->elements,femmodel->nodes, femmodel->loads, femmodel->materials,femmodel->parameters,
     87        Gradjx( &grad_g, numberofnodes,femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,femmodel->parameters,
    8888                                inputs,analysis_type,sub_analysis_type,control_type);
    8989
    … …  
    9191
    9292                _printf_("%s\n","      extruding gradient...");
    93                 FieldExtrudex( grad_g, femmodel->elements,femmodel->nodes,femmodel->loads,femmodel->materials,femmodel->parameters,"gradj",0);
     93                FieldExtrudex( grad_g, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,"gradj",0);
    9494        }
    9595

  • issm/trunk/src/c/parallel/objectivefunctionC.cpp

    r3332 r3446  
    9494        /*Compute misfit for this velocity field.*/
    9595        inputs->Add("fit",fit[n]);
    96         CostFunctionx( &J, femmodel->elements,femmodel->nodes, femmodel->loads, femmodel->materials, femmodel->parameters,inputs,analysis_type,sub_analysis_type);
     96        CostFunctionx( &J, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters,inputs,analysis_type,sub_analysis_type);
    9797
    9898        /*Free ressources:*/

  • issm/trunk/src/c/parallel/prognostic2_core.cpp

    r3378 r3446  
    4444        vx_g=inputs->Get("vx",&dofs[0],1);
    4545        vy_g=inputs->Get("vy",&dofs[0],1);
    46         FieldDepthAveragex(vx_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"vx");
    47         FieldDepthAveragex(vy_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"vy");
     46        FieldDepthAveragex(vx_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"vx");
     47        FieldDepthAveragex(vy_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"vy");
    4848        inputs->Add("vx_average",vx_g,1,numberofnodes);
    4949        inputs->Add("vy_average",vy_g,1,numberofnodes);
    … …  
    5353
    5454        _printf_("extrude computed thickness on all layers:\n");
    55         //FieldAverageOntoVertices(h_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"thickness",0);
     55        //FieldAverageOntoVertices(h_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"thickness",0);
    5656
    5757        /*Plug results into output dataset: */

  • issm/trunk/src/c/parallel/prognostic_core.cpp

    r3332 r3446  
    4343        _printf_("depth averaging velocity...\n");
    4444        u_g=inputs->Get("velocity",&dofs[0],2); //take (vx,vy) from inputs velocity
    45         FieldDepthAveragex( u_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"velocity");
     45        FieldDepthAveragex( u_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"velocity");
    4646        inputs->Add("velocity_average",u_g,2,numberofnodes);
    4747       
    … …  
    5050
    5151        _printf_("extrude computed thickness on all layers:\n");
    52         FieldExtrudex( h_g, fem_p->elements,fem_p->nodes, fem_p->loads, fem_p->materials,fem_p->parameters,"thickness",0);
     52        FieldExtrudex( h_g, fem_p->elements,fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials,fem_p->parameters,"thickness",0);
    5353
    5454        /*Plug results into output dataset: */

  • issm/trunk/src/c/parallel/slopecompute_core.cpp

    r3332 r3446  
    4343
    4444        _printf_("extrude computed slope on all layers:\n");
    45         FieldExtrudex( sx_g, fem_sl->elements,fem_sl->nodes, fem_sl->loads, fem_sl->materials,fem_sl->parameters,"slopex",0);
    46         FieldExtrudex( sy_g, fem_sl->elements,fem_sl->nodes, fem_sl->loads, fem_sl->materials,fem_sl->parameters,"slopey",0);
     45        FieldExtrudex( sx_g, fem_sl->elements,fem_sl->nodes, fem_sl->vertices,fem_sl->loads, fem_sl->materials,fem_sl->parameters,"slopex",0);
     46        FieldExtrudex( sy_g, fem_sl->elements,fem_sl->nodes, fem_sl->vertices,fem_sl->loads, fem_sl->materials,fem_sl->parameters,"slopey",0);
    4747
    4848        /*Plug results into output dataset: */

  • issm/trunk/src/c/parallel/steadystate_core.cpp

    r3332 r3446  
    9292                //compute depth averaged temperature and add to inputs
    9393                VecDuplicatePatch(&t_g_average,t_g);
    94                 FieldDepthAveragex( t_g_average, fem_t->elements,fem_t->nodes, fem_t->loads, fem_t->materials,fem_t->parameters,"temperature");
     94                FieldDepthAveragex( t_g_average, fem_t->elements,fem_t->nodes, fem_t->vertices,fem_t->loads, fem_t->materials,fem_t->parameters,"temperature");
    9595                inputs->Add("temperature_average",t_g_average,1,numberofnodes);
    9696                inputs->Add("temperature",t_g,1,numberofnodes);

  • issm/trunk/src/c/parallel/thermal_core_nonlinear.cpp

    r3332 r3446  
    6060
    6161                /*Update parameters: */
    62                 UpdateFromInputsx(fem->elements,fem->nodes,fem->loads, fem->materials,fem->parameters,inputs);
     62                UpdateFromInputsx(fem->elements,fem->nodes,fem->vertices,fem->loads, fem->materials,fem->parameters,inputs);
    6363
    6464                //*Generate system matrices
    … …  
    6767                        /*Compute Kgg_nopenalty and pg_nopenalty once for all: */
    6868                        if (count==1){
    69                                 SystemMatricesx(&Kgg_nopenalty, &pg_nopenalty,fem->elements,fem->nodes,fem->loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
     69                                SystemMatricesx(&Kgg_nopenalty, &pg_nopenalty,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
    7070                        }
    7171
    … …  
    7575
    7676                        //apply penalties each time
    77                         PenaltySystemMatricesx(Kgg, pg,&melting_offset,fem->elements,fem->nodes,fem->loads,fem->materials,fem->parameters,kflag,pflag,inputs,analysis_type,sub_analysis_type);
     77                        PenaltySystemMatricesx(Kgg, pg,&melting_offset,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag,inputs,analysis_type,sub_analysis_type);
    7878                }
    7979                else{
    80                         SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
     80                        SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag,connectivity,numberofdofspernode,inputs,analysis_type,sub_analysis_type);
    8181                        //apply penalties
    82                         PenaltySystemMatricesx(Kgg, pg,&melting_offset,fem->elements,fem->nodes,fem->loads,fem->materials,fem->parameters,kflag,pflag,inputs,analysis_type,sub_analysis_type);
     82                        PenaltySystemMatricesx(Kgg, pg,&melting_offset,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag,inputs,analysis_type,sub_analysis_type);
    8383                }
    8484
    … …  
    114114                inputs->Add("temperature",tg,numberofdofspernode,numberofnodes);
    115115               
    116                 PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, fem->elements,fem->nodes,fem->loads,fem->materials,fem->parameters,inputs,analysis_type,sub_analysis_type);
     116                PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,inputs,analysis_type,sub_analysis_type);
    117117
    118118                if (!converged){

  • issm/trunk/src/c/parallel/transient_core_2d.cpp

    r3332 r3446  
    140140                //update surface and bed using the new thickness
    141141                _printf_("   updating geometry\n");
    142                 UpdateGeometryx(&new_h_g,&new_b_g,&new_s_g, fem_p->elements, fem_p->nodes,fem_p->loads, fem_p->materials, fem_p->parameters,h_g_intermediary,b_g,s_g);
     142                UpdateGeometryx(&new_h_g,&new_b_g,&new_s_g, fem_p->elements, fem_p->nodes,fem_p->vertices,fem_p->loads, fem_p->materials, fem_p->parameters,h_g_intermediary,b_g,s_g);
    143143
    144144                VecFree(&h_g);h_g=new_h_g;

  • issm/trunk/src/c/parallel/transient_core_3d.cpp

    r3333 r3446  
    143143                if(verbose)_printf_("%s\n","computing depth average temperature");
    144144                VecDuplicatePatch(&t_g_average,t_g);
    145                 FieldDepthAveragex( t_g_average, fem_t->elements,fem_t->nodes, fem_t->loads, fem_t->materials,fem_t->parameters,"temperature");
     145                FieldDepthAveragex( t_g_average, fem_t->elements,fem_t->nodes, fem_t->vertices,fem_t->loads, fem_t->materials,fem_t->parameters,"temperature");
    146146                inputs->Add("temperature_average",t_g_average,1,numberofnodes);
    147147                VecFree(&t_g_average); //not needed anymore
    … …  
    168168                //update surface and bed using the new thickness
    169169                if(verbose)_printf_("   updating geometry\n");
    170                 UpdateGeometryx(&h_g,&b_g,&s_g, fem_p->elements, fem_p->nodes,fem_p->loads, fem_p->materials, fem_p->parameters,h_g_intermediary,b_g,s_g);
     170                UpdateGeometryx(&h_g,&b_g,&s_g, fem_p->elements, fem_p->nodes, fem_p->vertices,fem_p->loads, fem_p->materials, fem_p->parameters,h_g_intermediary,b_g,s_g);
    171171                VecFree(&h_g_intermediary);
    172172               
    173173                if(verbose)_printf_("%s\n","updating node positions");
    174                 UpdateNodePositionsx( fem_dh->elements,fem_dh->nodes,fem_dh->loads,fem_dh->materials,fem_dh->parameters,h_g,b_g);
    175                 UpdateNodePositionsx( fem_dv->elements,fem_dv->nodes,fem_dv->loads,fem_dv->materials,fem_dv->parameters,h_g,b_g);
    176                 UpdateNodePositionsx( fem_dhu->elements,fem_dhu->nodes,fem_dhu->loads,fem_dhu->materials,fem_dhu->parameters,h_g,b_g);
    177                 UpdateNodePositionsx( fem_ds->elements,fem_ds->nodes,fem_ds->loads,fem_ds->materials,fem_ds->parameters,h_g,b_g);
    178                 UpdateNodePositionsx( fem_sl->elements,fem_sl->nodes,fem_sl->loads,fem_sl->materials,fem_sl->parameters,h_g,b_g);
    179                 UpdateNodePositionsx( fem_p->elements,fem_p->nodes,fem_p->loads,fem_p->materials,fem_p->parameters,h_g,b_g);
    180                 UpdateNodePositionsx( fem_t->elements,fem_t->nodes,fem_t->loads,fem_t->materials,fem_t->parameters,h_g,b_g);
    181                 UpdateNodePositionsx( fem_m->elements,fem_m->nodes,fem_m->loads,fem_m->materials,fem_m->parameters,h_g,b_g);
     174                UpdateVertexPositionsx( fem_dh->vertices,h_g,b_g);
     175                UpdateVertexPositionsx( fem_dh->vertices,h_g,b_g);
     176                UpdateVertexPositionsx( fem_dh->vertices,h_g,b_g);
     177                UpdateVertexPositionsx( fem_dh->vertices,h_g,b_g);
     178                UpdateVertexPositionsx( fem_dh->vertices,h_g,b_g);
     179                UpdateVertexPositionsx( fem_dh->vertices,h_g,b_g);
     180                UpdateVertexPositionsx( fem_dh->vertices,h_g,b_g);
     181                UpdateVertexPositionsx( fem_dh->vertices,h_g,b_g);
    182182
    183183                //plug into results.
Note: See TracChangeset for help on using the changeset viewer.