Changeset 1833


Ignore:
Timestamp:
08/24/09 17:53:37 (16 years ago)
Author:
Eric.Larour
Message:

Brachning back from issm.controlstatic, by hand

Location:
issm/trunk/src/c/ModelProcessorx/SlopeCompute
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • issm/trunk/src/c/ModelProcessorx/SlopeCompute/CreateConstraintsSlopeCompute.cpp

    r358 r1833  
    1111#include "../../objects/objects.h"
    1212#include "../../shared/shared.h"
    13 #include "../Model.h"
     13#include "../IoModel.h"
    1414
    1515
    16 void    CreateConstraintsSlopeCompute(DataSet** pconstraints, Model* model,ConstDataHandle model_handle){
     16void    CreateConstraintsSlopeCompute(DataSet** pconstraints, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1717
    1818
     
    2323
    2424        /*Now, is the flag isstokes on? otherwise, do nothing: */
    25         if (!model->isstokes)goto cleanup_and_return;
     25        if (!iomodel->isstokes)goto cleanup_and_return;
    2626       
    2727        cleanup_and_return:     
  • issm/trunk/src/c/ModelProcessorx/SlopeCompute/CreateElementsNodesAndMaterialsSlopeCompute.cpp

    r1648 r1833  
    1212#include "../../shared/shared.h"
    1313#include "../../MeshPartitionx/MeshPartitionx.h"
    14 #include "../Model.h"
    15 
    16 
    17 void    CreateElementsNodesAndMaterialsSlopeCompute(DataSet** pelements,DataSet** pnodes, DataSet** pmaterials, Model* model,ConstDataHandle model_handle){
     14#include "../IoModel.h"
     15
     16
     17void    CreateElementsNodesAndMaterialsSlopeCompute(DataSet** pelements,DataSet** pnodes, DataSet** pmaterials, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1818
    1919
     
    124124
    125125        /*Now, is the flag isstokes on? otherwise, do nothing: */
    126         if (!model->isstokes & !model->ishutter)goto cleanup_and_return;
     126        if (!iomodel->isstokes & !iomodel->ishutter)goto cleanup_and_return;
    127127
    128128        /*Width of elements: */
    129         if(strcmp(model->meshtype,"2d")==0){
     129        if(strcmp(iomodel->meshtype,"2d")==0){
    130130                elements_width=3; //tria elements
    131131        }
     
    136136        #ifdef _PARALLEL_
    137137        /*Determine parallel partitioning of elements: we use Metis for now. First load the data, then partition*/
    138         if(strcmp(model->meshtype,"2d")==0){
     138        if(strcmp(iomodel->meshtype,"2d")==0){
    139139                /*load elements: */
    140                 ModelFetchData((void**)&model->elements,NULL,NULL,model_handle,"elements","Matrix","Mat");
     140                IoModelFetchData((void**)&iomodel->elements,NULL,NULL,iomodel_handle,"elements","Matrix","Mat");
    141141        }
    142142        else{
    143143                /*load elements2d: */
    144                 ModelFetchData((void**)&model->elements2d,NULL,NULL,model_handle,"elements2d","Matrix","Mat");
    145         }
    146 
    147 
    148         MeshPartitionx(&epart, &npart,model->numberofelements,model->numberofnodes,model->elements, model->numberofelements2d,model->numberofnodes2d,model->elements2d,model->numlayers,elements_width, model->meshtype,num_procs);
     144                IoModelFetchData((void**)&iomodel->elements2d,NULL,NULL,iomodel_handle,"elements2d","Matrix","Mat");
     145        }
     146
     147
     148        MeshPartitionx(&epart, &npart,iomodel->numberofelements,iomodel->numberofnodes,iomodel->elements, iomodel->numberofelements2d,iomodel->numberofnodes2d,iomodel->elements2d,iomodel->numlayers,elements_width, iomodel->meshtype,num_procs);
    149149
    150150        /*Free elements and elements2d: */
    151         xfree((void**)&model->elements);
    152         xfree((void**)&model->elements2d);
     151        xfree((void**)&iomodel->elements);
     152        xfree((void**)&iomodel->elements2d);
    153153
    154154
    155155        /*Used later on: */
    156         my_grids=(int*)xcalloc(model->numberofnodes,sizeof(int));
     156        my_grids=(int*)xcalloc(iomodel->numberofnodes,sizeof(int));
    157157        #endif
    158158
     
    162162
    163163        /*2d mesh: */
    164         if (strcmp(model->meshtype,"2d")==0){
     164        if (strcmp(iomodel->meshtype,"2d")==0){
    165165
    166166                /*Fetch data needed: */
    167                 ModelFetchData((void**)&model->elements,NULL,NULL,model_handle,"elements","Matrix","Mat");
    168                 ModelFetchData((void**)&model->surface,NULL,NULL,model_handle,"surface","Matrix","Mat");
    169                 ModelFetchData((void**)&model->elementonwater,NULL,NULL,model_handle,"elementonwater","Matrix","Mat");
    170                 ModelFetchData((void**)&model->bed,NULL,NULL,model_handle,"bed","Matrix","Mat");
    171                
    172                 for (i=0;i<model->numberofelements;i++){
     167                IoModelFetchData((void**)&iomodel->elements,NULL,NULL,iomodel_handle,"elements","Matrix","Mat");
     168                IoModelFetchData((void**)&iomodel->surface,NULL,NULL,iomodel_handle,"surface","Matrix","Mat");
     169                IoModelFetchData((void**)&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater","Matrix","Mat");
     170                IoModelFetchData((void**)&iomodel->bed,NULL,NULL,iomodel_handle,"bed","Matrix","Mat");
     171               
     172                for (i=0;i<iomodel->numberofelements;i++){
    173173
    174174                #ifdef _PARALLEL_
     
    184184
    185185                        /*vertices offsets: */
    186                         tria_g[0]=(int)*(model->elements+elements_width*i+0);
    187                         tria_g[1]=(int)*(model->elements+elements_width*i+1);
    188                         tria_g[2]=(int)*(model->elements+elements_width*i+2);
     186                        tria_g[0]=(int)*(iomodel->elements+elements_width*i+0);
     187                        tria_g[1]=(int)*(iomodel->elements+elements_width*i+1);
     188                        tria_g[2]=(int)*(iomodel->elements+elements_width*i+2);
    189189
    190190                        /*surface and bed:*/
    191                         tria_s[0]=*(model->surface+    ((int)*(model->elements+elements_width*i+0)-1));
    192                         tria_s[1]=*(model->surface+    ((int)*(model->elements+elements_width*i+1)-1));
    193                         tria_s[2]=*(model->surface+    ((int)*(model->elements+elements_width*i+2)-1));
    194 
    195                         tria_b[0]=*(model->bed+        ((int)*(model->elements+elements_width*i+0)-1));
    196                         tria_b[1]=*(model->bed+        ((int)*(model->elements+elements_width*i+1)-1));
    197                         tria_b[2]=*(model->bed+        ((int)*(model->elements+elements_width*i+2)-1));
     191                        tria_s[0]=*(iomodel->surface+    ((int)*(iomodel->elements+elements_width*i+0)-1));
     192                        tria_s[1]=*(iomodel->surface+    ((int)*(iomodel->elements+elements_width*i+1)-1));
     193                        tria_s[2]=*(iomodel->surface+    ((int)*(iomodel->elements+elements_width*i+2)-1));
     194
     195                        tria_b[0]=*(iomodel->bed+        ((int)*(iomodel->elements+elements_width*i+0)-1));
     196                        tria_b[1]=*(iomodel->bed+        ((int)*(iomodel->elements+elements_width*i+1)-1));
     197                        tria_b[2]=*(iomodel->bed+        ((int)*(iomodel->elements+elements_width*i+2)-1));
    198198                       
    199199                        /*element on water? : */
    200                         tria_onwater=(bool)*(model->elementonwater+i);
     200                        tria_onwater=(bool)*(iomodel->elementonwater+i);
    201201
    202202                        /*Create tria element using its constructor:*/
     
    211211                         into the grid coordinates. If we start plugging 1 into my_grids for each index[n][i] (i=0:2), then my_grids
    212212                         will hold which grids belong to this partition*/
    213                         my_grids[(int)*(model->elements+elements_width*i+0)-1]=1;
    214                         my_grids[(int)*(model->elements+elements_width*i+1)-1]=1;
    215                         my_grids[(int)*(model->elements+elements_width*i+2)-1]=1;
     213                        my_grids[(int)*(iomodel->elements+elements_width*i+0)-1]=1;
     214                        my_grids[(int)*(iomodel->elements+elements_width*i+1)-1]=1;
     215                        my_grids[(int)*(iomodel->elements+elements_width*i+2)-1]=1;
    216216                        #endif
    217217
     
    224224       
    225225                /*Free data : */
    226                 xfree((void**)&model->elements);
    227                 xfree((void**)&model->surface);
    228                 xfree((void**)&model->bed);
    229                 xfree((void**)&model->elementonwater);
     226                xfree((void**)&iomodel->elements);
     227                xfree((void**)&iomodel->surface);
     228                xfree((void**)&iomodel->bed);
     229                xfree((void**)&iomodel->elementonwater);
    230230
    231231        }
     
    233233
    234234                /*Fetch data needed: */
    235                 ModelFetchData((void**)&model->elements,NULL,NULL,model_handle,"elements","Matrix","Mat");
    236                 ModelFetchData((void**)&model->surface,NULL,NULL,model_handle,"surface","Matrix","Mat");
    237                 ModelFetchData((void**)&model->bed,NULL,NULL,model_handle,"bed","Matrix","Mat");
    238                 ModelFetchData((void**)&model->elementonbed,NULL,NULL,model_handle,"elementonbed","Matrix","Mat");
    239                 ModelFetchData((void**)&model->elementonwater,NULL,NULL,model_handle,"elementonwater","Matrix","Mat");
    240        
    241                 for (i=0;i<model->numberofelements;i++){
     235                IoModelFetchData((void**)&iomodel->elements,NULL,NULL,iomodel_handle,"elements","Matrix","Mat");
     236                IoModelFetchData((void**)&iomodel->surface,NULL,NULL,iomodel_handle,"surface","Matrix","Mat");
     237                IoModelFetchData((void**)&iomodel->bed,NULL,NULL,iomodel_handle,"bed","Matrix","Mat");
     238                IoModelFetchData((void**)&iomodel->elementonbed,NULL,NULL,iomodel_handle,"elementonbed","Matrix","Mat");
     239                IoModelFetchData((void**)&iomodel->elementonwater,NULL,NULL,iomodel_handle,"elementonwater","Matrix","Mat");
     240       
     241                for (i=0;i<iomodel->numberofelements;i++){
    242242                #ifdef _PARALLEL_
    243243                /*We are using our element partition to decide which elements will be created on this node: */
     
    254254                        /*vertices,thickness,surface,bed and drag: */
    255255                        for(j=0;j<6;j++){
    256                                 penta_g[j]=(int)*(model->elements+elements_width*i+j);
    257                                 penta_s[j]=*(model->surface+    ((int)*(model->elements+elements_width*i+j)-1));
    258                                 penta_b[j]=*(model->bed+    ((int)*(model->elements+elements_width*i+j)-1));
     256                                penta_g[j]=(int)*(iomodel->elements+elements_width*i+j);
     257                                penta_s[j]=*(iomodel->surface+    ((int)*(iomodel->elements+elements_width*i+j)-1));
     258                                penta_b[j]=*(iomodel->bed+    ((int)*(iomodel->elements+elements_width*i+j)-1));
    259259                        }
    260260                       
    261261                        /*diverse: */
    262                         penta_onbed=(int)*(model->elementonbed+i);
    263                         penta_onwater=(bool)*(model->elementonwater+i);
     262                        penta_onbed=(int)*(iomodel->elementonbed+i);
     263                        penta_onwater=(bool)*(iomodel->elementonwater+i);
    264264
    265265                        /*Create Penta using its constructor:*/
     
    278278                         into the grid coordinates. If we start plugging 1 into my_grids for each index[n][i] (i=0:2), then my_grids
    279279                         will hold which grids belong to this partition*/
    280                         my_grids[(int)*(model->elements+elements_width*i+0)-1]=1;
    281                         my_grids[(int)*(model->elements+elements_width*i+1)-1]=1;
    282                         my_grids[(int)*(model->elements+elements_width*i+2)-1]=1;
    283                         my_grids[(int)*(model->elements+elements_width*i+3)-1]=1;
    284                         my_grids[(int)*(model->elements+elements_width*i+4)-1]=1;
    285                         my_grids[(int)*(model->elements+elements_width*i+5)-1]=1;
     280                        my_grids[(int)*(iomodel->elements+elements_width*i+0)-1]=1;
     281                        my_grids[(int)*(iomodel->elements+elements_width*i+1)-1]=1;
     282                        my_grids[(int)*(iomodel->elements+elements_width*i+2)-1]=1;
     283                        my_grids[(int)*(iomodel->elements+elements_width*i+3)-1]=1;
     284                        my_grids[(int)*(iomodel->elements+elements_width*i+4)-1]=1;
     285                        my_grids[(int)*(iomodel->elements+elements_width*i+5)-1]=1;
    286286                        #endif
    287287
     
    293293
    294294                /*Free data: */
    295                 xfree((void**)&model->elements);
    296                 xfree((void**)&model->surface);
    297                 xfree((void**)&model->bed);
    298                 xfree((void**)&model->elementonbed);
    299                 xfree((void**)&model->elementonwater);
     295                xfree((void**)&iomodel->elements);
     296                xfree((void**)&iomodel->surface);
     297                xfree((void**)&iomodel->bed);
     298                xfree((void**)&iomodel->elementonbed);
     299                xfree((void**)&iomodel->elementonwater);
    300300
    301301        } //if (strcmp(meshtype,"2d")==0)
     
    304304                /*From the element partitioning, we can determine which grids are on the inside of this cpu's
    305305                 *element partition, and which are on its border with other nodes:*/
    306                 gridborder=NewVec(model->numberofnodes);
    307 
    308                 for (i=0;i<model->numberofnodes;i++){
     306                gridborder=NewVec(iomodel->numberofnodes);
     307
     308                for (i=0;i<iomodel->numberofnodes;i++){
    309309                        if(my_grids[i])VecSetValue(gridborder,i,1,ADD_VALUES);
    310310                }
     
    320320                #ifdef _DEBUG_
    321321                if(my_rank==0){
    322                         for (i=0;i<model->numberofnodes;i++){
     322                        for (i=0;i<iomodel->numberofnodes;i++){
    323323                                printf("Grid id %i Border grid %lf\n",i+1,my_bordergrids[i]);
    324324                        }
     
    328328
    329329        /*Partition penalties in 3d: */
    330         if(strcmp(model->meshtype,"3d")==0){
     330        if(strcmp(iomodel->meshtype,"3d")==0){
    331331       
    332332                /*Get penalties: */
    333                 ModelFetchData((void**)&model->penalties,&model->numpenalties,NULL,model_handle,"penalties","Matrix","Mat");
    334 
    335                 if(model->numpenalties){
    336 
    337                         model->penaltypartitioning=(int*)xmalloc(model->numpenalties*sizeof(int));
     333                IoModelFetchData((void**)&iomodel->penalties,&iomodel->numpenalties,NULL,iomodel_handle,"penalties","Matrix","Mat");
     334
     335                if(iomodel->numpenalties){
     336
     337                        iomodel->penaltypartitioning=(int*)xmalloc(iomodel->numpenalties*sizeof(int));
    338338                        #ifdef _SERIAL_
    339                         for(i=0;i<model->numpenalties;i++)model->penaltypartitioning[i]=1;
     339                        for(i=0;i<iomodel->numpenalties;i++)iomodel->penaltypartitioning[i]=1;
    340340                        #else
    341                         for(i=0;i<model->numpenalties;i++)model->penaltypartitioning[i]=-1;
    342 
    343                         for(i=0;i<model->numpenalties;i++){
    344                                 first_grid_index=(int)(*(model->penalties+i*model->numlayers+0)-1);
     341                        for(i=0;i<iomodel->numpenalties;i++)iomodel->penaltypartitioning[i]=-1;
     342
     343                        for(i=0;i<iomodel->numpenalties;i++){
     344                                first_grid_index=(int)(*(iomodel->penalties+i*iomodel->numlayers+0)-1);
    345345                                if((my_grids[first_grid_index]==1) && (my_bordergrids[first_grid_index]<=1.0) ) { //this grid belongs to this node's internal partition  grids
    346346                                        /*All grids that are being penalised belong to this node's internal grid partition.:*/
    347                                         model->penaltypartitioning[i]=1;
     347                                        iomodel->penaltypartitioning[i]=1;
    348348                                }
    349349                                if(my_bordergrids[first_grid_index]>1.0) { //this grid belongs to a partition border
    350                                         model->penaltypartitioning[i]=0;
     350                                        iomodel->penaltypartitioning[i]=0;
    351351                                }
    352352                        }
     
    355355
    356356                /*Free penalties: */
    357                 xfree((void**)&model->penalties);
     357                xfree((void**)&iomodel->penalties);
    358358        }
    359359
     
    366366               
    367367        /*First fetch data: */
    368         if (strcmp(model->meshtype,"3d")==0){
    369                 ModelFetchData((void**)&model->deadgrids,NULL,NULL,model_handle,"deadgrids","Matrix","Mat");
    370                 ModelFetchData((void**)&model->uppernodes,NULL,NULL,model_handle,"uppergrids","Matrix","Mat");
    371         }
    372         ModelFetchData((void**)&model->x,NULL,NULL,model_handle,"x","Matrix","Mat");
    373         ModelFetchData((void**)&model->y,NULL,NULL,model_handle,"y","Matrix","Mat");
    374         ModelFetchData((void**)&model->z,NULL,NULL,model_handle,"z","Matrix","Mat");
    375         ModelFetchData((void**)&model->thickness,NULL,NULL,model_handle,"thickness","Matrix","Mat");
    376         ModelFetchData((void**)&model->bed,NULL,NULL,model_handle,"bed","Matrix","Mat");
    377         ModelFetchData((void**)&model->gridonbed,NULL,NULL,model_handle,"gridonbed","Matrix","Mat");
    378         ModelFetchData((void**)&model->gridonsurface,NULL,NULL,model_handle,"gridonsurface","Matrix","Mat");
    379         ModelFetchData((void**)&model->gridonicesheet,NULL,NULL,model_handle,"gridonicesheet","Matrix","Mat");
    380         ModelFetchData((void**)&model->gridoniceshelf,NULL,NULL,model_handle,"gridoniceshelf","Matrix","Mat");
     368        if (strcmp(iomodel->meshtype,"3d")==0){
     369                IoModelFetchData((void**)&iomodel->deadgrids,NULL,NULL,iomodel_handle,"deadgrids","Matrix","Mat");
     370                IoModelFetchData((void**)&iomodel->uppernodes,NULL,NULL,iomodel_handle,"uppergrids","Matrix","Mat");
     371        }
     372        IoModelFetchData((void**)&iomodel->x,NULL,NULL,iomodel_handle,"x","Matrix","Mat");
     373        IoModelFetchData((void**)&iomodel->y,NULL,NULL,iomodel_handle,"y","Matrix","Mat");
     374        IoModelFetchData((void**)&iomodel->z,NULL,NULL,iomodel_handle,"z","Matrix","Mat");
     375        IoModelFetchData((void**)&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness","Matrix","Mat");
     376        IoModelFetchData((void**)&iomodel->bed,NULL,NULL,iomodel_handle,"bed","Matrix","Mat");
     377        IoModelFetchData((void**)&iomodel->gridonbed,NULL,NULL,iomodel_handle,"gridonbed","Matrix","Mat");
     378        IoModelFetchData((void**)&iomodel->gridonsurface,NULL,NULL,iomodel_handle,"gridonsurface","Matrix","Mat");
     379        IoModelFetchData((void**)&iomodel->gridonicesheet,NULL,NULL,iomodel_handle,"gridonicesheet","Matrix","Mat");
     380        IoModelFetchData((void**)&iomodel->gridoniceshelf,NULL,NULL,iomodel_handle,"gridoniceshelf","Matrix","Mat");
    381381
    382382
    383383        /*Get number of dofs per node: */
    384         DistributeNumDofs(&node_numdofs,model->analysis_type,model->sub_analysis_type);
    385 
    386         for (i=0;i<model->numberofnodes;i++){
     384        DistributeNumDofs(&node_numdofs,iomodel->analysis_type,iomodel->sub_analysis_type);
     385
     386        for (i=0;i<iomodel->numberofnodes;i++){
    387387        #ifdef _PARALLEL_
    388388        /*keep only this partition's nodes:*/
     
    405405                #endif
    406406
    407                 node_x[0]=model->x[i];
    408                 node_x[1]=model->y[i];
    409                 node_x[2]=model->z[i];
    410                 node_sigma=(model->z[i]-model->bed[i])/(model->thickness[i]);
    411                
    412                 node_onbed=(int)model->gridonbed[i];
    413                 node_onsurface=(int)model->gridonsurface[i];   
    414                 node_onshelf=(int)model->gridoniceshelf[i];     
    415                 node_onsheet=(int)model->gridonicesheet[i];     
    416 
    417                 if (strcmp(model->meshtype,"3d")==0){
    418                         if (isnan(model->uppernodes[i])){
     407                node_x[0]=iomodel->x[i];
     408                node_x[1]=iomodel->y[i];
     409                node_x[2]=iomodel->z[i];
     410                node_sigma=(iomodel->z[i]-iomodel->bed[i])/(iomodel->thickness[i]);
     411               
     412                node_onbed=(int)iomodel->gridonbed[i];
     413                node_onsurface=(int)iomodel->gridonsurface[i]; 
     414                node_onshelf=(int)iomodel->gridoniceshelf[i];   
     415                node_onsheet=(int)iomodel->gridonicesheet[i];   
     416
     417                if (strcmp(iomodel->meshtype,"3d")==0){
     418                        if (isnan(iomodel->uppernodes[i])){
    419419                                node_upper_node_id=node_id;  //nodes on surface do not have upper nodes, only themselves.
    420420                        }
    421421                        else{
    422                                 node_upper_node_id=(int)model->uppernodes[i];
     422                                node_upper_node_id=(int)iomodel->uppernodes[i];
    423423                        }
    424424                }
     
    432432
    433433                /*set single point constraints.: */
    434                 if (strcmp(model->meshtype,"3d")==0){
     434                if (strcmp(iomodel->meshtype,"3d")==0){
    435435                        /*On a 3d mesh, we may have collapsed elements, hence dead grids. Freeze them out: */
    436                         if (model->gridonbed[i]==0){
     436                        if (iomodel->gridonbed[i]==0){
    437437                                for(k=1;k<=node_numdofs;k++){
    438438                                        node->FreezeDof(k);
     
    455455
    456456        /*Clean fetched data: */
    457         xfree((void**)&model->deadgrids);
    458         xfree((void**)&model->x);
    459         xfree((void**)&model->y);
    460         xfree((void**)&model->z);
    461         xfree((void**)&model->thickness);
    462         xfree((void**)&model->bed);
    463         xfree((void**)&model->gridonbed);
    464         xfree((void**)&model->gridonsurface);
    465         xfree((void**)&model->uppernodes);
    466         xfree((void**)&model->gridonicesheet);
    467         xfree((void**)&model->gridoniceshelf);
    468        
    469 
    470         /*Keep partitioning information into model*/
    471         model->epart=epart;
    472         model->my_grids=my_grids;
    473         model->my_bordergrids=my_bordergrids;
     457        xfree((void**)&iomodel->deadgrids);
     458        xfree((void**)&iomodel->x);
     459        xfree((void**)&iomodel->y);
     460        xfree((void**)&iomodel->z);
     461        xfree((void**)&iomodel->thickness);
     462        xfree((void**)&iomodel->bed);
     463        xfree((void**)&iomodel->gridonbed);
     464        xfree((void**)&iomodel->gridonsurface);
     465        xfree((void**)&iomodel->uppernodes);
     466        xfree((void**)&iomodel->gridonicesheet);
     467        xfree((void**)&iomodel->gridoniceshelf);
     468       
     469
     470        /*Keep partitioning information into iomodel*/
     471        iomodel->epart=epart;
     472        iomodel->my_grids=my_grids;
     473        iomodel->my_bordergrids=my_bordergrids;
    474474
    475475        /*Free ressources:*/
  • issm/trunk/src/c/ModelProcessorx/SlopeCompute/CreateLoadsSlopeCompute.cpp

    r358 r1833  
    1111#include "../../shared/shared.h"
    1212#include "../../include/macros.h"
    13 #include "../Model.h"
     13#include "../IoModel.h"
    1414
    1515
    16 void    CreateLoadsSlopeCompute(DataSet** ploads, Model* model,ConstDataHandle model_handle){
     16void    CreateLoadsSlopeCompute(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1717
    1818        DataSet*    loads    = NULL;
     
    2222
    2323        /*Now, is the flag isstokes on? otherwise, do nothing: */
    24         if (!model->isstokes)goto cleanup_and_return;
     24        if (!iomodel->isstokes)goto cleanup_and_return;
    2525
    2626        cleanup_and_return:
Note: See TracChangeset for help on using the changeset viewer.