Changeset 13699


Ignore:
Timestamp:
10/16/12 12:04:31 (12 years ago)
Author:
Eric.Larour
Message:

CHG: moved Responsex, ThicknessAbsGradientx, RequestedOutputsx and DakotaResponsesx methods
to FemModel.

Location:
issm/trunk-jpl/src/c
Files:
5 deleted
13 edited

Legend:

Unmodified
Added
Removed

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

    r13696 r13699  
    318318                                        ./modules/ConstraintsStatex/ConstraintsStatex.h\
    319319                                        ./modules/ConstraintsStatex/ConstraintsStateLocal.h\
    320                                         ./modules/Responsex/Responsex.h\
    321                                         ./modules/Responsex/Responsex.cpp\
    322                                         ./modules/RequestedOutputsx/RequestedOutputsx.h\
    323                                         ./modules/RequestedOutputsx/RequestedOutputsx.cpp\
    324320                                        ./modules/RequestedDependentsx/RequestedDependentsx.h\
    325321                                        ./modules/RequestedDependentsx/RequestedDependentsx.cpp\
    … …  
    363359                                          ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.h\
    364360                                          ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp\
    365                                           ./modules/DakotaResponsesx/DakotaResponsesx.h\
    366                                           ./modules/DakotaResponsesx/DakotaResponsesx.cpp\
    367361                                          ./modules/InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.h\
    368362                                          ./modules/InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.cpp\
    … …  
    437431                                          ./modules/ThicknessAbsMisfitx/ThicknessAbsMisfitx.h\
    438432                                          ./modules/ThicknessAbsMisfitx/ThicknessAbsMisfitx.cpp\
    439                                           ./modules/CostFunctionx/CostFunctionx.h\
    440                                           ./modules/CostFunctionx/CostFunctionx.cpp\
    441433                                          ./modules/Orthx/Orthx.h\
    442434                                          ./modules/Orthx/Orthx.cpp\
    … …  
    445437                                          ./modules/DragCoefficientAbsGradientx/DragCoefficientAbsGradientx.cpp\
    446438                                          ./modules/DragCoefficientAbsGradientx/DragCoefficientAbsGradientx.h\
    447                                           ./modules/ThicknessAbsGradientx/ThicknessAbsGradientx.cpp\
    448                                           ./modules/ThicknessAbsGradientx/ThicknessAbsGradientx.h\
    449439                                          ./modules/ThicknessAlongGradientx/ThicknessAlongGradientx.cpp\
    450440                                          ./modules/ThicknessAlongGradientx/ThicknessAlongGradientx.h\

  • issm/trunk-jpl/src/c/classes/FemModel.cpp

    r13696 r13699  
    412412}
    413413/*}}}*/
     414void FemModel::Responsex(IssmDouble* responses,const char* response_descriptor,bool process_units,int weight_index){/*{{{*/
     415
     416
     417        int response_descriptor_enum;
     418
     419        response_descriptor_enum=StringToEnumx(response_descriptor);
     420        this->Responsex(responses, response_descriptor_enum, process_units, weight_index);
     421
     422}
     423/*}}}*/
     424void FemModel::Responsex(IssmDouble* responses,int response_descriptor_enum,bool process_units,int weight_index){/*{{{*/
     425
     426
     427        switch (response_descriptor_enum){
     428
     429                #ifdef _HAVE_RESPONSES_
     430                case IceVolumeEnum:              IceVolumex(               responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     431                case MinVelEnum:                 MinVelx(                  responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     432                case MaxVelEnum:                 MaxVelx(                  responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     433                case MinVxEnum:                  MinVxx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     434                case MaxVxEnum:                  MaxVxx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     435                case MaxAbsVxEnum:               MaxAbsVxx(                responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     436                case MinVyEnum:                  MinVyx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     437                case MaxVyEnum:                  MaxVyx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     438                case MaxAbsVyEnum:               MaxAbsVyx(                responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     439                case MinVzEnum:                  MinVzx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     440                case MaxVzEnum:                  MaxVzx(                   responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     441                case MaxAbsVzEnum:               MaxAbsVzx(                responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     442                case MassFluxEnum:               MassFluxx(                responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     443                case SurfaceAbsVelMisfitEnum:    SurfaceAbsVelMisfitx(     responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     444                case SurfaceRelVelMisfitEnum:    SurfaceRelVelMisfitx(     responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     445                case SurfaceLogVelMisfitEnum:    SurfaceLogVelMisfitx(     responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     446                case SurfaceLogVxVyMisfitEnum:   SurfaceLogVxVyMisfitx(    responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     447                case SurfaceAverageVelMisfitEnum:SurfaceAverageVelMisfitx( responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     448                case ThicknessAbsMisfitEnum:     ThicknessAbsMisfitx(      responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     449                case ThicknessAbsGradientEnum:   this->ThicknessAbsGradientx(    responses, process_units,weight_index); break;
     450                case ThicknessAlongGradientEnum:   ThicknessAlongGradientx(    responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     451                case ThicknessAcrossGradientEnum:   ThicknessAcrossGradientx(    responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     452                case TotalSmbEnum:                                      TotalSmbx(                responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
     453                case RheologyBbarAbsGradientEnum:RheologyBbarAbsGradientx( responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     454                case DragCoefficientAbsGradientEnum:DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
     455                case MaterialsRheologyBbarEnum:ElementResponsex(responses, elements,nodes, vertices, loads, materials, parameters,MaterialsRheologyBbarEnum,process_units); break;
     456                case VelEnum:ElementResponsex(responses, elements,nodes, vertices, loads, materials, parameters,VelEnum,process_units); break;
     457                case FrictionCoefficientEnum:NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters,process_units); break;
     458                default: _error_("response descriptor \"" << EnumToStringx(response_descriptor_enum) << "\" not supported yet!"); break;
     459                #else
     460                default: _error_("ISSM was not compiled with responses capabilities, exiting!");
     461                #endif
     462        }
     463
     464}
     465/*}}}*/
     466void FemModel::RequestedOutputsx(int* requested_outputs, int numoutputs){/*{{{*/
     467
     468
     469        int      output_enum;
     470        int      step;
     471        IssmDouble   time;
     472        IssmDouble   output_value;
     473        Element *element      = NULL;
     474
     475        /*Get time and step*/
     476        parameters->FindParam(&step,StepEnum);
     477        parameters->FindParam(&time,TimeEnum);
     478
     479        /*retrieve Inputs*/
     480        if(numoutputs){
     481                for(int i=0;i<numoutputs;i++){
     482                        output_enum=requested_outputs[i];
     483
     484                        switch(output_enum){
     485
     486                                case IceVolumeEnum:
     487                                        Responsex(&output_value,"IceVolume",false,0);
     488                                        results->AddObject(new GenericExternalResult<double>(results->Size()+1,IceVolumeEnum,reCast<IssmPDouble>(output_value),step,time));
     489                                        break;
     490                                case TotalSmbEnum:
     491                                        Responsex(&output_value,"TotalSmb",false,0);
     492                                        results->AddObject(new GenericExternalResult<double>(results->Size()+1,TotalSmbEnum,reCast<IssmPDouble>(output_value),step,time));
     493                                        break;
     494                                case MaxVelEnum:
     495                                        Responsex(&output_value,"MaxVel",false,0);
     496                                        results->AddObject(new GenericExternalResult<double>(results->Size()+1,MaxVelEnum,reCast<IssmPDouble>(output_value),step,time));
     497                                        break;
     498                                default:
     499                                        /*create this output in the element inputs, and then transfer to results:*/
     500                                        for(int j=0;j<elements->Size();j++){
     501                                                element=(Element*)elements->GetObjectByOffset(j);
     502                                                element->RequestedOutput(output_enum,step,time);
     503                                        }
     504                                        break;
     505                        }
     506                }
     507        }
     508}
     509/*}}}*/
     510#ifdef _HAVE_CONTROL_
     511void FemModel::ThicknessAbsGradientx( IssmDouble* pJ, bool process_units, int weight_index){/*{{{*/
     512
     513
     514        /*Intermediary*/
     515        int i;
     516        Element* element=NULL;
     517
     518        /*output: */
     519        IssmDouble J=0;
     520        IssmDouble J_sum;
     521
     522        /*Compute Misfit: */
     523        for (i=0;i<elements->Size();i++){
     524                element=(Element*)elements->GetObjectByOffset(i);
     525                J+=element->ThicknessAbsGradient(process_units,weight_index);
     526        }
     527
     528        /*Sum all J from all cpus of the cluster:*/
     529        #ifdef _HAVE_MPI_
     530        MPI_Reduce (&J,&J_sum,1,MPI_DOUBLE,MPI_SUM,0,IssmComm::GetComm() );
     531        MPI_Bcast(&J_sum,1,MPI_DOUBLE,0,IssmComm::GetComm());
     532        J=J_sum;
     533        #endif
     534
     535        /*Assign output pointers: */
     536        *pJ=J;
     537}
     538/*}}}*/
     539#endif
     540
     541#ifdef  _HAVE_DAKOTA_
     542void FemModel::CostFunctionx(IssmDouble* pJ){/*{{{*/
     543
     544
     545        /*Intermediary*/
     546        int      i;
     547        int      num_responses;
     548        Element *element       = NULL;
     549        int     *responses     = NULL;
     550
     551        /*output: */
     552        IssmDouble J,Jplus;
     553
     554        /*Recover parameters*/
     555        parameters->FindParam(&num_responses,InversionNumCostFunctionsEnum);
     556        parameters->FindParam(&responses,NULL,NULL,StepResponsesEnum);
     557
     558        /*Get response*/
     559        J=0;
     560        for(int i=0;i<num_responses;i++){
     561                this->Responsex(&Jplus,EnumToStringx(responses[i]),false,i); //False means DO NOT process units
     562                J+=Jplus;
     563        }
     564
     565        /*Assign output pointers: */
     566        xDelete<int>(responses);
     567        *pJ=J;
     568}
     569/*}}}*/
     570void FemModel::DakotaResponsesx(double* d_responses,char** responses_descriptors,int numresponsedescriptors,int d_numresponses){/*{{{*/
     571
     572
     573        int        i,j,k;
     574        int        my_rank;
     575        bool       process_units = true;
     576
     577        /*intermediary: */
     578        char   root[50];
     579        int    index;
     580        int    npart;
     581        double femmodel_response;
     582        int    flag;
     583        double *vertex_response   = NULL;
     584        double *qmu_response      = NULL;
     585        double *responses_pointer = NULL;
     586
     587        /*retrieve npart: */
     588        parameters->FindParam(&npart,QmuNumberofpartitionsEnum);
     589        my_rank=IssmComm::GetRank();
     590
     591        /*save the d_responses pointer: */
     592        responses_pointer=d_responses;
     593
     594        //watch out, we have more d_numresponses than numresponsedescriptors, because the responses have been expanded if they were scaled.
     595        //because we don't know the d_responses descriptors (the scaled ones) we can't key off them, so we will key off the responses_descriptors: */
     596
     597        for(i=0;i<numresponsedescriptors;i++){
     598
     599                flag=DescriptorIndex(root,&index,responses_descriptors[i]);
     600
     601                if(flag==ScaledEnum){
     602
     603                        /*this response was scaled. pick up the response from the inputs: */
     604                        GetVectorFromInputsx(&vertex_response,elements,nodes, vertices, loads, materials, parameters, StringToEnumx(root),VertexEnum);
     605
     606                        /*Now, average it onto the partition nodes: */
     607                        AverageOntoPartitionx(&qmu_response,elements,nodes,vertices,loads,materials,parameters,vertex_response);
     608
     609                        /*Copy onto our dakota responses: */
     610                        if(my_rank==0){
     611                                /*plug response: */
     612                                for(i=0;i<npart;i++)responses_pointer[i]=qmu_response[i];
     613
     614                                /*increment response_pointer :*/
     615                                responses_pointer+=npart;
     616                        }
     617
     618                        /*Free ressources:*/
     619                        xDelete<double>(vertex_response);
     620                        xDelete<double>(qmu_response);
     621
     622                }
     623                else if (flag==IndexedEnum){
     624
     625                        /*indexed response: plug index into parameters and call response module: */
     626                        parameters->SetParam(index,IndexEnum);
     627
     628                        this->Responsex(&femmodel_response,root,process_units,0);//0 is the index for weights
     629
     630                        if(my_rank==0){
     631                                /*plug response: */
     632                                responses_pointer[0]=femmodel_response;
     633
     634                                /*increment response_pointer :*/
     635                                responses_pointer++;
     636                        }
     637                }
     638                else if (flag==NodalEnum){
     639                        _error_("nodal response functions not supported yet!");
     640
     641                        /*increment response_pointer :*/
     642                        responses_pointer++;
     643                }
     644                else if (flag==RegularEnum){
     645
     646                        /*perfectly normal response function: */
     647                        this->Responsex(&femmodel_response,root,process_units,0);//0 is the weight index
     648
     649                        if(my_rank==0){
     650                                /*plug response: */
     651                                responses_pointer[0]=femmodel_response;
     652
     653                                /*increment response_pointer :*/
     654                                responses_pointer++;
     655                        }
     656                }
     657                else _error_("flag type " << flag << " not supported yet for response analysis");
     658        }
     659
     660        /*Synthesize echo: {{{*/
     661        if(my_rank==0){
     662                _printString_("   responses: " << d_numresponses << ": ");
     663                for(i=0;i<d_numresponses-1;i++)_printString_(d_responses[i] << "|");
     664                _printString_(d_responses[d_numresponses-1]);
     665                _printLine_("");
     666        }
     667        /*}}}*/
     668
     669}
     670/*}}}*/
     671#endif

  • issm/trunk-jpl/src/c/classes/FemModel.h

    r13696 r13699  
    6363                /*}}}*/
    6464                /*Modules: {{{*/
    65                 int UpdateVertexPositionsx(void);
     65                 #ifdef  _HAVE_DAKOTA_
     66                void CostFunctionx( IssmDouble* pJ);
     67                void DakotaResponsesx(double* d_responses,char** responses_descriptors,int numresponsedescriptors,int d_numresponses);
     68                #endif
     69
     70                void RequestedOutputsx(int* requested_outputs, int numoutputs);
     71                void Responsex(IssmDouble* presponse,int response_descriptor_enum,bool process_units,int weight_index);
     72                void Responsex(IssmDouble* presponse,const char* response_descriptor,bool process_units,int weight_index);
     73                #ifdef _HAVE_CONTROL_
     74                void ThicknessAbsGradientx( IssmDouble* pJ, bool process_units,int weight_index);
     75                #endif
     76                void TimeAdaptx(IssmDouble* pdt);
    6677                void UpdateConstraintsx(void);
    67                 void TimeAdaptx(IssmDouble* pdt);
     78                int  UpdateVertexPositionsx(void);
     79
     80
    6881                /*}}}*/
    6982

  • issm/trunk-jpl/src/c/classes/objects/DependentObject.cpp

    r13622 r13699  
    1616#include "../../Container/Container.h"
    1717#include "../../include/include.h"
    18 #include "../../modules/Responsex/Responsex.h"
    1918
    2019/*DependentObject constructors and destructor*/
    … …  
    9291/*}}}*/
    9392/*FUNCTION DependentObject::Responsex{{{*/
    94 void  DependentObject::Responsex(IssmDouble* poutput_value,Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters){
     93void  DependentObject::Responsex(IssmDouble* poutput_value,FemModel* femmodel){
    9594
    9695        if(this->name==MassFluxEnum){
    9796
    9897                /*to identify the mass flux that will be computed, we need the index of the profile: */
    99                 parameters->SetParam(this->index,IndexEnum);
     98                femmodel->parameters->SetParam(this->index,IndexEnum);
    10099        }
    101100
    102         ::Responsex(poutput_value,elements,nodes,vertices,loads,materials,parameters,this->name,false,0);
     101        femmodel->Responsex(poutput_value,this->name,false,0);
    103102
    104103}

  • issm/trunk-jpl/src/c/classes/objects/DependentObject.h

    r13623 r13699  
    1717class Materials;
    1818class Parameters;
     19class FemModel;
    1920
    2021class DependentObject: public Object{
    … …  
    4142                /*DependentObject methods: */
    4243                int  NumDependents(void);
    43                 void Responsex(IssmDouble* poutput_value,Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters);
     44                void Responsex(IssmDouble* poutput_value,FemModel* femmodel);
    4445
    4546};

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

    r13696 r13699  
    2121#include "./ControlInputSetGradientx/ControlInputSetGradientx.h"
    2222#include "./ControlInputScaleGradientx/ControlInputScaleGradientx.h"
    23 #include "./CostFunctionx/CostFunctionx.h"
    2423#include "./CreateNodalConstraintsx/CreateNodalConstraintsx.h"
    25 #include "./DakotaResponsesx/DakotaResponsesx.h"
    2624#include "./Delta18oParameterizationx/Delta18oParameterizationx.h"
    2725#include "./DragCoefficientAbsGradientx/DragCoefficientAbsGradientx.h"
    … …  
    10098#include "./Reducevectorgtosx/Reducevectorgtosx.h"
    10199#include "./Reducevectorgtofx/Reducevectorgtofx.h"
    102 #include "./RequestedOutputsx/RequestedOutputsx.h"
    103100#include "./RequestedDependentsx/RequestedDependentsx.h"
    104101#include "./ResetConstraintsx/ResetConstraintsx.h"
    105102#include "./ResetCoordinateSystemx/ResetCoordinateSystemx.h"
    106 #include "./Responsex/Responsex.h"
    107103#include "./RheologyBbarAbsGradientx/RheologyBbarAbsGradientx.h"
    108104#include "./Scotchx/Scotchx.h"
    … …  
    117113#include "./TriMeshProcessRiftsx/TriMeshProcessRiftsx.h"
    118114#include "./ThicknessAbsMisfitx/ThicknessAbsMisfitx.h"
    119 #include "./ThicknessAbsGradientx/ThicknessAbsGradientx.h"
    120115#include "./ThicknessAlongGradientx/ThicknessAlongGradientx.h"
    121116#include "./ThicknessAcrossGradientx/ThicknessAcrossGradientx.h"

  • issm/trunk-jpl/src/c/solutions/DakotaSpawnCore.cpp

    r13621 r13699  
    8686        /*compute responses: */
    8787        if(VerboseQmu()) _pprintLine_("compute dakota responses:");
    88         DakotaResponsesx(d_responses,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,responses_descriptors,numresponsedescriptors,d_numresponses);
     88        femmodel->DakotaResponsesx(d_responses,responses_descriptors,numresponsedescriptors,d_numresponses);
    8989
    9090        /*Free ressources:*/

  • issm/trunk-jpl/src/c/solutions/controltao_core.cpp

    r13608 r13699  
    141141
    142142        /*Compute objective function*/
    143         CostFunctionx(fcn,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     143        femmodel->CostFunctionx(fcn);
    144144
    145145        /*Compute gradient*/

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

    r13622 r13699  
    102102                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,PressureEnum);
    103103                if(dim==3) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzEnum);
    104                 RequestedOutputsx(femmodel->results,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,requested_outputs,numoutputs);
     104                femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    105105        }
    106106

  • issm/trunk-jpl/src/c/solutions/objectivefunction.cpp

    r13621 r13699  
    7070
    7171        /*Compute misfit for this velocity field.*/
    72         CostFunctionx(&J, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
     72        femmodel->CostFunctionx(&J);
    7373
    7474        /*Free ressources:*/

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

    r13621 r13699  
    5151                if(VerboseSolution()) _pprintLine_("   saving results");
    5252                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
    53                 RequestedOutputsx(femmodel->results,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,requested_outputs,numoutputs);
     53                femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    5454        }
    5555

  • issm/trunk-jpl/src/c/solutions/steadystate_core.cpp

    r13621 r13699  
    8989                if(isenthalpy) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,EnthalpyEnum);
    9090                if(!isenthalpy) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BasalforcingsMeltingRateEnum);
    91                 RequestedOutputsx(femmodel->results,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,requested_outputs,numoutputs);
     91                femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    9292        }
    9393

  • issm/trunk-jpl/src/c/solutions/transient_core.cpp

    r13696 r13699  
    140140                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceforcingsMassBalanceEnum);
    141141                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,MaskElementonfloatingiceEnum);
    142                         RequestedOutputsx(femmodel->results,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,requested_outputs,numoutputs);
     142                        femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    143143
    144144                        if(isdelta18o){
Note: See TracChangeset for help on using the changeset viewer.