Changeset 3922


Ignore:
Timestamp:
05/24/10 14:24:48 (15 years ago)
Author:
Eric.Larour
Message:

Reverted FemModel back to a simple class, with no methods, similar to just a structure

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

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.cpp

    r3913 r3922  
    1616        VecToMPISerial(&serial_solution,solution);
    1717
     18        /*Call overloaded form of UpdateInputsFromSolutionx: */
     19        UpdateInputsFromSolutionx(  elements, nodes,  vertices,  loads,  materials,  parameters,serial_solution, analysis_type, sub_analysis_type);
     20
     21        /*Free ressources:*/
     22        xfree((void**)&serial_solution);
     23
     24}
     25
     26
     27void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int analysis_type, int sub_analysis_type){
     28
    1829        /*First, get elements and loads configured: */
    1930        elements->Configure(elements,loads, nodes,vertices, materials,parameters);
    … …  
    2435       
    2536        /*Elements drive the update: */
    26         elements->UpdateInputsFromSolution(serial_solution,analysis_type,sub_analysis_type);
    27 
    28         /*Free ressources:*/
    29         xfree((void**)&serial_solution);
     37        elements->UpdateInputsFromSolution(solution,analysis_type,sub_analysis_type);
    3038
    3139}

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

    r3913 r3922  
    1111/* local prototypes: */
    1212void            UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters,Vec solution, int analysis_type, int sub_analysis_type);
     13void        UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int analysis_type, int sub_analysis_type);
    1314
    1415#endif  /* _UPDATEINPUTSFROMSOLUTIONXX_H */

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

    r3816 r3922  
    8484}
    8585/*}}}*/
    86 
    87 /*object functions*/
    88 /*FUNCTION FemModel::Echo {{{1*/
    89 void FemModel::Echo(void){
    90 
    91         printf("FemModels echo: \n");
    92         printf("   elements: %p\n",elements);
    93         printf("   nodes: %p\n",nodes);
    94         printf("   vertices: %p\n",vertices);
    95         printf("   loads: %p\n",loads);
    96         printf("   materials: %p\n",materials);
    97         printf("   parameters: %p\n",parameters);
    98        
    99         printf("   partition: %p\n",partition);
    100         printf("   tpartition: %p\n",tpartition);
    101         printf("   yg: %p\n",yg);
    102         printf("   Rmg: %p\n",Rmg);
    103         printf("   nodesets: %p\n",nodesets);
    104         printf("   ys: %p\n",ys);
    105         printf("   ys0: %p\n",ys0);
    106         printf("   Gmn: %p\n",Gmn);
    107 
    108 }
    109 /*}}}*/
    110 /*FUNCTION FemModel::DeepEcho {{{1*/
    111 void FemModel::DeepEcho(void){
    112        
    113         printf("FemModels echo: \n");
    114         printf("   elements: \n");
    115         elements->Echo();
    116         printf("   nodes: \n");
    117         nodes->Echo();
    118         printf("   vertices: \n");
    119         vertices->Echo();
    120         printf("   loads: \n");
    121         nodes->Echo();
    122         printf("   materials: \n");
    123         nodes->Echo();
    124         printf("   parameters: \n");
    125         nodes->Echo();
    126        
    127         printf("   partition: \n");
    128         partition->Echo();
    129         printf("   tpartition: \n");
    130         tpartition->Echo();
    131         printf("   yg: \n");
    132         yg->Echo();
    133         printf("   Rmg: \n");
    134         MatView(Rmg,PETSC_VIEWER_STDOUT_WORLD);
    135         printf("   nodesets: \n");
    136         nodesets->Echo();
    137         printf("   ys: \n");
    138         VecView(ys,PETSC_VIEWER_STDOUT_WORLD);
    139         printf("   ys0: \n");
    140         VecView(ys0,PETSC_VIEWER_STDOUT_WORLD);
    141         printf("   Gmn: \n");
    142         MatView(Gmn,PETSC_VIEWER_STDOUT_WORLD);
    143 
    144 }
    145 /*}}}*/
    146 /*FUNCTION FemModel::Id {{{1*/
    147 int   FemModel::Id(void){
    148         ISSMERROR("not implemented yet!");
    149 }
    150 /*}}}*/
    151 /*FUNCTION FemModel::MyRank {{{1*/
    152 int   FemModel::MyRank(void){
    153         ISSMERROR("not implemented yet!");
    154 }
    155 /*}}}*/
    156 /*FUNCTION FemModel::Marshall {{{1*/
    157 void  FemModel::Marshall(char** pmarshalled_dataset){
    158         ISSMERROR("not implemented yet!");
    159 }
    160 /*}}}*/
    161 /*FUNCTION FemModel::MarshallSize {{{1*/
    162 int   FemModel::MarshallSize(void){
    163         ISSMERROR("not implemented yet!");
    164 }
    165 /*}}}*/
    166 /*FUNCTION FemModel::Demarshall {{{1*/
    167 void  FemModel::Demarshall(char** pmarshalled_dataset){
    168         ISSMERROR("not implemented yet!");
    169 }
    170 /*}}}*/
    171 /*FUNCTION FemModel::Enum {{{1*/
    172 int   FemModel::Enum(void){
    173         ISSMERROR("not implemented yet!");
    174 }
    175 /*}}}*/
    176 /*FUNCTION FemModel::copy {{{1*/
    177 Object* FemModel::copy(void){
    178         ISSMERROR("not implemented yet!");
    179 }
    180 /*}}}*/
    181 /*FUNCTION FemModel::FindParam(bool* pinteger,int enum_type) {{{1*/
    182 int FemModel::FindParam(bool* pinteger,int enum_type){
    183        
    184         return parameters->FindParam(pinteger,enum_type);
    185 
    186 }
    187 /*}}}*/
    188 /*FUNCTION FemModel::FindParam(int* pinteger,int enum_type) {{{1*/
    189 int FemModel::FindParam(int* pinteger,int enum_type){
    190        
    191         return parameters->FindParam(pinteger,enum_type);
    192 
    193 }
    194 /*}}}*/
    195 /*FUNCTION FemModel::FindParam(double* pscalar,int enum_type) {{{1*/
    196 int FemModel::FindParam(double* pscalar,int enum_type){
    197        
    198         return parameters->FindParam(pscalar,enum_type);
    199 
    200 }
    201 /*}}}*/
    202 /*FUNCTION FemModel::FindParam(char** pstring,int enum_type) {{{1*/
    203 int FemModel::FindParam(char** pstring,int enum_type){
    204        
    205         return parameters->FindParam(pstring,enum_type);
    206 
    207 }
    208 /*}}}*/
    209 /*FUNCTION FemModel::FindParam(char*** pstringarray,int* pM,int enum_type) {{{1*/
    210 int FemModel::FindParam(char*** pstringarray,int* pM,int enum_type){
    211        
    212         return parameters->FindParam(pstringarray,pM,enum_type);
    213 
    214 }
    215 /*}}}*/
    216 /*FUNCTION FemModel::FindParam(double** pdoublearray,int* pM,int* pN,int enum_type) {{{1*/
    217 int FemModel::FindParam(double** pdoublearray,int* pM,int* pN,int enum_type){
    218        
    219         return parameters->FindParam(pdoublearray,pM,pN,enum_type);
    220 
    221 }
    222 /*}}}*/
    223 /*FUNCTION FemModel::FindParam(double** pdoublearray,int* pM,int enum_type) {{{1*/
    224 int FemModel::FindParam(double** pdoublearray,int* pM,int enum_type){
    225        
    226         return parameters->FindParam(pdoublearray,pM,enum_type);
    227 
    228 }
    229 /*}}}*/
    230 /*FUNCTION FemModel::FindParam(Vec* pvec,int enum_type) {{{1*/
    231 int FemModel::FindParam(Vec* pvec,int enum_type){
    232        
    233         return parameters->FindParam(pvec,enum_type);
    234 
    235 }
    236 /*}}}*/
    237 /*FUNCTION FemModel::FindParam(Mat* pmat,int enum_type) {{{1*/
    238 int FemModel::FindParam(Mat* pmat,int enum_type){
    239        
    240         return parameters->FindParam(pmat,enum_type);
    241 
    242 }
    243 /*}}}*/
    244 
    245 /*access to internal data: */
    246 /*FUNCTION FemModel::get_elements {{{1*/
    247 DataSet* FemModel::get_elements(void){
    248         return elements;
    249 }
    250 /*}}}*/
    251 /*FUNCTION FemModel::get_nodes {{{1*/
    252 DataSet* FemModel::get_nodes(void){
    253         return nodes;
    254 }
    255 /*}}}*/
    256 /*FUNCTION FemModel::get_vertices {{{1*/
    257 DataSet* FemModel::get_vertices(void){
    258         return vertices;
    259 }
    260 /*}}}*/
    261 /*FUNCTION FemModel::get_constraints {{{1*/
    262 DataSet* FemModel::get_constraints(void){
    263         return constraints;
    264 }
    265 /*}}}*/
    266 /*FUNCTION FemModel::get_loads {{{1*/
    267 DataSet* FemModel::get_loads(void){
    268         return loads;
    269 }
    270 /*}}}*/
    271 /*FUNCTION FemModel::get_materials {{{1*/
    272 DataSet* FemModel::get_materials(void){
    273         return materials;
    274 }
    275 /*}}}*/
    276 /*FUNCTION FemModel::get_parameters {{{1*/
    277 Parameters* FemModel::get_parameters(void){
    278         return parameters;
    279 }
    280 /*}}}*/
    281 /*FUNCTION FemModel::get_partition {{{1*/
    282 DofVec* FemModel::get_partition(void){
    283         return partition;
    284 }
    285 /*}}}*/
    286 /*FUNCTION FemModel::get_tpartition {{{1*/
    287 DofVec* FemModel::get_tpartition(void){
    288         return tpartition;
    289 }
    290 /*}}}*/
    291 /*FUNCTION FemModel::get_yg {{{1*/
    292 DofVec* FemModel::get_yg(void){
    293         return yg;
    294 }
    295 /*}}}*/
    296 /*FUNCTION FemModel::get_Rmg {{{1*/
    297 Mat FemModel::get_Rmg(void){
    298         return Rmg;
    299 }
    300 /*}}}*/
    301 /*FUNCTION FemModel::get_nodesets {{{1*/
    302 NodeSets* FemModel::get_nodesets(void){
    303         return nodesets;
    304 }
    305 /*}}}*/
    306 /*FUNCTION FemModel::get_ys {{{1*/
    307 Vec FemModel::get_ys(void){
    308         return ys;
    309 }
    310 /*}}}*/
    311 /*FUNCTION FemModel::get_ys0 {{{1*/
    312 Vec FemModel::get_ys0(void){
    313         return ys0;
    314 }
    315 /*}}}*/
    316 /*FUNCTION FemModel::get_Gmn {{{1*/
    317 Mat FemModel::get_Gmn(void){
    318         return Gmn;
    319 }
    320 /*}}}*/
    321 /*FUNCTION FemModel::UpdateInputsFromVector(Vec vector, int name, int type){{{1*/
    322 void FemModel::UpdateInputsFromVector(Vec vector, int name, int type){
    323 
    324         double* serial_vector=NULL;
    325 
    326         if(vector==NULL)return; //don't bother
    327 
    328         VecToMPISerial(&serial_vector,vector);
    329 
    330         this->UpdateInputsFromVector(serial_vector,name,type);
    331 
    332         /*Free ressources:*/
    333         xfree((void**)&serial_vector);
    334 }
    335 /*}}}*/
    336 /*FUNCTION FemModel::UpdateInputsFromVector(double* vector, int name, int type){{{1*/
    337 void FemModel::UpdateInputsFromVector(double* vector, int name, int type){
    338 
    339         if(vector==NULL)return; //don't bother
    340 
    341         elements->UpdateInputsFromVector(vector,name,type);
    342         nodes->UpdateInputsFromVector(vector,name,type);
    343         vertices->UpdateInputsFromVector(vector,name,type);
    344         loads->UpdateInputsFromVector(vector,name,type);
    345         materials->UpdateInputsFromVector(vector,name,type);
    346         parameters->UpdateInputsFromVector(vector,name,type);
    347 
    348 }
    349 /*}}}*/
    350 /*FUNCTION FemModel::UpdateInputsFromVector(int* vector, int name, int type){{{1*/
    351 void FemModel::UpdateInputsFromVector(int* vector, int name, int type){
    352 
    353         if(vector==NULL)return; //don't bother
    354 
    355         elements->UpdateInputsFromVector(vector,name,type);
    356         nodes->UpdateInputsFromVector(vector,name,type);
    357         vertices->UpdateInputsFromVector(vector,name,type);
    358         loads->UpdateInputsFromVector(vector,name,type);
    359         materials->UpdateInputsFromVector(vector,name,type);
    360         parameters->UpdateInputsFromVector(vector,name,type);
    361 
    362 }
    363 /*}}}*/
    364 /*FUNCTION FemModel::UpdateInputsFromVector(bool* vector, int name, int type){{{1*/
    365 void FemModel::UpdateInputsFromVector(bool* vector, int name, int type){
    366 
    367         if(vector==NULL)return; //don't bother
    368 
    369         elements->UpdateInputsFromVector(vector,name,type);
    370         nodes->UpdateInputsFromVector(vector,name,type);
    371         vertices->UpdateInputsFromVector(vector,name,type);
    372         loads->UpdateInputsFromVector(vector,name,type);
    373         materials->UpdateInputsFromVector(vector,name,type);
    374         parameters->UpdateInputsFromVector(vector,name,type);
    375 
    376 }
    377 /*}}}*/
    378 /*FUNCTION FemModel::UpdateInputsFromConstant(double constant, int name){{{1*/
    379 void    FemModel::UpdateInputsFromConstant(double constant, int name){
    380        
    381         elements->UpdateInputsFromConstant(constant,name);
    382         nodes->UpdateInputsFromConstant(constant,name);
    383         vertices->UpdateInputsFromConstant(constant,name);
    384         loads->UpdateInputsFromConstant(constant,name);
    385         materials->UpdateInputsFromConstant(constant,name);
    386         parameters->UpdateInputsFromConstant(constant,name);
    387 
    388 }
    389 /*}}}*/
    390 /*FUNCTION FemModel::UpdateInputsFromConstant(int constant, int name){{{1*/
    391 void    FemModel::UpdateInputsFromConstant(int constant, int name){
    392        
    393         elements->UpdateInputsFromConstant(constant,name);
    394         nodes->UpdateInputsFromConstant(constant,name);
    395         vertices->UpdateInputsFromConstant(constant,name);
    396         loads->UpdateInputsFromConstant(constant,name);
    397         materials->UpdateInputsFromConstant(constant,name);
    398         parameters->UpdateInputsFromConstant(constant,name);
    399 
    400 }
    401 /*}}}*/
    402 /*FUNCTION FemModel::UpdateInputsFromConstant(bool constant, int name){{{1*/
    403 void    FemModel::UpdateInputsFromConstant(bool constant, int name){
    404        
    405         elements->UpdateInputsFromConstant(constant,name);
    406         nodes->UpdateInputsFromConstant(constant,name);
    407         vertices->UpdateInputsFromConstant(constant,name);
    408         loads->UpdateInputsFromConstant(constant,name);
    409         materials->UpdateInputsFromConstant(constant,name);
    410         parameters->UpdateInputsFromConstant(constant,name);
    411 
    412 }
    413 /*}}}*/
    414 /*FUNCTION FemModel::UpdateInputsFromSolution(Vec vector, int name, int type){{{1*/
    415 void FemModel::UpdateInputsFromSolution(Vec vector,int name, int type){
    416 
    417         double* serial_vector=NULL;
    418 
    419         VecToMPISerial(&serial_vector,vector);
    420         elements->UpdateInputsFromSolution(serial_vector,name,type);
    421 
    422         /*Free ressources:*/
    423         xfree((void**)&serial_vector);
    424 
    425 }
    426 /*}}}*/
    427 /*FUNCTION FemModel::UpdateInputsFromSolution(double* vector, int name, int type){{{1*/
    428 void FemModel::UpdateInputsFromSolution(double* vector,int name, int type){
    429         ISSMERROR(" not supported yet!");
    430 }
    431 /*}}}*/

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

    r3751 r3922  
    1616/*}}}*/
    1717
    18 class FemModel: public Object{
     18class FemModel {
    1919
    2020        /*no private members, as we need access to these datasets quite often!:*/
    … …  
    4444                FemModel(DataSet* elements,DataSet* nodes,DataSet* vertices, DataSet* constraints,DataSet* loads,DataSet* materials,Parameters* parameters,
    4545                                      DofVec* partition,DofVec* tpartition,DofVec* yg,Mat Rmg,Mat Gmn,NodeSets* nodesets,Vec ys,Vec ys0);
    46      
    47                 /*virtual resolves: */
    48                 void  Echo();
    49                 void  DeepEcho();
    50                 int   Id();
    51                 int   MyRank();
    52                 void  Marshall(char** pmarshalled_dataset);
    53                 int   MarshallSize();
    54                 void  Demarshall(char** pmarshalled_dataset);
    55                 int   Enum();
    56                 Object* copy();
    57                
    58                 int FindParam(double* pscalar,int enum_type);
    59                 int FindParam(bool* pinteger,int enum_type);
    60                 int FindParam(int* pinteger,int enum_type);
    61                 int FindParam(char** pstring,int enum_type);
    62                 int FindParam(char*** pstringarray,int* pM,int enum_type);
    63                 int FindParam(double** pdoublearray,int* pM, int enum_type);
    64                 int FindParam(double** pdoublearray,int* pM, int* pN,int enum_type);
    65                 int FindParam(Vec* pvec,int enum_type);
    66                 int FindParam(Mat* pmat,int enum_type);
    67                 DataSet* get_elements(void);
    68                 DataSet* get_nodes(void);
    69                 DataSet* get_vertices(void);
    70                 DataSet* get_constraints(void);
    71                 DataSet* get_loads(void);
    72                 DataSet* get_materials(void);
    73                 Parameters* get_parameters(void);
    74                 DofVec*      get_partition(void);
    75                 DofVec*      get_tpartition(void);
    76                 DofVec*      get_yg(void);
    77                 Mat      get_Rmg(void);
    78                 NodeSets* get_nodesets(void);
    79                 Vec      get_ys(void);
    80                 Vec      get_ys0(void);
    81                 Mat      get_Gmn(void);
    82 
    83                 void    UpdateInputsFromVector(Vec vector, int name, int type);
    84                 void    UpdateInputsFromVector(double* vector, int name, int type);
    85                 void    UpdateInputsFromVector(bool* vector, int name, int type);
    86                 void    UpdateInputsFromVector(int* vector, int name, int type);
    87 
    88                 void    UpdateInputsFromConstant(double constant, int name);
    89                 void    UpdateInputsFromConstant(int constant, int name);
    90                 void    UpdateInputsFromConstant(bool constant, int name);
    91 
    92                 void    UpdateInputsFromSolution(Vec solution, int analysis_type, int sub_analysis_type);
    93                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
    9446
    9547};

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

    r3913 r3922  
    220220        if(!femmodel)return 0;
    221221
    222         femmodel->FindParam(pparameter,enum_type);
     222        femmodel->parameters->FindParam(pparameter,enum_type);
    223223
    224224}
    … …  
    238238        if(!femmodel)return 0;
    239239
    240         femmodel->FindParam(pparameter,enum_type);
     240        femmodel->parameters->FindParam(pparameter,enum_type);
    241241
    242242}
    … …  
    255255        if(!femmodel)return 0;
    256256       
    257         femmodel->FindParam(pparameter,enum_type);
     257        femmodel->parameters->FindParam(pparameter,enum_type);
    258258
    259259
    … …  
    273273        if(!femmodel)return 0;
    274274       
    275         femmodel->FindParam(pparameter,pM, pN,enum_type);
     275        femmodel->parameters->FindParam(pparameter,pM, pN,enum_type);
    276276
    277277
    … …  
    291291        if(!femmodel)return 0;
    292292       
    293         femmodel->FindParam(pparameter,pM, enum_type);
     293        femmodel->parameters->FindParam(pparameter,pM, enum_type);
    294294
    295295
    … …  
    309309        if(!femmodel)return 0;
    310310       
    311         femmodel->FindParam(pparameter,enum_type);
     311        femmodel->parameters->FindParam(pparameter,enum_type);
    312312
    313313}
    … …  
    324324
    325325        /*extract our parameter from the found formulation: */
    326         femmodel->FindParam(pparameter,enum_type);
     326        femmodel->parameters->FindParam(pparameter,enum_type);
    327327}
    328328/*}}}1*/
    … …  
    338338
    339339        /*extract our parameter from the found formulation: */
    340         femmodel->FindParam(pparameter,enum_type);
     340        femmodel->parameters->FindParam(pparameter,enum_type);
    341341}
    342342/*}}}1*/
    … …  
    352352
    353353        /*extract our parameter from the found formulation: */
    354         femmodel->FindParam(pparameter,enum_type);
     354        femmodel->parameters->FindParam(pparameter,enum_type);
    355355}
    356356/*}}}1*/
    … …  
    366366
    367367        /*extract our parameter from the found formulation: */
    368         femmodel->FindParam(pparameter,pM, pN,enum_type);
     368        femmodel->parameters->FindParam(pparameter,pM, pN,enum_type);
    369369}
    370370/*}}}1*/
    … …  
    380380
    381381        /*extract our parameter from the found formulation: */
    382         femmodel->FindParam(pparameter,pM, enum_type);
     382        femmodel->parameters->FindParam(pparameter,pM, enum_type);
    383383}
    384384/*}}}1*/
    … …  
    394394
    395395        /*extract our parameter from the found formulation: */
    396         femmodel->FindParam(pparameter,enum_type);
     396        femmodel->parameters->FindParam(pparameter,enum_type);
    397397}
    398398/*}}}1*/
    … …  
    408408
    409409        /*extract our parameter from the found formulation: */
    410         femmodel->FindParam(pparameter,enum_type);
     410        femmodel->parameters->FindParam(pparameter,enum_type);
    411411}
    412412/*}}}1*/
    … …  
    422422
    423423        /*extract our parameter from the found formulation: */
    424         femmodel->FindParam(pparameter,enum_type);
     424        femmodel->parameters->FindParam(pparameter,enum_type);
    425425}
    426426/*}}}1*/
    … …  
    436436
    437437        /*extract our parameter from the found formulation: */
    438         femmodel->FindParam(pparameter,enum_type);
     438        femmodel->parameters->FindParam(pparameter,enum_type);
    439439}
    440440/*}}}1*/
    … …  
    450450
    451451        /*extract our parameter from the found formulation: */
    452         femmodel->FindParam(pparameter,pM,pN,enum_type);
     452        femmodel->parameters->FindParam(pparameter,pM,pN,enum_type);
    453453}
    454454/*}}}1*/
    … …  
    464464
    465465        /*extract our parameter from the found formulation: */
    466         femmodel->FindParam(pparameter,pM,enum_type);
     466        femmodel->parameters->FindParam(pparameter,pM,enum_type);
    467467}
    468468/*}}}1*/
    … …  
    478478
    479479        /*extract our parameter from the found formulation: */
    480         femmodel->FindParam(pparameter,enum_type);
     480        femmodel->parameters->FindParam(pparameter,enum_type);
    481481}       
    482482/*}}}1*/
    … …  
    500500
    501501                femmodel=(FemModel*)femmodels->GetObjectByOffset(i);
    502                 femmodel->FindParam(&femmodel_analysis_type,AnalysisTypeEnum);
    503                 femmodel->FindParam(&femmodel_sub_analysis_type,SubAnalysisTypeEnum);
     502                femmodel->parameters->FindParam(&femmodel_analysis_type,AnalysisTypeEnum);
     503                femmodel->parameters->FindParam(&femmodel_sub_analysis_type,SubAnalysisTypeEnum);
    504504
    505505                if((analysis_type==femmodel_analysis_type) && (sub_analysis_type==femmodel_sub_analysis_type)){
    … …  
    529529
    530530                femmodel=(FemModel*)femmodels->GetObjectByOffset(i);
    531                 femmodel->FindParam(&femmodel_analysis_type,AnalysisTypeEnum);
     531                femmodel->parameters->FindParam(&femmodel_analysis_type,AnalysisTypeEnum);
    532532
    533533                if((analysis_type==femmodel_analysis_type)){
    … …  
    554554        for(i=0;i<this->femmodels->Size();i++){
    555555                femmodel=(FemModel*)this->femmodels->GetObjectByOffset(i);
    556                 femmodel->UpdateInputsFromConstant(constant,name);
     556                UpdateInputsFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,constant,name);
    557557        }
    558558
    … …  
    567567        for(i=0;i<this->femmodels->Size();i++){
    568568                femmodel=(FemModel*)this->femmodels->GetObjectByOffset(i);
    569                 femmodel->UpdateInputsFromConstant(constant,name);
     569                UpdateInputsFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,constant,name);
    570570        }
    571571
    … …  
    580580        for(i=0;i<this->femmodels->Size();i++){
    581581                femmodel=(FemModel*)this->femmodels->GetObjectByOffset(i);
    582                 femmodel->UpdateInputsFromConstant(constant,name);
     582                UpdateInputsFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,constant,name);
    583583        }
    584584
    … …  
    595595        for(i=0;i<this->femmodels->Size();i++){
    596596                femmodel=(FemModel*)this->femmodels->GetObjectByOffset(i);
    597                 femmodel->UpdateInputsFromVector(vector,name,type);
     597                UpdateInputsFromVectorx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,vector,name,type);
    598598        }
    599599
    … …  
    626626        for(i=0;i<this->femmodels->Size();i++){
    627627                femmodel=(FemModel*)this->femmodels->GetObjectByOffset(i);
    628                 femmodel->UpdateInputsFromSolution(vector,analysis_type,sub_analysis_type);
     628                UpdateInputsFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,vector,analysis_type,sub_analysis_type);
    629629        }
    630630

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

    r3913 r3922  
    7171
    7272        //specific parameters for specific models
    73         fem_dh->FindParam(&numberofdofspernode_dh,NumberOfDofsPerNodeEnum);
    74         fem_sl->FindParam(&numberofdofspernode_sl,NumberOfDofsPerNodeEnum);
    75         fem_ds->FindParam(&numberofdofspernode_ds,NumberOfDofsPerNodeEnum);
     73        fem_dh->parameters->FindParam(&numberofdofspernode_dh,NumberOfDofsPerNodeEnum);
     74        fem_sl->parameters->FindParam(&numberofdofspernode_sl,NumberOfDofsPerNodeEnum);
     75        fem_ds->parameters->FindParam(&numberofdofspernode_ds,NumberOfDofsPerNodeEnum);
    7676
    7777        /*if no Stokes, assign output and return*/

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

    r3913 r3922  
    8989
    9090        //specific parameters for specific models
    91         fem_dh->FindParam(&numberofdofspernode_dh,NumberOfDofsPerNodeEnum);
    92         fem_sl->FindParam(&numberofdofspernode_sl,NumberOfDofsPerNodeEnum);
    93         fem_ds->FindParam(&numberofdofspernode_ds,NumberOfDofsPerNodeEnum);
     91        fem_dh->parameters->FindParam(&numberofdofspernode_dh,NumberOfDofsPerNodeEnum);
     92        fem_sl->parameters->FindParam(&numberofdofspernode_sl,NumberOfDofsPerNodeEnum);
     93        fem_ds->parameters->FindParam(&numberofdofspernode_ds,NumberOfDofsPerNodeEnum);
    9494
    9595        //for qmu analysis, be sure the velocity input we are starting from  is the one in the parameters: */
    9696        if(qmu_analysis){
    97                 fem_dh->FindParam(&vx,&dummy,VxEnum); model->UpdateInputsFromVector(vx,VxEnum,VertexEnum);
    98                 fem_dh->FindParam(&vy,&dummy,VyEnum); model->UpdateInputsFromVector(vy,VyEnum,VertexEnum);
    99                 fem_dh->FindParam(&vz,&dummy,VzEnum); model->UpdateInputsFromVector(vz,VzEnum,VertexEnum);
     97                fem_dh->parameters->FindParam(&vx,&dummy,VxEnum); model->UpdateInputsFromVector(vx,VxEnum,VertexEnum);
     98                fem_dh->parameters->FindParam(&vy,&dummy,VyEnum); model->UpdateInputsFromVector(vy,VyEnum,VertexEnum);
     99                fem_dh->parameters->FindParam(&vz,&dummy,VzEnum); model->UpdateInputsFromVector(vz,VzEnum,VertexEnum);
    100100        }
    101101

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

    r3917 r3922  
    9999
    100100                //Update inputs using new solution:
    101                 fem->UpdateInputsFromSolution(ug,analysis_type,sub_analysis_type);
     101                UpdateInputsFromSolutionx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,ug,analysis_type, sub_analysis_type);
    102102
    103103                //Deal with penalty loads
    … …  
    112112               
    113113                /*add converged to inputs: */
    114                 fem->UpdateInputsFromConstant(converged,ConvergedEnum);
     114                UpdateInputsFromConstantx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,converged,ConvergedEnum);
    115115
    116116                //rift convergence

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

    r3913 r3922  
    8888
    8989        /*Add new parameter to inputs: */
    90         femmodel->UpdateInputsFromVector(param_g_copy,control_type,VertexEnum);
     90        UpdateInputsFromVectorx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,param_g_copy,control_type,VertexEnum);
    9191
    9292        /*Run diagnostic with updated parameters.*/
    9393        if(!control_steady){
    9494                diagnostic_core_nonlinear(&u_g,NULL,NULL,NULL,femmodel,DiagnosticAnalysisEnum,sub_analysis_type);
    95                 femmodel->UpdateInputsFromSolution(u_g,DiagnosticAnalysisEnum,sub_analysis_type);
     95                UpdateInputsFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,u_g,DiagnosticAnalysisEnum,sub_analysis_type);
    9696                VecFree(&u_g);
    9797        }
    … …  
    104104               
    105105                SplitSolutionVectorx(u_g,numberofnodes,3,&vx,&vy,&vz);
    106                 femmodel->UpdateInputsFromVector(vx,VxEnum,VertexEnum);
    107                 femmodel->UpdateInputsFromVector(vy,VxEnum,VertexEnum);
    108                 femmodel->UpdateInputsFromVector(vz,VxEnum,VertexEnum);
     106                UpdateInputsFromVectorx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,vx,VxEnum,VertexEnum);
     107                UpdateInputsFromVectorx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,vy,VyEnum,VertexEnum);
     108                UpdateInputsFromVectorx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,vz,VzEnum,VertexEnum);
    109109               
    110110                delete diagnostic_results;
    … …  
    112112
    113113        /*Compute misfit for this velocity field.*/
    114         femmodel->UpdateInputsFromConstant(fit[n],FitEnum);
     114        UpdateInputsFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,fit[n],FitEnum);
    115115        CostFunctionx( &J, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters,analysis_type,sub_analysis_type);
    116116

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

    r3913 r3922  
    4444               
    4545        _printf_("update inputs:\n");
    46         fem_p->UpdateInputsFromSolution(h_g,PrognosticAnalysisEnum,NoneAnalysisEnum);
     46        UpdateInputsFromSolutionx( fem_p->elements,fem_p->nodes, fem_p->vertices, fem_p->loads, fem_p->materials, fem_p->parameters,h_g,PrognosticAnalysisEnum,NoneAnalysisEnum);
    4747
    4848        _printf_("extrude computed thickness on all layers:\n");

  • issm/trunk/src/c/solutions/thermal_core.cpp

    r3913 r3922  
    5353
    5454        //first recover parameters common to all solutions
    55         fem_t->FindParam(&numberofnodes,NumberOfNodesEnum);
    56         fem_t->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
    57         fem_t->FindParam(&verbose,VerboseEnum);
    58         fem_t->FindParam(&ndt,NdtEnum);
    59         fem_t->FindParam(&dt,DtEnum);
     55        fem_t->parameters->FindParam(&numberofnodes,NumberOfNodesEnum);
     56        fem_t->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
     57        fem_t->parameters->FindParam(&verbose,VerboseEnum);
     58        fem_t->parameters->FindParam(&ndt,NdtEnum);
     59        fem_t->parameters->FindParam(&dt,DtEnum);
    6060
    6161        if(dt==0){

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

    r3913 r3922  
    5656
    5757                if(count==1) reset_penalties=1; else reset_penalties=0;
    58                 fem->UpdateInputsFromConstant(reset_penalties,ResetPenaltiesEnum);
     58                UpdateInputsFromConstantx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,reset_penalties,ResetPenaltiesEnum);
    5959
    6060                //*Generate system matrices
    … …  
    110110                PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,analysis_type,sub_analysis_type);
    111111               
    112                 fem->UpdateInputsFromVector(tg,TemperatureEnum,VertexEnum);
     112                UpdateInputsFromVectorx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,tg,TemperatureEnum,VertexEnum);
     113
    113114
    114115                if (!converged){
Note: See TracChangeset for help on using the changeset viewer.