Changeset 4453


Ignore:
Timestamp:
07/07/10 17:35:32 (15 years ago)
Author:
Eric.Larour
Message:

Fixed some bugs in DakotaResponses and InputUpdateFromDakota modules.
Took out noerr variable in many of the modules.

Location:
issm/trunk/src
Files:
58 edited

Legend:

Unmodified
Added
Removed

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

    r4439 r4453  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void InputUpdateFromDakotax(FemModel* femmodel, double* variables,char** variables_descriptors,int numvariables){
     11void  InputUpdateFromDakotax(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials*  materials,Parameters* parameters,double* variables,char* *variables_descriptors,int numvariables){
    1212
    1313        int     verbose;
    … …  
    1717
    1818        /*retrieve parameters: */
    19         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    20         femmodel->parameters->FindParam(&qmu_npart,QmuNPartEnum);
    21         femmodel->parameters->FindParam(&qmu_part,&dummy,QmuPartEnum);
     19        parameters->FindParam(&verbose,VerboseEnum);
     20        parameters->FindParam(&qmu_npart,QmuNPartEnum);
     21        parameters->FindParam(&qmu_part,&dummy,QmuPartEnum);
    2222
    2323        ISSMERROR(" not supported yet!");

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

    r4236 r4453  
    99#include "../../Container/Container.h"
    1010
    11 void InputUpdateFromDakotax(FemModel* femmodel,double* variables,char** variables_descriptors,int numvariables);
     11void  InputUpdateFromDakotax(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials*  materials,Parameters* parameters,double* variables,char* *variables_descriptors,int numvariables);
    1212
    1313#endif  /* _INPUTUPDATEFROMDAKOTAXX_H */

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

    r4439 r4453  
    6161
    6262        /*Modify core inputs in objects contained in femmodel, to reflect the dakota variables inputs: */
    63         InputUpdateFromDakotax(femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters,variables,variables_descriptors,numvariables);
     63        InputUpdateFromDakotax(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,variables,variables_descriptors,numvariables);
    6464
    6565        /*Run the core solution sequence: */
    6666        if(verbose)_printf_("%s%s%s\n","Starting ",EnumAsString(solution_type)," core:");
    67         SolutionConfiguration(NULL,NULL,&solutioncore); solution_core(femmodel);
     67        SolutionConfiguration(NULL,NULL,&solutioncore,solution_type); solutioncore(femmodel);
    6868
    6969        /*compute responses: */
    7070        if(verbose)_printf_("compute dakota responses:\n");
    71         DakotaResponsesx(responses,femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters,responses_descriptors,numresponses,);
     71        DakotaResponsesx(responses,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,responses_descriptors,numresponses);
    7272
    7373        /*Free ressources:*/

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

    r4168 r4453  
    8282#include "./GetVectorFromInputsx/GetVectorFromInputsx.h"
    8383#include "./InputConvergencex/InputConvergencex.h"
     84#include "./DakotaResponsesx/DakotaResponsesx.h"
    8485
    8586#endif

  • issm/trunk/src/mex/AverageFilter/AverageFilter.cpp

    r2775 r4453  
    1717{
    1818
    19         int i,j,noerr;
     19        int i,j;
    2020
    2121        /* required input: */

  • issm/trunk/src/mex/Bamg/Bamg.cpp

    r3579 r4453  
    1111
    1212        /*diverse: */
    13         int   noerr=1;
    1413        int   i;
    1514        int   lines,cols;

  • issm/trunk/src/mex/BuildNodeSets/BuildNodeSets.cpp

    r4211 r4453  
    77
    88void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    9 
    10         /*diverse: */
    11         int   noerr=1;
    129
    1310        /*input datasets: */

  • issm/trunk/src/mex/ComputeBasalStress/ComputeBasalStress.cpp

    r4404 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/ComputePressure/ComputePressure.cpp

    r4404 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/ConfigureObjects/ConfigureObjects.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/ControlOptimization/ControlOptimization.cpp

    r3841 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/CostFunction/CostFunction.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/DakotaResponses/DakotaResponses.cpp

    r4449 r4453  
    1 /*\file InputUpdateFromDakota.c
    2 *\brief: update inputs using dakota input variables
     1/*\file DakotaResponses.c
     2*\brief: compute dakota responses after a run
    33*/
    44
    5 #include "./InputUpdateFromDakota.h"
     5#include "./DakotaResponses.h"
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    88
    9         /*diverse: */
    10         int   noerr=1;
     9        int i;
    1110
    1211        /*input datasets: */
    … …  
    2221        int         numresponses;
    2322        mxArray*    pfield=NULL;
     23        int         stringlength;
    2424
    2525        /*Boot module: */
    … …  
    2727
    2828        /*checks on arguments on the matlab side: */
    29         CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputUpdateFromDakotaUsage);
     29        CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&DakotaResponsesUsage);
    3030
    3131        /*Input datasets: */
    … …  
    7575}
    7676
    77 void InputUpdateFromDakotaUsage(void)
     77void DakotaResponsesUsage(void)
    7878{
    7979        _printf_("\n");
    80         _printf_("   usage: [elements loads] = %s(elements,nodes,vertices,loads,materials,parameters,variables,variables_descriptors);\n",__FUNCT__);
     80        _printf_("   usage: [responses] = %s(elements,nodes,vertices,loads,materials,parameters,responses_descritpors,numresponses);\n",__FUNCT__);
    8181        _printf_("\n");
    8282}

  • issm/trunk/src/mex/Du/Du.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Echo/Echo.cpp

    r2333 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/FieldAverageOntoVertices/FieldAverageOntoVertices.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/FieldDepthAverage/FieldDepthAverage.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/GetSolutionFromInputs/GetSolutionFromInputs.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Gradj/Gradj.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int         noerr        = 1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/HoleFiller/HoleFiller.cpp

    r2333 r4453  
    1717{
    1818
    19         int i,j,noerr;
     19        int i,j;
    2020
    2121        /* required input: */

  • issm/trunk/src/mex/InputControlConstrain/InputControlConstrain.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9 /*diverse: */
    10 int         noerr             = 1;
    118
    129/*input datasets: */

  • issm/trunk/src/mex/InputDepthAverage/InputDepthAverage.cpp

    r4218 r4453  
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    88
    9 /*diverse: */
    10 int         noerr             = 1;
     9        /*input datasets: */
     10        Elements*   elements          = NULL;
     11        Nodes       *nodes             = NULL;
     12        Vertices    *vertices          = NULL;
     13        Loads     *loads             = NULL;
     14        Materials   *materials         = NULL;
     15        Parameters *parameters        = NULL;
     16        int         enum_type;
     17        int         average_enum_type;
    1118
    12 /*input datasets: */
    13 Elements*   elements          = NULL;
    14 Nodes       *nodes             = NULL;
    15 Vertices    *vertices          = NULL;
    16 Loads     *loads             = NULL;
    17 Materials   *materials         = NULL;
    18 Parameters *parameters        = NULL;
    19 int         enum_type;
    20 int         average_enum_type;
     19        /*Boot module: */
     20        MODULEBOOT();
    2121
    22 /*Boot module: */
    23 MODULEBOOT();
     22        /*checks on arguments on the matlab side: */
     23        CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputDepthAverageUsage);
    2424
    25 /*checks on arguments on the matlab side: */
    26 CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputDepthAverageUsage);
     25        /*Input datasets: */
     26        FetchData((DataSet**)&elements,ELEMENTSIN);
     27        FetchData((DataSet**)&nodes,NODESIN);
     28        FetchData((DataSet**)&vertices,VERTICESIN);
     29        FetchData((DataSet**)&loads,LOADSIN);
     30        FetchData((DataSet**)&materials,MATERIALSIN);
     31        FetchParams(&parameters,PARAMETERSIN);
     32        FetchData(&enum_type,ENUMTYPE);
     33        FetchData(&average_enum_type,AVERAGEENUMTYPE);
    2734
    28 /*Input datasets: */
    29 FetchData((DataSet**)&elements,ELEMENTSIN);
    30 FetchData((DataSet**)&nodes,NODESIN);
    31 FetchData((DataSet**)&vertices,VERTICESIN);
    32 FetchData((DataSet**)&loads,LOADSIN);
    33 FetchData((DataSet**)&materials,MATERIALSIN);
    34 FetchParams(&parameters,PARAMETERSIN);
    35 FetchData(&enum_type,ENUMTYPE);
    36 FetchData(&average_enum_type,AVERAGEENUMTYPE);
     35        /*call "x" code layer*/
     36        InputDepthAveragex(elements,nodes,vertices,loads, materials,parameters,enum_type,average_enum_type);
    3737
    38 /*call "x" code layer*/
    39 InputDepthAveragex(elements,nodes,vertices,loads, materials,parameters,enum_type,average_enum_type);
     38        /*write output datasets: */
     39        WriteData(ELEMENTS,elements);
     40        WriteData(NODES,nodes);
     41        WriteData(VERTICES,vertices);
     42        WriteData(LOADS,loads);
     43        WriteData(MATERIALS,materials);
     44        WriteParams(PARAMETERS,parameters);
    4045
    41 /*write output datasets: */
    42 WriteData(ELEMENTS,elements);
    43 WriteData(NODES,nodes);
    44 WriteData(VERTICES,vertices);
    45 WriteData(LOADS,loads);
    46 WriteData(MATERIALS,materials);
    47 WriteParams(PARAMETERS,parameters);
     46        /*Free ressources: */
     47        delete elements;
     48        delete nodes;
     49        delete vertices;
     50        delete loads;
     51        delete materials;
     52        delete parameters;
    4853
    49 /*Free ressources: */
    50 delete elements;
    51 delete nodes;
    52 delete vertices;
    53 delete loads;
    54 delete materials;
    55 delete parameters;
    56 
    57 /*end module: */
    58 MODULEEND();
     54        /*end module: */
     55        MODULEEND();
    5956}
    6057

  • issm/trunk/src/mex/InputDuplicate/InputDuplicate.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/InputExtrude/InputExtrude.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/InputScale/InputScale.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/InputToResult/InputToResult.cpp

    r4228 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/InputUpdateFromConstant/InputUpdateFromConstant.cpp

    r4218 r4453  
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    88
    9 /*diverse: */
    10 int   noerr=1;
     9        /*input datasets: */
     10        Elements* elements=NULL;
     11        Nodes* nodes=NULL;
     12        Vertices* vertices=NULL;
     13        Loads* loads=NULL;
     14        Materials* materials=NULL;
     15        Parameters* parameters=NULL;
     16        double   constant;
     17        int      name;
    1118
    12 /*input datasets: */
    13 Elements* elements=NULL;
    14 Nodes* nodes=NULL;
    15 Vertices* vertices=NULL;
    16 Loads* loads=NULL;
    17 Materials* materials=NULL;
    18 Parameters* parameters=NULL;
    19 double   constant;
    20 int      name;
     19        /*Boot module: */
     20        MODULEBOOT();
    2121
    22 /*Boot module: */
    23 MODULEBOOT();
     22        /*checks on arguments on the matlab side: */
     23        CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputUpdateFromConstantUsage);
    2424
    25 /*checks on arguments on the matlab side: */
    26 CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputUpdateFromConstantUsage);
     25        /*Input datasets: */
     26        FetchData((DataSet**)&elements,ELEMENTSIN);
     27        FetchData((DataSet**)&nodes,NODESIN);
     28        FetchData((DataSet**)&vertices,VERTICESIN);
     29        FetchData((DataSet**)&loads,LOADSIN);
     30        FetchData((DataSet**)&materials,MATERIALSIN);
     31        FetchParams(&parameters,PARAMETERSIN);
     32        FetchData(&constant,CONSTANT);
     33        FetchData(&name,NAME);
    2734
    28 /*Input datasets: */
    29 FetchData((DataSet**)&elements,ELEMENTSIN);
    30 FetchData((DataSet**)&nodes,NODESIN);
    31 FetchData((DataSet**)&vertices,VERTICESIN);
    32 FetchData((DataSet**)&loads,LOADSIN);
    33 FetchData((DataSet**)&materials,MATERIALSIN);
    34 FetchParams(&parameters,PARAMETERSIN);
    35 FetchData(&constant,CONSTANT);
    36 FetchData(&name,NAME);
     35        /*!Generate internal degree of freedom numbers: */
     36        InputUpdateFromConstantx(elements,nodes,vertices,loads, materials,parameters,constant,name);
    3737
    38 /*!Generate internal degree of freedom numbers: */
    39 InputUpdateFromConstantx(elements,nodes,vertices,loads, materials,parameters,constant,name);
     38        /*write output datasets: */
     39        WriteData(ELEMENTS,elements);
     40        WriteData(LOADS,loads);
    4041
    41 /*write output datasets: */
    42 WriteData(ELEMENTS,elements);
    43 WriteData(LOADS,loads);
     42        /*Free ressources: */
     43        delete elements;
     44        delete nodes;
     45        delete vertices;
     46        delete loads;
     47        delete materials;
     48        delete parameters;
    4449
    45 /*Free ressources: */
    46 delete elements;
    47 delete nodes;
    48 delete vertices;
    49 delete loads;
    50 delete materials;
    51 delete parameters;
    52 
    53 /*end module: */
    54 MODULEEND();
     50        /*end module: */
     51        MODULEEND();
    5552}
    5653

  • issm/trunk/src/mex/InputUpdateFromDakota/InputUpdateFromDakota.cpp

    r4449 r4453  
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    88
    9         /*diverse: */
    10         int   noerr=1;
     9        int i;
    1110
    1211        /*input datasets: */
    … …  
    2019        char**      variables_descriptors=NULL;
    2120        char*       string=NULL;
     21        int         stringlength;
    2222        int         numvariables;
    2323        mxArray*    pfield=NULL;
    … …  
    3838       
    3939        /*dakota input: */
    40         FetchData(&variables,&numvariables,VARIABLESIN);
     40        FetchData(&variables,&numvariables,VARIABLES);
    4141
    4242        variables_descriptors=(char**)xmalloc(numvariables*sizeof(char*));

  • issm/trunk/src/mex/InputUpdateFromSolution/InputUpdateFromSolution.cpp

    r4218 r4453  
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    88
    9 /*diverse: */
    10 int   noerr=1;
     9        /*input datasets: */
     10        Elements* elements=NULL;
     11        Nodes* nodes=NULL;
     12        Vertices* vertices=NULL;
     13        Loads* loads=NULL;
     14        Materials* materials=NULL;
     15        Parameters* parameters=NULL;
     16        Vec      solution=NULL;
    1117
    12 /*input datasets: */
    13 Elements* elements=NULL;
    14 Nodes* nodes=NULL;
    15 Vertices* vertices=NULL;
    16 Loads* loads=NULL;
    17 Materials* materials=NULL;
    18 Parameters* parameters=NULL;
    19 Vec      solution=NULL;
     18        /*Boot module: */
     19        MODULEBOOT();
    2020
    21 /*Boot module: */
    22 MODULEBOOT();
     21        /*checks on arguments on the matlab side: */
     22        CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputUpdateFromSolutionUsage);
    2323
    24 /*checks on arguments on the matlab side: */
    25 CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputUpdateFromSolutionUsage);
     24        /*Input datasets: */
     25        FetchData((DataSet**)&elements,ELEMENTSIN);
     26        FetchData((DataSet**)&nodes,NODESIN);
     27        FetchData((DataSet**)&vertices,VERTICESIN);
     28        FetchData((DataSet**)&loads,LOADSIN);
     29        FetchData((DataSet**)&materials,MATERIALSIN);
     30        FetchParams(&parameters,PARAMETERSIN);
     31        FetchData(&solution,SOLUTION);
    2632
    27 /*Input datasets: */
    28 FetchData((DataSet**)&elements,ELEMENTSIN);
    29 FetchData((DataSet**)&nodes,NODESIN);
    30 FetchData((DataSet**)&vertices,VERTICESIN);
    31 FetchData((DataSet**)&loads,LOADSIN);
    32 FetchData((DataSet**)&materials,MATERIALSIN);
    33 FetchParams(&parameters,PARAMETERSIN);
    34 FetchData(&solution,SOLUTION);
     33        /*!Generate internal degree of freedom numbers: */
     34        InputUpdateFromSolutionx(elements,nodes,vertices,loads, materials,parameters,solution);
    3535
    36 /*!Generate internal degree of freedom numbers: */
    37 InputUpdateFromSolutionx(elements,nodes,vertices,loads, materials,parameters,solution);
     36        /*write output datasets: */
     37        WriteData(ELEMENTS,elements);
    3838
    39 /*write output datasets: */
    40 WriteData(ELEMENTS,elements);
     39        /*Free ressources: */
     40        delete elements;
     41        delete nodes;
     42        delete vertices;
     43        delete loads;
     44        delete materials;
     45        delete parameters;
     46        VecFree(&solution);
    4147
    42 /*Free ressources: */
    43 delete elements;
    44 delete nodes;
    45 delete vertices;
    46 delete loads;
    47 delete materials;
    48 delete parameters;
    49 VecFree(&solution);
    50 
    51 /*end module: */
    52 MODULEEND();
     48        /*end module: */
     49        MODULEEND();
    5350}
    5451

  • issm/trunk/src/mex/InputUpdateFromVector/InputUpdateFromVector.cpp

    r4218 r4453  
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    88
    9 /*diverse: */
    10 int   noerr=1;
     9        /*input datasets: */
     10        Elements* elements=NULL;
     11        Nodes* nodes=NULL;
     12        Vertices* vertices=NULL;
     13        Loads* loads=NULL;
     14        Materials* materials=NULL;
     15        Parameters* parameters=NULL;
     16        double*  vector=NULL;
     17        int      dummy;
     18        int      NameEnum;
     19        int      TypeEnum;
    1120
    12 /*input datasets: */
    13 Elements* elements=NULL;
    14 Nodes* nodes=NULL;
    15 Vertices* vertices=NULL;
    16 Loads* loads=NULL;
    17 Materials* materials=NULL;
    18 Parameters* parameters=NULL;
    19 double*  vector=NULL;
    20 int      dummy;
    21 int      NameEnum;
    22 int      TypeEnum;
     21        /*Boot module: */
     22        MODULEBOOT();
    2323
    24 /*Boot module: */
    25 MODULEBOOT();
     24        /*checks on arguments on the matlab side: */
     25        CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputUpdateFromVectorUsage);
    2626
    27 /*checks on arguments on the matlab side: */
    28 CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&InputUpdateFromVectorUsage);
     27        /*Input datasets: */
     28        FetchData((DataSet**)&elements,ELEMENTSIN);
     29        FetchData((DataSet**)&nodes,NODESIN);
     30        FetchData((DataSet**)&vertices,VERTICESIN);
     31        FetchData((DataSet**)&loads,LOADSIN);
     32        FetchData((DataSet**)&materials,MATERIALSIN);
     33        FetchParams(&parameters,PARAMETERSIN);
     34        FetchData(&vector,&dummy,VECTOR);
     35        FetchData(&NameEnum,NAME);
     36        FetchData(&TypeEnum,TYPE);
    2937
    30 /*Input datasets: */
    31 FetchData((DataSet**)&elements,ELEMENTSIN);
    32 FetchData((DataSet**)&nodes,NODESIN);
    33 FetchData((DataSet**)&vertices,VERTICESIN);
    34 FetchData((DataSet**)&loads,LOADSIN);
    35 FetchData((DataSet**)&materials,MATERIALSIN);
    36 FetchParams(&parameters,PARAMETERSIN);
    37 FetchData(&vector,&dummy,VECTOR);
    38 FetchData(&NameEnum,NAME);
    39 FetchData(&TypeEnum,TYPE);
     38        /*Check that type is one of Constant, Vertex or Element: */
     39        if ((TypeEnum!=ConstantEnum) && (TypeEnum!=VertexEnum) && (TypeEnum!=ElementEnum)){
     40                ISSMERROR("%s%s%s\n","Type of input can only be a constant, a vertex or an element vector.  Right now, you input a ",EnumAsString(TypeEnum)," type data for input update");
     41        }
    4042
    41 /*Check that type is one of Constant, Vertex or Element: */
    42 if ((TypeEnum!=ConstantEnum) && (TypeEnum!=VertexEnum) && (TypeEnum!=ElementEnum)){
    43         ISSMERROR("%s%s%s\n","Type of input can only be a constant, a vertex or an element vector.  Right now, you input a ",EnumAsString(TypeEnum)," type data for input update");
    44 }
     43        /*!Generate internal degree of freedom numbers: */
     44        InputUpdateFromVectorx(elements,nodes,vertices,loads, materials,parameters,vector,NameEnum,TypeEnum);
    4545
    46 /*!Generate internal degree of freedom numbers: */
    47 InputUpdateFromVectorx(elements,nodes,vertices,loads, materials,parameters,vector,NameEnum,TypeEnum);
     46        /*write output datasets: */
     47        WriteData(ELEMENTS,elements);
     48        WriteData(NODES,nodes);
     49        WriteData(VERTICES,vertices);
     50        WriteData(LOADS,loads);
     51        WriteData(MATERIALS,materials);
     52        WriteParams(PARAMETERS,parameters);
    4853
    49 /*write output datasets: */
    50 WriteData(ELEMENTS,elements);
    51 WriteData(NODES,nodes);
    52 WriteData(VERTICES,vertices);
    53 WriteData(LOADS,loads);
    54 WriteData(MATERIALS,materials);
    55 WriteParams(PARAMETERS,parameters);
     54        /*Free ressources: */
     55        delete elements;
     56        delete nodes;
     57        delete vertices;
     58        delete loads;
     59        delete materials;
     60        delete parameters;
     61        xfree((void**)&vector);
    5662
    57 /*Free ressources: */
    58 delete elements;
    59 delete nodes;
    60 delete vertices;
    61 delete loads;
    62 delete materials;
    63 delete parameters;
    64 xfree((void**)&vector);
    65 
    66 /*end module: */
    67 MODULEEND();
     63        /*end module: */
     64        MODULEEND();
    6865}
    6966

  • issm/trunk/src/mex/MassFlux/MassFlux.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Mergesolutionfromftog/Mergesolutionfromftog.cpp

    r3960 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Misfit/Misfit.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/MpcNodes/MpcNodes.cpp

    r4217 r4453  
    77
    88void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    9 
    10         /*diverse: */
    11         int   noerr=1;
    129
    1310        /*input datasets: */

  • issm/trunk/src/mex/NormalizeConstraints/NormalizeConstraints.cpp

    r2333 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Orth/Orth.cpp

    r2333 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/OutputResults/OutputResults.cpp

    r4306 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/OutputRifts/OutputRifts.cpp

    r4214 r4453  
    88
    99        /*diverse: */
    10         int   noerr=1;
    1110        int   numrifts;
    1211

  • issm/trunk/src/mex/ParameterOutput/ParameterOutput.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/PenaltyConstraints/PenaltyConstraints.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/PenaltySystemMatrices/PenaltySystemMatrices.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*output: */

  • issm/trunk/src/mex/PropagateFlagsFromConnectivity/PropagateFlagsFromConnectivity.cpp

    r2888 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    11 
    128
    139        /*input/output datasets: */

  • issm/trunk/src/mex/Qmu/Qmu.cpp

    r4211 r4453  
    1212
    1313void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    14 
    15         /*diverse: */
    16         int         noerr      = 1;
    1714
    1815        /*input datasets: */

  • issm/trunk/src/mex/Reduceloadfromgtof/Reduceloadfromgtof.cpp

    r3960 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Reducematrixfromgtof/Reducematrixfromgtof.cpp

    r2333 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Reducevectorgtof/Reducevectorgtof.cpp

    r2333 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Reducevectorgtos/Reducevectorgtos.cpp

    r3960 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Solver/Solver.cpp

    r3715 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/SpcNodes/SpcNodes.cpp

    r4217 r4453  
    77
    88void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    9 
    10         /*diverse: */
    11         int   noerr=1;
    129
    1310        /*input datasets: */

  • issm/trunk/src/mex/SystemMatrices/SystemMatrices.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */

  • issm/trunk/src/mex/Test/Test.cpp.grid

    r2994 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*Boot module: */

  • issm/trunk/src/mex/TriMesh/TriMesh.cpp

    r3755 r4453  
    4848        double** riftsgridsy=NULL;
    4949
    50         /* error handling: */
    51         int             noerr=1;       
    52  
    5350        /* Triangle structures: */
    5451        struct triangulateio in,out;
    … …  
    9996       
    10097        /*Start reading the domain outline file: */
    101         noerr=DomainOutlineRead(&nprof,&profngrids,&pprofx,&pprofy,domainname);
    102         if(!noerr){
     98        if(!DomainOutlineRead(&nprof,&profngrids,&pprofx,&pprofy,domainname)){
    10399                printf("%s%s%s\n",__FUNCT__," error message reading domain outline ",domainname);
    104100                mexErrMsgTxt(" ");
    … …  
    107103        /*Read rifts file if present: */
    108104        if(riftname){
    109                 noerr=DomainOutlineRead(&numrifts,&riftsnumgrids,&riftsgridsx,&riftsgridsy,riftname);
    110                 if(!noerr){
     105                if(!DomainOutlineRead(&numrifts,&riftsnumgrids,&riftsgridsx,&riftsgridsy,riftname)){
    111106                        printf("%s%s%s\n",__FUNCT__," error message reading rifts outline ",riftname);
    112107                        mexErrMsgTxt(" ");
    … …  
    268263
    269264        /*Associate elements with segments: */
    270         noerr=AssociateSegmentToElement(&segments,out.numberofsegments,index,out.numberoftriangles);
     265        AssociateSegmentToElement(&segments,out.numberofsegments,index,out.numberoftriangles);
    271266
    272267        /*Order segments so that their normals point outside the domain: */

  • issm/trunk/src/mex/TriMeshNoDensity/TriMeshNoDensity.cpp

    r3755 r4453  
    4646        double** riftsgridsy=NULL;
    4747
    48         /* error handling: */
    49         int             noerr=1;       
    50  
    5148        /* Triangle structures: */
    5249        struct triangulateio in,out;
    … …  
    8986       
    9087        /*Start reading the domain outline file: */
    91         noerr=DomainOutlineRead(&nprof,&profngrids,&pprofx,&pprofy,domainname);
    92         if(!noerr){
     88        if(!DomainOutlineRead(&nprof,&profngrids,&pprofx,&pprofy,domainname)){
    9389                printf("%s%s%s\n",__FUNCT__," error message reading domain outline ",domainname);
    9490                mexErrMsgTxt(" ");
    … …  
    9793        /*Read rifts file if present: */
    9894        if(riftname){
    99                 noerr=DomainOutlineRead(&numrifts,&riftsnumgrids,&riftsgridsx,&riftsgridsy,riftname);
    100                 if(!noerr){
     95                if(!DomainOutlineRead(&numrifts,&riftsnumgrids,&riftsgridsx,&riftsgridsy,riftname)){
    10196                        printf("%s%s%s\n",__FUNCT__," error message reading rifts outline ",riftname);
    10297                        mexErrMsgTxt(" ");
    … …  
    259254
    260255        /*Associate elements with segments: */
    261         noerr=AssociateSegmentToElement(&segments,out.numberofsegments,index,out.numberoftriangles);
     256        AssociateSegmentToElement(&segments,out.numberofsegments,index,out.numberoftriangles);
    262257
    263258        /*Order segments so that their normals point outside the domain: */

  • issm/trunk/src/mex/TriMeshProcessRifts/TriMeshProcessRifts.cpp

    r3755 r4453  
    5353        int     numrifts;
    5454
    55         /* error handling: */
    56         int             noerr=1;       
    57  
    5855        /* verify correct usage: */
    5956        if (nlhs==0 && nrhs==0) {
    … …  
    176173
    177174        /*Order segments so that their normals point outside the domain: */
    178         noerr=OrderSegments(&segments_in,num_seg, index_in,nel);
     175        OrderSegments(&segments_in,num_seg, index_in,nel);
    179176
    180177       

  • issm/trunk/src/mex/TriMeshRefine/TriMeshRefine.cpp

    r3755 r4453  
    4343        char*   order=NULL;
    4444
    45         /* error handling: */
    46         int             noerr=1;       
    47  
    4845        /* Triangle structures: */
    4946        struct triangulateio in,out;
    … …  
    276273
    277274        /*Associate elements with segments: */
    278         noerr=AssociateSegmentToElement(&segments,out.numberofsegments,index,out.numberoftriangles);
     275        AssociateSegmentToElement(&segments,out.numberofsegments,index,out.numberoftriangles);
    279276
    280277        /*Order segments so that their normals point outside the domain: */
    281278        if(!strcmp(order,"yes")){
    282                 noerr=OrderSegments(&segments,out.numberofsegments, index,out.numberoftriangles);
     279                OrderSegments(&segments,out.numberofsegments, index,out.numberoftriangles);
    283280        }
    284281       

  • issm/trunk/src/mex/UpdateGeometry/UpdateGeometry.cpp

    r4218 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9 /*diverse: */
    10 int         noerr             = 1;
    118
    129/*input datasets: */

  • issm/trunk/src/mex/UpdateVertexPositions/UpdateVertexPositions.cpp

    r4218 r4453  
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    88
    9 /*diverse: */
    10 int         noerr             = 1;
     9        /*input datasets: */
     10        Elements*   elements          = NULL;
     11        Nodes      *nodes             = NULL;
     12        Vertices    *vertices          = NULL;
     13        Loads     *loads             = NULL;
     14        Materials   *materials         = NULL;
     15        Parameters *parameters        = NULL;
    1116
    12 /*input datasets: */
    13 Elements*   elements          = NULL;
    14 Nodes      *nodes             = NULL;
    15 Vertices    *vertices          = NULL;
    16 Loads     *loads             = NULL;
    17 Materials   *materials         = NULL;
    18 Parameters *parameters        = NULL;
     17        /*Boot module: */
     18        MODULEBOOT();
    1919
    20 /*Boot module: */
    21 MODULEBOOT();
     20        /*checks on arguments on the matlab side: */
     21        CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&UpdateVertexPositionsUsage);
    2222
    23 /*checks on arguments on the matlab side: */
    24 CheckNumMatlabArguments(nlhs,NLHS,nrhs,NRHS,__FUNCT__,&UpdateVertexPositionsUsage);
     23        /*Input datasets: */
     24        FetchData((DataSet**)&elements,ELEMENTSIN);
     25        FetchData((DataSet**)&nodes,NODESIN);
     26        FetchData((DataSet**)&vertices,VERTICESIN);
     27        FetchData((DataSet**)&loads,LOADSIN);
     28        FetchData((DataSet**)&materials,MATERIALSIN);
     29        FetchParams(&parameters,PARAMETERSIN);
    2530
    26 /*Input datasets: */
    27 FetchData((DataSet**)&elements,ELEMENTSIN);
    28 FetchData((DataSet**)&nodes,NODESIN);
    29 FetchData((DataSet**)&vertices,VERTICESIN);
    30 FetchData((DataSet**)&loads,LOADSIN);
    31 FetchData((DataSet**)&materials,MATERIALSIN);
    32 FetchParams(&parameters,PARAMETERSIN);
     31        /*call "x" code layer*/
     32        UpdateVertexPositionsx(elements,nodes,vertices,loads, materials,parameters);
    3333
    34 /*call "x" code layer*/
    35 UpdateVertexPositionsx(elements,nodes,vertices,loads, materials,parameters);
     34        /*write output datasets: */
     35        WriteData(ELEMENTS,elements);
     36        WriteData(NODES,nodes);
     37        WriteData(VERTICES,vertices);
     38        WriteData(LOADS,loads);
     39        WriteData(MATERIALS,materials);
     40        WriteParams(PARAMETERS,parameters);
    3641
    37 /*write output datasets: */
    38 WriteData(ELEMENTS,elements);
    39 WriteData(NODES,nodes);
    40 WriteData(VERTICES,vertices);
    41 WriteData(LOADS,loads);
    42 WriteData(MATERIALS,materials);
    43 WriteParams(PARAMETERS,parameters);
     42        /*Free ressources: */
     43        delete elements;
     44        delete nodes;
     45        delete vertices;
     46        delete loads;
     47        delete materials;
     48        delete parameters;
    4449
    45 /*Free ressources: */
    46 delete elements;
    47 delete nodes;
    48 delete vertices;
    49 delete loads;
    50 delete materials;
    51 delete parameters;
    52 
    53 /*end module: */
    54 MODULEEND();
     50        /*end module: */
     51        MODULEEND();
    5552}
    5653

  • issm/trunk/src/mex/VerticesDof/VerticesDof.cpp

    r4213 r4453  
    66
    77void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
    8 
    9         /*diverse: */
    10         int   noerr=1;
    118
    129        /*input datasets: */
Note: See TracChangeset for help on using the changeset viewer.