Changeset 15430


Ignore:
Timestamp:
07/04/13 14:55:22 (12 years ago)
Author:
Mathieu Morlighem
Message:

NEW: create edges on the fly instead of relying on md.mesh.edges

Location:
issm/trunk-jpl/src/c
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed

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

    r15417 r15430  
    243243                                        ./modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp\
    244244                                        ./modules/ModelProcessorx/NodesPartitioning.cpp\
     245                                        ./modules/ModelProcessorx/ProcessMesh2d.cpp\
    245246                                        ./modules/ModelProcessorx/SortDataSets.cpp\
    246247                                        ./modules/ModelProcessorx/UpdateCounters.cpp\

  • issm/trunk-jpl/src/c/classes/IoModel.cpp

    r15428 r15430  
    6464
    6565        /*Initialize permanent data: */
    66         this->my_elements=NULL;
    67         this->my_nodes=NULL;
    68         this->my_vertices=NULL;
    69 
     66        this->my_elements = NULL;
     67        this->my_nodes    = NULL;
     68        this->my_vertices = NULL;
    7069        FetchData(&this->dim,MeshDimensionEnum);
    7170        FetchData(&this->numberofvertices,MeshNumberofverticesEnum);
    7271        FetchData(&this->numberofelements,MeshNumberofelementsEnum);
    7372        FetchData(&this->elements,NULL,NULL,MeshElementsEnum);
    74         this->edges=NULL;
    75         this->singlenodetoelementconnectivity=NULL;
    76         this->numbernodetoelementconnectivity=NULL;
     73        this->edges                           = NULL;
     74        this->elementedgeconnectivity         = NULL;
     75        this->singlenodetoelementconnectivity = NULL;
     76        this->numbernodetoelementconnectivity = NULL;
    7777
    7878        this->nodecounter=0;
    … …  
    8383/*FUNCTION IoModel::~IoModel(){{{*/
    8484IoModel::~IoModel(){
    85 
    86         if(this->constants) delete this->constants;
    8785
    8886        /*Some checks in debugging mode*/
    … …  
    9795        #endif
    9896
     97        if(this->constants) delete this->constants;
     98
    9999        xDelete<IssmDouble*>(this->data);
    100100        xDelete<bool>(this->independents);
    101101        if(this->independent_objects)delete this->independent_objects;
     102
    102103        xDelete<bool>(this->my_elements);
    103104        xDelete<bool>(this->my_nodes);
    104105        xDelete<int>(this->my_vertices);
     106
    105107        xDelete<int>(this->elements);
    106108        xDelete<int>(this->edges);
     109        xDelete<int>(this->elementedgeconnectivity);
    107110        xDelete<int>(this->singlenodetoelementconnectivity);
    108111        xDelete<int>(this->numbernodetoelementconnectivity);

  • issm/trunk-jpl/src/c/classes/IoModel.h

    r15428 r15430  
    3535                int   numberofvertices;
    3636                int   numberofelements;
     37                int   numberofedges;
    3738                int  *elements;
    3839                int  *edges;
     40                int  *elementedgeconnectivity;
    3941                int  *singlenodetoelementconnectivity;
    4042                int  *numbernodetoelementconnectivity;

  • issm/trunk-jpl/src/c/classes/Loads/Numericalflux.cpp

    r15428 r15430  
    3333/*}}}*/
    3434/*FUNCTION Numericalflux::Numericalflux(int id, int i, IoModel* iomodel, int analysis_type) {{{*/
    35 Numericalflux::Numericalflux(int numericalflux_id,int i, IoModel* iomodel, int in_analysis_type){
     35Numericalflux::Numericalflux(int numericalflux_id,int i,int index,IoModel* iomodel, int in_analysis_type){
    3636
    3737        /* Intermediary */
    38         int  e1,e2;
    39         int  i1,i2;
    4038        int  j;
    4139        int  pos1,pos2,pos3,pos4;
    … …  
    5048        int   numericalflux_type;
    5149
    52         int    numberofelements;
    53 
    54         /*Fetch parameters: */
    55         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    56 
    5750        /* Get MatPar id */
    58         numericalflux_mparid=numberofelements+1; //matlab indexing
     51        numericalflux_mparid=iomodel->numberofelements+1; //matlab indexing
     52
     53        /*Get edge*/
     54        int i1 = iomodel->edges[4*index+0];
     55        int i2 = iomodel->edges[4*index+1];
     56        int e1 = iomodel->edges[4*index+2];
     57        int e2 = iomodel->edges[4*index+3];
    5958
    6059        /*First, see wether this is an internal or boundary edge (if e2=-1)*/
    61         if (iomodel->Data(MeshEdgesEnum)[4*i+3]==-1.){ //edges are [node1 node2 elem1 elem2]
     60        if(e2==-1){
    6261                /* Boundary edge, only one element */
    63                 e1=reCast<int>(iomodel->Data(MeshEdgesEnum)[4*i+2]);
    64                 e2=reCast<int>(UNDEF);
    65                 num_elems=1;
    66                 num_nodes=2;
     62                num_elems=1; num_nodes=2;
    6763                numericalflux_type=BoundaryEnum;
    6864                numericalflux_elem_ids[0]=e1;
    … …  
    7066        else{
    7167                /* internal edge: connected to 2 elements */
    72                 e1=reCast<int>(iomodel->Data(MeshEdgesEnum)[4*i+2]);
    73                 e2=reCast<int>(iomodel->Data(MeshEdgesEnum)[4*i+3]);
    74                 num_elems=2;
    75                 num_nodes=4;
     68                num_elems=2; num_nodes=4;
    7669                numericalflux_type=InternalEnum;
    7770                numericalflux_elem_ids[0]=e1;
    … …  
    8073
    8174        /*1: Get vertices ids*/
    82         i1=reCast<int>(iomodel->Data(MeshEdgesEnum)[4*i+0]);
    83         i2=reCast<int>(iomodel->Data(MeshEdgesEnum)[4*i+1]);
    8475        numericalflux_vertex_ids[0]=i1;
    8576        numericalflux_vertex_ids[1]=i2;
    … …  
    9384                pos1=pos2=pos3=pos4=UNDEF;
    9485                for(j=0;j<3;j++){
    95                         if (iomodel->elements[3*(e1-1)+j]==i1) pos1=j+1;
    96                         if (iomodel->elements[3*(e1-1)+j]==i2) pos2=j+1;
    97                         if (iomodel->elements[3*(e2-1)+j]==i1) pos3=j+1;
    98                         if (iomodel->elements[3*(e2-1)+j]==i2) pos4=j+1;
     86                        if(iomodel->elements[3*(e1-1)+j]==i1) pos1=j+1;
     87                        if(iomodel->elements[3*(e1-1)+j]==i2) pos2=j+1;
     88                        if(iomodel->elements[3*(e2-1)+j]==i1) pos3=j+1;
     89                        if(iomodel->elements[3*(e2-1)+j]==i2) pos4=j+1;
    9990                }
    10091                _assert_(pos1!=UNDEF && pos2!=UNDEF && pos3!=UNDEF && pos4!=UNDEF);
    … …  
    112103                pos1=pos2=UNDEF;
    113104                for(j=0;j<3;j++){
    114                         if (iomodel->elements[3*(e1-1)+j]==i1) pos1=j+1;
    115                         if (iomodel->elements[3*(e1-1)+j]==i2) pos2=j+1;
     105                        if(iomodel->elements[3*(e1-1)+j]==i1) pos1=j+1;
     106                        if(iomodel->elements[3*(e1-1)+j]==i2) pos2=j+1;
    116107                }
    117108                _assert_(pos1!=UNDEF && pos2!=UNDEF);

  • issm/trunk-jpl/src/c/classes/Loads/Numericalflux.h

    r15373 r15430  
    3737                /*Numericalflux constructors,destructors {{{*/
    3838                Numericalflux();
    39                 Numericalflux(int numericalflux_id,int i, IoModel* iomodel,int analysis_type);
     39                Numericalflux(int numericalflux_id,int i,int index,IoModel* iomodel,int analysis_type);
    4040                ~Numericalflux();
    4141                /*}}}*/

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Balancethickness/CreateLoadsBalancethickness.cpp

    r15428 r15430  
    1212        int element;
    1313        int stabilization;
    14         int numberofedges;
    1514
    1615        /*Fetch parameters: */
    1716        iomodel->Constant(&stabilization,BalancethicknessStabilizationEnum);
    18         iomodel->Constant(&numberofedges,MeshNumberofedgesEnum);
    1917
    2018        /*Recover pointer: */
    … …  
    2826
    2927                /*Get edges and elements*/
    30                 iomodel->FetchData(2,MeshEdgesEnum,ThicknessEnum);
     28                ProcessMesh2d(&iomodel->edges,&iomodel->numberofedges,NULL,iomodel->elements,iomodel->numberofelements,iomodel->numberofvertices);
     29                iomodel->FetchData(1,ThicknessEnum);
    3130
    3231                /*First load data:*/
    33                 for (int i=0;i<numberofedges;i++){
     32                for(int i=0;i<iomodel->numberofedges;i++){
    3433
    3534                        /*Get left and right elements*/
    36                         element=reCast<int,IssmDouble>(iomodel->Data(MeshEdgesEnum)[4*i+2])-1; //edges are [node1 node2 elem1 elem2]
     35                        element=iomodel->edges[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
    3736
    3837                        /*Now, if this element is not in the partition, pass: */
    … …  
    4039
    4140                        /* Add load */
    42                         loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,iomodel,BalancethicknessAnalysisEnum));
     41                        loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,i,iomodel,BalancethicknessAnalysisEnum));
    4342                }
    4443
    4544                /*Free data: */
    46                 iomodel->DeleteData(2,MeshEdgesEnum,ThicknessEnum);
     45                iomodel->DeleteData(1,ThicknessEnum);
    4746        }
    4847

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

    r15428 r15430  
    4949
    5050        if(false){
     51
    5152                /*Quadratic element*/
    52                 int numberofedges;
     53                ProcessMesh2d(&iomodel->edges,&iomodel->numberofedges,NULL,iomodel->elements,iomodel->numberofelements,iomodel->numberofvertices);
    5354                int  element1,element2;
    5455                bool my_edge;
    5556
    56                 iomodel->Constant(&numberofedges,MeshNumberofedgesEnum);
    57 
    58                 for(int i=0;i<numberofedges;i++){
     57                for(int i=0;i<iomodel->numberofedges;i++){
    5958
    6059                        /*Get left and right elements*/
    61                         element1=reCast<int>(iomodel->Data(MeshEdgesEnum)[4*i+2])-1; //edges are [node1 node2 elem1 elem2]
    62                         element2=reCast<int>(iomodel->Data(MeshEdgesEnum)[4*i+3])-1; //edges are [node1 node2 elem1 elem2]
     60                        element1=iomodel->edges[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
     61                        element2=iomodel->edges[4*i+3]-1; //edges are [node1 node2 elem1 elem2]
    6362
    6463                        /*Check whether we should include this edge (element2 is -2 for boundary edges)*/

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h

    r15037 r15430  
    1313
    1414/*Creation of fem datasets: general drivers*/
    15 void  CreateDataSets(Elements** pelements,Nodes** pnodes,Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads,Parameters** pparameters,IoModel* iomodel,char* rootpath,const int solution_type,int analysis_type,const int nummodels,int analysis_counter);
    16 void  CreateElementsVerticesAndMaterials(Elements** pelements,Vertices** pvertices,Materials** pmaterials, IoModel* iomodel,const int nummodels);
    17 void  CreateParameters(Parameters** pparameters,IoModel* iomodel,char* rootpath,const int solution_type,int analysis_type,int analysis_counter);
    18 void  CreateParametersAutodiff(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
    19 void  CreateParametersControl(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
    20 void  CreateParametersDakota(Parameters** pparameters,IoModel* iomodel,char* rootpath,int solution_type,int analysis_type);
    21 void  CreateParametersHydrologyShreve(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
    22 void  CreateParametersHydrologyDCInefficient(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
    23 void  CreateParametersHydrologyDCEfficient(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
    24 void  UpdateElementsAndMaterialsControl(Elements* elements,Materials* materials, IoModel* iomodel);
     15void CreateDataSets(Elements** pelements,Nodes** pnodes,Vertices** pvertices, Materials** pmaterials, Constraints** pconstraints, Loads** ploads,Parameters** pparameters,IoModel* iomodel,char* rootpath,const int solution_type,int analysis_type,const int nummodels,int analysis_counter);
     16void CreateElementsVerticesAndMaterials(Elements** pelements,Vertices** pvertices,Materials** pmaterials, IoModel* iomodel,const int nummodels);
     17void CreateParameters(Parameters** pparameters,IoModel* iomodel,char* rootpath,const int solution_type,int analysis_type,int analysis_counter);
     18void CreateParametersAutodiff(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
     19void CreateParametersControl(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
     20void CreateParametersDakota(Parameters** pparameters,IoModel* iomodel,char* rootpath,int solution_type,int analysis_type);
     21void CreateParametersHydrologyShreve(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
     22void CreateParametersHydrologyDCInefficient(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
     23void CreateParametersHydrologyDCEfficient(Parameters** pparameters,IoModel* iomodel,int solution_type,int analysis_type);
     24void UpdateElementsAndMaterialsControl(Elements* elements,Materials* materials, IoModel* iomodel);
    2525
    2626/*Creation of fem datasets: specialised drivers: */
    2727
    2828/*diagnostic horizontal*/
    29 void    CreateNodesDiagnosticHoriz(Nodes** pnodes,IoModel* iomodel);
    30 void    CreateConstraintsDiagnosticHoriz(Constraints** pconstraints,IoModel* iomodel);
    31 void  CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel);
    32 void    UpdateElementsDiagnosticHoriz(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     29void CreateNodesDiagnosticHoriz(Nodes** pnodes,IoModel* iomodel);
     30void CreateConstraintsDiagnosticHoriz(Constraints** pconstraints,IoModel* iomodel);
     31void CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel);
     32void UpdateElementsDiagnosticHoriz(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    3333
    3434/*diagnostic vertical*/
    … …  
    7171
    7272/*enthalpy:*/
    73 void    CreateNodesEnthalpy(Nodes** pnodes,IoModel* iomodel);
    74 void    CreateConstraintsEnthalpy(Constraints** pconstraints,IoModel* iomodel);
    75 void  CreateLoadsEnthalpy(Loads** ploads, IoModel* iomodel);
    76 void    UpdateElementsEnthalpy(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     73void CreateNodesEnthalpy(Nodes** pnodes,IoModel* iomodel);
     74void CreateConstraintsEnthalpy(Constraints** pconstraints,IoModel* iomodel);
     75void CreateLoadsEnthalpy(Loads** ploads, IoModel* iomodel);
     76void UpdateElementsEnthalpy(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    7777
    7878/*hydrology Shreve:*/
    79 void    CreateNodesHydrologyShreve(Nodes** pnodes,IoModel* iomodel);
    80 void    CreateConstraintsHydrologyShreve(Constraints** pconstraints,IoModel* iomodel);
    81 void  CreateLoadsHydrologyShreve(Loads** ploads, IoModel* iomodel);
    82 void    UpdateElementsHydrologyShreve(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     79void CreateNodesHydrologyShreve(Nodes** pnodes,IoModel* iomodel);
     80void CreateConstraintsHydrologyShreve(Constraints** pconstraints,IoModel* iomodel);
     81void CreateLoadsHydrologyShreve(Loads** ploads, IoModel* iomodel);
     82void UpdateElementsHydrologyShreve(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    8383
    8484/*hydrology DC:*/
    85 void    CreateNodesHydrologyDCInefficient(Nodes** pnodes,IoModel* iomodel);
    86 void    CreateConstraintsHydrologyDCInefficient(Constraints** pconstraints,IoModel* iomodel);
    87 void  CreateLoadsHydrologyDCInefficient(Loads** ploads, IoModel* iomodel);
    88 void    UpdateElementsHydrologyDCInefficient(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    89 void    CreateNodesHydrologyDCEfficient(Nodes** pnodes,IoModel* iomodel);
    90 void    CreateConstraintsHydrologyDCEfficient(Constraints** pconstraints,IoModel* iomodel);
    91 void  CreateLoadsHydrologyDCEfficient(Loads** ploads, IoModel* iomodel);
    92 void    UpdateElementsHydrologyDCEfficient(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     85void CreateNodesHydrologyDCInefficient(Nodes** pnodes,IoModel* iomodel);
     86void CreateConstraintsHydrologyDCInefficient(Constraints** pconstraints,IoModel* iomodel);
     87void CreateLoadsHydrologyDCInefficient(Loads** ploads, IoModel* iomodel);
     88void UpdateElementsHydrologyDCInefficient(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     89void CreateNodesHydrologyDCEfficient(Nodes** pnodes,IoModel* iomodel);
     90void CreateConstraintsHydrologyDCEfficient(Constraints** pconstraints,IoModel* iomodel);
     91void CreateLoadsHydrologyDCEfficient(Loads** ploads, IoModel* iomodel);
     92void UpdateElementsHydrologyDCEfficient(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    9393
    9494/*melting:*/
    95 void    CreateNodesMelting(Nodes** pnodes,IoModel* iomodel);
    96 void    CreateConstraintsMelting(Constraints** pconstraints,IoModel* iomodel);
    97 void  CreateLoadsMelting(Loads** ploads, IoModel* iomodel);
    98 void    UpdateElementsMelting(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     95void CreateNodesMelting(Nodes** pnodes,IoModel* iomodel);
     96void CreateConstraintsMelting(Constraints** pconstraints,IoModel* iomodel);
     97void CreateLoadsMelting(Loads** ploads, IoModel* iomodel);
     98void UpdateElementsMelting(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    9999
    100100/*prognostic:*/
    101 void    CreateNodesPrognostic(Nodes** pnodes,IoModel* iomodel);
    102 void    CreateConstraintsPrognostic(Constraints** pconstraints,IoModel* iomodel);
    103 void  CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel);
    104 void    UpdateElementsPrognostic(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     101void CreateNodesPrognostic(Nodes** pnodes,IoModel* iomodel);
     102void CreateConstraintsPrognostic(Constraints** pconstraints,IoModel* iomodel);
     103void CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel);
     104void UpdateElementsPrognostic(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    105105
    106106/*balancedthickness:*/
    107 void    CreateNodesBalancethickness(Nodes** pnodes,IoModel* iomodel);
    108 void    CreateConstraintsBalancethickness(Constraints** pconstraints,IoModel* iomodel);
    109 void  CreateLoadsBalancethickness(Loads** ploads, IoModel* iomodel);
    110 void    UpdateElementsBalancethickness(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     107void CreateNodesBalancethickness(Nodes** pnodes,IoModel* iomodel);
     108void CreateConstraintsBalancethickness(Constraints** pconstraints,IoModel* iomodel);
     109void CreateLoadsBalancethickness(Loads** ploads, IoModel* iomodel);
     110void UpdateElementsBalancethickness(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    111111
    112112/*transient: */
    113 void    UpdateElementsTransient(Elements* elements,Parameters* parameters,IoModel* iomodel,int analysis_counter,int analysis_type);
     113void UpdateElementsTransient(Elements* elements,Parameters* parameters,IoModel* iomodel,int analysis_counter,int analysis_type);
    114114
    115115/*partitioning: */
    116 void  ElementsAndVerticesPartitioning(bool** pmy_elements, int** pmy_vertices, IoModel* iomodel);
    117 void  NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices,  IoModel* iomodel, bool continuous);
     116void ElementsAndVerticesPartitioning(bool** pmy_elements, int** pmy_vertices, IoModel* iomodel);
     117void NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices,  IoModel* iomodel, bool continuous);
    118118
    119119/*Connectivity*/
    120 void  CreateSingleNodeToElementConnectivity(IoModel* iomodel);
    121 void  CreateNumberNodeToElementConnectivity(IoModel* iomodel);
     120void ProcessMesh2d(int**,int*,int**,int* index,int numberofelements,int numberofvertices);
     121void CreateSingleNodeToElementConnectivity(IoModel* iomodel);
     122void CreateNumberNodeToElementConnectivity(IoModel* iomodel);
    122123
    123124/*Diverse: */

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/NodesPartitioning.cpp

    r15428 r15430  
    2020void  NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel, bool continuous){
    2121
    22         /*First thing, this is a new partition for a new analysis_type, therefore, to avoid a leak, erase the nodes partition that might come through pmy_nodes: */
     22        /*First thing, this is a new partition for a new analysis_type, therefore,
     23         * to avoid a leak, erase the nodes partition that might come through
     24         * pmy_nodes: */
    2325        xDelete<bool>(*pmy_nodes);
    2426
    … …  
    4244void  DiscontinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel){
    4345
    44         /*each element has it own nodes (as many as vertices) + additional nodes from neighbouring elements for each edge. This yields to a very different partition for
    45          * the nodes and the vertices. The vertices are similar to continuous galerkin, but the nodes partitioning involves edges, which mess up sorting of
    46          * ids. */
     46        /* Each element has it own nodes (as many as vertices) + additional nodes
     47         * from neighboring elements for each edge. This yields to a very different
     48         * partition for the nodes and the vertices. The vertices are similar to
     49         * continuous galerkin, but the nodes partitioning involves edges, which
     50         * mess up sorting of ids. */
    4751
    48         /*output: */
    49         bool*   my_nodes=NULL;
    5052
     53        /*Intermediaries*/
    5154        int  i,i1,i2;
    5255        int  cols;
    5356        int  e1,e2;
    5457        int  pos;
    55         int  numberofedges;
    56         int *edges         = NULL;
    57         int *elements      = NULL;
     58
     59        /*Get edges and elements*/
     60        ProcessMesh2d(&iomodel->edges,&iomodel->numberofedges,NULL,iomodel->elements,iomodel->numberofelements,iomodel->numberofvertices);
    5861
    5962        /*Build discontinuous node partitioning
    … …  
    6770
    6871        /*Allocate*/
    69         my_nodes=xNewZeroInit<bool>(3*iomodel->numberofelements);
     72        bool* my_nodes=xNewZeroInit<bool>(3*iomodel->numberofelements);
    7073
    7174        /*First: add all the nodes of all the elements belonging to this cpu*/
    … …  
    8689
    8790        /*Get edges and elements*/
    88         iomodel->FetchData(&edges,&numberofedges,&cols,MeshEdgesEnum);
    89         if (cols!=4) _error_("field edges should have 4 columns");
     91        ProcessMesh2d(&iomodel->edges,&iomodel->numberofedges,NULL,iomodel->elements,iomodel->numberofelements,iomodel->numberofvertices);
    9092
    9193        /*!All elements have been partitioned above, only create elements for this CPU: */
    92         for (i=0;i<numberofedges;i++){
     94        for(int i=0;i<iomodel->numberofedges;i++){
    9395
    9496                /*Get left and right elements*/
    95                 e1=edges[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
    96                 e2=edges[4*i+3]-1; //edges are [node1 node2 elem1 elem2]
     97                e1=iomodel->edges[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
     98                e2=iomodel->edges[4*i+3]-1; //edges are [node1 node2 elem1 elem2]
    9799
    98100                /* 1) If the element e1 is in the current partition
    … …  
    104106
    105107                        /*1: Get vertices ids*/
    106                         i1=edges[4*i+0];
    107                         i2=edges[4*i+1];
     108                        i1=iomodel->edges[4*i+0];
     109                        i2=iomodel->edges[4*i+1];
    108110
    109111                        /*2: Get the column where these ids are located in the index*/
    … …  
    115117                        /*3: We have the id of the elements and the position of the vertices in the index
    116118                         * we can now create the corresponding nodes:*/
    117                         if (pos==0){
     119                        if(pos==0){
    118120                                my_nodes[e2*3+0]=true;
    119121                                my_nodes[e2*3+2]=true;
    … …  
    123125                                my_nodes[e2*3+0]=true;
    124126                        }
    125                         else if (pos==2){
     127                        else if(pos==2){
    126128                                my_nodes[e2*3+2]=true;
    127129                                my_nodes[e2*3+1]=true;
    … …  
    133135        }
    134136
    135         /*Free data: */
    136         xDelete<int>(edges);
    137 
    138         /*Assign output pointers:*/
     137        /*Free data and assign output pointers */
    139138        *pmy_nodes=my_nodes;
    140139}

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Prognostic/CreateLoadsPrognostic.cpp

    r15428 r15430  
    1010
    1111        /*Intermediaries*/
    12         int i;
    1312        int element;
    1413        int penpair_ids[2];
    1514        int count=0;
    1615        int stabilization;
    17         int numberofedges;
    1816        int numvertex_pairing;
    1917
    2018        /*Fetch parameters: */
    2119        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    22         iomodel->Constant(&numberofedges,MeshNumberofedgesEnum);
    2320
    2421        /*Recover pointer: */
    … …  
    3229
    3330                /*Get edges and elements*/
    34                 iomodel->FetchData(2,MeshEdgesEnum,ThicknessEnum);
     31                ProcessMesh2d(&iomodel->edges,&iomodel->numberofedges,NULL,iomodel->elements,iomodel->numberofelements,iomodel->numberofvertices);
     32                iomodel->FetchData(1,ThicknessEnum);
    3533
    3634                /*First load data:*/
    37                 for (i=0;i<numberofedges;i++){
     35                for(int i=0;i<iomodel->numberofedges;i++){
    3836
    3937                        /*Get left and right elements*/
    40                         element=reCast<int>(iomodel->Data(MeshEdgesEnum)[4*i+2])-1; //edges are [node1 node2 elem1 elem2]
     38                        element=iomodel->edges[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
    4139
    4240                        /*Now, if this element is not in the partition, pass: */
    … …  
    4442
    4543                        /* Add load */
    46                         loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,iomodel,PrognosticAnalysisEnum));
     44                        loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,i,iomodel,PrognosticAnalysisEnum));
    4745                }
    4846
    4947                /*Free data: */
    50                 iomodel->DeleteData(2,MeshEdgesEnum,ThicknessEnum);
     48                iomodel->DeleteData(1,ThicknessEnum);
    5149        }
    5250
    … …  
    5755        iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
    5856
    59         for(i=0;i<numvertex_pairing;i++){
     57        for(int i=0;i<numvertex_pairing;i++){
    6058
    6159                if(iomodel->my_vertices[reCast<int>(vertex_pairing[2*i+0])-1]){
Note: See TracChangeset for help on using the changeset viewer.