Changeset 3999


Ignore:
Timestamp:
06/02/10 15:51:23 (15 years ago)
Author:
Mathieu Morlighem
Message:

updated CreateNodes

Location:
issm/trunk/src/c/modules/ModelProcessorx
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/modules/ModelProcessorx/Balancedthickness/CreateNodesBalancedthickness.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsBalancedthickness.c:
     2 * CreateNodesBalancedthickness.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsBalancedthickness(DataSet** pelements,DataSet** pnodes, DataSet** pvertices, DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesBalancedthickness(DataSet** pelements,DataSet** pnodes, DataSet** pvertices, DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j,k,n;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1921
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524
    26         /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
    28         nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
     25        /*First create nodes*/
     26        nodes = new DataSet(NodesEnum);
    3127
    32         /*Partition elements and vertices and nodes: */
    33         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     28        /*Recover number of nodes already created in other analyses: */
     29        totalnodes=iomodel->nodecounter;
    3430
    35         /*2d mesh: */
    36         if (iomodel->dim==2){
    37 
    38                 /*Fetch data needed: */
    39                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    40                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    41                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    42                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    43                 IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    44                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    45                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    46                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    47                 IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    48                 IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    49                 IoModelFetchData(&iomodel->dhdt,NULL,NULL,iomodel_handle,"dhdt");
    50                
    51                 for (i=0;i<iomodel->numberofelements;i++){
    52 
    53                         if(iomodel->my_elements[i]){
    54 
    55                                 /*Create and add tria element to elements dataset: */
    56                                 elements->AddObject(new Tria(i+1,i,iomodel));
    57 
    58                                 /*Create and add material property to materials dataset: */
    59                                 materials->AddObject(new Matice(i+1,i,iomodel,3));
    60                         }
    61                 }//for (i=0;i<numberofelements;i++)
    62 
    63                 /*Free data : */
    64                 xfree((void**)&iomodel->elements);
    65                 xfree((void**)&iomodel->thickness);
    66                 xfree((void**)&iomodel->surface);
    67                 xfree((void**)&iomodel->bed);
    68                 xfree((void**)&iomodel->elementoniceshelf);
    69                 xfree((void**)&iomodel->elementonwater);
    70                 xfree((void**)&iomodel->vx);
    71                 xfree((void**)&iomodel->vy);
    72                 xfree((void**)&iomodel->melting_rate);
    73                 xfree((void**)&iomodel->accumulation_rate);
    74                 xfree((void**)&iomodel->dhdt);
    75 
    76         }
    77         else{ //        if (dim==2)
    78 
    79                 /*Fetch data needed: */
    80                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    81                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    82                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    83                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    84                 IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    85                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    86                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,"elementonsurface");
    87                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    88                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    89                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    90                 IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    91                 IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    92                 IoModelFetchData(&iomodel->dhdt,NULL,NULL,iomodel_handle,"dhdt");
    93                 IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    94                 IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    95        
    96                 for (i=0;i<iomodel->numberofelements;i++){
    97                         if(iomodel->my_elements[i]){
    98                                 /*Create and add penta element to elements dataset: */
    99                                 elements->AddObject(new Penta(i+1,i,iomodel));
    100 
    101                                 /*Create and add material property to materials dataset: */
    102                                 materials->AddObject(new Matice(i+1,i,iomodel,6));
    103                         }
    104                 }//for (i=0;i<numberofelements;i++)
    105 
    106                 /*Free data: */
    107                 xfree((void**)&iomodel->elements);
    108                 xfree((void**)&iomodel->thickness);
    109                 xfree((void**)&iomodel->surface);
    110                 xfree((void**)&iomodel->bed);
    111                 xfree((void**)&iomodel->elementoniceshelf);
    112                 xfree((void**)&iomodel->elementonbed);
    113                 xfree((void**)&iomodel->elementonsurface);
    114                 xfree((void**)&iomodel->elementonwater);
    115                 xfree((void**)&iomodel->vx);
    116                 xfree((void**)&iomodel->vy);
    117                 xfree((void**)&iomodel->melting_rate);
    118                 xfree((void**)&iomodel->accumulation_rate);
    119                 xfree((void**)&iomodel->dhdt);
    120                 xfree((void**)&iomodel->upperelements);
    121                 xfree((void**)&iomodel->lowerelements);
    122 
    123 
    124         } //if (dim==2)
    125 
    126         /*Add new constrant material property to materials, at the end: */
    127         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));
     31        /*Continuous Galerkin partition of nodes: */
     32        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    12833
    12934        /*First fetch data: */
    … …  
    13237                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    13338        }
    134         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    135         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    136         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    137         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    138         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    13939        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    14040        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    14444        for (i=0;i<iomodel->numberofvertices;i++){
    14545
    146                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    14746                if(iomodel->my_vertices[i]){
    148 
    149                         /*Add vertex to vertices dataset: */
    150                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    15147
    15248                        /*Add node to nodes dataset: */
    … …  
    15854        /*Clean fetched data: */
    15955        xfree((void**)&iomodel->deadgrids);
    160         xfree((void**)&iomodel->x);
    161         xfree((void**)&iomodel->y);
    162         xfree((void**)&iomodel->z);
    163         xfree((void**)&iomodel->thickness);
    164         xfree((void**)&iomodel->bed);
    16556        xfree((void**)&iomodel->gridonbed);
    16657        xfree((void**)&iomodel->gridonsurface);
    … …  
    17162        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    17263         * datasets, it will not be redone: */
    173         elements->Presort();
    174         vertices->Presort();
    17564        nodes->Presort();
    176         materials->Presort();
    177 
    178         cleanup_and_return:
    17965
    18066        /*Assign output pointer: */
    181         *pelements=elements;
    18267        *pnodes=nodes;
    183         *pvertices=vertices;
    184         *pmaterials=materials;
    18568
    18669}

  • issm/trunk/src/c/modules/ModelProcessorx/Balancedthickness2/CreateNodesBalancedthickness2.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsBalancedthickness2.c:
     2 * CreateNodesBalancedthickness2.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsBalancedthickness2(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesBalancedthickness2(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j;
    19         int vertex_index;
    20         int node_index;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=false;
    2121
    2222        /*DataSets: */
    23         DataSet* elements  = NULL;
    2423        DataSet* nodes = NULL;
    25         DataSet* vertices = NULL;
    26         DataSet* materials = NULL;
    2724
    28         /*First create the elements, nodes and material properties: */
    29         elements  = new DataSet(ElementsEnum);
    30         nodes     = new DataSet(NodesEnum);
    31         vertices  = new DataSet(VerticesEnum);
    32         materials = new DataSet(MaterialsEnum);
     25        /*First create nodes*/
     26        nodes = new DataSet(NodesEnum);
    3327
    34         /*Partition elements and vertices and nodes: */
    35         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     28        /*Recover number of nodes already created in other analyses: */
     29        totalnodes=iomodel->nodecounter;
    3630
    37         /*elements created vary if we are dealing with a 2d mesh, or a 3d mesh: */
    38         /*2d mesh: */
    39         if (iomodel->dim==2){
     31        /*Continuous Galerkin partition of nodes: */
     32        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    4033
    41                 /*Fetch data needed: */
    42                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    43                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    44                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    45                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    46                 IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    47                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    48                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    49                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    50                 IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"melting_rate");
    51                 IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    52                 IoModelFetchData(&iomodel->dhdt,NULL,NULL,iomodel_handle,"dhdt");
    53                
    54                 for (i=0;i<iomodel->numberofelements;i++){
    55 
    56                         if(iomodel->my_elements[i]){
    57 
    58                                 /*Create and add tria element to elements dataset: */
    59                                 elements->AddObject(new Tria(i+1,i,iomodel));
    60 
    61                                 /*Create and add material property to materials dataset: */
    62                                 materials->AddObject(new Matice(i+1,i,iomodel,3));
    63                         }
    64                 }//for (i=0;i<numberofelements;i++)
    65        
    66                 /*Free data : */
    67                 xfree((void**)&iomodel->thickness);
    68                 xfree((void**)&iomodel->surface);
    69                 xfree((void**)&iomodel->bed);
    70                 xfree((void**)&iomodel->elementoniceshelf);
    71                 xfree((void**)&iomodel->elementonwater);
    72                 xfree((void**)&iomodel->vx);
    73                 xfree((void**)&iomodel->vy);
    74                 xfree((void**)&iomodel->melting_rate);
    75                 xfree((void**)&iomodel->accumulation_rate);
    76                 xfree((void**)&iomodel->dhdt);
    77 
    78         }
    79         else{ //        if (dim==2)
    80                 ISSMERROR("not implemented yet");
    81         } //if (dim==2)
    82 
    83         /*Add new constrant material property tgo materials, at the end: */
    84         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));
    85 
    86         /*Create nodes and vertices: */
    87         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    88         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    89         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    90         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    91         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
     34        /*Create nodes: */
    9235        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    9336        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    9538        IoModelFetchData(&iomodel->gridonicesheet,NULL,NULL,iomodel_handle,"gridonicesheet");
    9639        IoModelFetchData(&iomodel->gridoniceshelf,NULL,NULL,iomodel_handle,"gridoniceshelf");
     40        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    9741        if (iomodel->dim==3){
    9842                IoModelFetchData(&iomodel->deadgrids,NULL,NULL,iomodel_handle,"deadgrids");
    9943                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    100         }
    101 
    102         /*Build Vertices dataset*/
    103         for (i=0;i<iomodel->numberofvertices;i++){
    104 
    105                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    106                 if(iomodel->my_vertices[i]){
    107 
    108                         /*Add vertex to vertices dataset: */
    109                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    110 
    111                 }
     44                ISSMERROR("Not implemented yet");
    11245        }
    11346
    … …  
    13467        /*Clean fetched data: */
    13568        xfree((void**)&iomodel->deadgrids);
    136         xfree((void**)&iomodel->x);
    137         xfree((void**)&iomodel->y);
    138         xfree((void**)&iomodel->z);
    139         xfree((void**)&iomodel->thickness);
    140         xfree((void**)&iomodel->bed);
    14169        xfree((void**)&iomodel->gridonbed);
    14270        xfree((void**)&iomodel->gridonsurface);
    … …  
    14977        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    15078         * datasets, it will not be redone: */
    151         elements->Presort();
    15279        nodes->Presort();
    153         vertices->Presort();
    154         materials->Presort();
    155 
    156         cleanup_and_return:
    15780
    15881        /*Assign output pointer: */
    159         *pelements=elements;
    16082        *pnodes=nodes;
    161         *pvertices=vertices;
    162         *pmaterials=materials;
    16383}

  • issm/trunk/src/c/modules/ModelProcessorx/Balancedvelocities/CreateNodesBalancedvelocities.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsBalancedvelocities.c:
     2 * CreateNodesBalancedvelocities.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsBalancedvelocities(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesBalancedvelocities(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j,k,n;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1921
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524
    26         /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
    28         nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
     25        /*First create nodes*/
     26        nodes = new DataSet(NodesEnum);
    3127
    32         /*Partition elements and vertices and nodes: */
    33         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     28        /*Recover number of nodes already created in other analyses: */
     29        totalnodes=iomodel->nodecounter;
    3430
    35         /*2d mesh: */
    36         if (iomodel->dim==2){
     31        /*Continuous Galerkin partition of nodes: */
     32        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    3733
    38                 /*Fetch data needed: */
    39                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    40                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    41                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    42                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    43                 IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    44                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    45                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    46                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    47                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"melting_rate");
    48                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"accumulation_rate");
    49                
    50                 for (i=0;i<iomodel->numberofelements;i++){
    51 
    52                         if(iomodel->my_elements[i]){
    53 
    54                                 /*Create and add tria element to elements dataset: */
    55                                 elements->AddObject(new Tria(i+1,i,iomodel));
    56 
    57                                 /*Create and add material property to materials dataset: */
    58                                 materials->AddObject(new Matice(i+1,i,iomodel,3));
    59                         }
    60 
    61                 }//for (i=0;i<numberofelements;i++)
    62 
    63        
    64                 /*Free data : */
    65                 xfree((void**)&iomodel->elements);
    66                 xfree((void**)&iomodel->thickness);
    67                 xfree((void**)&iomodel->surface);
    68                 xfree((void**)&iomodel->bed);
    69                 xfree((void**)&iomodel->elementoniceshelf);
    70                 xfree((void**)&iomodel->elementonwater);
    71                 xfree((void**)&iomodel->vx);
    72                 xfree((void**)&iomodel->vy);
    73                 xfree((void**)&iomodel->melting_rate);
    74                 xfree((void**)&iomodel->accumulation_rate);
    75 
    76         }
    77         else{ //        if (dim==2)
    78 
    79                 /*Fetch data needed: */
    80                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    81                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    82                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    83                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    84                 IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    85                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    86                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,"elementonsurface");
    87                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    88                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    89                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    90                 IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    91                 IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    92                 IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    93                 IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    94 
    95                 for (i=0;i<iomodel->numberofelements;i++){
    96                         if(iomodel->my_elements[i]){
    97                                 /*Create and add penta element to elements dataset: */
    98                                 elements->AddObject(new Penta(i+1,i,iomodel));
    99 
    100                                 /*Create and add material property to materials dataset: */
    101                                 materials->AddObject(new Matice(i+1,i,iomodel,6));
    102 
    103                         }//if(my_elements[i])
    104 
    105                 }//for (i=0;i<numberofelements;i++)
    106 
    107                 /*Free data: */
    108                 xfree((void**)&iomodel->elements);
    109                 xfree((void**)&iomodel->thickness);
    110                 xfree((void**)&iomodel->surface);
    111                 xfree((void**)&iomodel->bed);
    112                 xfree((void**)&iomodel->elementoniceshelf);
    113                 xfree((void**)&iomodel->elementonbed);
    114                 xfree((void**)&iomodel->elementonsurface);
    115                 xfree((void**)&iomodel->elementonwater);
    116                 xfree((void**)&iomodel->vx);
    117                 xfree((void**)&iomodel->vy);
    118                 xfree((void**)&iomodel->melting_rate);
    119                 xfree((void**)&iomodel->accumulation_rate);
    120                 xfree((void**)&iomodel->upperelements);
    121                 xfree((void**)&iomodel->lowerelements);
    122 
    123 
    124         } //if (dim==2)
    125 
    126         /*Add new constrant material property to materials, at the end: */
    127         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel)); //put it at the end of the materials
    128                
    12934        /*First fetch data: */
    13035        if (iomodel->dim==3){
    … …  
    13237                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    13338        }
    134         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    135         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    136         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    137         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    138         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    13939        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    14040        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    14444        for (i=0;i<iomodel->numberofvertices;i++){
    14545
    146                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    14746                if(iomodel->my_vertices[i]){
    14847                       
    149                         /*Add vertex to vertices dataset: */
    150                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    151 
    15248                        /*Add node to nodes dataset: */
    15349                        nodes->AddObject(new Node(i+1,i,iomodel));
    … …  
    15854        /*Clean fetched data: */
    15955        xfree((void**)&iomodel->deadgrids);
    160         xfree((void**)&iomodel->x);
    161         xfree((void**)&iomodel->y);
    162         xfree((void**)&iomodel->z);
    163         xfree((void**)&iomodel->thickness);
    164         xfree((void**)&iomodel->bed);
    16556        xfree((void**)&iomodel->gridonbed);
    16657        xfree((void**)&iomodel->gridonsurface);
    … …  
    17162        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    17263         * datasets, it will not be redone: */
    173         elements->Presort();
    17464        nodes->Presort();
    175         vertices->Presort();
    176         materials->Presort();
    177 
    178         cleanup_and_return:
    17965
    18066        /*Assign output pointer: */
    181         *pelements=elements;
    18267        *pnodes=nodes;
    183         *pvertices=vertices;
    184         *pmaterials=materials;
    18568
    18669}

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateNodesDiagnosticHoriz.cpp

    r3998 r3999  
    1717        /*Intermediary*/
    1818        int i;
     19        int totalnodes;
    1920        bool continuous_galerkin=true;
    2021
    … …  
    2223        DataSet*    nodes = NULL;
    2324
    24         /*First create the elements, vertices, nodes and material properties, if they don't already exist */
    25         nodes     = new DataSet(NodesEnum);
     25        /*First create nodes*/
     26        nodes = new DataSet(NodesEnum);
    2627       
    2728        /*Now, is the flag macayaealpattyn on? otherwise, do nothing: */

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHutter/CreateNodesDiagnosticHutter.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsDiagnosticHutter.c:
     2 * CreateNodesDiagnosticHutter.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsDiagnosticHutter(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesDiagnosticHutter(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j,k,n;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1921
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524
    26         /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
     25        /*First create nodes*/
    2826        nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
    3127
    3228        /*Now, is the flag ishutter on? otherwise, do nothing: */
    3329        if (!iomodel->ishutter)goto cleanup_and_return;
    3430
    35         /*Partition elements and vertices and nodes: */
    36         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     31        /*Recover number of nodes already created in other analyses: */
     32        totalnodes=iomodel->nodecounter;
    3733
    38         /*Hutter elements can be partitioned using epart, even if
    39          * each hutter elements either lies on a node (in 2d), or a pair of vertically juxtaposed nodes (in 3d): */
     34        /*Continuous Galerkin partition of nodes: */
     35        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    4036
    41         /*Fetch data temporarily needed: */
    42         IoModelFetchData(&iomodel->gridonhutter,NULL,NULL,iomodel_handle,"gridonhutter");
    43         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    44         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    45         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    46         IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    47         IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    48         IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    49         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,"drag_coefficient");
    50         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,"rheology_B");
    51         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,"rheology_n");
    52         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,"elements_type");
    53         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    54         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,"elementonsurface");
    55         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    56         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    57         IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    58         IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    59 
    60         /*2d mesh: */
    61         if (iomodel->dim==2){
    62 
    63                 for (i=0;i<iomodel->numberofelements;i++){
    64 
    65                         if(iomodel->my_elements[i]){
    66 
    67                                 if (*(iomodel->elements_type+2*i+0)==HutterFormulationEnum){ //create only Hutter elements
    68 
    69                                         /*Create and add penta element to elements dataset: */
    70                                         elements->AddObject(new Tria(i+1,i,iomodel));
    71 
    72                                         /*Create and add material property to materials dataset: */
    73                                         materials->AddObject(new Matice(i+1,i,iomodel,3));
    74                                 }
    75                         }
    76                 } //for (i=0;i<iomodel->numberofvertices;i++)
    77         } //if (iomodel->dim==2)
    78         else{
    79 
    80                 for (i=0;i<iomodel->numberofelements;i++){
    81 
    82                         if(iomodel->my_elements[i]){
    83 
    84                                 if (*(iomodel->elements_type+2*i+0)==HutterFormulationEnum){ //create only Hutter elements
    85 
    86                                         /*Create and add penta element to elements dataset: */
    87                                         elements->AddObject(new Penta(i+1,i,iomodel));
    88 
    89 
    90                                         /*Create and add material property to materials dataset: */
    91                                         materials->AddObject(new Matice(i+1,i,iomodel,6));
    92 
    93                                 }
    94                         }
    95 
    96                 } //for (i=0;i<iomodel->numberofelements;i++)
    97 
    98         } //if (iomodel->dim==2)
    99        
    100         /*Free data: */
    101         xfree((void**)&iomodel->elements);
    102         xfree((void**)&iomodel->elementonbed);
    103         xfree((void**)&iomodel->elementonsurface);
    104         xfree((void**)&iomodel->elements_type);
    105         xfree((void**)&iomodel->gridonhutter);
    106         xfree((void**)&iomodel->thickness);
    107         xfree((void**)&iomodel->surface);
    108         xfree((void**)&iomodel->bed);
    109         xfree((void**)&iomodel->gridonbed);
    110         xfree((void**)&iomodel->elementonwater);
    111         xfree((void**)&iomodel->uppernodes);
    112         xfree((void**)&iomodel->drag_coefficient);
    113         xfree((void**)&iomodel->rheology_B);
    114         xfree((void**)&iomodel->rheology_n);
    115         xfree((void**)&iomodel->upperelements);
    116         xfree((void**)&iomodel->lowerelements);
    117 
    118         /*Add new constrant material property to materials, at the end: */
    119         if (iomodel->dim==2){
    120                 materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));                          //put it at the end of the materials
    121         }
    122         else{
    123                 materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel)); //put it at the end of the materials
    124         }
    125                
    12637        /*First fetch data: */
    12738        if (iomodel->dim==3){
    … …  
    12940                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    13041        }
    131         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    132         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    133         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    134         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    135         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    13642        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    13743        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    14450        for (i=0;i<iomodel->numberofvertices;i++){
    14551
    146                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    14752                if(iomodel->my_vertices[i]){
    148 
    149                         /*Add vertex to vertices dataset: */
    150                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    15153
    15254                        /*Add node to nodes dataset: */
    … …  
    15860        /*Clean fetched data: */
    15961        xfree((void**)&iomodel->deadgrids);
    160         xfree((void**)&iomodel->x);
    161         xfree((void**)&iomodel->y);
    162         xfree((void**)&iomodel->z);
    163         xfree((void**)&iomodel->thickness);
    164         xfree((void**)&iomodel->bed);
    16562        xfree((void**)&iomodel->gridonbed);
    16663        xfree((void**)&iomodel->gridonsurface);
    … …  
    17572         * datasets, it will not be redone: */
    17673        elements->Presort();
    177         nodes->Presort();
    178         vertices->Presort();
    179         materials->Presort();
    18074
    18175        cleanup_and_return:
    18276
    18377        /*Assign output pointer: */
    184         *pelements=elements;
    18578        *pnodes=nodes;
    186         *pvertices=vertices;
    187         *pmaterials=materials;
    18879}

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticStokes/CreateNodesDiagnosticStokes.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsDiagnosticStokes.c:
     2 * CreateNodesDiagnosticStokes.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsDiagnosticStokes(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesDiagnosticStokes(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j,k,n;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1921
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524
    26         /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
    28         nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
     25        /*First create nodes*/
     26        nodes = new DataSet(NodesEnum);
    3127
    3228        /*Now, do we have Stokes elements?*/
    … …  
    3430        if (!iomodel->isstokes)                goto cleanup_and_return;
    3531
     32        /*Recover number of nodes already created in other analyses: */
     33        totalnodes=iomodel->nodecounter;
    3634
    37         /*Partition elements and vertices and nodes: */
    38         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     35        /*Continuous Galerkin partition of nodes: */
     36        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    3937
    40         /*Fetch data needed: */
    41         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    42         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    43         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    44         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    45         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,"drag_coefficient");
    46         IoModelFetchData(&iomodel->drag_p,NULL,NULL,iomodel_handle,"drag_p");
    47         IoModelFetchData(&iomodel->drag_q,NULL,NULL,iomodel_handle,"drag_q");
    48         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    49         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    50         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,"elementonsurface");
    51         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,"elements_type");
    52         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,"rheology_B");
    53         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,"rheology_n");
    54         IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    55         IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    56         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    57         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    58         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    59         IoModelFetchData(&iomodel->vz,NULL,NULL,iomodel_handle,"vz");
    60         IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    61         IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    62        
    63         if (iomodel->control_analysis){
    64                 IoModelFetchData(&iomodel->vx_obs,NULL,NULL,iomodel_handle,"vx_obs");
    65                 IoModelFetchData(&iomodel->vy_obs,NULL,NULL,iomodel_handle,"vy_obs");
    66                 IoModelFetchData(&iomodel->weights,NULL,NULL,iomodel_handle,"weights");
    67         }
    68 
    69         for (i=0;i<iomodel->numberofelements;i++){
    70 
    71                 if(iomodel->my_elements[i]){
    72                          if (*(iomodel->elements_type+2*i+1)==StokesFormulationEnum){
    73 
    74                                  /*Create and add penta element to elements dataset: */
    75                                  elements->AddObject(new Penta(i+1,i,iomodel));
    76 
    77                                  /*Create and add material property to materials dataset: */
    78                                  materials->AddObject(new Matice(i+1,i,iomodel,6));
    79                          }
    80 
    81                 }
    82 
    83         }//for (i=0;i<numberofelements;i++)
    84 
    85         /*Free data: */
    86         xfree((void**)&iomodel->elements);
    87         xfree((void**)&iomodel->thickness);
    88         xfree((void**)&iomodel->surface);
    89         xfree((void**)&iomodel->bed);
    90         xfree((void**)&iomodel->drag_coefficient);
    91         xfree((void**)&iomodel->drag_p);
    92         xfree((void**)&iomodel->drag_q);
    93         xfree((void**)&iomodel->elementoniceshelf);
    94         xfree((void**)&iomodel->elementonbed);
    95         xfree((void**)&iomodel->elementonsurface);
    96         xfree((void**)&iomodel->elements_type);
    97         xfree((void**)&iomodel->rheology_n);
    98         xfree((void**)&iomodel->rheology_B);
    99         xfree((void**)&iomodel->accumulation_rate);
    100         xfree((void**)&iomodel->melting_rate);
    101         xfree((void**)&iomodel->vx);
    102         xfree((void**)&iomodel->vy);
    103         xfree((void**)&iomodel->vz);
    104         if (iomodel->control_analysis){
    105                 xfree((void**)&iomodel->vx_obs);
    106                 xfree((void**)&iomodel->vy_obs);
    107                 xfree((void**)&iomodel->weights);
    108         }
    109         xfree((void**)&iomodel->upperelements);
    110         xfree((void**)&iomodel->lowerelements);
    111 
    112 
    113         /*Add new constrant material property to materials, at the end: */
    114         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));
    115        
    11638        /*First fetch data: */
    11739        IoModelFetchData(&iomodel->deadgrids,NULL,NULL,iomodel_handle,"deadgrids");
    11840        IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    119         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    120         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    121         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    122         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    123         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    12441        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    12542        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    13148        for (i=0;i<iomodel->numberofvertices;i++){
    13249
    133                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    13450                if(iomodel->my_vertices[i]){
    135 
    136                         /*Add vertex to vertices dataset: */
    137                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    13851
    13952                        /*Add node to nodes dataset: */
    … …  
    14558        /*Clean fetched data: */
    14659        xfree((void**)&iomodel->deadgrids);
    147         xfree((void**)&iomodel->x);
    148         xfree((void**)&iomodel->y);
    149         xfree((void**)&iomodel->z);
    150         xfree((void**)&iomodel->thickness);
    151         xfree((void**)&iomodel->bed);
    15260        xfree((void**)&iomodel->gridonbed);
    15361        xfree((void**)&iomodel->gridonsurface);
    … …  
    16068        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    16169         * datasets, it will not be redone: */
    162         elements->Presort();
    16370        nodes->Presort();
    164         vertices->Presort();
    165         materials->Presort();
    16671
    16772        cleanup_and_return:
    16873
    16974        /*Assign output pointer: */
    170         *pelements=elements;
    17175        *pnodes=nodes;
    172         *pvertices=vertices;
    173         *pmaterials=materials;
    17476
    17577}

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticVert/CreateNodesDiagnosticVert.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsDiagnosticVert.c:
     2 * CreateNodesDiagnosticVert.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsDiagnosticVert(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesDiagnosticVert(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j,k,n;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1921
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524
    2625        /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
    2826        nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
    3127
    3228        /*Now, is the flag macayaealpattyn on? otherwise, do nothing: */
    3329        if (iomodel->dim==2)goto cleanup_and_return;
    3430
    35         /*Partition elements and vertices and nodes: */
    36         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     31        /*Recover number of nodes already created in other analyses: */
     32        totalnodes=iomodel->nodecounter;
    3733
    38         /*Create 3d elements: */
    39         /*Fetch data needed: */
    40         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    41         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    42         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    43         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    44         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    45         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    46         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,"elementonsurface");
    47         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,"elements_type");
    48         IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    49         IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    50         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    51         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    52         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    53         IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    54         IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    55        
    56         for (i=0;i<iomodel->numberofelements;i++){
    57 
    58                 if(iomodel->my_elements[i]){
    59 
    60                         /*Create and add penta element to elements dataset: */
    61                         elements->AddObject(new Penta(i+1,i,iomodel));
    62 
    63                         /*Create and add material property to materials dataset: */
    64                         materials->AddObject(new Matice(i+1,i,iomodel,6));
    65 
    66                 }
    67 
    68         }//for (i=0;i<numberofelements;i++)
    69 
    70         /*Free data: */
    71         xfree((void**)&iomodel->elements);
    72         xfree((void**)&iomodel->thickness);
    73         xfree((void**)&iomodel->surface);
    74         xfree((void**)&iomodel->bed);
    75         xfree((void**)&iomodel->elementoniceshelf);
    76         xfree((void**)&iomodel->elementonbed);
    77         xfree((void**)&iomodel->elementonsurface);
    78         xfree((void**)&iomodel->elements_type);
    79         xfree((void**)&iomodel->melting_rate);
    80         xfree((void**)&iomodel->accumulation_rate);
    81         xfree((void**)&iomodel->elementonwater);
    82         xfree((void**)&iomodel->vx);
    83         xfree((void**)&iomodel->vy);
    84         xfree((void**)&iomodel->upperelements);
    85         xfree((void**)&iomodel->lowerelements);
    86 
    87         /*Add new constrant material property to materials, at the end: */
    88         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));//put it at the end of the materials
     34        /*Continuous Galerkin partition of nodes: */
     35        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    8936       
    9037        /*First fetch data: */
    9138        IoModelFetchData(&iomodel->deadgrids,NULL,NULL,iomodel_handle,"deadgrids");
    9239        IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    93         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    94         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    95         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    96         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    97         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    9840        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    9941        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    10345        for (i=0;i<iomodel->numberofvertices;i++){
    10446
    105                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    10647                if(iomodel->my_vertices[i]){
    107 
    108                         /*Add vertex to vertices dataset: */
    109                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    11048
    11149                        /*Add node to nodes dataset: */
    … …  
    11755        /*Clean fetched data: */
    11856        xfree((void**)&iomodel->deadgrids);
    119         xfree((void**)&iomodel->x);
    120         xfree((void**)&iomodel->y);
    121         xfree((void**)&iomodel->z);
    122         xfree((void**)&iomodel->thickness);
    123         xfree((void**)&iomodel->bed);
    12457        xfree((void**)&iomodel->gridonbed);
    12558        xfree((void**)&iomodel->gridonsurface);
    … …  
    13063        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    13164         * datasets, it will not be redone: */
    132         elements->Presort();
    13365        nodes->Presort();
    134         vertices->Presort();
    135         materials->Presort();
    13666
    13767        cleanup_and_return:
    13868
    13969        /*Assign output pointer: */
    140         *pelements=elements;
    14170        *pnodes=nodes;
    142         *pvertices=vertices;
    143         *pmaterials=materials;
    14471
    14572}

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/CreateNodesMelting.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsMelting.c:
     2 * CreateNodesMelting.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsMelting(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesMelting(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j,k,n;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1921
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524       
    26         /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
    28         nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
     25        /*First create nodes*/
     26        nodes = new DataSet(NodesEnum);
    3127
    32         /*Partition elements and vertices and nodes: */
    33         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     28        /*Recover number of nodes already created in other analyses: */
     29        totalnodes=iomodel->nodecounter;
    3430
    35         /*Fetch data needed: */
    36         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    37         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    38         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    39         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    40         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,"drag_coefficient");
    41         IoModelFetchData(&iomodel->drag_p,NULL,NULL,iomodel_handle,"drag_p");
    42         IoModelFetchData(&iomodel->drag_q,NULL,NULL,iomodel_handle,"drag_q");
    43         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    44         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    45         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,"elementonsurface");
    46         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,"elements_type");
    47         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,"rheology_B");
    48         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,"rheology_n");
    49         IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    50         IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    51         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    52         IoModelFetchData(&iomodel->pressure,NULL,NULL,iomodel_handle,"pressure");
    53         IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    54         IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    55        
    56         for (i=0;i<iomodel->numberofelements;i++){
    57                
    58                         if(iomodel->my_elements[i]){
    59 
    60                                 /*Create and add tria element to elements dataset: */
    61                                 elements->AddObject(new Penta(i+1,i,iomodel));
    62 
    63                                 /*Create and add material property to materials dataset: */
    64                                 materials->AddObject(new Matice(i+1,i,iomodel,6));
    65                         }
    66 
    67         }//for (i=0;i<numberofelements;i++)
    68 
    69         /*Free data: */
    70         xfree((void**)&iomodel->elements);
    71         xfree((void**)&iomodel->thickness);
    72         xfree((void**)&iomodel->surface);
    73         xfree((void**)&iomodel->bed);
    74         xfree((void**)&iomodel->drag_coefficient);
    75         xfree((void**)&iomodel->drag_p);
    76         xfree((void**)&iomodel->drag_q);
    77         xfree((void**)&iomodel->elementoniceshelf);
    78         xfree((void**)&iomodel->elementonbed);
    79         xfree((void**)&iomodel->elementonsurface);
    80         xfree((void**)&iomodel->elements_type);
    81         xfree((void**)&iomodel->rheology_n);
    82         xfree((void**)&iomodel->rheology_B);
    83         xfree((void**)&iomodel->accumulation_rate);
    84         xfree((void**)&iomodel->melting_rate);
    85         xfree((void**)&iomodel->elementonwater);
    86         xfree((void**)&iomodel->pressure);
    87         xfree((void**)&iomodel->upperelements);
    88         xfree((void**)&iomodel->lowerelements);
    89 
    90         /*Add new constrant material property tgo materials, at the end: */
    91         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));//put it at the end of the materials
     31        /*Continuous Galerkin partition of nodes: */
     32        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    9233
    9334        /*First fetch data: */
    … …  
    9637                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    9738        }
    98         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    99         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    100         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    101         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    102         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    10339        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    10440        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    10844        for (i=0;i<iomodel->numberofvertices;i++){
    10945
    110                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    11146                if(iomodel->my_vertices[i]){
    11247                       
    113                         /*Add vertex to vertices dataset: */
    114                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    115 
    11648                        /*Add node to nodes dataset: */
    11749                        nodes->AddObject(new Node(i+1,i,iomodel));
    … …  
    12254        /*Clean fetched data: */
    12355        xfree((void**)&iomodel->deadgrids);
    124         xfree((void**)&iomodel->x);
    125         xfree((void**)&iomodel->y);
    126         xfree((void**)&iomodel->z);
    127         xfree((void**)&iomodel->thickness);
    128         xfree((void**)&iomodel->bed);
    12956        xfree((void**)&iomodel->gridonbed);
    13057        xfree((void**)&iomodel->gridonsurface);
    … …  
    13562        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    13663         * datasets, it will not be redone: */
    137         elements->Presort();
    13864        nodes->Presort();
    139         vertices->Presort();
    140         materials->Presort();
    141 
    142         cleanup_and_return:
    14365
    14466        /*Assign output pointer: */
    145         *pelements=elements;
    14667        *pnodes=nodes;
    147         *pvertices=vertices;
    148         *pmaterials=materials;
    14968}

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/CreateNodesPrognostic.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsPrognostic.c:
     2 * CreateNodesPrognostic.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsPrognostic(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesPrognostic(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j,k,n;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1921
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524       
    26         /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
     25        /*First create nodes*/
    2826        nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
    3127
    32         /*Partition elements and vertices and nodes: */
    33         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     28        /*Recover number of nodes already created in other analyses: */
     29        totalnodes=iomodel->nodecounter;
    3430
    35         /*2d mesh: */
    36         if (iomodel->dim==2){
    37 
    38                 /*Fetch data needed: */
    39                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    40                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    41                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    42                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    43                 IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    44                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    45                 IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    46                 IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    47                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    48                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    49 
    50                 for (i=0;i<iomodel->numberofelements;i++){
    51 
    52                         if(iomodel->my_elements[i]){
    53 
    54                                 /*Create and add tria element to elements dataset: */
    55                                 elements->AddObject(new Tria(i+1,i,iomodel));
    56 
    57                                 /*Create and add material property to materials dataset: */
    58                                 materials->AddObject(new Matice(i+1,i,iomodel,3));
    59                         }
    60                 }//for (i=0;i<numberofelements;i++)
    61 
    62 
    63                 /*Free data : */
    64                 xfree((void**)&iomodel->elements);
    65                 xfree((void**)&iomodel->thickness);
    66                 xfree((void**)&iomodel->surface);
    67                 xfree((void**)&iomodel->bed);
    68                 xfree((void**)&iomodel->elementoniceshelf);
    69                 xfree((void**)&iomodel->elementonwater);
    70                 xfree((void**)&iomodel->melting_rate);
    71                 xfree((void**)&iomodel->accumulation_rate);
    72                 xfree((void**)&iomodel->vx);
    73                 xfree((void**)&iomodel->vy);
    74 
    75         }
    76         else{ //        if (dim==2)
    77 
    78                 /*Fetch data needed: */
    79                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    80                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    81                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    82                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    83                 IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    84                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    85                 IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,"elementonsurface");
    86                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    87                 IoModelFetchData(&iomodel->pressure,NULL,NULL,iomodel_handle,"pressure");
    88                 IoModelFetchData(&iomodel->temperature,NULL,NULL,iomodel_handle,"temperature");
    89                 IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    90                 IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    91                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    92                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    93                 IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    94                 IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    95 
    96                 for (i=0;i<iomodel->numberofelements;i++){
    97                         if(iomodel->my_elements[i]){
    98                                 /*Create and add penta element to elements dataset: */
    99                                 elements->AddObject(new Penta(i+1,i,iomodel));
    100 
    101                                 /*Create and add material property to materials dataset: */
    102                                 materials->AddObject(new Matice(i+1,i,iomodel,6));
    103                         }
    104                 }//for (i=0;i<numberofelements;i++)
    105 
    106                 /*Free data: */
    107                 xfree((void**)&iomodel->elements);
    108                 xfree((void**)&iomodel->thickness);
    109                 xfree((void**)&iomodel->surface);
    110                 xfree((void**)&iomodel->bed);
    111                 xfree((void**)&iomodel->elementoniceshelf);
    112                 xfree((void**)&iomodel->elementonbed);
    113                 xfree((void**)&iomodel->elementonsurface);
    114                 xfree((void**)&iomodel->elementonwater);
    115                 xfree((void**)&iomodel->pressure);
    116                 xfree((void**)&iomodel->temperature);
    117                 xfree((void**)&iomodel->melting_rate);
    118                 xfree((void**)&iomodel->accumulation_rate);
    119                 xfree((void**)&iomodel->vx);
    120                 xfree((void**)&iomodel->vy);
    121                 xfree((void**)&iomodel->upperelements);
    122                 xfree((void**)&iomodel->lowerelements);
    123 
    124 
    125         } //if (dim==2)
    126 
    127         /*Add new constrant material property to materials, at the end: */
    128         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));//put it at the end of the materials
     31        /*Continuous Galerkin partition of nodes: */
     32        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    12933
    13034        /*First fetch data: */
    … …  
    13337                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    13438        }
    135         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    136         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    137         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    138         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    139         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    14039        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    14140        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    14544        for (i=0;i<iomodel->numberofvertices;i++){
    14645
    147                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    14846                if(iomodel->my_vertices[i]){
    149 
    150                         /*Add vertex to vertices dataset: */
    151                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    15247
    15348                        /*Add node to nodes dataset: */
    … …  
    15954        /*Clean fetched data: */
    16055        xfree((void**)&iomodel->deadgrids);
    161         xfree((void**)&iomodel->x);
    162         xfree((void**)&iomodel->y);
    163         xfree((void**)&iomodel->z);
    164         xfree((void**)&iomodel->thickness);
    165         xfree((void**)&iomodel->bed);
    16656        xfree((void**)&iomodel->gridonbed);
    16757        xfree((void**)&iomodel->gridonsurface);
    … …  
    17262        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    17363         * datasets, it will not be redone: */
    174         elements->Presort();
    17564        nodes->Presort();
    176         vertices->Presort();
    177         materials->Presort();
    178 
    179 cleanup_and_return:
    18065
    18166        /*Assign output pointer: */
    182         *pelements=elements;
    18367        *pnodes=nodes;
    184         *pvertices=vertices;
    185         *pmaterials=materials;
    18668
    18769}

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic2/CreateNodesPrognostic2.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsPrognostic2.c:
     2 * CreateNodesPrognostic2.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsPrognostic2(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesPrognostic2(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j;
     18        int i;
    1919        int vertex_index;
    2020        int node_index;
     21        int totalnodes;
     22        bool continuous_galerkin=false;
    2123
    2224        /*DataSets: */
    23         DataSet* elements  = NULL;
    2425        DataSet* nodes = NULL;
    25         DataSet* vertices = NULL;
    26         DataSet* materials = NULL;
    2726
    28         /*First create the elements, nodes and material properties: */
    29         elements  = new DataSet(ElementsEnum);
     27        /*First create nodes*/
    3028        nodes     = new DataSet(NodesEnum);
    31         vertices  = new DataSet(VerticesEnum);
    32         materials = new DataSet(MaterialsEnum);
    3329
    34         /*Partition elements and vertices and nodes: */
    35         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     30        /*Recover number of nodes already created in other analyses: */
     31        totalnodes=iomodel->nodecounter;
    3632
    37         /*elements created vary if we are dealing with a 2d mesh, or a 3d mesh: */
    38         /*2d mesh: */
    39         if (iomodel->dim==2){
     33        /*Continuous Galerkin partition of nodes: */
     34        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    4035
    41                 /*Fetch data needed: */
    42                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    43                 IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    44                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    45                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    46                 IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    47                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    48                 IoModelFetchData(&iomodel->melting_rate,NULL,NULL,iomodel_handle,"melting_rate");
    49                 IoModelFetchData(&iomodel->accumulation_rate,NULL,NULL,iomodel_handle,"accumulation_rate");
    50                 IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    51                 IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    52                
    53                 for (i=0;i<iomodel->numberofelements;i++){
    54 
    55                         if(iomodel->my_elements[i]){
    56 
    57                                 /*Create and add tria element to elements dataset: */
    58                                 elements->AddObject(new Tria(i+1,i,iomodel));
    59 
    60                                 /*Create and add material property to materials dataset: */
    61                                 materials->AddObject(new Matice(i+1,i,iomodel,3));
    62                         }
    63                 }//for (i=0;i<numberofelements;i++)
    64        
    65                 /*Free data : */
    66                 xfree((void**)&iomodel->thickness);
    67                 xfree((void**)&iomodel->surface);
    68                 xfree((void**)&iomodel->bed);
    69                 xfree((void**)&iomodel->elementoniceshelf);
    70                 xfree((void**)&iomodel->elementonwater);
    71                 xfree((void**)&iomodel->melting_rate);
    72                 xfree((void**)&iomodel->accumulation_rate);
    73                 xfree((void**)&iomodel->vx);
    74                 xfree((void**)&iomodel->vy);
    75 
    76         }
    77         else{ //        if (dim==2)
    78                 ISSMERROR("not implemented yet");
    79         } //if (dim==2)
    80 
    81         /*Add new constrant material property tgo materials, at the end: */
    82         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));
    83 
    84         /*Create nodes and vertices: */
    85         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    86         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    87         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    88         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    89         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
     36        /*Create nodes: */
    9037        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    9138        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    9340        IoModelFetchData(&iomodel->gridonicesheet,NULL,NULL,iomodel_handle,"gridonicesheet");
    9441        IoModelFetchData(&iomodel->gridoniceshelf,NULL,NULL,iomodel_handle,"gridoniceshelf");
     42        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    9543        if (iomodel->dim==3){
    9644                IoModelFetchData(&iomodel->deadgrids,NULL,NULL,iomodel_handle,"deadgrids");
    9745                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    98         }
    99 
    100         /*Build Vertices dataset*/
    101         for (i=0;i<iomodel->numberofvertices;i++){
    102 
    103                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    104                 if(iomodel->my_vertices[i]){
    105 
    106                         /*Add vertex to vertices dataset: */
    107                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    108 
    109                 }
    11046        }
    11147
    … …  
    13268        /*Clean fetched data: */
    13369        xfree((void**)&iomodel->deadgrids);
    134         xfree((void**)&iomodel->x);
    135         xfree((void**)&iomodel->y);
    136         xfree((void**)&iomodel->z);
    137         xfree((void**)&iomodel->thickness);
    138         xfree((void**)&iomodel->bed);
    13970        xfree((void**)&iomodel->gridonbed);
    14071        xfree((void**)&iomodel->gridonsurface);
    … …  
    14677        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    14778         * datasets, it will not be redone: */
    148         elements->Presort();
    14979        nodes->Presort();
    150         vertices->Presort();
    151         materials->Presort();
    152 
    153         cleanup_and_return:
    15480
    15581        /*Assign output pointer: */
    156         *pelements=elements;
    15782        *pnodes=nodes;
    158         *pvertices=vertices;
    159         *pmaterials=materials;
    16083}

  • issm/trunk/src/c/modules/ModelProcessorx/SlopeCompute/CreateNodesSlopeConpute.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsSlopeCompute.c:
     2 * CreateNodesSlopeCompute.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsSlopeCompute(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesSlopeCompute(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    17                 /*output: int* epart, int* my_grids, double* my_bordergrids*/
     17        /*Intermediary*/
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1821
    19         int i,j,k,n;
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524       
    26         /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
    28         nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
     25        /*First create nodes*/
     26        nodes = new DataSet(NodesEnum);
    3127
    32         /*Partition elements and vertices and nodes: */
    33         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     28        /*Recover number of nodes already created in other analyses: */
     29        totalnodes=iomodel->nodecounter;
    3430
    35         /*2d mesh: */
    36         if (iomodel->dim==2){
    37 
    38                 /*Fetch data needed: */
    39                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    40                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    41                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    42                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    43                
    44                 for (i=0;i<iomodel->numberofelements;i++){
    45 
    46                         if(iomodel->my_elements[i]){
    47                                
    48                                 /*Create and add tria element to elements dataset: */
    49                                 elements->AddObject(new Tria(i+1,i,iomodel));
    50 
    51                                 /*Create and add material property to materials dataset: */
    52                                 materials->AddObject(new Matice(i+1,i,iomodel,3));
    53                         }
    54 
    55                 }//for (i=0;i<numberofelements;i++)
    56 
    57        
    58                 /*Free data : */
    59                 xfree((void**)&iomodel->elements);
    60                 xfree((void**)&iomodel->surface);
    61                 xfree((void**)&iomodel->bed);
    62                 xfree((void**)&iomodel->elementonwater);
    63 
    64         }
    65         else{ //        if (dim==2)
    66 
    67                 /*Fetch data needed: */
    68                 IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    69                 IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    70                 IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    71                 IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    72                 IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    73                 IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    74                 IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    75        
    76                 for (i=0;i<iomodel->numberofelements;i++){
    77                         if(iomodel->my_elements[i]){
    78                                 /*Create and add penta element to elements dataset: */
    79                                 elements->AddObject(new Penta(i+1,i,iomodel));
    80 
    81                                 /*Create and add material property to materials dataset: */
    82                                 materials->AddObject(new Matice(i+1,i,iomodel,6));
    83 
    84                         }//if(my_elements[i])
    85                 }//for (i=0;i<numberofelements;i++)
    86 
    87                 /*Free data: */
    88                 xfree((void**)&iomodel->elements);
    89                 xfree((void**)&iomodel->surface);
    90                 xfree((void**)&iomodel->bed);
    91                 xfree((void**)&iomodel->elementonbed);
    92                 xfree((void**)&iomodel->elementonwater);
    93                 xfree((void**)&iomodel->upperelements);
    94                 xfree((void**)&iomodel->lowerelements);
    95 
    96         } //if (dim==2)
    97 
    98         /*Add new constrant material property tgo materials, at the end: */
    99         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel)); //put it at the end of the materials
     31        /*Continuous Galerkin partition of nodes: */
     32        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    10033       
    10134        /*First fetch data: */
    … …  
    10437                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    10538        }
    106         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    107         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    108         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    109         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    110         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    11139        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    11240        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    11644        for (i=0;i<iomodel->numberofvertices;i++){
    11745
    118                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    11946                if(iomodel->my_vertices[i]){
    12047                       
    121                         /*Add vertex to vertices dataset: */
    122                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    123 
    12448                        /*Add node to nodes dataset: */
    12549                        nodes->AddObject(new Node(i+1,i,iomodel));
    … …  
    13054        /*Clean fetched data: */
    13155        xfree((void**)&iomodel->deadgrids);
    132         xfree((void**)&iomodel->x);
    133         xfree((void**)&iomodel->y);
    134         xfree((void**)&iomodel->z);
    135         xfree((void**)&iomodel->thickness);
    136         xfree((void**)&iomodel->bed);
    13756        xfree((void**)&iomodel->gridonbed);
    13857        xfree((void**)&iomodel->gridonsurface);
    … …  
    14362        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    14463         * datasets, it will not be redone: */
    145         elements->Presort();
    14664        nodes->Presort();
    147         vertices->Presort();
    148         materials->Presort();
    149 
    150         cleanup_and_return:
    15165
    15266        /*Assign output pointer: */
    153         *pelements=elements;
    15467        *pnodes=nodes;
    155         *pvertices=vertices;
    156         *pmaterials=materials;
    15768
    15869}

  • issm/trunk/src/c/modules/ModelProcessorx/Thermal/CreateNodesThermal.cpp

    r3998 r3999  
    11/*
    2  * CreateElementsNodesAndMaterialsThermal.c:
     2 * CreateNodesThermal.c:
    33 */
    44
    … …  
    1313#include "../ModelProcessorx.h"
    1414
    15 void    CreateElementsNodesAndMaterialsThermal(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
     15void    CreateNodesThermal(DataSet** pelements,DataSet** pnodes, DataSet** pvertices,DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1616
    1717        /*Intermediary*/
    18         int i,j,k,n;
     18        int i;
     19        int totalnodes;
     20        bool continuous_galerkin=true;
    1921
    2022        /*DataSets: */
    21         DataSet*    elements  = NULL;
    2223        DataSet*    nodes = NULL;
    23         DataSet*    vertices = NULL;
    24         DataSet*    materials = NULL;
    2524       
    26         /*First create the elements, nodes and material properties: */
    27         elements  = new DataSet(ElementsEnum);
    28         nodes     = new DataSet(NodesEnum);
    29         vertices  = new DataSet(VerticesEnum);
    30         materials = new DataSet(MaterialsEnum);
     25        /*First create nodes*/
     26        nodes = new DataSet(NodesEnum);
    3127
    32         /*Partition elements and vertices and nodes: */
    33         Partitioning(&iomodel->my_elements, &iomodel->my_vertices, &iomodel->my_nodes, &iomodel->my_bordervertices, iomodel, iomodel_handle);
     28        /*Recover number of nodes already created in other analyses: */
     29        totalnodes=iomodel->nodecounter;
    3430
    35         /*Fetch data needed: */
    36         IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    37         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    38         IoModelFetchData(&iomodel->surface,NULL,NULL,iomodel_handle,"surface");
    39         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    40         IoModelFetchData(&iomodel->drag_coefficient,NULL,NULL,iomodel_handle,"drag_coefficient");
    41         IoModelFetchData(&iomodel->drag_p,NULL,NULL,iomodel_handle,"drag_p");
    42         IoModelFetchData(&iomodel->drag_q,NULL,NULL,iomodel_handle,"drag_q");
    43         IoModelFetchData(&iomodel->elementoniceshelf,NULL,NULL,iomodel_handle,"elementoniceshelf");
    44         IoModelFetchData(&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed");
    45         IoModelFetchData(&iomodel->elementonsurface,NULL,NULL,iomodel_handle,"elementonsurface");
    46         IoModelFetchData(&iomodel->elements_type,NULL,NULL,iomodel_handle,"elements_type");
    47         IoModelFetchData(&iomodel->geothermalflux,NULL,NULL,iomodel_handle,"geothermalflux");
    48         IoModelFetchData(&iomodel->rheology_B,NULL,NULL,iomodel_handle,"rheology_B");
    49         IoModelFetchData(&iomodel->rheology_n,NULL,NULL,iomodel_handle,"rheology_n");
    50         IoModelFetchData(&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater");
    51         IoModelFetchData(&iomodel->pressure,NULL,NULL,iomodel_handle,"pressure");
    52         IoModelFetchData(&iomodel->temperature,NULL,NULL,iomodel_handle,"temperature");
    53         IoModelFetchData(&iomodel->vx,NULL,NULL,iomodel_handle,"vx");
    54         IoModelFetchData(&iomodel->vy,NULL,NULL,iomodel_handle,"vy");
    55         IoModelFetchData(&iomodel->vz,NULL,NULL,iomodel_handle,"vz");
    56         IoModelFetchData(&iomodel->upperelements,NULL,NULL,iomodel_handle,"upperelements");
    57         IoModelFetchData(&iomodel->lowerelements,NULL,NULL,iomodel_handle,"lowerelements");
    58        
    59         for (i=0;i<iomodel->numberofelements;i++){
    60                 if(iomodel->my_elements[i]){
     31        /*Continuous Galerkin partition of nodes: */
     32        NodesPartitioning(&iomodel->my_nodes,iomodel->my_elements, iomodel->my_vertices, iomodel->my_bordervertices, iomodel, iomodel_handle,continuous_galerkin);
    6133
    62                         /*Create and add tria element to elements dataset: */
    63                         elements->AddObject(new Penta(i+1,i,iomodel));
    64 
    65                         /*Create and add material property to materials dataset: */
    66                         materials->AddObject(new Matice(i+1,i,iomodel,6));
    67                 }
    68         }//for (i=0;i<numberofelements;i++)
    69 
    70         /*Free data: */
    71         xfree((void**)&iomodel->elements);
    72         xfree((void**)&iomodel->thickness);
    73         xfree((void**)&iomodel->surface);
    74         xfree((void**)&iomodel->bed);
    75         xfree((void**)&iomodel->drag_coefficient);
    76         xfree((void**)&iomodel->drag_p);
    77         xfree((void**)&iomodel->drag_q);
    78         xfree((void**)&iomodel->elementoniceshelf);
    79         xfree((void**)&iomodel->elementonbed);
    80         xfree((void**)&iomodel->elementonsurface);
    81         xfree((void**)&iomodel->elements_type);
    82         xfree((void**)&iomodel->geothermalflux);
    83         xfree((void**)&iomodel->rheology_n);
    84         xfree((void**)&iomodel->rheology_B);
    85         xfree((void**)&iomodel->elementonwater);
    86         xfree((void**)&iomodel->pressure);
    87         xfree((void**)&iomodel->temperature);
    88         xfree((void**)&iomodel->vx);
    89         xfree((void**)&iomodel->vy);
    90         xfree((void**)&iomodel->vz);
    91         xfree((void**)&iomodel->upperelements);
    92         xfree((void**)&iomodel->lowerelements);
    93 
    94         /*Add new constrant material property tgo materials, at the end: */
    95         materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));//put it at the end of the materials
    96        
    9734        /*Create nodes and vertices: */
    9835        if (iomodel->dim==3){
    … …  
    10037                IoModelFetchData(&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids");
    10138        }
    102         IoModelFetchData(&iomodel->x,NULL,NULL,iomodel_handle,"x");
    103         IoModelFetchData(&iomodel->y,NULL,NULL,iomodel_handle,"y");
    104         IoModelFetchData(&iomodel->z,NULL,NULL,iomodel_handle,"z");
    105         IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    106         IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
    10739        IoModelFetchData(&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed");
    10840        IoModelFetchData(&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface");
    … …  
    11244        for (i=0;i<iomodel->numberofvertices;i++){
    11345
    114                 /*vertices and nodes (same number, as we are running continuous galerkin formulation: */
    11546                if(iomodel->my_vertices[i]){
    11647                       
    117                         /*Add vertex to vertices dataset: */
    118                         vertices->AddObject(new Vertex(i+1,i,iomodel));
    119 
    12048                        /*Add node to nodes dataset: */
    12149                        nodes->AddObject(new Node(i+1,i,iomodel));
    … …  
    12654        /*Clean fetched data: */
    12755        xfree((void**)&iomodel->deadgrids);
    128         xfree((void**)&iomodel->x);
    129         xfree((void**)&iomodel->y);
    130         xfree((void**)&iomodel->z);
    131         xfree((void**)&iomodel->thickness);
    132         xfree((void**)&iomodel->bed);
    13356        xfree((void**)&iomodel->gridonbed);
    13457        xfree((void**)&iomodel->gridonsurface);
    … …  
    13962        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    14063         * datasets, it will not be redone: */
    141         elements->Presort();
    14264        nodes->Presort();
    143         vertices->Presort();
    144         materials->Presort();
    145 
    146         cleanup_and_return:
    14765
    14866        /*Assign output pointer: */
    149         *pelements=elements;
    15067        *pnodes=nodes;
    151         *pvertices=vertices;
    152         *pmaterials=materials;
    15368
    15469}
Note: See TracChangeset for help on using the changeset viewer.