Changeset 1881


Ignore:
Timestamp:
08/25/09 13:04:05 (16 years ago)
Author:
Eric.Larour
Message:

Model and FemModel are now classes in their own right.
This changes the cores quite a bit.

Location:
issm/trunk/src/c
Files:
2 added
34 edited

Legend:

Unmodified
Added
Removed

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

    r1864 r1881  
    2323                                        ./objects/Model.h\
    2424                                        ./objects/Model.cpp\
     25                                        ./objects/FemModel.h\
     26                                        ./objects/FemModel.cpp\
    2527                                        ./objects/Material.h\
    2628                                        ./objects/Material.cpp\
    … …  
    318320                                        ./objects/Model.h\
    319321                                        ./objects/Model.cpp\
     322                                        ./objects/FemModel.h\
     323                                        ./objects/FemModel.cpp\
    320324                                        ./objects/Material.h\
    321325                                        ./objects/Material.cpp\

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

    r1864 r1881  
    1111#include "../toolkits/toolkits.h"
    1212
    13 #define RIFTINFOSIZE 10
     13#define RIFTINFOSIZE 11
    1414
    1515struct IoModel {

  • issm/trunk/src/c/Qmux/DakotaResponses.cpp

    r1842 r1881  
    2020        char* response_descriptor=NULL;
    2121        int numberofnodes;
    22         FemModel* fem=NULL;
    2322        extern int my_rank;
    2423
    25         /*recover first model: */
    26         fem=model->DiagnosticHorizontal();
    27 
    2824        /*some data needed across the responses: */
    29         found=fem->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    30         if(!found)throw ErrorException(__FUNCT__," could not find numberofnodes in fem model");
    31 
     25        model->FindParam(&numberofnodes,"numberofnodes");
    3226
    3327        for(i=0;i<numresponses;i++){

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

    r1840 r1881  
    7676        #ifdef _PARALLEL_
    7777        /*Recover dakota_input_file, dakota_output_file and dakota_error_file, in the parameters dataset in parallel */
    78         model->DiagnosticHorizontal()->parameters->FindParam((void*)&dakota_input_file,"qmuinname");
    79         model->DiagnosticHorizontal()->parameters->FindParam((void*)&dakota_output_file,"qmuoutname");
    80         model->DiagnosticHorizontal()->parameters->FindParam((void*)&dakota_error_file,"qmuerrname");
     78        model->FindParam(&dakota_input_file,"qmuinname");
     79        model->FindParam(&dakota_output_file,"qmuoutname");
     80        model->FindParam(&dakota_error_file,"qmuerrname");
    8181        #endif
    8282

  • issm/trunk/src/c/Qmux/SpawnCoreParallel.cpp

    r1841 r1881  
    5858       
    5959        /*some parameters needed: */
    60         model->DiagnosticHorizontal()->parameters->FindParam((void*)&debug,"debug");
     60        model->FindParam(&debug,"debug");
    6161               
    6262        /*First off, recover the response descriptors for the response functions: */
    63         param=(Param*)model->DiagnosticHorizontal()->parameters->FindParamObject("responsedescriptors");
     63        param=(Param*)model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum())->parameters->FindParamObject("responsedescriptors");
    6464        if(!param)throw ErrorException(__FUNCT__," could not find response descriptors!");
    6565
    … …  
    6767
    6868        /*Recover partitioning for dakota: */
    69         model->DiagnosticHorizontal()->parameters->FindParam((void*)&qmu_npart,"qmu_npart");
    70         model->DiagnosticHorizontal()->parameters->FindParam((void*)&qmu_part,"qmu_part");
     69        model->FindParam(&qmu_npart,"qmu_npart");
     70        model->FindParam(&qmu_part,"qmu_part");
    7171        #ifdef _DEBUG_
    7272        for(i=0;i<numresponses;i++){
    … …  
    116116
    117117        /*Modify core inputs to reflect the dakota variables inputs: */
    118         inputs->UpdateFromDakota(variables,variables_descriptors,numvariables,model->DiagnosticHorizontal()->parameters,qmu_part,qmu_npart); //diagnostic horiz model is the one holding the parameters for Dakota.
     118        inputs->UpdateFromDakota(variables,variables_descriptors,numvariables,model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum())->parameters,qmu_part,qmu_npart); //diagnostic horiz model is the one holding the parameters for Dakota.
    119119
    120120        /*Run the analysis core solution sequence, with the updated inputs: */

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

    r1844 r1881  
    88#include "../objects/NodeSets.h"
    99#include "../DataSet/DataSet.h"
     10#include "../include/types.h"
    1011
    11 /*Define abstract type for I/O: */
    12 #ifdef _SERIAL_
    13 #include <mex.h>
    14 typedef const mxArray* ConstDataHandle;  //serially, we are reading data from a matlab array.
    15 typedef mxArray* DataHandle; 
    16 #else
    17 typedef FILE* ConstDataHandle; //in parallel, we are reading data from a file.
    18 typedef FILE* DataHandle;
    19 #endif
    20 
     12class DataSet;
    2113
    2214void FetchData(void** pdata,int* pM,int* pN,ConstDataHandle data_handle,char* data_type,char* sub_data_type);
    … …  
    4537/*File I/O: */
    4638FILE* pfopen(char* filename,char* format);
    47 void* pfclose(FILE* fid,char* filename);
     39void  pfclose(FILE* fid,char* filename);
    4840
    4941#endif  /* _IMDB_H */

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

    r1844 r1881  
    1616#include "include/macros.h"
    1717#include "include/globals.h"
     18#include "include/types.h"
    1819
    1920/*Modules: */

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

    r246 r1881  
    88#include "../toolkits/toolkits.h"
    99#include "../DataSet/DataSet.h"
     10#include "../parallel/parallel.h"
    1011
    1112class DataSet;
     13struct OptArgs;
    1214
    13 struct FemModel{
     15class FemModel{
    1416
    15         DataSet*            elements;
    16         DataSet*            nodes;
    17         DataSet*            constraints;
    18         DataSet*            loads;
    19         DataSet*            materials;
    20         DataSet*            parameters;
     17        friend  Vec GradJCompute(ParameterInputs* inputs,FemModel* femmodel);
     18        friend  void diagnostic_core(DataSet* results,Model* model, ParameterInputs* inputs);
     19        friend  void prognostic_core(DataSet* results,Model* model, ParameterInputs* inputs);
     20        friend  void control_core(DataSet* results,Model* model, ParameterInputs* inputs);
     21        friend  void thermal_core(DataSet* results,Model* model, ParameterInputs* inputs);
     22        friend  void thermal_core_nonlinear(Vec* ptg,double* pmelting_offset,FemModel* fem,ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
     23        friend  void steadystate_core(DataSet* results,Model* model, ParameterInputs* inputs);
     24        friend  void diagnostic_core_nonlinear(Vec* pug,Mat* pK_ff0,Mat* pK_fs0, DataSet* loads, FemModel* fem,ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
     25        friend  void diagnostic_core_linear(Vec* ppg,FemModel* fem,ParameterInputs* inputs,int  analysis_type,int sub_analysis_type);
     26        friend  void transient_core(DataSet* results,Model* model, ParameterInputs* inputs);
     27        friend  void transient_core_2d(DataSet* results,Model* model, ParameterInputs* inputs);
     28        friend  void transient_core_3d(DataSet* results,Model* model, ParameterInputs* inputs);
     29        friend  double objectivefunctionC(double search_scalar,OptArgs* optargs);
     30        friend  int GradJSearch(double* search_vector,FemModel* femmodel,int step);
     31        friend  void OutputResults(DataSet* results,char* filename);
     32        friend  void WriteLockFile(char* filename);
     33        friend  void ControlInitialization(Model* model, ParameterInputs* inputs);
     34        friend  void ControlTemporaryResults(Model* model,double* param_g,double* J,int n,ParameterInputs* inputs);
     35        friend  void CreateFemModel(FemModel* femmodel,ConstDataHandle MODEL,int analysis_type,int sub_analysis_type);
     36        friend  void ProcessResults(DataSet** presults,Model* model,int analysis_type);
     37        friend  void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, Model* model,ParameterInputs* inputs,int analysis_type,int sub_analysis_type,int counter);
    2138
    22         Vec                 partition;
    23         Vec                 tpartition;
    24         Vec                 yg;
    25         Mat                 Rmg;
    26         NodeSets*           nodesets;
    27         Vec                 ys;
    28         Vec                 ys0;
    29         Mat                 Gmn;
     39        private:
     40                DataSet*            elements;
     41                DataSet*            nodes;
     42                DataSet*            constraints;
     43                DataSet*            loads;
     44                DataSet*            materials;
     45                DataSet*            parameters;
     46
     47                Vec                 partition;
     48                Vec                 tpartition;
     49                Vec                 yg;
     50                Mat                 Rmg;
     51                NodeSets*           nodesets;
     52                Vec                 ys;
     53                Vec                 ys0;
     54                Mat                 Gmn;
     55
     56        public:
     57
     58                FemModel();
     59                ~FemModel();
     60                FemModel(DataSet* elements,DataSet* nodes,DataSet* constraints,DataSet* loads,DataSet* materials,DataSet* parameters,
     61                                      Vec partition,Vec tpartition,Vec yg,Mat Rmg,Mat Gmn,NodeSets* nodesets,Vec ys,Vec ys0);
     62     
     63                void  Echo();
     64                void  DeepEcho();
     65               
     66                int FindParam(void* pparameter,char* parametername);
     67                DataSet* get_elements(void);
     68                DataSet* get_nodes(void);
     69                DataSet* get_constraints(void);
     70                DataSet* get_loads(void);
     71                DataSet* get_materials(void);
     72                DataSet* get_parameters(void);
     73                Vec      get_partition(void);
     74                Vec      get_tpartition(void);
     75                Vec      get_yg(void);
     76                Mat      get_Rmg(void);
     77                NodeSets* get_nodesets(void);
     78                Vec      get_ys(void);
     79                Vec      get_ys0(void);
     80                Mat      get_Gmn(void);
     81
     82
    3083
    3184};
    3285
     86
    3387#endif

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

    r1843 r1881  
    22 * \brief: implementation of the Model object
    33 */
     4
     5#include "./objects.h"
     6#include "../io/io.h"
     7#include "../shared/shared.h"
     8#include "../include/macros.h"
     9#include "../issm.h"
    410
    511#ifdef HAVE_CONFIG_H
    … …  
    1319
    1420Model::Model(){
    15         return;
     21
     22        femmodels=new DataSet(0);
     23        active=NULL;
     24
    1625}
    1726
    1827Model::~Model(){
    19         /*none of the FemModels are copied, just pointers -> no dynamic allocation.*/
    20         return;
     28
     29        delete femmodels;
     30        /*do not delete active, it just points to one of the femmodels!*/
    2131}
    2232
    … …  
    2636void Model::Echo(void){
    2737
    28         printf("Model:\n");
    29         printf("   diagnostichorizontal: %p\n",diagnostichorizontal);
    30         printf("   diagnosticvertical: %p\n",diagnosticvertical);
    31         printf("   diagnosticstokes: %p\n",diagnosticstokes);
    32         printf("   diagnostichutter: %p\n",diagnostichutter);
    33         printf("   slope: %p\n",slope);
    34         printf("   prognostic: %p\n",prognostic);
    35         printf("   thermal: %p\n",thermal);
    36         printf("   melting: %p\n",melting);
    37         printf("   active: %p\n",active);
     38        printf("Models echo: \n");
     39        printf("   number of fem models: %i\n",femmodels->Size());
    3840
    3941}
    … …  
    4345void Model::DeepEcho(void){
    4446
    45         printf("Model:\n");
    46         printf("   diagnostichorizontal: %p\n",diagnostichorizontal);
    47         printf("   diagnosticvertical: %p\n",diagnosticvertical);
    48         printf("   diagnosticstokes: %p\n",diagnosticstokes);
    49         printf("   diagnostichutter: %p\n",diagnostichutter);
    50         printf("   slope: %p\n",slope);
    51         printf("   prognostic: %p\n",prognostic);
    52         printf("   thermal: %p\n",thermal);
    53         printf("   melting: %p\n",melting);
    54         printf("   active: %p\n",active);
    55 
    56 }
    57 
    58 FemModel* Model::DiagnosticHorizontal(void){
    59         return diagnostichorizontal;
    60 }
    61 FemModel* Model::DiagnosticVertical(void){
    62         return diagnosticvertical;
    63 }
    64 FemModel* Model::DiagnosticStokes(void){
    65         return diagnosticstokes;
    66 }
    67 FemModel* Model::DiagnosticHutter(void){
    68         return diagnostichutter;
    69 }
    70 FemModel* Model::Slope(void){
    71         return slope;
    72 }
    73 FemModel* Model::Prognostic(void){
    74         return prognostic;
    75 }
    76 FemModel* Model::Thermal(void){
    77         return thermal;
    78 }
    79 FemModel* Model::Melting(void){
    80         return melting;
    81 }
    82 FemModel* Model::Active(void){
    83         return active;
     47        femmodels->Echo();
     48
    8449}
    8550               
    86 void      Model::SetActive(FemModel* femmodel){
     51#undef __FUNCT__
     52#define __FUNCT__ "Model::AddFormulation"
     53void  Model::AddFormulation(ConstDataHandle MODEL, int analysis_type,int sub_analysis_type){
     54
     55        /*FemModel: */
     56        FemModel*           femmodel=NULL;
     57        DataSet*            elements=NULL;
     58        DataSet*            nodes=NULL;
     59        DataSet*            constraints=NULL;
     60        DataSet*            loads=NULL;
     61        DataSet*            materials=NULL;
     62        DataSet*            parameters=NULL;
     63        Vec                 partition=NULL;
     64        Vec                 tpartition=NULL;
     65        Vec                 yg=NULL;
     66        Mat                 Rmg=NULL;
     67        Mat                 Gmn=NULL;
     68        NodeSets*           nodesets=NULL;
     69        Vec                 ys=NULL;
     70        Vec                 ys0=NULL;
     71
     72        /*intermediary: */
     73        IoModel* iomodel=NULL;
     74       
     75        _printf_("   fill model with matlab workspace data\n");
     76        IoModelInit(&iomodel,MODEL);
     77
     78        _printf_("   specifying analysis\n");
     79        if (analysis_type!=0){
     80                iomodel->analysis_type=analysis_type;
     81        }
     82        if (sub_analysis_type!=0){
     83                iomodel->sub_analysis_type=sub_analysis_type;
     84        }
     85
     86        _printf_("   create datasets:\n");
     87        CreateDataSets(&elements,&nodes,&materials,&constraints,&loads,&parameters,iomodel,MODEL);
     88
     89        _printf_("   create degrees of freedom: \n");
     90        Dofx( &partition,&tpartition,elements,nodes, parameters);
     91       
     92        _printf_("   create single point constraints: \n");
     93        SpcNodesx( &yg, nodes,constraints);
     94       
     95        _printf_("   create rigid body constraints:\n");
     96        MpcNodesx( &Rmg, nodes,constraints);
     97       
     98        _printf_("   create node sets:\n");
     99        BuildNodeSetsx(&nodesets, nodes);
     100
     101        _printf_("   reducing single point constraints vector:\n");
     102        Reducevectorgtosx(&ys,&ys0, yg,nodesets);
     103       
     104        _printf_("   normalizing rigid body constraints matrix:\n");
     105        NormalizeConstraintsx(&Gmn, Rmg,nodesets);
     106
     107        _printf_("   configuring element and loads:\n");
     108        ConfigureObjectsx(elements, loads, nodes, materials);
     109
     110        _printf_("   process parameters:\n");
     111        ProcessParamsx( parameters, partition);
     112
     113        _printf_("   free ressources:\n");
     114        DeleteIoModel(&iomodel);
     115
     116        /*Use all the data created to create an femmodel: */
     117        femmodel=new FemModel(elements,nodes,constraints,loads,materials,parameters,
     118                                      partition,tpartition,yg,Rmg,Gmn,nodesets,ys,ys0);
     119
     120        /*Add to femmodels in model: */
     121        femmodels->AddObject((Object*)femmodel);
     122
     123}
     124
     125
     126#undef __FUNCT__
     127#define __FUNCT__ "Model::FindParam"
     128
     129int   Model::FindParam(int* pparameter,char* parametername){
     130
     131        FemModel* femmodel=NULL;
     132
     133        /*no analysis_type or sub_analysis_type, find the parameter in the first dataset we find: */
     134        if (!femmodels->Size())throw ErrorException(__FUNCT__," no fem models were found!");
     135
     136        /*recover first femmodel: */
     137        femmodel=(FemModel*)femmodels->GetObjectByOffset(0);
     138
     139        if(!femmodel)return 0;
     140
     141        femmodel->FindParam((void*)pparameter,parametername);
     142
     143}
     144int   Model::FindParam(double* pparameter,char* parametername){
     145       
     146        FemModel* femmodel=NULL;
     147
     148        /*no analysis_type or sub_analysis_type, find the parameter in the first dataset we find: */
     149        if (!femmodels->Size())throw ErrorException(__FUNCT__," no fem models were found!");
     150
     151        /*recover first femmodel: */
     152        femmodel=(FemModel*)femmodels->GetObjectByOffset(0);
     153       
     154        if(!femmodel)return 0;
     155       
     156        femmodel->FindParam((void*)pparameter,parametername);
     157
     158
     159}
     160int   Model::FindParam(double** pparameter,char* parametername){
     161       
     162        FemModel* femmodel=NULL;
     163
     164        /*no analysis_type or sub_analysis_type, find the parameter in the first dataset we find: */
     165        if (!femmodels->Size())throw ErrorException(__FUNCT__," no fem models were found!");
     166
     167        /*recover first femmodel: */
     168        femmodel=(FemModel*)femmodels->GetObjectByOffset(0);
     169       
     170        if(!femmodel)return 0;
     171       
     172        femmodel->FindParam((void*)pparameter,parametername);
     173
     174
     175}
     176int   Model::FindParam(char** pparameter,char* parametername){
     177       
     178        FemModel* femmodel=NULL;
     179
     180        /*no analysis_type or sub_analysis_type, find the parameter in the first dataset we find: */
     181        if (!femmodels->Size())throw ErrorException(__FUNCT__," no fem models were found!");
     182
     183        /*recover first femmodel: */
     184        femmodel=(FemModel*)femmodels->GetObjectByOffset(0);
     185       
     186        if(!femmodel)return 0;
     187       
     188        femmodel->FindParam((void*)pparameter,parametername);
     189
     190}
     191
     192int   Model::FindParam(int* pparameter,char* parametername,int analysis_type,int sub_analysis_type){
     193       
     194        FemModel* femmodel=NULL;
     195
     196        /*find the correct formulation: */
     197        femmodel=this->GetFormulation(analysis_type,sub_analysis_type);
     198       
     199        if(!femmodel)return 0;
     200
     201        /*extract our parameter from the found formulation: */
     202        femmodel->FindParam((void*)pparameter,parametername);
     203}
     204
     205int   Model::FindParam(double* pparameter,char* parametername,int analysis_type,int sub_analysis_type){
     206       
     207        FemModel* femmodel=NULL;
     208
     209        /*find the correct formulation: */
     210        femmodel=this->GetFormulation(analysis_type,sub_analysis_type);
     211       
     212        if(!femmodel)return 0;
     213
     214        /*extract our parameter from the found formulation: */
     215        femmodel->FindParam((void*)pparameter,parametername);
     216}
     217
     218
     219int   Model::FindParam(double** pparameter,char* parametername,int analysis_type,int sub_analysis_type){
     220
     221        FemModel* femmodel=NULL;
     222
     223        /*find the correct formulation: */
     224        femmodel=this->GetFormulation(analysis_type,sub_analysis_type);
     225       
     226        if(!femmodel)return 0;
     227
     228        /*extract our parameter from the found formulation: */
     229        femmodel->FindParam((void*)pparameter,parametername);
     230}
     231
     232int   Model::FindParam(char** pparameter,char* parametername,int analysis_type,int sub_analysis_type){
     233
     234        FemModel* femmodel=NULL;
     235       
     236        /*find the correct formulation: */
     237        femmodel=this->GetFormulation(analysis_type,sub_analysis_type);
     238       
     239        if(!femmodel)return 0;
     240
     241        /*extract our parameter from the found formulation: */
     242        femmodel->FindParam((void*)pparameter,parametername);
     243}
     244
     245int   Model::FindParam(int* pparameter,char* parametername,int analysis_type){
     246       
     247        FemModel* femmodel=NULL;
     248
     249        /*find the correct formulation: */
     250        femmodel=this->GetFormulation(analysis_type);
     251       
     252        if(!femmodel)return 0;
     253
     254        /*extract our parameter from the found formulation: */
     255        femmodel->FindParam((void*)pparameter,parametername);
     256}
     257
     258int   Model::FindParam(double* pparameter,char* parametername,int analysis_type){
     259       
     260        FemModel* femmodel=NULL;
     261
     262        /*find the correct formulation: */
     263        femmodel=this->GetFormulation(analysis_type);
     264       
     265        if(!femmodel)return 0;
     266
     267        /*extract our parameter from the found formulation: */
     268        femmodel->FindParam((void*)pparameter,parametername);
     269}
     270
     271
     272int   Model::FindParam(double** pparameter,char* parametername,int analysis_type){
     273
     274        FemModel* femmodel=NULL;
     275
     276        /*find the correct formulation: */
     277        femmodel=this->GetFormulation(analysis_type);
     278       
     279        if(!femmodel)return 0;
     280
     281        /*extract our parameter from the found formulation: */
     282        femmodel->FindParam((void*)pparameter,parametername);
     283}
     284
     285int   Model::FindParam(char** pparameter,char* parametername,int analysis_type){
     286
     287        FemModel* femmodel=NULL;
     288       
     289        /*find the correct formulation: */
     290        femmodel=this->GetFormulation(analysis_type);
     291       
     292        if(!femmodel)return 0;
     293
     294        /*extract our parameter from the found formulation: */
     295        femmodel->FindParam((void*)pparameter,parametername);
     296}       
     297
     298#undef __FUNCT__
     299#define __FUNCT__ "Model::GetFormulation"
     300
     301FemModel* Model::GetFormulation(int analysis_type,int sub_analysis_type){
     302       
     303        int i;
     304        FemModel* femmodel=NULL;
     305        int femmodel_analysis_type;
     306        int femmodel_sub_analysis_type;
     307        int found=0;
     308       
     309        if (!femmodels->Size())throw ErrorException(__FUNCT__," no fem models were found!");
     310
     311        /*find femmodel with correct analysis_type and sub_analysis_type: */
     312        for(i=0;i<femmodels->Size();i++){
     313
     314                femmodel=(FemModel*)femmodels->GetObjectByOffset(i);
     315                femmodel->FindParam((void*)&femmodel_analysis_type,"analysis_type");
     316                femmodel->FindParam((void*)&femmodel_sub_analysis_type,"sub_analysis_type");
     317
     318                if((analysis_type==femmodel_analysis_type) && (sub_analysis_type==femmodel_sub_analysis_type)){
     319                        found=1;
     320                        break;
     321                }
     322        }
     323
     324        if(!found)return NULL;
     325        else return femmodel;
     326}
     327               
     328#undef __FUNCT__
     329#define __FUNCT__ "Model::GetFormulation"
     330
     331FemModel* Model::GetFormulation(int analysis_type){
     332       
     333        int i;
     334        FemModel* femmodel=NULL;
     335        int femmodel_analysis_type;
     336        int femmodel_sub_analysis_type;
     337        int found=0;
     338       
     339        if (!femmodels->Size())throw ErrorException(__FUNCT__," no fem models were found!");
     340
     341        /*find femmodel with correct analysis_type and sub_analysis_type: */
     342        for(i=0;i<femmodels->Size();i++){
     343
     344                femmodel=(FemModel*)femmodels->GetObjectByOffset(i);
     345                femmodel->FindParam((void*)&femmodel_analysis_type,"analysis_type");
     346
     347                if((analysis_type==femmodel_analysis_type)){
     348                        found=1;
     349                        break;
     350                }
     351        }
     352
     353        if(!found)return NULL;
     354        else return femmodel;
     355}
     356               
     357
     358FemModel* Model::GetActiveFormulation(){return active;}
     359               
     360
     361void* Model::SetActiveFormulation(FemModel* femmodel){
    87362        active=femmodel;
    88363}
     364

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

    r1843 r1881  
    66#define _MODEL_H_
    77
     8#include "../include/types.h"
     9
    810struct FemModel;
     11class DataSet;
     12
    913class Model{
    1014
    1115        private:
    1216
    13                 /*femmodels for each formulation:*/
    14                 FemModel* diagnostichorizontal;
    15                 FemModel* diagnosticvertical;
    16                 FemModel* diagnosticstokes;
    17                 FemModel* diagnostichutter;
    18                 FemModel* slope;
    19                 FemModel* prognostic;
    20                 FemModel* thermal;
    21                 FemModel* melting;
     17                /*femmodels for each formulation: dynamic, can have as many*/
     18                DataSet* femmodels;
    2219               
    23                 /*active one: */
     20                /*active femmodel: points to a FemModel in the femmodels dataset*/
    2421                FemModel* active;
    2522
    … …  
    3128                void  Echo();
    3229                void  DeepEcho();
    33                 FemModel* DiagnosticHorizontal(void);
    34                 FemModel* DiagnosticVertical(void);
    35                 FemModel* DiagnosticStokes(void);
    36                 FemModel* DiagnosticHutter(void);
    37                 FemModel* Slope(void);
    38                 FemModel* Prognostic(void);
    39                 FemModel* Thermal(void);
    40                 FemModel* Melting(void);
    41                 FemModel* Active(void);
    42                 void      SetActive(FemModel* femmodel);
     30
     31                void  AddFormulation(ConstDataHandle MODEL, int analysis_type,int sub_analysis_type);
     32
     33                /*all overloaded forms of the FindParam routine: */
     34                int   FindParam(int* pparameter,char* parametername);
     35                int   FindParam(double* pparameter,char* parametername);
     36                int   FindParam(double** pparameter,char* parametername);
     37                int   FindParam(char** pparameter,char* parametername);
     38
     39                int   FindParam(int* pparameter,char* parametername,int analysis_type,int sub_analysis_type);
     40                int   FindParam(double* pparameter,char* parametername,int analysis_type,int sub_analysis_type);
     41                int   FindParam(double** pparameter,char* parametername,int analysis_type,int sub_analysis_type);
     42                int   FindParam(char** pparameter,char* parametername,int analysis_type,int sub_analysis_type);
     43
     44                int   FindParam(int* pparameter,char* parametername,int analysis_type);
     45                int   FindParam(double* pparameter,char* parametername,int analysis_type);
     46                int   FindParam(double** pparameter,char* parametername,int analysis_type);
     47                int   FindParam(char** pparameter,char* parametername,int analysis_type);
     48
     49                FemModel* GetFormulation(int analysis_type,int sub_analysis_type);
     50                FemModel* GetFormulation(int analysis_type);
     51
     52                FemModel* GetActiveFormulation();
     53                void* SetActiveFormulation(FemModel* femmodel);
    4354
    4455};

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

    r1843 r1881  
    2424#else
    2525
    26 #include "./FemModel.h"
    2726#include "./ParameterInputs.h"
    2827class ParameterInputs;

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

    r1843 r1881  
    268268        nodesin=(DataSet*)pnodesin;
    269269        materialsin=(DataSet*)pmaterialsin;
    270        
     270
    271271        /*Link this load with its nodes: */
    272272        ResolvePointers((Object**)nodes,node_ids,node_offsets,MAX_RIFTFRONT_GRIDS,nodesin);

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

    r1854 r1881  
    5252        int dof3[1]={3};
    5353
     54        /*first recover parameters common to all solutions:*/
     55        model->FindParam(&debug,"debug");
     56        model->FindParam(&dim,"dim");
     57        model->FindParam(&ishutter,"ishutter");
     58        model->FindParam(&ismacayealpattyn,"ismacayealpattyn");
     59        model->FindParam(&numberofnodes,"numberofnodes");
     60        model->FindParam(&isstokes,"isstokes");
     61        model->FindParam(&stokesreconditioning,"stokesreconditioning");
     62
    5463        /*recover fem models: */
    55         fem_dh=model->DiagnosticHorizontal();
    56         fem_dv=model->DiagnosticVertical();
    57         fem_ds=model->DiagnosticStokes();
    58         fem_dhu=model->DiagnosticHutter();
    59         fem_sl=model->Slope();
    60 
    61         //first recover parameters common to all solutions
    62         fem_dh->parameters->FindParam((void*)&debug,"debug");
    63         fem_dh->parameters->FindParam((void*)&dim,"dim");
    64         fem_dhu->parameters->FindParam((void*)&ishutter,"ishutter");
    65         fem_dh->parameters->FindParam((void*)&ismacayealpattyn,"ismacayealpattyn");
    66         fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    67         fem_ds->parameters->FindParam((void*)&isstokes,"isstokes");
    68         fem_ds->parameters->FindParam((void*)&stokesreconditioning,"stokesreconditioning");
     64        fem_dh=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     65        fem_dv=model->GetFormulation(DiagnosticAnalysisEnum(),VertAnalysisEnum());
     66        fem_ds=model->GetFormulation(DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     67        fem_dhu=model->GetFormulation(DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     68        fem_sl=model->GetFormulation(SlopeComputeAnalysisEnum());
    6969
    7070        //specific parameters for specific models
    71         fem_dh->parameters->FindParam((void*)&numberofdofspernode_dh,"numberofdofspernode");
    72         fem_sl->parameters->FindParam((void*)&numberofdofspernode_sl,"numberofdofspernode");
    73         fem_ds->parameters->FindParam((void*)&numberofdofspernode_ds,"numberofdofspernode");
     71        fem_dh->FindParam((void*)&numberofdofspernode_dh,"numberofdofspernode");
     72        fem_sl->FindParam((void*)&numberofdofspernode_sl,"numberofdofspernode");
     73        fem_ds->FindParam((void*)&numberofdofspernode_ds,"numberofdofspernode");
    7474
    7575        /*if no Stokes, assign output and return*/
    7676        if (!isstokes){
    77                 model->SetActive(fem_dh);
     77                model->SetActiveFormulation(fem_dh);
    7878                return;
    7979        }
    … …  
    146146
    147147        /*Assign output*/
    148         model->SetActive(fem_ds);
     148        model->SetActiveFormulation(fem_ds);
    149149}

  • issm/trunk/src/c/parallel/ControlTemporaryResults.cpp

    r1819 r1881  
    3333
    3434        /*recover fem models: */
    35         fem_dh=model->DiagnosticHorizontal();
     35        fem_dh=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum());
    3636
    3737        /*Recover parameters used throughout the solution:*/
    38         fem_dh->parameters->FindParam((void*)&control_type,"control_type");
    39         fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    40         fem_dh->parameters->FindParam((void*)&outputfilename,"outputfilename");
     38        model->FindParam(&control_type,"control_type");
     39        model->FindParam(&numberofnodes,"numberofnodes");
     40        model->FindParam(&outputfilename,"outputfilename");
    4141        gsize=fem_dh->nodes->NumberOfDofs();
    4242

  • issm/trunk/src/c/parallel/CreateFemModel.cpp

    r1822 r1881  
    3131        IoModel* model=NULL;
    3232       
    33 
    3433        _printf_("   fill model with matlab workspace data\n");
    3534        IoModelInit(&model,MODEL);
    … …  
    7170
    7271        _printf_("   free ressources:\n");
     72        PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok1\n");
     73        PetscSynchronizedFlush(MPI_COMM_WORLD);
     74
    7375        DeleteIoModel(&model);
     76        PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok2\n");
     77        PetscSynchronizedFlush(MPI_COMM_WORLD);
     78
    7479
    7580        /*Assign output pointers:*/
     81PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok2a\n");
     82PetscSynchronizedFlush(MPI_COMM_WORLD);
    7683        femmodel->elements=elements;
     84PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok2b\n");
     85PetscSynchronizedFlush(MPI_COMM_WORLD);
    7786        femmodel->nodes=nodes;
     87PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok2c\n");
     88PetscSynchronizedFlush(MPI_COMM_WORLD);
    7889        femmodel->constraints=constraints;
    79         femmodel->loads=loads;
     90PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok3\n");
     91PetscSynchronizedFlush(MPI_COMM_WORLD);
     92femmodel->loads=loads;
    8093        femmodel->materials=materials;
    8194        femmodel->parameters=parameters;
    8295        femmodel->partition=partition;
    8396        femmodel->tpartition=tpartition;
    84         femmodel->yg=yg;
     97PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok4\n");
     98PetscSynchronizedFlush(MPI_COMM_WORLD);
     99femmodel->yg=yg;
    85100        femmodel->Rmg=Rmg;
    86101        femmodel->Gmn=Gmn;
    87102        femmodel->nodesets=nodesets;
    88         femmodel->ys=ys;
     103PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok5\n");
     104PetscSynchronizedFlush(MPI_COMM_WORLD);
     105femmodel->ys=ys;
    89106        femmodel->ys0=ys0;
     107PetscSynchronizedPrintf(MPI_COMM_WORLD,"ok6\n");
     108PetscSynchronizedFlush(MPI_COMM_WORLD);
     109
     110
    90111}

  • issm/trunk/src/c/parallel/ProcessResults.cpp

    r1870 r1881  
    101101        /*Initialize new results: */
    102102        newresults=new DataSet(ResultsEnum());
    103                
     103       
     104        /*some flags needed: */
     105        model->FindParam(&dim,"dim");
     106        model->FindParam(&ishutter,"ishutter");
     107        model->FindParam(&isstokes,"isstokes");
     108        model->FindParam(&ismacayealpattyn,"ismacayealpattyn");
     109
    104110        /*Recover femmodels first: */
    105         if(analysis_type==DiagnosticAnalysisEnum()){
    106                 fem_dh=model->DiagnosticHorizontal();
    107                 fem_dv=model->DiagnosticVertical();
    108                 fem_ds=model->DiagnosticStokes();
    109                 fem_dhu=model->DiagnosticHutter();
    110                 fem_sl=model->Slope();
    111        
    112                 /*some flags needed: */
    113                 fem_dh->parameters->FindParam((void*)&dim,"dim");
    114                 fem_dhu->parameters->FindParam((void*)&ishutter,"ishutter");
    115                 fem_ds->parameters->FindParam((void*)&isstokes,"isstokes");
    116                 fem_dh->parameters->FindParam((void*)&ismacayealpattyn,"ismacayealpattyn");
    117         }
    118         if(analysis_type==SteadystateAnalysisEnum()){
    119                 fem_dh=model->DiagnosticHorizontal();
    120                 fem_dv=model->DiagnosticVertical();
    121                 fem_ds=model->DiagnosticStokes();
    122                 fem_dhu=model->DiagnosticHutter();
    123                 fem_sl=model->Slope();
    124                 fem_t=model->Thermal();
    125        
    126                 /*some flags needed: */
    127                 fem_dh->parameters->FindParam((void*)&dim,"dim");
    128                 fem_dhu->parameters->FindParam((void*)&ishutter,"ishutter");
    129                 fem_ds->parameters->FindParam((void*)&isstokes,"isstokes");
    130                 fem_dh->parameters->FindParam((void*)&ismacayealpattyn,"ismacayealpattyn");
    131         }
    132 
    133         if(analysis_type==TransientAnalysisEnum()){
    134                 fem_dh=model->DiagnosticHorizontal();
    135                 fem_dv=model->DiagnosticVertical();
    136                 fem_ds=model->DiagnosticStokes();
    137                 fem_dhu=model->DiagnosticHutter();
    138                 fem_sl=model->Slope();
    139                 fem_p=model->Prognostic();
    140        
    141                 /*some flags needed: */
    142                 fem_dh->parameters->FindParam((void*)&dim,"dim");
    143                 fem_dhu->parameters->FindParam((void*)&ishutter,"ishutter");
    144                 fem_ds->parameters->FindParam((void*)&isstokes,"isstokes");
    145                 fem_dh->parameters->FindParam((void*)&ismacayealpattyn,"ismacayealpattyn");
    146 
    147                 if (dim==3){
    148                         fem_t=model->Thermal();
    149                 }
    150         }
    151        
    152         if(analysis_type==PrognosticAnalysisEnum()){
    153                 fem_p=model->Prognostic();
    154         }
    155 
    156         if(analysis_type==ThermalAnalysisEnum()){
    157                 fem_t=model->Thermal();
    158         }
    159 
    160         if(analysis_type==ControlAnalysisEnum()){
    161                 fem_dh=model->DiagnosticHorizontal();
    162                 fem_dv=model->DiagnosticVertical();
    163                 fem_ds=model->DiagnosticStokes();
    164                 fem_dhu=model->DiagnosticHutter();
    165                 fem_sl=model->Slope();
    166                 fem_p=model->Prognostic();
    167                 fem_c=model->DiagnosticHorizontal(); //load param_g
    168 
    169                 /*some flags needed: */
    170                 fem_dh->parameters->FindParam((void*)&dim,"dim");
    171                 fem_dh->parameters->FindParam((void*)&ishutter,"ishutter");
    172                 fem_dh->parameters->FindParam((void*)&isstokes,"isstokes");
    173                 fem_dh->parameters->FindParam((void*)&ismacayealpattyn,"ismacayealpattyn");
    174         }
     111        fem_dh=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     112        fem_c=fem_dh;
     113        fem_dv=model->GetFormulation(DiagnosticAnalysisEnum(),VertAnalysisEnum());
     114        fem_ds=model->GetFormulation(DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     115        fem_dhu=model->GetFormulation(DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     116        fem_sl=model->GetFormulation(SlopeComputeAnalysisEnum());
     117        fem_p=model->GetFormulation(PrognosticAnalysisEnum());
     118        fem_t=model->GetFormulation(ThermalAnalysisEnum());
    175119
    176120        for(n=0;n<results->Size();n++){

  • issm/trunk/src/c/parallel/control.cpp

    r1824 r1881  
    4141        Param*  param=NULL;
    4242        int      count;
     43        DataSet* parameters=NULL;
    4344
    4445        MODULEBOOT();
    … …  
    5960        lockname=argv[4];
    6061
     62        /*Initialize model structure: */
     63        model=new Model();
     64
    6165        /*Open handle to data on disk: */
    6266        fid=pfopen(inputfilename,"rb");
    … …  
    6670
    6771        _printf_("read and create finite element model:\n");
    68         _printf_("\n   reading control horiz model data:\n");
    69         CreateFemModel(model->DiagnosticHorizontal(),fid,ControlAnalysisEnum(),HorizAnalysisEnum());
    70         _printf_("\n   reading control vert model data:\n");
    71         CreateFemModel(model->DiagnosticVertical(),fid,ControlAnalysisEnum(),VertAnalysisEnum());
    72         _printf_("\n   reading control stokes model data:\n");
    73         CreateFemModel(model->DiagnosticStokes(),fid,ControlAnalysisEnum(),StokesAnalysisEnum());
    74         _printf_("\n   reading control hutter model data:\n");
    75         CreateFemModel(model->DiagnosticHutter(),fid,ControlAnalysisEnum(),HutterAnalysisEnum());
     72        _printf_("\n   reading diagnostic horiz model data:\n");
     73        model->AddFormulation(fid,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     74
     75        _printf_("\n   reading diagnostic vert model data:\n");
     76        model->AddFormulation(fid,DiagnosticAnalysisEnum(),VertAnalysisEnum());
     77       
     78        _printf_("\n   reading diagnostic stokes model data:\n");
     79        model->AddFormulation(fid,DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     80       
     81        _printf_("\n   reading diagnostic hutter model data:\n");
     82        model->AddFormulation(fid,DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     83       
    7684        _printf_("\n   reading surface and bed slope computation model data:\n");
    77         CreateFemModel(model->Slope(),fid,SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
     85        model->AddFormulation(fid,SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
    7886
    7987        _printf_("initialize inputs:\n");
    80         model->DiagnosticHorizontal()->parameters->FindParam((void*)&u_g_initial,"u_g");
    81         model->DiagnosticHorizontal()->parameters->FindParam((void*)&u_g_obs,"u_g_obs");
    82         model->DiagnosticHorizontal()->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
     88        model->FindParam(&u_g_initial,"u_g",DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     89        model->FindParam(&u_g_obs,"u_g_obs",DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     90        model->FindParam(&numberofnodes,"numberofnodes");
    8391
    8492        inputs=new ParameterInputs;
    … …  
    8694        inputs->Add("velocity_obs",u_g_obs,2,numberofnodes);
    8795       
    88 
    89         /*erase velocities: */
    90         param=(Param*)model->DiagnosticHorizontal()->parameters->FindParamObject("u_g");
    91         model->DiagnosticHorizontal()->parameters->DeleteObject((Object*)param);
    92 
    93         param=(Param*)model->DiagnosticHorizontal()->parameters->FindParamObject("u_g_obs");
    94         model->DiagnosticHorizontal()->parameters->DeleteObject((Object*)param);
    95 
    9696        _printf_("initialize results:\n");
    9797        results=new DataSet(ResultsEnum());
    9898
    9999        //Add output file name to parameters of femmodels[0]
    100         count=model->DiagnosticHorizontal()->parameters->Size()+1;
     100        parameters=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum())->get_parameters();
     101        count=parameters->Size()+1;
    101102        param= new Param(count,"outputfilename",STRING);
    102103        param->SetString(outputfilename);
    103         model->DiagnosticHorizontal()->parameters->AddObject(param);
     104        parameters->AddObject(param);
    104105
    105106        /*are we running the solution sequence, or a qmu wrapper around it? : */
    106         model->DiagnosticHorizontal()->parameters->FindParam((void*)&qmu_analysis,"qmu_analysis");
     107        model->FindParam(&qmu_analysis,"qmu_analysis");
    107108       
    108109        if(!qmu_analysis){
    … …  
    128129        results->AddObject(result);
    129130       
    130         model->DiagnosticHorizontal()->parameters->FindParam((void*)&control_type,"control_type");
     131        model->FindParam(&control_type,"control_type");
    131132        result=new Result(results->Size()+1,0,1,"control_type",control_type);
    132133        results->AddObject(result);
    … …  
    139140
    140141        _printf_("write lock file:\n");
    141         model->DiagnosticHorizontal()->parameters->FindParam((void*)&waitonlock,"waitonlock");
     142        model->FindParam(&waitonlock,"waitonlock");
    142143        if (waitonlock){
    143144                WriteLockFile(lockname);

  • issm/trunk/src/c/parallel/control_core.cpp

    r1828 r1881  
    5050        /*Process models*/
    5151        ControlInitialization(model,inputs);
    52         fem_model=model->Active();
     52        fem_model=model->GetActiveFormulation();
    5353
    5454        /*Recover parameters used throughout the solution:*/
    55         fem_model->parameters->FindParam((void*)&nsteps,"nsteps");
    56         fem_model->parameters->FindParam((void*)&control_type,"control_type");
    57         fem_model->parameters->FindParam((void*)&fit,"fit");
    58         fem_model->parameters->FindParam((void*)&optscal,"optscal");
    59         fem_model->parameters->FindParam((void*)&maxiter,"maxiter");
    60         fem_model->parameters->FindParam((void*)&tolx,"tolx");
    61         fem_model->parameters->FindParam((void*)&mincontrolconstraint,"mincontrolconstraint");
    62         fem_model->parameters->FindParam((void*)&maxcontrolconstraint,"maxcontrolconstraint");
    63         fem_model->parameters->FindParam((void*)&param_g,"param_g");
    64         fem_model->parameters->FindParam((void*)&analysis_type,"analysis_type");
    65         fem_model->parameters->FindParam((void*)&sub_analysis_type,"sub_analysis_type");
    66         fem_model->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
     55        model->FindParam(&nsteps,"nsteps");
     56        model->FindParam(&control_type,"control_type");
     57        model->FindParam(&fit,"fit");
     58        model->FindParam(&optscal,"optscal");
     59        model->FindParam(&maxiter,"maxiter");
     60        model->FindParam(&tolx,"tolx");
     61        model->FindParam(&mincontrolconstraint,"mincontrolconstraint");
     62        model->FindParam(&maxcontrolconstraint,"maxcontrolconstraint");
     63        model->FindParam(&param_g,"param_g");
     64        model->FindParam(&analysis_type,"analysis_type");
     65        model->FindParam(&sub_analysis_type,"sub_analysis_type");
     66        model->FindParam(&numberofnodes,"numberofnodes");
    6767        gsize=fem_model->nodes->NumberOfDofs();
    6868

  • issm/trunk/src/c/parallel/convergence.cpp

    r1711 r1881  
    99#include "../issm.h"
    1010
    11 int convergence(int* pconverged, Mat Kff,Vec pf,Vec uf,Vec old_uf,DataSet* parameters){
     11void convergence(int* pconverged, Mat Kff,Vec pf,Vec uf,Vec old_uf,DataSet* parameters){
    1212
    1313        /*output*/

  • issm/trunk/src/c/parallel/diagnostic.cpp

    r1826 r1881  
    6464        _printf_("read and create finite element model:\n");
    6565        _printf_("\n   reading diagnostic horiz model data:\n");
    66         CreateFemModel(model->DiagnosticHorizontal(),fid,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     66        model->AddFormulation(fid,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     67
    6768        _printf_("\n   reading diagnostic vert model data:\n");
    68         CreateFemModel(model->DiagnosticVertical(),fid,DiagnosticAnalysisEnum(),VertAnalysisEnum());
     69        model->AddFormulation(fid,DiagnosticAnalysisEnum(),VertAnalysisEnum());
     70       
    6971        _printf_("\n   reading diagnostic stokes model data:\n");
    70         CreateFemModel(model->DiagnosticStokes(),fid,DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     72        model->AddFormulation(fid,DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     73       
    7174        _printf_("\n   reading diagnostic hutter model data:\n");
    72         CreateFemModel(model->DiagnosticHutter(),fid,DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     75        model->AddFormulation(fid,DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     76       
    7377        _printf_("\n   reading surface and bed slope computation model data:\n");
    74         CreateFemModel(model->Slope(),fid,SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
     78        model->AddFormulation(fid,SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
    7579
    7680        _printf_("initialize inputs:\n");
    77         model->DiagnosticHorizontal()->parameters->FindParam((void*)&u_g_initial,"u_g");
    78         model->DiagnosticHorizontal()->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
     81        model->FindParam(&u_g_initial,"u_g",DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     82        model->FindParam(&numberofnodes,"numberofnodes");
    7983
    8084        inputs=new ParameterInputs;
    8185        inputs->Add("velocity",u_g_initial,3,numberofnodes);
    8286       
    83         /*erase velocities: */
    84         param=(Param*)model->DiagnosticHorizontal()->parameters->FindParamObject("u_g");
    85         model->DiagnosticHorizontal()->parameters->DeleteObject((Object*)param);
    86 
    8787        _printf_("initialize results:\n");
    8888        results=new DataSet(ResultsEnum());
    8989
    9090        /*are we running the solution sequence, or a qmu wrapper around it? : */
    91         model->DiagnosticHorizontal()->parameters->FindParam((void*)&qmu_analysis,"qmu_analysis");
     91        model->FindParam(&qmu_analysis,"qmu_analysis");
     92       
    9293        if(!qmu_analysis){
    9394
    … …  
    119120
    120121        _printf_("write lock file:\n");
    121         model->DiagnosticHorizontal()->parameters->FindParam((void*)&waitonlock,"waitonlock");
     122        model->FindParam(&waitonlock,"waitonlock");
    122123        if (waitonlock){
    123124                WriteLockFile(lockname);
    … …  
    127128        PetscFinalize();
    128129       
    129 
    130130        /*end module: */
    131131        MODULEEND();
    132132       
    133         /*Free ressources */
    134         xfree((void**)&u_g_initial);
    135 
    136133        return 0; //unix success return;
    137134}

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

    r1831 r1881  
    5757        int dof3[1]={3};
    5858
    59         /*recover fem models: */
    60         fem_dh=model->DiagnosticHorizontal();
    61         fem_dv=model->DiagnosticVertical();
    62         fem_ds=model->DiagnosticStokes();
    63         fem_dhu=model->DiagnosticHutter();
    64         fem_sl=model->Slope();
    6559
    6660        //first recover parameters common to all solutions
    67         fem_dh->parameters->FindParam((void*)&debug,"debug");
    68         fem_dh->parameters->FindParam((void*)&dim,"dim");
    69         fem_dhu->parameters->FindParam((void*)&ishutter,"ishutter");
    70         fem_dh->parameters->FindParam((void*)&ismacayealpattyn,"ismacayealpattyn");
    71         fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    72         fem_ds->parameters->FindParam((void*)&isstokes,"isstokes");
    73         fem_ds->parameters->FindParam((void*)&stokesreconditioning,"stokesreconditioning");
    74         fem_dh->parameters->FindParam((void*)&numrifts,"numrifts");
     61        model->FindParam(&debug,"debug");
     62        model->FindParam(&dim,"dim");
     63        model->FindParam(&ishutter,"ishutter");
     64        model->FindParam(&ismacayealpattyn,"ismacayealpattyn");
     65        model->FindParam(&numberofnodes,"numberofnodes");
     66        model->FindParam(&isstokes,"isstokes");
     67        model->FindParam(&stokesreconditioning,"stokesreconditioning");
     68        model->FindParam(&numrifts,"numrifts");
     69
     70        /*recover fem models: */
     71        fem_dh=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     72        fem_dv=model->GetFormulation(DiagnosticAnalysisEnum(),VertAnalysisEnum());
     73        fem_ds=model->GetFormulation(DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     74        fem_dhu=model->GetFormulation(DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     75        fem_sl=model->GetFormulation(SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
    7576
    7677        //specific parameters for specific models
    77         fem_dh->parameters->FindParam((void*)&numberofdofspernode_dh,"numberofdofspernode");
    78         fem_sl->parameters->FindParam((void*)&numberofdofspernode_sl,"numberofdofspernode");
    79         fem_ds->parameters->FindParam((void*)&numberofdofspernode_ds,"numberofdofspernode");
     78        fem_dh->FindParam((void*)&numberofdofspernode_dh,"numberofdofspernode");
     79        fem_sl->FindParam((void*)&numberofdofspernode_sl,"numberofdofspernode");
     80        fem_ds->FindParam((void*)&numberofdofspernode_ds,"numberofdofspernode");
    8081
    8182        if(ishutter){
    … …  
    126127
    127128                if(debug)_printf_("%s\n"," extruding horizontal velocities...");
    128                 VecDuplicatePatch(&ug_horiz,ug); FieldExtrudex( ug_horiz,fem_dh->elements,fem_dh->nodes, fem_dh->loads,fem_dh-> materials,"velocity",1);
     129                VecDuplicatePatch(&ug_horiz,ug); FieldExtrudex( ug_horiz,fem_dh->elements,fem_dh->nodes, fem_dh->loads,fem_dh->materials,"velocity",1);
    129130
    130131                if(debug)_printf_("%s\n"," computing vertical velocities...");

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

    r1813 r1881  
    4242        /*Recover parameters: */
    4343        kflag=1; pflag=1;
    44         fem->parameters->FindParam((void*)&connectivity,"connectivity");
    45         fem->parameters->FindParam((void*)&numberofdofspernode,"numberofdofspernode");
    46         fem->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    47         fem->parameters->FindParam((void*)&solver_string,"solverstring");
     44        fem->FindParam((void*)&connectivity,"connectivity");
     45        fem->FindParam((void*)&numberofdofspernode,"numberofdofspernode");
     46        fem->FindParam((void*)&numberofnodes,"numberofnodes");
     47        fem->FindParam((void*)&solver_string,"solverstring");
     48
    4849
    4950        /*Were loads requested as output? : */

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

    r1861 r1881  
    5454        /*Recover active model: */
    5555        model=optargs->model;
    56         femmodel=model->Active();
     56        femmodel=model->GetActiveFormulation();
    5757
    5858        /*Recover parameters: */

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

    r1861 r1881  
    88#include "../objects/objects.h"
    99#include "../io/io.h"
     10
     11struct OptArgs;
     12class ParameterInputs;
     13class FemModel;
    1014
    1115Vec GradJCompute(ParameterInputs* inputs,FemModel* femmodel);

  • issm/trunk/src/c/parallel/prognostic.cpp

    r1827 r1881  
    6262        lockname=argv[4];
    6363
     64        /*Initialize model structure: */
     65        model=new Model();
     66
    6467        /*Open handle to data on disk: */
    6568        fid=pfopen(inputfilename,"rb");
    … …  
    6972
    7073        _printf_("read and create finite element model:\n");
    71         CreateFemModel(model->Prognostic(),fid,PrognosticAnalysisEnum(),NoneAnalysisEnum());
     74        model->AddFormulation(fid,PrognosticAnalysisEnum(),NoneAnalysisEnum());
    7275
    7376        //retrieve parameters used to fill inputs
    74         model->Prognostic()->parameters->FindParam((void*)&u_g_serial,"u_g");
    75         model->Prognostic()->parameters->FindParam((void*)&h_g_initial,"h_g");
    76         model->Prognostic()->parameters->FindParam((void*)&melting_g,"m_g");
    77         model->Prognostic()->parameters->FindParam((void*)&accumulation_g,"a_g");
    78         model->Prognostic()->parameters->FindParam((void*)&dt,"dt");
    79         model->Prognostic()->parameters->FindParam((void*)&yts,"yts");
    80         model->Prognostic()->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
     77        model->FindParam(&u_g_serial,"u_g",PrognosticAnalysisEnum());
     78        model->FindParam(&h_g_initial,"h_g",PrognosticAnalysisEnum());
     79        model->FindParam(&melting_g,"m_g",PrognosticAnalysisEnum());
     80        model->FindParam(&accumulation_g,"a_g",PrognosticAnalysisEnum());
     81        model->FindParam(&dt,"dt");
     82        model->FindParam(&yts,"yts");
     83        model->FindParam(&numberofnodes,"numberofnodes");
     84        model->FindParam(&qmu_analysis,"qmu_analysis");
     85        model->FindParam(&waitonlock,"waitonlock");
    8186
    8287        _printf_("initialize inputs:\n");
    … …  
    9297
    9398        /*are we running the solutoin sequence, or a qmu wrapper around it? : */
    94         model->Prognostic()->parameters->FindParam((void*)&qmu_analysis,"qmu_analysis");
    9599        if(!qmu_analysis){
    96100
    … …  
    123127
    124128        _printf_("write lock file:\n");
    125         model->Prognostic()->parameters->FindParam((void*)&waitonlock,"waitonlock");
    126129        if (waitonlock){
    127130                WriteLockFile(lockname);

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

    r1811 r1881  
    3737
    3838        /*recover fem model: */
    39         fem_p=model->Prognostic();
     39        fem_p=model->GetFormulation(PrognosticAnalysisEnum());
    4040
    4141        //first recover parameters common to all solutions
    42         fem_p->parameters->FindParam((void*)&debug,"debug");
    43         fem_p->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    44         fem_p->parameters->FindParam((void*)&numberofdofspernode,"numberofdofspernode");
     42        model->FindParam(&debug,"debug");
     43        model->FindParam(&numberofnodes,"numberofnodes");
     44        model->FindParam(&numberofdofspernode,"numberofdofspernode");
    4545
    4646        _printf_("depth averaging velocity...\n");

  • issm/trunk/src/c/parallel/steadystate.cpp

    r1870 r1881  
    5858        lockname=argv[4];
    5959
     60        /*Initialize model structure: */
     61        model=new Model();
     62
    6063        /*Open handle to data on disk: */
    6164        fid=pfopen(inputfilename,"rb");
    … …  
    6568
    6669        _printf_("read and create finite element model:\n");
     70       
    6771        _printf_("\n   reading diagnostic horiz model data:\n");
    68         CreateFemModel(model->DiagnosticHorizontal(),fid,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     72        model->AddFormulation(fid,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     73
    6974        _printf_("\n   reading diagnostic vert model data:\n");
    70         CreateFemModel(model->DiagnosticVertical(),fid,DiagnosticAnalysisEnum(),VertAnalysisEnum());
     75        model->AddFormulation(fid,DiagnosticAnalysisEnum(),VertAnalysisEnum());
     76       
    7177        _printf_("\n   reading diagnostic stokes model data:\n");
    72         CreateFemModel(model->DiagnosticStokes(),fid,DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     78        model->AddFormulation(fid,DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     79       
    7380        _printf_("\n   reading diagnostic hutter model data:\n");
    74         CreateFemModel(model->DiagnosticHutter(),fid,DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     81        model->AddFormulation(fid,DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     82       
    7583        _printf_("\n   reading surface and bed slope computation model data:\n");
    76         CreateFemModel(model->Slope(),fid,SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
     84        model->AddFormulation(fid,SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
     85
    7786        _printf_("\n   read and create thermal finite element model:\n");
    78         CreateFemModel(model->Thermal(),fid,ThermalAnalysisEnum(),SteadyAnalysisEnum());
     87        model->AddFormulation(fid,ThermalAnalysisEnum(),SteadyAnalysisEnum());
    7988        _printf_("\n   read and create melting finite element model:\n");
    80         CreateFemModel(model->Melting(),fid,MeltingAnalysisEnum(),SteadyAnalysisEnum());
     89        model->AddFormulation(fid,MeltingAnalysisEnum(),SteadyAnalysisEnum());
    8190
    8291        _printf_("initialize inputs:\n");
    83         model->DiagnosticHorizontal()->parameters->FindParam((void*)&u_g_initial,"u_g");
    84         model->DiagnosticHorizontal()->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    85         model->Thermal()->parameters->FindParam((void*)&dt,"dt");
    86         model->Thermal()->parameters->FindParam((void*)&p_g_initial,"p_g");
     92       
     93        model->FindParam(&u_g_initial,"u_g",DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     94        model->FindParam(&p_g_initial,"p_g",ThermalAnalysisEnum());
     95        model->FindParam(&dt,"dt");
     96        model->FindParam(&numberofnodes,"numberofnodes");
     97        model->FindParam(&waitonlock,"waitonlock");
     98        model->FindParam(&qmu_analysis,"qmu_analysis");
     99
    87100
    88101        inputs=new ParameterInputs;
    … …  
    91104        inputs->Add("dt",dt);
    92105       
    93         /*erase velocities: */
    94         param=(Param*)model->DiagnosticHorizontal()->parameters->FindParamObject("u_g");
    95         model->DiagnosticHorizontal()->parameters->DeleteObject((Object*)param);
    96 
    97106        _printf_("initialize results:\n");
    98107        results=new DataSet(ResultsEnum());
    99108
    100109        /*are we running the solution sequence, or a qmu wrapper around it? : */
    101         model->DiagnosticHorizontal()->parameters->FindParam((void*)&qmu_analysis,"qmu_analysis");
    102110        if(!qmu_analysis){
    103111
    … …  
    129137
    130138        _printf_("write lock file:\n");
    131         model->DiagnosticHorizontal()->parameters->FindParam((void*)&waitonlock,"waitonlock");
    132139        if (waitonlock){
    133140                WriteLockFile(lockname);

  • issm/trunk/src/c/parallel/steadystate_core.cpp

    r1861 r1881  
    5454
    5555        /*recover fem models: */
    56         fem_dh=model->DiagnosticHorizontal();
    57         fem_dv=model->DiagnosticVertical();
    58         fem_ds=model->DiagnosticStokes();
    59         fem_dhu=model->DiagnosticHutter();
    60         fem_sl=model->Slope();
    61         fem_t=model->Thermal();
    62         fem_m=model->Melting();
     56        fem_dh=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     57        fem_dv=model->GetFormulation(DiagnosticAnalysisEnum(),VertAnalysisEnum());
     58        fem_ds=model->GetFormulation(DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     59        fem_dhu=model->GetFormulation(DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     60        fem_sl=model->GetFormulation(SlopeComputeAnalysisEnum());
     61        fem_t=model->GetFormulation(ThermalAnalysisEnum());
     62        fem_m=model->GetFormulation(MeltingAnalysisEnum());
     63
    6364
    6465        //first recover parameters common to all solutions
    65         fem_dh->parameters->FindParam((void*)&debug,"debug");debug=1;
    66         fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    67         fem_dh->parameters->FindParam((void*)&eps_rel,"eps_rel");
    68         fem_ds->parameters->FindParam((void*)&isstokes,"isstokes");
     66        model->FindParam(&debug,"debug");debug=1;
     67        model->FindParam(&numberofnodes,"numberofnodes");
     68        model->FindParam(&eps_rel,"eps_rel");
     69        model->FindParam(&isstokes,"isstokes");
    6970
    7071        //initialize:

  • issm/trunk/src/c/parallel/thermal.cpp

    r1830 r1881  
    6161        lockname=argv[4];
    6262
     63        /*Initialize model structure: */
     64        model=new Model();
     65
    6366        /*Open handle to data on disk: */
    6467        fid=pfopen(inputfilename,"rb");
    … …  
    6871
    6972        _printf_("read and create thermal finite element model:\n");
    70         CreateFemModel(model->Thermal(),fid,ThermalAnalysisEnum(),0);
     73        model->AddFormulation(fid,ThermalAnalysisEnum(),0);
    7174        _printf_("read and create melting finite element model:\n");
    72         CreateFemModel(model->Melting(),fid,MeltingAnalysisEnum(),0);
     75        model->AddFormulation(fid,MeltingAnalysisEnum(),0);
    7376
    7477        _printf_("initialize inputs:\n");
    75         model->Thermal()->parameters->FindParam((void*)&u_g,"u_g");
    76         model->Thermal()->parameters->FindParam((void*)&p_g,"p_g");
    77         model->Thermal()->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    78         model->Thermal()->parameters->FindParam((void*)&waitonlock,"waitonlock");
    79         model->Thermal()->parameters->FindParam((void*)&dt,"dt");
    80         model->Thermal()->parameters->FindParam((void*)&yts,"yts");
     78        model->FindParam(&u_g,"u_g",ThermalAnalysisEnum(),0);
     79        model->FindParam(&p_g,"p_g",ThermalAnalysisEnum(),0);
     80        model->FindParam(&numberofnodes,"numberofnodes");
     81        model->FindParam(&waitonlock,"waitonlock");
     82        model->FindParam(&dt,"dt");
     83        model->FindParam(&yts,"yts");
     84        model->FindParam(&qmu_analysis,"qmu_analysis");
    8185
    8286        inputs=new ParameterInputs;
    … …  
    8993        results=new DataSet(ResultsEnum());
    9094
    91         //erase velocities and pressure embedded in parameters
    92         param=(Param*)model->Thermal()->parameters->FindParamObject("u_g");
    93         param=(Param*)model->Thermal()->parameters->FindParamObject("velocity");
    94         model->Thermal()->parameters->DeleteObject((Object*)param);
    95         param=(Param*)model->Thermal()->parameters->FindParamObject("p_g");
    96         model->Thermal()->parameters->DeleteObject((Object*)param);
    97         param=(Param*)model->Melting()->parameters->FindParamObject("u_g");
    98         model->Melting()->parameters->DeleteObject((Object*)param);
    99         param=(Param*)model->Melting()->parameters->FindParamObject("p_g");
    100         model->Melting()->parameters->DeleteObject((Object*)param);
    101 
    10295        /*are we running the solutoin sequence, or a qmu wrapper around it? : */
    103         model->Thermal()->parameters->FindParam((void*)&qmu_analysis,"qmu_analysis");
    10496        if(!qmu_analysis){
    10597
    … …  
    131123
    132124        _printf_("write lock file:\n");
    133         model->Thermal()->parameters->FindParam((void*)&waitonlock,"waitonlock");
     125        model->FindParam(&waitonlock,"waitonlock");
    134126
    135127        if (waitonlock){

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

    r1818 r1881  
    4646
    4747        /*recover fem models: */
    48         fem_t=model->Thermal();
    49         fem_m=model->Melting();
     48        fem_t=model->GetFormulation(ThermalAnalysisEnum());
     49        fem_m=model->GetFormulation(MeltingAnalysisEnum());
    5050
    5151        //first recover parameters common to all solutions
    52         fem_t->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    53         fem_t->parameters->FindParam((void*)&sub_analysis_type,"sub_analysis_type");
    54         fem_t->parameters->FindParam((void*)&debug,"debug");
    55         fem_t->parameters->FindParam((void*)&dt,"dt");
    56         fem_t->parameters->FindParam((void*)&ndt,"ndt");
     52        fem_t->FindParam((void*)&numberofnodes,"numberofnodes");
     53        fem_t->FindParam((void*)&sub_analysis_type,"sub_analysis_type");
     54        fem_t->FindParam((void*)&debug,"debug");
     55        fem_t->FindParam((void*)&dt,"dt");
     56        fem_t->FindParam((void*)&ndt,"ndt");
    5757
    5858        if(sub_analysis_type==SteadyAnalysisEnum()){
    … …  
    8484
    8585                //initialize temperature and melting
    86                 fem_t->parameters->FindParam((void*)&t_g_serial,"t_g");
     86                fem_t->FindParam((void*)&t_g_serial,"t_g");
    8787                t_g[0]=SerialToVec(t_g_serial,numberofnodes);
    8888                xfree((void**)&t_g_serial);
    89                 fem_m->parameters->FindParam((void*)&m_g_serial,"m_g");
     89                fem_m->FindParam((void*)&m_g_serial,"m_g");
    9090                m_g[0]=SerialToVec(m_g_serial,numberofnodes);
    9191                xfree((void**)&m_g_serial);
    92 
    93                 //erase temperature and melting embedded in parameters
    94                 param=(Param*)fem_t->parameters->FindParamObject("t_g");
    95                 fem_t->parameters->DeleteObject((Object*)param);
    96                 param=(Param*)fem_m->parameters->FindParamObject("m_g");
    97                 fem_m->parameters->DeleteObject((Object*)param);
    9892
    9993                for(i=0;i<nsteps;i++){

  • issm/trunk/src/c/parallel/transient.cpp

    r1820 r1881  
    6262        lockname=argv[4];
    6363
     64        /*Initialize model structure: */
     65        model=new Model();
     66
    6467        /*Open handle to data on disk: */
    6568        fid=pfopen(inputfilename,"rb");
    … …  
    7073        _printf_("read and create finite element model:\n");
    7174        _printf_("\n   reading diagnostic horiz model data:\n");
    72         CreateFemModel(model->DiagnosticHorizontal(),fid,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     75        model->AddFormulation(fid,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     76
    7377        _printf_("\n   reading diagnostic vert model data:\n");
    74         CreateFemModel(model->DiagnosticVertical(),fid,DiagnosticAnalysisEnum(),VertAnalysisEnum());
     78        model->AddFormulation(fid,DiagnosticAnalysisEnum(),VertAnalysisEnum());
     79       
    7580        _printf_("\n   reading diagnostic stokes model data:\n");
    76         CreateFemModel(model->DiagnosticStokes(),fid,DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     81        model->AddFormulation(fid,DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     82       
    7783        _printf_("\n   reading diagnostic hutter model data:\n");
    78         CreateFemModel(model->DiagnosticHutter(),fid,DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     84        model->AddFormulation(fid,DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     85       
    7986        _printf_("\n   reading surface and bed slope computation model data:\n");
    80         CreateFemModel(model->Slope(),fid,SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
     87        model->AddFormulation(fid,SlopeComputeAnalysisEnum(),NoneAnalysisEnum());
     88
    8189        _printf_("\n   reading prognositc model data:\n");
    82         CreateFemModel(model->Prognostic(),fid,PrognosticAnalysisEnum(),NoneAnalysisEnum());
     90        model->AddFormulation(fid,PrognosticAnalysisEnum(),NoneAnalysisEnum());
    8391       
    8492        /*Do we run in 3d?, in which case we need thermal and melting also:*/
    85         model->DiagnosticHorizontal()->parameters->FindParam((void*)&dim,"dim");
     93        model->FindParam(&dim,"dim");
    8694        if(dim==3){
    8795                _printf_("read and create thermal finite element model:\n");
    88                 CreateFemModel(model->Thermal(),fid,ThermalAnalysisEnum(),TransientAnalysisEnum());
     96                model->AddFormulation(fid,ThermalAnalysisEnum(),TransientAnalysisEnum());
    8997                _printf_("read and create melting finite element model:\n");
    90                 CreateFemModel(model->Melting(),fid,MeltingAnalysisEnum(),TransientAnalysisEnum());
     98                model->AddFormulation(fid,MeltingAnalysisEnum(),TransientAnalysisEnum());
    9199        }
    92100
    93101        _printf_("initialize inputs:\n");
     102       
     103        model->FindParam(&u_g,"u_g",ThermalAnalysisEnum());
     104        model->FindParam(&m_g,"m_g",ThermalAnalysisEnum());
     105        model->FindParam(&a_g,"a_g",ThermalAnalysisEnum());
     106        model->FindParam(&numberofnodes,"numberofnodes");
     107        model->FindParam(&dt,"dt");
     108        model->FindParam(&yts,"yts");
     109        model->FindParam(&waitonlock,"waitonlock");
     110        model->FindParam(&qmu_analysis,"qmu_analysis");
     111
     112
    94113        inputs=new ParameterInputs;
    95         model->Thermal()->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
    96        
    97         model->Thermal()->parameters->FindParam((void*)&u_g,"u_g");
    98114        inputs->Add("velocity",u_g,3,numberofnodes);
    99 
    100         model->Thermal()->parameters->FindParam((void*)&m_g,"m_g");
    101115        inputs->Add("melting",m_g,1,numberofnodes);
    102 
    103         model->Thermal()->parameters->FindParam((void*)&a_g,"a_g");
    104116        inputs->Add("accumulation",a_g,1,numberofnodes);
    105 
    106         model->Thermal()->parameters->FindParam((void*)&dt,"dt");
    107         model->Thermal()->parameters->FindParam((void*)&yts,"yts");
    108117        inputs->Add("dt",dt*yts);
    109118       
    … …  
    112121
    113122        /*are we running the solution sequence, or a qmu wrapper around it? : */
    114         model->Thermal()->parameters->FindParam((void*)&qmu_analysis,"qmu_analysis");
    115123        if(!qmu_analysis){
    116124
    … …  
    141149
    142150        _printf_("write lock file:\n");
    143         model->DiagnosticHorizontal()->parameters->FindParam((void*)&waitonlock,"waitonlock");
    144151        if (waitonlock){
    145152                WriteLockFile(lockname);

  • issm/trunk/src/c/parallel/transient_core.cpp

    r1823 r1881  
    1717        extern int my_rank;
    1818
    19         /*fem models: */
    20         FemModel* fem_p=NULL;
    21 
    2219        int dim=-1;
    2320
    24         fem_p=model->Prognostic();
    25 
    2621        //first recover parameters common to all solutions
    27         fem_p->parameters->FindParam((void*)&dim,"dim");
     22        model->FindParam(&dim,"dim");
    2823
    2924        //branch out

  • issm/trunk/src/c/parallel/transient_core_2d.cpp

    r1817 r1881  
    6464
    6565        /*recover fem models: */
    66         fem_dh=model->DiagnosticHorizontal();
    67         fem_dv=model->DiagnosticVertical();
    68         fem_ds=model->DiagnosticStokes();
    69         fem_dhu=model->DiagnosticHutter();
    70         fem_sl=model->Slope();
    71         fem_p=model->Prognostic();
     66        fem_dh=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     67        fem_dv=model->GetFormulation(DiagnosticAnalysisEnum(),VertAnalysisEnum());
     68        fem_ds=model->GetFormulation(DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     69        fem_dhu=model->GetFormulation(DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     70        fem_sl=model->GetFormulation(SlopeComputeAnalysisEnum());
     71        fem_p=model->GetFormulation(PrognosticAnalysisEnum());
    7272
    7373
    7474        //first recover parameters common to all solutions
    75         fem_dh->parameters->FindParam((void*)&debug,"debug");
    76         fem_dh->parameters->FindParam((void*)&finaltime,"ndt");
    77         fem_dh->parameters->FindParam((void*)&dt,"dt");
    78         fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
     75        model->FindParam(&debug,"debug");
     76        model->FindParam(&finaltime,"ndt");
     77        model->FindParam(&dt,"dt");
     78        model->FindParam(&numberofnodes,"numberofnodes");
    7979
    8080        /*initialize: */

  • issm/trunk/src/c/parallel/transient_core_3d.cpp

    r1817 r1881  
    7070
    7171        /*recover fem models: */
    72         fem_dh=model->DiagnosticHorizontal();
    73         fem_dv=model->DiagnosticVertical();
    74         fem_ds=model->DiagnosticStokes();
    75         fem_dhu=model->DiagnosticHutter();
    76         fem_sl=model->Slope();
    77         fem_p=model->Prognostic();
    78         fem_t=model->Thermal();
    79         fem_m=model->Melting();
     72        fem_dh=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     73        fem_dv=model->GetFormulation(DiagnosticAnalysisEnum(),VertAnalysisEnum());
     74        fem_ds=model->GetFormulation(DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     75        fem_dhu=model->GetFormulation(DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     76        fem_sl=model->GetFormulation(SlopeComputeAnalysisEnum());
     77        fem_p=model->GetFormulation(PrognosticAnalysisEnum());
     78        fem_t=model->GetFormulation(ThermalAnalysisEnum());
     79        fem_m=model->GetFormulation(MeltingAnalysisEnum());
    8080
    8181
    8282        //first recover parameters common to all solutions
    83         fem_dh->parameters->FindParam((void*)&debug,"debug");
    84         fem_dh->parameters->FindParam((void*)&finaltime,"ndt");
    85         fem_dh->parameters->FindParam((void*)&dt,"dt");
    86         fem_dh->parameters->FindParam((void*)&numberofnodes,"numberofnodes");
     83        model->FindParam(&debug,"debug");
     84        model->FindParam(&finaltime,"ndt");
     85        model->FindParam(&dt,"dt");
     86        model->FindParam(&numberofnodes,"numberofnodes");
    8787
    8888        /*initialize: */
Note: See TracChangeset for help on using the changeset viewer.