Changeset 1628


Ignore:
Timestamp:
08/10/09 17:16:00 (16 years ago)
Author:
Eric.Larour
Message:

Added rifts formulation, in diagnostic 2d

Location:
issm/trunk/src/c
Files:
4 added
1 deleted
19 edited

Legend:

Unmodified
Added
Removed

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

    r1579 r1628  
    300300                        rgb->Demarshall(&marshalled_dataset);
    301301                        dataset->AddObject(rgb);
     302                }
     303                else if(enum_type==RiftfrontEnum()){
     304                        Riftfront* riftfront=NULL;
     305                        riftfront=new Riftfront();
     306                        riftfront->Demarshall(&marshalled_dataset);
     307                        dataset->AddObject(riftfront);
    302308                }
    303309                else{
    … …  
    13711377                }
    13721378        }
    1373 
    1374 
    1375 
    1376 }
     1379}
     1380               
     1381
     1382int   DataSet::GetEnum(int offset){
     1383
     1384        return objects[offset]->Enum();
     1385
     1386}

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

    r1188 r1628  
    3636
    3737                int   GetEnum();
     38                int   GetEnum(int offset);
    3839                void  Echo();
    3940                void  DeepEcho();

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

    r1626 r1628  
    7070int NodeEnum(void){                     return          420; }
    7171/*Loads: */
    72 int LoadEnum(void){                     return          430; }
    73 int IcefrontEnum(void){                 return          431; }
    74 int PenpairEnum(void){                  return          432; }
    75 int PengridEnum(void){                  return          433; }
     72int LoadEnum(void){                     return         200; }
     73int IcefrontEnum(void){                 return         201; }
     74int RiftfrontEnum(void){                return         202; }
     75int PenpairEnum(void){                  return         203; }
     76int PengridEnum(void){                  return         204; }
     77
    7678/*Materials: */
    7779int MaterialEnum(void){                 return          440; }

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

    r1312 r1628  
    2020int PengridEnum(void);
    2121int IcefrontEnum(void);
     22int RiftfrontEnum(void);
    2223int ParamEnum(void);
    2324int ElementEnum(void);

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

    r1569 r1628  
    6464                                        ./objects/Icefront.cpp\
    6565                                        ./objects/Icefront.h\
     66                                        ./objects/Riftfront.cpp\
     67                                        ./objects/Riftfront.h\
    6668                                        ./objects/Param.cpp\
    6769                                        ./objects/Param.h\
    … …  
    169171                                        ./io/WriteParams.cpp\
    170172                                        ./io/FetchNodeSets.cpp\
    171                                         ./io/FetchRifts.cpp\
    172173                                        ./io/ParameterInputsInit.cpp\
    173174                                        ./io/pfopen.cpp\
    … …  
    272273                                        ./PenaltyConstraintsx/PenaltyConstraintsx.cpp\
    273274                                        ./PenaltyConstraintsx/PenaltyConstraintsx.h\
     275                                        ./PenaltyConstraintsx/RiftConstraints.cpp\
     276                                        ./PenaltyConstraintsx/RiftConstraints.h\
    274277                                        ./PenaltySystemMatricesx/PenaltySystemMatricesx.cpp\
    275278                                        ./PenaltySystemMatricesx/PenaltySystemMatricesx.h\
    … …  
    350353                                        ./objects/Icefront.cpp\
    351354                                        ./objects/Icefront.h\
     355                                        ./objects/Riftfront.cpp\
     356                                        ./objects/Riftfront.h\
    352357                                        ./objects/Param.cpp\
    353358                                        ./objects/Param.h\
    … …  
    453458                                        ./io/WriteParams.cpp\
    454459                                        ./io/FetchNodeSets.cpp\
    455                                         ./io/FetchRifts.cpp\
    456460                                        ./io/ParameterInputsInit.cpp\
    457461                                        ./io/pfopen.cpp\
    … …  
    550554                                        ./PenaltyConstraintsx/PenaltyConstraintsx.cpp\
    551555                                        ./PenaltyConstraintsx/PenaltyConstraintsx.h\
     556                                        ./PenaltyConstraintsx/RiftConstraints.cpp\
     557                                        ./PenaltyConstraintsx/RiftConstraints.h\
    552558                                        ./PenaltySystemMatricesx/PenaltySystemMatricesx.cpp\
    553559                                        ./PenaltySystemMatricesx/PenaltySystemMatricesx.h\

  • issm/trunk/src/c/ModelProcessorx/DiagnosticHoriz/CreateElementsNodesAndMaterialsDiagnosticHoriz.cpp

    r1321 r1628  
    143143
    144144        /*Rifts:*/
    145         int* riftsnumpenaltypairs;
    146         double** riftspenaltypairs;
    147         int* riftsfill;
    148         double* riftsfriction;
    149         double* riftpenaltypairs=NULL;
    150145        int el1,el2;
    151146         
    … …  
    193188
    194189        /*Deal with rifts, they have to be included into one partition only, not several: */
    195         FetchRifts(&riftsnumpenaltypairs,&riftspenaltypairs,&riftsfill,&riftsfriction,model_handle,model->numrifts);
     190        ModelFetchData((void**)&model->riftinfo,&model->numrifts,NULL,model_handle,"riftinfo","Matrix","Mat");
    196191       
    197192        for(i=0;i<model->numrifts;i++){
    198                 riftpenaltypairs=model->riftspenaltypairs[i];
    199                 for(j=0;j<model->riftsnumpenaltypairs[i];j++){
    200                         el1=(int)*(riftpenaltypairs+7*j+2)-1; //matlab indexing to c indexing
    201                         el2=(int)*(riftpenaltypairs+7*j+3)-1; //matlab indexing to c indexing
    202                         epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding grids;
    203                 }
     193                el1=(int)*(model->riftinfo+9*j+2)-1; //matlab indexing to c indexing
     194                el2=(int)*(model->riftinfo+9*j+3)-1; //matlab indexing to c indexing
     195                epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding grids;
    204196        }
    205197        /*Free rifts: */
    206         xfree((void**)&riftsnumpenaltypairs);
    207         for(i=0;i<model->numrifts;i++){
    208                 double* temp=riftspenaltypairs[i];
    209                 xfree((void**)&temp);
    210         }
    211         xfree((void**)&riftspenaltypairs);
    212         xfree((void**)&riftsfill);
    213         xfree((void**)&riftsfriction);
     198        xfree((void**)&model->riftinfo);
    214199
    215200        /*Used later on: */

  • issm/trunk/src/c/ModelProcessorx/DiagnosticHoriz/CreateLoadsDiagnosticHoriz.cpp

    r786 r1628  
    1616void    CreateLoadsDiagnosticHoriz(DataSet** ploads, Model* model,ConstDataHandle model_handle){
    1717
    18         int i,j,counter;
     18        int i;
    1919        int element;
    2020
    … …  
    2424        DataSet*    loads    = NULL;
    2525        Icefront*   icefront = NULL;
    26         Penpair*    penpair  = NULL;
     26        Riftfront*  riftfront= NULL;
    2727
    2828        int segment_width;
    … …  
    3030        int i1,i2,i3,i4;
    3131        int i0,range;
    32         int grid1,grid2;
    33 
    34         /*rift penpair: */
    35         double  normal[2];
    36         double  length;
    37         double  friction;
    38         int     fill;
     32
    3933               
    4034        /*icefront intermediary data: */
    … …  
    4842        double  icefront_b[MAX_ICEFRONT_GRIDS];
    4943
    50         /*penpair intermediary data: */
    51         int penpair_id;
    52         int penpair_node_ids[2];
    53         double penpair_penalty_offset;
    54         int penpair_numdofs;
    55         int penpair_dof;
    56         int penpair_penalty_lock;
    57         int penpair_element_ids[2];
    58         double penpair_friction;
    59         int penpair_fill;
    60         double penpair_normal[2];
    61         double penpair_length;
    62 
    63         /*Rifts:*/
    64         int* riftsnumpenaltypairs=NULL;
    65         double** riftspenaltypairs=NULL;
    66         int* riftsfill=NULL;
    67         int* riftsfriction=NULL;
    68         double* riftpenaltypairs=NULL;
     44        /*rifts: */
     45        char riftfront_type[RIFTFRONTSTRING];
     46        int  riftfront_id;
     47        int  riftfront_node_ids[2];
     48        int  riftfront_mparid;
     49        double riftfront_h[2];
     50        double riftfront_b[2];
     51        double riftfront_s[2];
     52        double riftfront_normal[2];
     53        double riftfront_length;
     54        int    riftfront_fill;
     55        double riftfront_friction;
     56        bool   riftfront_shelf;
     57        double riftfront_penalty_offset;
     58        int riftfront_penalty_lock;
     59        bool riftfront_active;
     60        int  riftfront_counter;
     61        bool riftfront_prestable;
    6962        int el1,el2;
     63        int grid1,grid2;
     64        double normal[2];
     65        double length;
     66        int    fill;
     67        double friction;
    7068       
    7169        /*Create loads: */
    … …  
    153151        xfree((void**)&model->bed);
    154152
    155         counter=0;
    156 
    157153        /*Create penpair loads also for rift grids, so that they don't penetrate one another, if needed: */
    158154        /*First fetch rifts: */
     155        ModelFetchData((void**)&model->riftinfo,&model->numrifts,NULL,model_handle,"riftinfo","Matrix","Mat");
     156        ModelFetchData((void**)&model->thickness,NULL,NULL,model_handle,"thickness","Matrix","Mat");
     157        ModelFetchData((void**)&model->bed,NULL,NULL,model_handle,"bed","Matrix","Mat");
     158        ModelFetchData((void**)&model->surface,NULL,NULL,model_handle,"surface","Matrix","Mat");
     159        ModelFetchData((void**)&model->gridoniceshelf,NULL,NULL,model_handle,"gridoniceshelf","Matrix","Mat");
     160
    159161        if(model->numrifts){
    160 
    161162                for(i=0;i<model->numrifts;i++){
    162                         riftpenaltypairs=model->riftspenaltypairs[i];
    163                         for(j=0;j<model->riftsnumpenaltypairs[i];j++){
    164 
    165                                 el1=(int)*(riftpenaltypairs+7*j+2);
    166                                 #ifdef _PARALLEL_
    167                                 if (model->epart[el1-1]!=my_rank){
    168                                         /*This load does not belong to this cluster node, as it references an element
    169                                          *that does not belong to this node's partition. Drop this 'j':*/
    170                                         continue;
    171                                 }
    172                                 #endif
    173 
    174                                 /*Ok, retrieve all the data needed to add a penalty between the two grids: */
    175                                 el2=(int)*(riftpenaltypairs+7*j+3);
    176                                 grid1=(int)*(riftpenaltypairs+7*j+0);
    177                                 grid2=(int)*(riftpenaltypairs+7*j+1);
    178                                 normal[0]=*(riftpenaltypairs+7*j+4);
    179                                 normal[1]=*(riftpenaltypairs+7*j+5);
    180                                 length=*(riftpenaltypairs+7*j+6);
    181                                 friction=model->riftsfriction[i];
    182                                 fill=model->riftsfill[i];
    183 
    184                                 penpair_id=counter+1; //matlab indexing
    185                                 penpair_node_ids[0]=grid1;
    186                                 penpair_node_ids[1]=grid2;
    187                                 penpair_element_ids[0]=el1;
    188                                 penpair_element_ids[1]=el2;
    189                                 penpair_penalty_offset=model->penalty_offset;
    190                                 penpair_penalty_lock=model->penalty_lock;
    191                                 penpair_numdofs=2;
    192                                 penpair_normal[0]=normal[0];
    193                                 penpair_normal[1]=normal[1];
    194                                 penpair_length=length;
    195                                 penpair_friction=friction;
    196                                 penpair_fill=fill;
    197 
    198                                 penpair= new Penpair(penpair_id,penpair_penalty_offset,penpair_penalty_lock,penpair_numdofs,penpair_node_ids,penpair_dof,
    199                                                 penpair_element_ids,penpair_friction,penpair_fill,penpair_normal,penpair_length);
    200163                               
    201                                 loads->AddObject(penpair);
    202 
    203                                 counter++;
     164                        el1=(int)*(model->riftinfo+9*i+2);
     165                        #ifdef _PARALLEL_
     166                        if (model->epart[el1-1]!=my_rank){
     167                                /*This load does not belong to this cluster node, as it references an element
     168                                 *that does not belong to this node's partition. Drop this 'j':*/
     169                                continue;
    204170                        }
     171                        #endif
     172
     173                        /*Ok, retrieve all the data needed to add a penalty between the two grids: */
     174                        el2=(int)*(model->riftinfo+9*i+3);
     175
     176                        grid1=(int)*(model->riftinfo+9*i+0);
     177                        grid2=(int)*(model->riftinfo+9*i+1);
     178                       
     179                        normal[0]=*(model->riftinfo+9*i+4);
     180                        normal[1]=*(model->riftinfo+9*i+5);
     181                        length=*(model->riftinfo+9*i+6);
     182                       
     183                        fill = (int)*(model->riftinfo+9*i+7);
     184                        friction=*(model->riftinfo+9*i+8);
     185       
     186                        strcpy(riftfront_type,"2d");
     187                        riftfront_id=i+1; //matlab indexing
     188                        riftfront_node_ids[0]=grid1;
     189                        riftfront_node_ids[1]=grid2;
     190                        riftfront_mparid=model->numberofelements+1; //matlab indexing
     191
     192                        riftfront_h[0]=model->thickness[grid1-1];
     193                        riftfront_h[1]=model->thickness[grid2-1];
     194
     195                        riftfront_b[0]=model->bed[grid1-1];
     196                        riftfront_b[1]=model->bed[grid2-1];
     197
     198                        riftfront_s[0]=model->surface[grid1-1];
     199                        riftfront_s[1]=model->surface[grid2-1];
     200
     201                        riftfront_normal[0]=normal[0];
     202                        riftfront_normal[1]=normal[1];
     203                        riftfront_length=length;
     204                       
     205                        riftfront_fill=fill;
     206                        riftfront_friction=friction;
     207                        riftfront_shelf=(bool)model->gridoniceshelf[grid1-1];
     208
     209                        riftfront_penalty_offset=model->penalty_offset;
     210                        riftfront_penalty_lock=model->penalty_lock;
     211
     212                        riftfront_active=0;
     213                        riftfront_counter=0;
     214                        riftfront_prestable=0;
     215                       
     216                        riftfront=new Riftfront(riftfront_type,riftfront_id, riftfront_node_ids, riftfront_mparid, riftfront_h,riftfront_b,riftfront_s,riftfront_normal,riftfront_length,riftfront_fill,riftfront_friction, riftfront_penalty_offset, riftfront_penalty_lock, riftfront_active,riftfront_counter,riftfront_prestable,riftfront_shelf);
     217
     218                        loads->AddObject(riftfront);
    205219                }
    206220        }
     221
     222        /*free ressources: */
     223        xfree((void**)&model->riftinfo);
     224        xfree((void**)&model->thickness);
     225        xfree((void**)&model->bed);
     226        xfree((void**)&model->surface);
     227        xfree((void**)&model->gridoniceshelf);
     228
     229        cleanup_and_return:
    207230
    208231        /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    … …  
    210233        loads->Presort();
    211234
    212 
    213         /*Free ressources:*/
    214         xfree((void**)&riftsnumpenaltypairs);
    215         for(i=0;i<model->numrifts;i++){
    216                 double* temp=riftspenaltypairs[i];
    217                 xfree((void**)&temp);
    218         }
    219         xfree((void**)&riftspenaltypairs);
    220         xfree((void**)&riftsfill);
    221         xfree((void**)&riftsfriction);
    222        
    223         cleanup_and_return:
    224 
    225235        /*Assign output pointer: */
    226236        *ploads=loads;

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

    r1321 r1628  
    121121        int  first_grid_index;
    122122
    123         /*Rifts:*/
    124         int* riftsnumpenaltypairs;
    125         double** riftspenaltypairs;
    126         int* riftsfill;
    127         double* riftsfriction;
    128         double* riftpenaltypairs=NULL;
    129         int el1,el2;
    130          
    131123        /*First create the elements, nodes and material properties: */
    132124        elements  = new DataSet(ElementsEnum());
    … …  
    167159        xfree((void**)&model->elements);
    168160        xfree((void**)&model->elements2d);
    169 
    170 
    171         /*Deal with rifts, they have to be included into one partition only, not several: */
    172         FetchRifts(&riftsnumpenaltypairs,&riftspenaltypairs,&riftsfill,&riftsfriction,model_handle,model->numrifts);
    173        
    174         for(i=0;i<model->numrifts;i++){
    175                 riftpenaltypairs=model->riftspenaltypairs[i];
    176                 for(j=0;j<model->riftsnumpenaltypairs[i];j++){
    177                         el1=(int)*(riftpenaltypairs+7*j+2)-1; //matlab indexing to c indexing
    178                         el2=(int)*(riftpenaltypairs+7*j+3)-1; //matlab indexing to c indexing
    179                         epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding grids;
    180                 }
    181         }
    182         /*Free rifts: */
    183         xfree((void**)&riftsnumpenaltypairs);
    184         for(i=0;i<model->numrifts;i++){
    185                 double* temp=riftspenaltypairs[i];
    186                 xfree((void**)&temp);
    187         }
    188         xfree((void**)&riftspenaltypairs);
    189         xfree((void**)&riftsfill);
    190         xfree((void**)&riftsfriction);
    191161
    192162        /*Used later on: */

  • issm/trunk/src/c/ModelProcessorx/DiagnosticVert/CreateElementsNodesAndMaterialsDiagnosticVert.cpp

    r1310 r1628  
    120120        int  first_grid_index;
    121121
    122         /*Rifts:*/
    123         int* riftsnumpenaltypairs;
    124         double** riftspenaltypairs;
    125         int* riftsfill;
    126         double* riftsfriction;
    127         double* riftpenaltypairs=NULL;
    128         int el1,el2;
    129          
    130122        /*Penalty partitioning: */
    131123        int num_grids3d_collapsed;
    … …  
    167159        xfree((void**)&model->elements2d);
    168160               
    169 
    170         /*Deal with rifts, they have to be included into one partition only, not several: */
    171         FetchRifts(&riftsnumpenaltypairs,&riftspenaltypairs,&riftsfill,&riftsfriction,model_handle,model->numrifts);
    172        
    173         for(i=0;i<model->numrifts;i++){
    174                 riftpenaltypairs=model->riftspenaltypairs[i];
    175                 for(j=0;j<model->riftsnumpenaltypairs[i];j++){
    176                         el1=(int)*(riftpenaltypairs+7*j+2)-1; //matlab indexing to c indexing
    177                         el2=(int)*(riftpenaltypairs+7*j+3)-1; //matlab indexing to c indexing
    178                         epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding grids;
    179                 }
    180         }
    181         /*Free rifts: */
    182         xfree((void**)&riftsnumpenaltypairs);
    183         for(i=0;i<model->numrifts;i++){
    184                 double* temp=riftspenaltypairs[i];
    185                 xfree((void**)&temp);
    186         }
    187         xfree((void**)&riftspenaltypairs);
    188         xfree((void**)&riftsfill);
    189         xfree((void**)&riftsfriction);
    190 
    191161        /*Used later on: */
    192162        my_grids=(int*)xcalloc(model->numberofnodes,sizeof(int));

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

    r1321 r1628  
    120120        int  first_grid_index;
    121121
    122         /*Rifts:*/
    123         int* riftsnumpenaltypairs;
    124         double** riftspenaltypairs;
    125         int* riftsfill;
    126         double* riftsfriction;
    127         double* riftpenaltypairs=NULL;
    128         int el1,el2;
    129          
    130122        /*First create the elements, nodes and material properties: */
    131123        elements  = new DataSet(ElementsEnum());
    … …  
    151143        /*Free elements and elements2d: */
    152144        xfree((void**)&model->elements2d);
    153 
    154 
    155         /*Deal with rifts, they have to be included into one partition only, not several: */
    156         FetchRifts(&riftsnumpenaltypairs,&riftspenaltypairs,&riftsfill,&riftsfriction,model_handle,model->numrifts);
    157        
    158         for(i=0;i<model->numrifts;i++){
    159                 riftpenaltypairs=model->riftspenaltypairs[i];
    160                 for(j=0;j<model->riftsnumpenaltypairs[i];j++){
    161                         el1=(int)*(riftpenaltypairs+7*j+2)-1; //matlab indexing to c indexing
    162                         el2=(int)*(riftpenaltypairs+7*j+3)-1; //matlab indexing to c indexing
    163                         epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding grids;
    164                 }
    165         }
    166         /*Free rifts: */
    167         xfree((void**)&riftsnumpenaltypairs);
    168         for(i=0;i<model->numrifts;i++){
    169                 double* temp=riftspenaltypairs[i];
    170                 xfree((void**)&temp);
    171         }
    172         xfree((void**)&riftspenaltypairs);
    173         xfree((void**)&riftsfill);
    174         xfree((void**)&riftsfriction);
    175145
    176146        /*Used later on: */

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

    r1104 r1628  
    156156       
    157157        model->numrifts=0;
    158         model->riftsnumpenaltypairs=NULL;
    159         model->riftspenaltypairs=NULL;
    160         model->riftsfill=NULL;
    161         model->riftsfriction=NULL;
     158        model->riftinfo=NULL;
    162159
    163160        /*!penalties: */
    … …  
    271268        xfree((void**)&model->sub_analysis_type);
    272269       
    273         if(model->numrifts){
    274                 for(i=0;i<model->numrifts;i++){
    275                         double* riftpenaltypairs=model->riftspenaltypairs[i];
    276                         xfree((void**)&riftpenaltypairs);
    277                 }
    278                 xfree((void**)&model->riftspenaltypairs);
    279                 xfree((void**)&model->riftsnumpenaltypairs);
    280                 xfree((void**)&model->riftsfill);
    281                 xfree((void**)&model->riftsfriction);
    282         }
     270        xfree((void**)&model->riftinfo);
    283271       
    284272        xfree((void**)&model->penalties);
    … …  
    387375        ModelFetchData((void**)&model->thermal_exchange_velocity,NULL,NULL,model_handle,"thermal_exchange_velocity","Scalar",NULL);
    388376
    389         /*rifts: */
    390         ModelFetchData((void**)&model->numrifts,NULL,NULL,model_handle,"numrifts","Integer",NULL);
    391 
    392377        /*qmu: */
    393378        if(model->qmu_analysis){
    … …  
    426411        }
    427412       
    428         if(which_part==2 && my_rank==rank){
    429                 printf("Model rifts: \n");
    430                 printf("   number of rifts: %i\n",model->numrifts);
    431                 for(i=0;i<model->numrifts;i++){
    432                         double* penaltypairs=model->riftspenaltypairs[i];
    433                         printf("   rift #%i\n",i);
    434                         for (j=0;j<model->riftsnumpenaltypairs[i];j++){
    435                                 printf("      grids %g %g  elements %g %g normal [%g,%g] length %g\n",*(penaltypairs+7*j+0),*(penaltypairs+7*j+1),*(penaltypairs+7*j+2),*(penaltypairs+7*j+3),
    436                                                 *(penaltypairs+7*j+4),*(penaltypairs+7*j+5),*(penaltypairs+7*j+6));
    437                         }
    438                         printf("                  friction %g fill %i\n",model->riftsfriction[i],model->riftsfill[i]);
    439                 }
    440         }
    441         cleanup_and_return:
    442413        return;
    443414}

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

    r1104 r1628  
    152152        /*rifts: */
    153153        int      numrifts;
    154         int*     riftsnumpenaltypairs;
    155         double** riftspenaltypairs;
    156         int*     riftsfill;
    157         double*  riftsfriction;
     154        double*  riftinfo;
    158155
    159156        /*penalties: */

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

    r1310 r1628  
    143143        int  first_grid_index;
    144144
    145         /*Rifts:*/
    146         int* riftsnumpenaltypairs;
    147         double** riftspenaltypairs;
    148         int* riftsfill;
    149         double* riftsfriction;
    150         double* riftpenaltypairs=NULL;
    151         int el1,el2;
    152          
    153145        /*First create the elements, nodes and material properties: */
    154146        elements  = new DataSet(ElementsEnum());
    … …  
    187179        xfree((void**)&model->elements);
    188180        xfree((void**)&model->elements2d);
    189 
    190 
    191         /*Deal with rifts, they have to be included into one partition only, not several: */
    192         FetchRifts(&riftsnumpenaltypairs,&riftspenaltypairs,&riftsfill,&riftsfriction,model_handle,model->numrifts);
    193        
    194         for(i=0;i<model->numrifts;i++){
    195                 riftpenaltypairs=model->riftspenaltypairs[i];
    196                 for(j=0;j<model->riftsnumpenaltypairs[i];j++){
    197                         el1=(int)*(riftpenaltypairs+7*j+2)-1; //matlab indexing to c indexing
    198                         el2=(int)*(riftpenaltypairs+7*j+3)-1; //matlab indexing to c indexing
    199                         epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding grids;
    200                 }
    201         }
    202         /*Free rifts: */
    203         xfree((void**)&riftsnumpenaltypairs);
    204         for(i=0;i<model->numrifts;i++){
    205                 double* temp=riftspenaltypairs[i];
    206                 xfree((void**)&temp);
    207         }
    208         xfree((void**)&riftspenaltypairs);
    209         xfree((void**)&riftsfill);
    210         xfree((void**)&riftsfriction);
    211181
    212182        /*Used later on: */

  • issm/trunk/src/c/ModelProcessorx/SlopeCompute/CreateElementsNodesAndMaterialsSlopeCompute.cpp

    r1321 r1628  
    121121        int  first_grid_index;
    122122
    123         /*Rifts:*/
    124         int* riftsnumpenaltypairs;
    125         double** riftspenaltypairs;
    126         int* riftsfill;
    127         double* riftsfriction;
    128         double* riftpenaltypairs=NULL;
    129         int el1,el2;
    130 
    131123        /*First create the elements, nodes and material properties: */
    132124        elements  = new DataSet(ElementsEnum());
    … …  
    167159        xfree((void**)&model->elements2d);
    168160
    169 
    170         /*Deal with rifts, they have to be included into one partition only, not several: */
    171         FetchRifts(&riftsnumpenaltypairs,&riftspenaltypairs,&riftsfill,&riftsfriction,model_handle,model->numrifts);
    172        
    173         for(i=0;i<model->numrifts;i++){
    174                 riftpenaltypairs=model->riftspenaltypairs[i];
    175                 for(j=0;j<model->riftsnumpenaltypairs[i];j++){
    176                         el1=(int)*(riftpenaltypairs+7*j+2)-1; //matlab indexing to c indexing
    177                         el2=(int)*(riftpenaltypairs+7*j+3)-1; //matlab indexing to c indexing
    178                         epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding grids;
    179                 }
    180         }
    181         /*Free rifts: */
    182         xfree((void**)&riftsnumpenaltypairs);
    183         for(i=0;i<model->numrifts;i++){
    184                 double* temp=riftspenaltypairs[i];
    185                 xfree((void**)&temp);
    186         }
    187         xfree((void**)&riftspenaltypairs);
    188         xfree((void**)&riftsfill);
    189         xfree((void**)&riftsfriction);
    190161
    191162        /*Used later on: */

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

    r1310 r1628  
    121121        int  first_grid_index;
    122122
    123         /*Rifts:*/
    124         int* riftsnumpenaltypairs;
    125         double** riftspenaltypairs;
    126         int* riftsfill;
    127         double* riftsfriction;
    128         double* riftpenaltypairs=NULL;
    129         int el1,el2;
    130          
    131123        /*First create the elements, nodes and material properties: */
    132124        elements  = new DataSet(ElementsEnum());
    … …  
    154146        /*Free elements and elements2d: */
    155147        xfree((void**)&model->elements2d);
    156 
    157         /*Deal with rifts, they have to be included into one partition only, not several: */
    158         FetchRifts(&riftsnumpenaltypairs,&riftspenaltypairs,&riftsfill,&riftsfriction,model_handle,model->numrifts);
    159        
    160         for(i=0;i<model->numrifts;i++){
    161                 riftpenaltypairs=model->riftspenaltypairs[i];
    162                 for(j=0;j<model->riftsnumpenaltypairs[i];j++){
    163                         el1=(int)*(riftpenaltypairs+7*j+2)-1; //matlab indexing to c indexing
    164                         el2=(int)*(riftpenaltypairs+7*j+3)-1; //matlab indexing to c indexing
    165                         epart[el2]=epart[el1]; //ensures that this pair of elements will be in the same partition, as well as the corresponding grids;
    166                 }
    167         }
    168         /*Free rifts: */
    169         xfree((void**)&riftsnumpenaltypairs);
    170         for(i=0;i<model->numrifts;i++){
    171                 double* temp=riftspenaltypairs[i];
    172                 xfree((void**)&temp);
    173         }
    174         xfree((void**)&riftspenaltypairs);
    175         xfree((void**)&riftsfill);
    176         xfree((void**)&riftsfriction);
    177148
    178149        /*Used later on: */

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

    r465 r1628  
    44
    55#include "./PenaltyConstraintsx.h"
     6#include "./RiftConstraints.h"
    67
    78#undef __FUNCT__
    … …  
    3031        /*Do we have penalties linked to rifts? In this case, run our special rifts penalty
    3132         * management routine, otherwise, skip : */
    32         if (loads->RiftIsPresent()){
    33                 loads->RiftConstraints(&num_unstable_constraints,inputs,analysis_type,sub_analysis_type);
     33        if (RiftIsPresent(loads)){
     34                RiftConstraints(&num_unstable_constraints,loads,inputs,analysis_type,sub_analysis_type);
    3435        }
    3536        else if(loads->MeltingIsPresent()){

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

    r472 r1628  
    4343#endif
    4444
    45 int FetchRifts(int** priftsnumpenaltypairs,double*** priftspenaltypairs,int** priftsfill,double** priftsfriction,ConstDataHandle model_handle,int numrifts);
    46 
    4745/*File I/O: */
    4846FILE* pfopen(char* filename,char* format);

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

    r1439 r1628  
    771771
    772772        int i;
    773         int doflist0[MAXDOFSPERNODE];
    774         int doflist1[MAXDOFSPERNODE];
    775         int doflist2[MAXDOFSPERNODE];
    776         int doflist3[MAXDOFSPERNODE];
    777773        int numberofdofspernode;
    778774

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

    r643 r1628  
    2222#include "./Rgb.h"
    2323#include "./Icefront.h"
     24#include "./Riftfront.h"
    2425#include "./Penpair.h"
    2526#include "./Pengrid.h"
Note: See TracChangeset for help on using the changeset viewer.