Changeset 4043


Ignore:
Timestamp:
06/14/10 18:08:59 (15 years ago)
Author:
Eric.Larour
Message:

Changing to new framework where analysis_type and sub_analysis_type are picked up in the parameters, whenever needed.
This greatly simplifies the API of the code -> don't have to carry along analysis_type and sub_analysis_type.

Location:
issm/trunk/src
Files:
38 added
196 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified issm/trunk/src/c/DataSet/DataSet.cpp

    r4034 r4043  
    835835/*}}}*/
    836836/*FUNCTION DataSet::MeltingConstraints{{{1*/
    837 void  DataSet::MeltingConstraints(int* pconverged, int* pnum_unstable_constraints,int analysis_type,int sub_analysis_type){
     837void  DataSet::MeltingConstraints(int* pconverged, int* pnum_unstable_constraints){
    838838
    839839        /* generic object pointer: */
    … …  
    855855                        pengrid=(Pengrid*)(*object);
    856856
    857                         pengrid->PenaltyConstrain(&unstable,analysis_type,sub_analysis_type);
     857                        pengrid->PenaltyConstrain(&unstable);
    858858
    859859                        num_unstable_constraints+=unstable;

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

    r4037 r4043  
    5555                void  DistributeDofs(int numberofnodes,int numdofspernode);
    5656                void  CreatePartitioningVector(Vec* ppartition,int numobjects);
    57                 void  DistributeNumDofs(int** pnumdofspernode,int numberofnodes,int analysis_type,int sub_analysis_type);
    5857                void  FlagClones(int numberofnodes);
    5958                int   NumberOfDofs(int analysis_type);
    … …  
    7776                int   RiftIsPresent();
    7877                int   MeltingIsPresent();
    79                 void  MeltingConstraints(int* pconverged, int* pnum_unstable_constraints,int analysis_type,int sub_analysis_type);
     78                void  MeltingConstraints(int* pconverged, int* pnum_unstable_constraints);
    8079                DataSet* Copy(void);
    8180                void  InputExtrude(int enum_type);

  • TabularUnified issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp

    r4039 r4043  
    172172                case PressureEnum : return "Pressure";
    173173                case PressureOldEnum : return "PressureOld";
     174                case QmuPressureEnum : return "QmuPressure";
     175                case StokesPressureEnum : return "StokesPressure";
    174176                case ResetPenaltiesEnum : return "ResetPenalties";
    175177                case RheologyBEnum : return "RheologyB";
    … …  
    191193                case VxObsEnum : return "VxObs";
    192194                case VxOldEnum : return "VxOld";
     195                case QmuVxEnum : return "QmuVx";
    193196                case VyAverageEnum : return "VyAverage";
    194197                case VyEnum : return "Vy";
    195198                case VyObsEnum : return "VyObs";
    196199                case VyOldEnum : return "VyOld";
     200                case QmuVyEnum : return "QmuVy";
    197201                case VzAverageEnum : return "VzAverage";
    198202                case VzEnum : return "Vz";
    199203                case VzObsEnum : return "VzObs";
    200204                case VzOldEnum : return "VzOld";
     205                case QmuVzEnum : return "QmuVz";
    201206                case WeightsEnum : return "Weights";
    202207                case P0Enum : return "P0";

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

    r4039 r4043  
    201201        PressureEnum,
    202202        PressureOldEnum,
     203        QmuPressureEnum,
     204        StokesPressureEnum,
    203205        ResetPenaltiesEnum,
    204206        RheologyBEnum,
    … …  
    220222        VxObsEnum,
    221223        VxOldEnum,
     224        QmuVxEnum,
    222225        VyAverageEnum,
    223226        VyEnum,
    224227        VyObsEnum,
    225228        VyOldEnum,
     229        QmuVyEnum,
    226230        VzAverageEnum,
    227231        VzEnum,
    228232        VzObsEnum,
    229233        VzOldEnum,
     234        QmuVzEnum,
    230235        WeightsEnum,
    231236        /*}}}*/

  • TabularUnified issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp

    r4039 r4043  
    170170        else if (strcmp(name,"Pressure")==0) return PressureEnum;
    171171        else if (strcmp(name,"PressureOld")==0) return PressureOldEnum;
     172        else if (strcmp(name,"QmuPressure")==0) return QmuPressureEnum;
     173        else if (strcmp(name,"StokesPressure")==0) return StokesPressureEnum;
    172174        else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum;
    173175        else if (strcmp(name,"RheologyB")==0) return RheologyBEnum;
    … …  
    189191        else if (strcmp(name,"VxObs")==0) return VxObsEnum;
    190192        else if (strcmp(name,"VxOld")==0) return VxOldEnum;
     193        else if (strcmp(name,"QmuVx")==0) return QmuVxEnum;
    191194        else if (strcmp(name,"VyAverage")==0) return VyAverageEnum;
    192195        else if (strcmp(name,"Vy")==0) return VyEnum;
    193196        else if (strcmp(name,"VyObs")==0) return VyObsEnum;
    194197        else if (strcmp(name,"VyOld")==0) return VyOldEnum;
     198        else if (strcmp(name,"QmuVy")==0) return QmuVyEnum;
    195199        else if (strcmp(name,"VzAverage")==0) return VzAverageEnum;
    196200        else if (strcmp(name,"Vz")==0) return VzEnum;
    197201        else if (strcmp(name,"VzObs")==0) return VzObsEnum;
    198202        else if (strcmp(name,"VzOld")==0) return VzOldEnum;
     203        else if (strcmp(name,"QmuVz")==0) return QmuVzEnum;
    199204        else if (strcmp(name,"Weights")==0) return WeightsEnum;
    200205        else if (strcmp(name,"P0")==0) return P0Enum;

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

    r3914 r4043  
    1212#include "./EnumDefinitions/EnumDefinitions.h"
    1313#include "./toolkits/toolkits.h"
     14#include "./solutions/solutions.h"
     15#include "./solvers/solvers.h"
    1416
    1517#endif //ifndef _ISSM_H_

  • TabularUnified issm/trunk/src/c/modules/ComputeBasalStressx/ComputeBasalStressx.cpp

    r3966 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void    ComputeBasalStressx( Vec* psigma,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters,
    13                         int analysis_type,int sub_analysis_type){
     12void    ComputeBasalStressx( Vec* psigma,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters){
    1413
    1514        /*Intermediary*/
    … …  
    3736        for (i=0;i<elements->Size();i++){
    3837                element=(Element*)elements->GetObjectByOffset(i);
    39                 element->ComputeBasalStress(sigma,analysis_type,sub_analysis_type);
     38                element->ComputeBasalStress(sigma);
    4039        }
    4140

  • TabularUnified issm/trunk/src/c/modules/ComputePressurex/ComputePressurex.cpp

    r3966 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void    ComputePressurex( Vec* pp_g,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters,
    13                         int analysis_type,int sub_analysis_type){
     12void    ComputePressurex( Vec* pp_g,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters){
    1413
    1514        /*intermediary*/
    … …  
    3635        for (i=0;i<elements->Size();i++){
    3736                element=(Element*)elements->GetObjectByOffset(i);
    38                 element->ComputePressure(p_g,analysis_type,sub_analysis_type);
     37                element->ComputePressure(p_g);
    3938        }
    4039

  • TabularUnified issm/trunk/src/c/modules/ComputeStrainRatex/ComputeStrainRatex.cpp

    r3966 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void    ComputeStrainRatex( Vec* peps,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters,
    13                         int analysis_type,int sub_analysis_type){
     12void    ComputeStrainRatex( Vec* peps,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters){
    1413
    1514        /*Intermediary*/
    … …  
    3635        for (i=0;i<elements->Size();i++){
    3736                element=(Element*)elements->GetObjectByOffset(i);
    38                 element->ComputeStrainRate(eps,analysis_type,sub_analysis_type);
     37                element->ComputeStrainRate(eps);
    3938        }
    4039

  • TabularUnified issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.cpp

    r3967 r4043  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void CostFunctionx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters,
    14                         int analysis_type,int sub_analysis_type){
     13void CostFunctionx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){
    1514
    1615        /*Intermediary*/
    … …  
    3029
    3130        /*Compute surface area: */
    32         SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters,analysis_type,sub_analysis_type);
     31        SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters);
    3332
    3433        /*add surface area to elements :*/
    … …  
    3837        for (i=0;i<elements->Size();i++){
    3938                element=(Element*)elements->GetObjectByOffset(i);
    40                 J+=element->CostFunction(analysis_type,sub_analysis_type);
     39                J+=element->CostFunction();
    4140        }
    4241

  • TabularUnified issm/trunk/src/c/modules/Dux/Dux.cpp

    r4034 r4043  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void Dux( Vec* pdu_g, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads,
    14                 DataSet* materials, Parameters* parameters,int analysis_type,int sub_analysis_type){
     13void Dux( Vec* pdu_g, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters){
    1514
    1615        /*Intermediary*/
    … …  
    2221        Element* element=NULL;
    2322
     23        int analysis_type;
     24
    2425        /*output: */
    2526        Vec du_g=NULL;
     27
     28        /*retrive parameters: */
     29        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    2630
    2731        /*First, get elements and loads configured: */
    … …  
    3135
    3236        /*Compute surface area: */
    33         SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters,analysis_type,sub_analysis_type);
     37        SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters);
    3438
    3539        /*add surface area to elements :*/
    … …  
    4549        for (i=0;i<elements->Size();i++){
    4650                element=(Element*)elements->GetObjectByOffset(i);
    47                 element->Du(du_g,analysis_type,sub_analysis_type);
     51                element->Du(du_g);
    4852        }
    4953

  • TabularUnified issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp

    r4034 r4043  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void    GetSolutionFromInputsx( Vec* psolution, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters, int analysis_type, int sub_analysis_type){
     11void    GetSolutionFromInputsx( Vec* psolution, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters){
    1212
    1313        /*intermediary: */
    … …  
    1616        Element* element=NULL;
    1717
     18        int analysis_type;
     19
    1820        /*output: */
    1921        Vec solution=NULL;
     22
     23        /*retrive parameters: */
     24        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    2025
    2126        /*First, get elements and loads configured: */
    … …  
    3439        for (i=0;i<elements->Size();i++){
    3540                element=(Element*)elements->GetObjectByOffset(i);
    36                 element->GetSolutionFromInputs(solution,analysis_type,sub_analysis_type);
     41                element->GetSolutionFromInputs(solution);
    3742        }
    3843

  • TabularUnified issm/trunk/src/c/modules/Gradjx/Gradjx.cpp

    r3967 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void Gradjx( Vec* pgrad_g, int numberofnodes, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,
    13                         int analysis_type,int sub_analysis_type,int control_type){
     12void Gradjx( Vec* pgrad_g, int numberofnodes, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,int control_type){
    1413
    1514        /*Intermediary*/
    … …  
    3130        for (i=0;i<elements->Size();i++){
    3231                element=(Element*)elements->GetObjectByOffset(i);
    33                 element->Gradj(grad_g,analysis_type,sub_analysis_type,control_type);
     32                element->Gradj(grad_g,control_type);
    3433        }
    3534

  • TabularUnified issm/trunk/src/c/modules/InputToResultx/InputToResultx.cpp

    r4037 r4043  
    44
    55#include "./InputToResultx.h"
    6 
    76#include "../../shared/shared.h"
    87#include "../../include/include.h"
    … …  
    109#include "../../EnumDefinitions/EnumDefinitions.h"
    1110
    12 void InputToResultx(DataSet* elements,DataSet* nodes,DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters,int enum_type,int step=1, double time=0){
     11void InputToResultx(DataSet* elements,DataSet* nodes,DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters,int enum_type,int step, double time){
    1312
    1413        /*intermediary:*/

  • TabularUnified issm/trunk/src/c/modules/MassFluxx/MassFluxx.cpp

    r3913 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters,  double* segments,int num_segments,double* ug){
     12void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters,  double* segments,int num_segments){
    1313
    1414        int i,j;
    … …  
    3838                        if (element->Id()==element_id){
    3939                                /*We found the element which owns this segment, use it to compute the mass flux: */
    40                                 mass_flux+=element->MassFlux(segments+5*i+0,ug);
     40                                mass_flux+=element->MassFlux(segments+5*i+0);
    4141                                break;
    4242                        }

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

    r3913 r4043  
    1010
    1111/* local prototypes: */
    12 void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters,double* segments,int num_segments,double* ug);
     12void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters,double* segments,int num_segments);
    1313
    1414

  • TabularUnified issm/trunk/src/c/modules/MaxVelx/MaxVelx.cpp

    r4042 r4043  
    1717        double node_maxvel;
    1818        bool   process_units=true;
     19        double element_maxvel;
    1920
    2021        /*First, configure elements:*/

  • TabularUnified issm/trunk/src/c/modules/MinVelx/MinVelx.cpp

    r4042 r4043  
    1717        double node_minvel;
    1818        bool   process_units=true;
     19        double element_minvel;
    1920
    2021        /*First, configure elements:*/

  • TabularUnified issm/trunk/src/c/modules/Misfitx/Misfitx.cpp

    r3967 r4043  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters,
    14                         int analysis_type,int sub_analysis_type){
     13void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){
    1514       
    1615        /*Intermediary*/
    … …  
    3029
    3130        /*Compute surface area: */
    32         SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters,analysis_type,sub_analysis_type);
     31        SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters);
    3332
    3433        /*add surface area to elements :*/
    … …  
    3837        for (i=0;i<elements->Size();i++){
    3938                element=(Element*)elements->GetObjectByOffset(i);
    40                 J+=element->Misfit(analysis_type,sub_analysis_type);
     39                J+=element->Misfit();
    4140        }
    4241

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

    r3913 r4043  
    1010
    1111/* local prototypes: */
    12 void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,
    13                         int analysis_type,int sub_analysis_type);
     12void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters);
    1413
    1514#endif  /* _MISFITX_H */

  • TabularUnified issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.cpp

    r3913 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices,
    13                 DataSet* loads,DataSet* materials,  Parameters* parameters,int analysis_type,int sub_analysis_type){
     12void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads,DataSet* materials,  Parameters* parameters){
    1413
    1514        int i;
    … …  
    3433         * management routine, otherwise, skip : */
    3534        if (RiftIsPresent(loads)){
    36                 RiftConstraints(&converged,&num_unstable_constraints,loads,min_mechanical_constraints,analysis_type,sub_analysis_type);
     35                RiftConstraints(&converged,&num_unstable_constraints,loads,min_mechanical_constraints);
    3736        }
    3837        else if(loads->MeltingIsPresent()){
    39                 loads->MeltingConstraints(&converged,&num_unstable_constraints,analysis_type,sub_analysis_type);
     38                loads->MeltingConstraints(&converged,&num_unstable_constraints);
    4039        }
    4140        else{

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

    r3913 r4043  
    1010
    1111/* local prototypes: */
    12 void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices,
    13                 DataSet* loads,DataSet* materials,  Parameters* parameters,int analysis_type,int sub_analysis_type);
     12void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads,DataSet* materials,  Parameters* parameters);
    1413
    1514#endif  /* _PENALTYCONSTRAINTSX_H */

  • TabularUnified issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.cpp

    r3913 r4043  
    1010#define _ZIGZAGCOUNTER_
    1111
    12 int RiftConstraints(int* pconverged, int* pnum_unstable_constraints,DataSet* loads,int min_mechanical_constraints,int analysis_type,int sub_analysis_type){
     12int RiftConstraints(int* pconverged, int* pnum_unstable_constraints,DataSet* loads,int min_mechanical_constraints){
    1313
    1414        int num_unstable_constraints=0;
    … …  
    1717        extern int my_rank;
    1818
    19         Constrain(&num_unstable_constraints,loads,analysis_type);
     19        Constrain(&num_unstable_constraints,loads);
    2020        if(num_unstable_constraints==0)converged=1;
    2121       
    … …  
    2727        else if(num_unstable_constraints<=min_mechanical_constraints){
    2828                _printf_("   freezing constraints\n");
    29                 FreezeConstraints(loads,analysis_type);
     29                FreezeConstraints(loads);
    3030        }
    3131
    … …  
    3535}
    3636
    37 int IsMaterialStable(DataSet* loads,int analysis_type){
     37int IsMaterialStable(DataSet* loads){
    3838
    3939        int i;
    … …  
    5050                        riftfront=(Riftfront*)loads->GetObjectByOffset(i);
    5151
    52                         if (riftfront->IsMaterialStable(analysis_type)){
     52                        if (riftfront->IsMaterialStable()){
    5353                                found=1;
    5454                                /*do not break! all penalties should get informed the non-linearity converged!*/
    … …  
    150150}
    151151
    152 int PreConstrain(int* pnum_unstable_constraints,DataSet* loads,int analysis_type){
     152int PreConstrain(int* pnum_unstable_constraints,DataSet* loads){
    153153
    154154        int                     i;
    … …  
    168168                        riftfront=(Riftfront*)loads->GetObjectByOffset(i);
    169169
    170                         riftfront->PreConstrain(&unstable,analysis_type);
     170                        riftfront->PreConstrain(&unstable);
    171171
    172172                        num_unstable_constraints+=unstable;
    … …  
    185185}
    186186
    187 int Constrain(int* pnum_unstable_constraints,DataSet* loads,int analysis_type){
     187int Constrain(int* pnum_unstable_constraints,DataSet* loads){
    188188
    189189        int                     i;
    … …  
    203203                        riftfront=(Riftfront*)loads->GetObjectByOffset(i);
    204204
    205                         riftfront->Constrain(&unstable,analysis_type);
     205                        riftfront->Constrain(&unstable);
    206206
    207207                        num_unstable_constraints+=unstable;
    … …  
    220220}
    221221
    222 void FreezeConstraints(DataSet* loads,int analysis_type){
     222void FreezeConstraints(DataSet* loads){
    223223
    224224        int                     i;
    … …  
    234234                        riftfront=(Riftfront*)loads->GetObjectByOffset(i);
    235235
    236                         riftfront->FreezeConstraints(analysis_type);
     236                        riftfront->FreezeConstraints();
    237237
    238238                }
    … …  
    273273}
    274274
    275 int MaxPenetrationInInputs(DataSet* loads,int analysis_type){
     275int MaxPenetrationInInputs(DataSet* loads){
    276276
    277277        int                     i;
    … …  
    295295                        riftfront=(Riftfront*)loads->GetObjectByOffset(i);
    296296
    297                         riftfront->MaxPenetration(&penetration,analysis_type);
     297                        riftfront->MaxPenetration(&penetration);
    298298
    299299                        if (penetration>max_penetration)max_penetration=penetration;
    … …  
    311311}
    312312
    313 int PotentialUnstableConstraints(DataSet* loads,int analysis_type){
     313int PotentialUnstableConstraints(DataSet* loads){
    314314
    315315        int                     i;
    … …  
    330330                        riftfront=(Riftfront*)loads->GetObjectByOffset(i);
    331331
    332                         riftfront->PotentialUnstableConstraint(&unstable,analysis_type);
     332                        riftfront->PotentialUnstableConstraint(&unstable);
    333333
    334334                        num_unstable_constraints+=unstable;

  • TabularUnified issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.h

    r3913 r4043  
    1010#include "../../DataSet/DataSet.h"
    1111
    12 int RiftConstraints(int* pconverged, int* pnum_unstable_constraints,DataSet* loads,int min_mechanical_constraints,int analysis_type,int sub_analysis_type);
     12int RiftConstraints(int* pconverged, int* pnum_unstable_constraints,DataSet* loads,int min_mechanical_constraints);
    1313
    1414int RiftIsPresent(DataSet* loads);
    … …  
    1818int SetPreStable(DataSet* loads);
    1919
    20 int PreConstrain(int* pnum_unstable_constraints,DataSet* loads,int analysis_type_enum);
     20int PreConstrain(int* pnum_unstable_constraints,DataSet* loads);
    2121
    22 int Constrain(int* pnum_unstable_constraints,DataSet* loads,int analysis_type_enum);
     22int Constrain(int* pnum_unstable_constraints,DataSet* loads);
    2323
    24 void FreezeConstraints(DataSet* loads,int analysis_type);
     24void FreezeConstraints(DataSet* loads);
    2525
    26 int MaxPenetrationInInputs(DataSet* loads,int analysis_type_enum);
     26int MaxPenetrationInInputs(DataSet* loads);
    2727
    28 int PotentialUnstableConstraints(DataSet* loads,int analysis_type_enum);
     28int PotentialUnstableConstraints(DataSet* loads);
    2929
    30 int IsMaterialStable(DataSet* loads,int analysis_type_enum);
     30int IsMaterialStable(DataSet* loads);
    3131
    3232int IsFrozen(DataSet* loads);

  • TabularUnified issm/trunk/src/c/modules/PenaltySystemMatricesx/PenaltySystemMatricesx.cpp

    r3965 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void PenaltySystemMatricesx(Mat Kgg, Vec pg,double* pkmax,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters,
    13                 int kflag,int pflag,int analysis_type,int sub_analysis_type){
     12void PenaltySystemMatricesx(Mat Kgg, Vec pg,double* pkmax,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters, int kflag,int pflag){
    1413       
    1514        int i;
    … …  
    3231                for (i=0;i<loads->Size();i++){
    3332                        load=(Load*)loads->GetObjectByOffset(i);
    34                         load->PenaltyCreateKMatrix(Kgg,kmax,analysis_type,sub_analysis_type);
     33                        load->PenaltyCreateKMatrix(Kgg,kmax);
    3534                }
    3635
    … …  
    4746                for (i=0;i<loads->Size();i++){
    4847                        load=(Load*)loads->GetObjectByOffset(i);
    49                         load->PenaltyCreatePVector(pg,kmax,analysis_type,sub_analysis_type);
     48                        load->PenaltyCreatePVector(pg,kmax);
    5049                }
    5150

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

    r4042 r4043  
    1313#include "../../include/include.h"
    1414#include "../../EnumDefinitions/EnumDefinitions.h"
    15 #include "../MassFluxx/MassFluxx.h"
    16 #include "../Misfitx/Misfitx.h"
    1715#include "../modules.h"
    1816
    … …  
    2018
    2119        int i;
     20        int dummy;
    2221        extern int my_rank;
    2322       
    … …  
    7069                }
    7170                else if(strcmp(response_descriptor,"mass_flux")==0){
    72                         MassFlux(&femmodel_response,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     71
     72                        double*   segments=NULL;
     73                        int       num_segments;
     74                       
     75                        /*retrieve qmu_mass_flux_segments: */
     76                        femmodel->parameters->FindParam(&segments,&num_segments,&dummy,QmuMassFluxSegmentsEnum);
     77
     78                        /*call mass flux module: */
     79                        MassFluxx(&femmodel_response,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,segments,num_segments);
     80
     81                        /*Free ressources:*/
     82                        xfree((void**)&segments);
     83
    7384                }
    7485                else{
    … …  
    8192
    8293}
     94
     95
     96
     97

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

    r4042 r4043  
    1010
    1111/* local prototypes: */
    12 int SpawnCore(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, void* femmodel,int analysis_type,int sub_analysis_type,int counter);
     12int SpawnCore(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, void* femmodel,int counter);
    1313#ifdef _SERIAL_
    14 void Qmux(mxArray* femmodel,int analysis_type,int sub_analysis_type,char* dakota_input_file,char* dakota_output_file,char* dakota_error_file);
    15 void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* femmodel,int analysis_type,int sub_analysis_type,int counter);
     14void Qmux(mxArray* femmodel,char* dakota_input_file,char* dakota_output_file,char* dakota_error_file);
     15void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* femmodel,int counter);
    1616#else
    17 void Qmux(FemModel* femmodel,int analysis_type,int sub_analysis_type);
    18 void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, FemModel* femmodel,int analysis_type,int sub_analysis_type,int counter);
    19 void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,FemModel* femmodel,int analysis_type,int sub_analysis_type);
     17void Qmux(FemModel* femmodel);
     18void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, FemModel* femmodel,int counter);
     19void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,FemModel* femmodel);
    2020#endif
    2121

  • TabularUnified issm/trunk/src/c/modules/Qmux/SpawnCore.cpp

    r4042 r4043  
    2626        MPI_Bcast(&counter,1,MPI_INT,0,MPI_COMM_WORLD); if(counter==-1)return 0;
    2727       
    28         SpawnCoreParallel(responses, numresponses, variables, variables_descriptors,numvariables, (FemModel*)femmodel);
     28        SpawnCoreParallel(responses, numresponses, variables, variables_descriptors,numvariables, (FemModel*)femmodel,counter);
    2929        #endif
    3030

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

    r4042 r4043  
    3333#include "../../include/include.h"
    3434#include "../../solutions/solutions.h"
     35#include "../modules.h"
    3536
    3637void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, FemModel* femmodel,int counter){
    … …  
    5960               
    6061        /*Recover partitioning for dakota: */
    61         femmodel->FindParam(&qmu_npart,QmuNPartEnum);
    62         femmodel->FindParam(&qmu_part,&dummy,QmuPartEnum);
     62        femmodel->parameters->FindParam(&qmu_npart,QmuNPartEnum);
     63        femmodel->parameters->FindParam(&qmu_part,&dummy,QmuPartEnum);
    6364
    6465        /*broadcast variables: only cpu 0 has correct values*/
    … …  
    8889
    8990        /*Modify core inputs in objects contained in femmodel, to reflect the dakota variables inputs: */
    90         UpdateFromDakota(variables,variables_descriptors,numvariables,femmodel,qmu_part,qmu_npart);
     91        UpdateInputsFromDakotax(variables,variables_descriptors,numvariables,femmodel,qmu_part,qmu_npart);
    9192
    9293        /*Run the analysis core solution sequence: */
    … …  
    120121        /*compute responses on cpu 0: dummy for now! */
    121122        if(verbose)_printf_("compute dakota responses:\n");
    122         DakotaResponses(responses,responses_descriptors,numresponses,femmodel,results,processed_results);
     123        DakotaResponses(responses,responses_descriptors,numresponses,femmodel);
    123124
    124125        /*Free ressources:*/

  • TabularUnified issm/trunk/src/c/modules/Qmux/SpawnCoreSerial.cpp

    r3913 r4043  
    1919#include "../../include/include.h"
    2020
    21 void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* model,int analysis_type,int sub_analysis_type,int counter){
     21void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* modelint counter){
    2222
    2323        int i;
    … …  
    2727        double*  variables_copy=NULL;
    2828        mxArray* mxvariabledescriptors=NULL;
    29         mxArray* mxanalysis_type=NULL;
    30         mxArray* mxsub_analysis_type=NULL;
    3129        mxArray* mxcounter=NULL;
    3230        mwSize   dims[2]={0};
    … …  
    5149        }
    5250
    53         mxanalysis_type=mxCreateDoubleScalar((double)analysis_type);
    54         mxsub_analysis_type=mxCreateDoubleScalar((double)sub_analysis_type);
    5551        mxcounter=mxCreateDoubleScalar((double)counter);
    5652
    … …  
    5955        array[2]=mxvariables;
    6056        array[3]=mxvariabledescriptors;
    61         array[4]=mxanalysis_type;
    62         array[5]=mxsub_analysis_type;
    63         array[6]=mxcounter;
     57        array[4]=mxcounter;
    6458
    65         mexCallMATLAB(1,&mxresponses,7,array,"SpawnCore");
     59        mexCallMATLAB(1,&mxresponses,5,array,"SpawnCore");
    6660
    6761        /*copy responses back to dakota: */
    … …  
    7266        mxDestroyArray(mxvariabledescriptors);
    7367        mxDestroyArray(mxresponses);
    74         mxDestroyArray(mxanalysis_type);
    75         mxDestroyArray(mxsub_analysis_type);
    7668        mxDestroyArray(mxcounter);
    7769

  • TabularUnified issm/trunk/src/c/modules/SurfaceAreax/SurfaceAreax.cpp

    r3968 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters,
    13                         int analysis_type,int sub_analysis_type){
     12void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){
    1413       
    1514        /*Intermediary*/
    … …  
    2827        for (i=0;i<elements->Size();i++){
    2928                element=(Element*)elements->GetObjectByOffset(i);
    30                 S+=element->SurfaceArea(analysis_type,sub_analysis_type);
     29                S+=element->SurfaceArea();
    3130        }
    3231

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

    r3913 r4043  
    1010
    1111/* local prototypes: */
    12 void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,
    13                         int analysis_type,int sub_analysis_type);
     12void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters);
    1413
    1514#endif  /* _SURFACEAREAX_H */

  • TabularUnified issm/trunk/src/c/modules/SystemMatricesx/SystemMatricesx.cpp

    r4034 r4043  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void SystemMatricesx(Mat* pKgg, Vec* ppg,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters,
    13                 int kflag,int pflag,int analysis_type,int sub_analysis_type){
     12void SystemMatricesx(Mat* pKgg, Vec* ppg,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters, int kflag,int pflag){
    1413       
    1514        /*intermediary: */
    … …  
    2524        Vec pg=NULL;
    2625
     26        int analysis_type;
     27
    2728        /*First, get elements and loads configured: */
    2829        elements->  Configure(elements,loads, nodes,vertices, materials,parameters);
    … …  
    3031        loads->     Configure(elements, loads, nodes,vertices, materials,parameters);
    3132        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
     33
     34        /*retrive parameters: */
     35        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    3236
    3337        /*Recover parameters: */
    … …  
    4751                for (i=0;i<elements->Size();i++){
    4852                        element=(Element*)elements->GetObjectByOffset(i);
    49                         element->CreateKMatrix(Kgg,analysis_type,sub_analysis_type);
     53                        element->CreateKMatrix(Kgg);
    5054                }
    5155
    … …  
    5357                for (i=0;i<loads->Size();i++){
    5458                        load=(Load*)loads->GetObjectByOffset(i);
    55                         load->CreateKMatrix(Kgg,analysis_type,sub_analysis_type);
     59                        load->CreateKMatrix(Kgg);
    5660                }
    5761
    … …  
    7175                for (i=0;i<elements->Size();i++){
    7276                        element=(Element*)elements->GetObjectByOffset(i);
    73                         element->CreatePVector(pg,analysis_type,sub_analysis_type);
     77                        element->CreatePVector(pg);
    7478                }
    7579
    … …  
    7781                for (i=0;i<loads->Size();i++){
    7882                        load=(Load*)loads->GetObjectByOffset(i);
    79                         load->CreatePVector(pg,analysis_type,sub_analysis_type);
     83                        load->CreatePVector(pg);
    8084                }
    8185

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

    r4042 r4043  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,Vec solution, int analysis_type, int sub_analysis_type){
     11void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,Vec solution){
    1212
    1313        double* serial_solution=NULL;
    … …  
    1717
    1818        /*Call overloaded form of UpdateInputsFromSolutionx: */
    19         UpdateInputsFromSolutionx( elements, nodes,  vertices,  loads,  materials,  parameters,serial_solution, analysis_type, sub_analysis_type);
     19        UpdateInputsFromSolutionx( elements, nodes,  vertices,  loads,  materials,  parameters,serial_solution);
    2020
    2121        /*Free ressources:*/
    … …  
    2525
    2626
    27 void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int analysis_type, int sub_analysis_type){
     27void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution){
    2828
    2929        /*Intermediary*/
    … …  
    4040        for (i=0;i<elements->Size();i++){
    4141                element=(Element*)elements->GetObjectByOffset(i);
    42                 element->UpdateInputsFromSolution(solution,analysis_type,sub_analysis_type);
     42                element->UpdateInputsFromSolution(solution);
    4343        }
    4444

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

    r4037 r4043  
    1010
    1111/* local prototypes: */
    12 void            UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters,Vec solution, int analysis_type, int sub_analysis_type);
    13 void        UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int analysis_type, int sub_analysis_type);
     12void            UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters,Vec solution);
     13void        UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution);
    1414
    1515//with timestep
    16 void            UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters,Vec solution, int analysis_type, int sub_analysis_type,int timestep);
    17 void        UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int analysis_type, int sub_analysis_type,int timestep);
     16void            UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters,Vec solution,int timestep);
     17void        UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int timestep);
    1818
    1919#endif  /* _UPDATEINPUTSFROMSOLUTIONXX_H */

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

    r4042 r4043  
    3030#include "./UpdateInputsFromConstantx/UpdateInputsFromConstantx.h"
    3131#include "./UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h"
     32#include "./UpdateInputsFromDakotax/UpdateInputsFromDakotax.h"
    3233#include "./UpdateInputsFromVectorx/UpdateInputsFromVectorx.h"
    3334#include "./UpdateGeometryx/UpdateGeometryx.h"
    … …  
    6869#include "./MinVelx/MinVelx.h"
    6970#include "./MaxVelx/MaxVelx.h"
     71#include "./MinVxx/MinVxx.h"
     72#include "./MaxVxx/MaxVxx.h"
     73#include "./MaxAbsVxx/MaxAbsVxx.h"
     74#include "./MinVyx/MinVyx.h"
     75#include "./MaxVyx/MaxVyx.h"
     76#include "./MaxAbsVyx/MaxAbsVyx.h"
     77#include "./MinVzx/MinVzx.h"
     78#include "./MaxVzx/MaxVzx.h"
     79#include "./MaxAbsVzx/MaxAbsVzx.h"
     80#include "./ReinitializeInputx/ReinitializeInputx.h"
     81
    7082#endif

  • TabularUnified issm/trunk/src/c/objects/Constraints/Rgb.h

    r4003 r4043  
    4141                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4242                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    43 
    44                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     43                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4544
    4645

  • TabularUnified issm/trunk/src/c/objects/Constraints/Spc.cpp

    r4003 r4043  
    122122}               
    123123/*}}}1*/
    124 /*FUNCTION Spc::DistributeNumDofs {{{1*/
    125 void  Spc::DistributeNumDofs(int* numdofspernode,int analysis_type){return;}
    126 /*}}}1*/
    127124/*FUNCTION Spc::Echo {{{1*/
    128125void Spc::Echo(void){

  • TabularUnified issm/trunk/src/c/objects/Constraints/Spc.h

    r4003 r4043  
    3535                int    Id();
    3636                int    MyRank();
    37                 void   DistributeNumDofs(int* numdofspernode,int analysis_type);
    3837                int    GetNodeId();
    3938                int    GetDof();
    … …  
    4645                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4746                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    48                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     47                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4948                bool    InAnalysis(int analysis_type);
    5049

  • TabularUnified issm/trunk/src/c/objects/DofVec.h

    r3751 r4043  
    5353                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    5454                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    55                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     55                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5656                Object* copy();
    5757

  • TabularUnified issm/trunk/src/c/objects/Elements/Beam.cpp

    r4042 r4043  
    131131/*}}}*/
    132132/*FUNCTION Beam::UpdateInputsFromSolution {{{1*/
    133 void  Beam::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){
    134         ISSMERROR(" not supported yet!");
    135 }
    136 /*}}}*/
    137 /*FUNCTION Beam::GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type);{{{1*/
    138 void  Beam::GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type){
     133void  Beam::UpdateInputsFromSolution(double* solution){
     134        ISSMERROR(" not supported yet!");
     135}
     136/*}}}*/
     137/*FUNCTION Beam::GetSolutionFromInputs(Vec solution);{{{1*/
     138void  Beam::GetSolutionFromInputs(Vec solution){
    139139        ISSMERROR(" not supported yet!");
    140140}
    … …  
    153153/*Object functions*/
    154154/*FUNCTION Beam::ComputeBasalStress{{{1*/
    155 void  Beam::ComputeBasalStress(Vec eps,int analysis_type,int sub_analysis_type){
     155void  Beam::ComputeBasalStress(Vec eps){
    156156
    157157        ISSMERROR("Not implemented yet");
    … …  
    160160/*}}}*/
    161161/*FUNCTION Beam::ComputePressure{{{1*/
    162 void  Beam::ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type){
     162void  Beam::ComputePressure(Vec p_g){
    163163
    164164        int i;
    … …  
    170170        double xyz_list[numgrids][3];
    171171        double gauss[numgrids][numgrids]={{1,0},{0,1}};
     172        int analysis_type,sub_analysis_type;
     173
     174        /*retrive parameters: */
     175        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     176        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    172177
    173178        /*Get dof list on which we will plug the pressure values: */
    … …  
    196201/*}}}*/
    197202/*FUNCTION Beam::ComputeStrainRate{{{1*/
    198 void  Beam::ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type){
     203void  Beam::ComputeStrainRate(Vec eps){
    199204
    200205        ISSMERROR("Not implemented yet");
    … …  
    203208/*}}}*/
    204209/*FUNCTION Beam::CostFunction{{{1*/
    205 double Beam::CostFunction(int,int){
     210double Beam::CostFunction(void){
    206211        ISSMERROR(" not supported yet!");
    207212}
    208213/*}}}*/
    209214/*FUNCTION Beam::CreateKMatrix{{{1*/
    210 void  Beam::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     215void  Beam::CreateKMatrix(Mat Kgg){
     216
     217        int analysis_type,sub_analysis_type;
     218
     219        /*retrive parameters: */
     220        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     221        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    211222
    212223        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    … …  
    215226                if (sub_analysis_type==HutterAnalysisEnum) {
    216227
    217                         CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type);
     228                        CreateKMatrixDiagnosticHutter( Kgg);
    218229                }
    219230                else
    … …  
    228239/*FUNCTION Beam::CreateKMatrixDiagnosticHutter{{{1*/
    229240
    230 void  Beam::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){
     241void  Beam::CreateKMatrixDiagnosticHutter(Mat Kgg){
    231242       
    232243       
    … …  
    279290/*}}}*/
    280291/*FUNCTION Beam::CreatePVector{{{1*/
    281 void  Beam::CreatePVector(Vec pg,int analysis_type,int sub_analysis_type){
     292void  Beam::CreatePVector(Vec pg){
     293
     294        int analysis_type,sub_analysis_type;
     295
     296        /*retrive parameters: */
     297        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     298        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    282299       
    283300        /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */
    284301        if (analysis_type==DiagnosticAnalysisEnum) {
    285302                if (sub_analysis_type==HutterAnalysisEnum) {
    286                         CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type);
     303                        CreatePVectorDiagnosticHutter( pg);
    287304                }
    288305                else
    … …  
    297314/*FUNCTION Beam::CreatePVectorDiagnosticHutter{{{1*/
    298315
    299 void Beam::CreatePVectorDiagnosticHutter( Vec pg,  int analysis_type,int sub_analysis_type){
     316void Beam::CreatePVectorDiagnosticHutter( Vec pg){
    300317
    301318        int i,j,k;
    … …  
    425442/*}}}*/
    426443/*FUNCTION Beam::Du{{{1*/
    427 void  Beam::Du(Vec,int,int){
     444void  Beam::Du(Vec){
    428445        ISSMERROR(" not supported yet!");
    429446}
    … …  
    545562/*}}}*/
    546563/*FUNCTION Beam::Gradj{{{1*/
    547 void  Beam::Gradj(Vec, int, int,int){
     564void  Beam::Gradj(Vec, int control_type){
    548565        ISSMERROR(" not supported yet!");
    549566}
    550567/*}}}*/
    551568/*FUNCTION Beam::GradjB{{{1*/
    552 void  Beam::GradjB(Vec, int, int){
     569void  Beam::GradjB(Vec){
    553570        ISSMERROR(" not supported yet!");
    554571}
    555572/*}}}*/
    556573/*FUNCTION Beam::GradjDrag{{{1*/
    557 void  Beam::GradjDrag(Vec, int,int ){
     574void  Beam::GradjDrag(Vec){
    558575        ISSMERROR(" not supported yet!");
    559576}
    560577/*}}}*/
    561578/*FUNCTION Beam::MassFlux{{{1*/
    562 double Beam::MassFlux( double* segment,double* ug){
     579double Beam::MassFlux( double* segment){
    563580        ISSMERROR(" not supported yet!");
    564581}
    565582/*}}}*/
    566583/*FUNCTION Beam::Misfit{{{1*/
    567 double Beam::Misfit(int,int){
     584double Beam::Misfit(void){
    568585        ISSMERROR(" not supported yet!");
    569586}
    … …  
    576593/*}}}*/
    577594/*FUNCTION Beam::SurfaceArea{{{1*/
    578 double Beam::SurfaceArea(int,int){
     595double Beam::SurfaceArea(void){
    579596        ISSMERROR(" not supported yet!");
    580597}
    … …  
    639656void  Beam::MinVel(double* pminvel, bool process_units){
    640657
     658        int i;
     659        int dim;
    641660        const int numgrids=2;
    642661        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
    … …  
    657676        /*now, compute minimum of velocity :*/
    658677        if(dim==2){
    659                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
     678                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
    660679        }
    661680        else{
    662                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
     681                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
    663682        }
    664683
    … …  
    677696void  Beam::MaxVel(double* pmaxvel, bool process_units){
    678697
     698        int i;
     699        int dim;
    679700        const int numgrids=2;
    680701        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
    … …  
    695716        /*now, compute maximum of velocity :*/
    696717        if(dim==2){
    697                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
     718                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
    698719        }
    699720        else{
    700                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
     721                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
    701722        }
    702723
    … …  
    712733}
    713734/*}}}*/
     735/*FUNCTION Beam::MinVx(double* pminvx, bool process_units);{{{1*/
     736void  Beam::MinVx(double* pminvx, bool process_units){
     737
     738        int i;
     739        int dim;
     740        const int numgrids=2;
     741        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     742        double  vx_values[numgrids];
     743        double  minvx;
     744
     745        /*retrieve dim parameter: */
     746        parameters->FindParam(&dim,DimEnum);
     747
     748        /*retrive velocity values at nodes */
     749        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     750
     751        /*now, compute minimum:*/
     752        minvx=vx_values[0];
     753        for(i=1;i<numgrids;i++){
     754                if (vx_values[i]<minvx)minvx=vx_values[i];
     755        }
     756
     757        /*Assign output pointers:*/
     758        *pminvx=minvx;
     759
     760}
     761/*}}}*/
     762/*FUNCTION Beam::MaxVx(double* pmaxvx, bool process_units);{{{1*/
     763void  Beam::MaxVx(double* pmaxvx, bool process_units){
     764
     765        int i;
     766        int dim;
     767        const int numgrids=2;
     768        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     769        double  vx_values[numgrids];
     770        double  maxvx;
     771
     772        /*retrieve dim parameter: */
     773        parameters->FindParam(&dim,DimEnum);
     774
     775        /*retrive velocity values at nodes */
     776        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     777
     778        /*now, compute maximum:*/
     779        maxvx=vx_values[0];
     780        for(i=1;i<numgrids;i++){
     781                if (vx_values[i]>maxvx)maxvx=vx_values[i];
     782        }
     783
     784        /*Assign output pointers:*/
     785        *pmaxvx=maxvx;
     786
     787}
     788/*}}}*/
     789/*FUNCTION Beam::MaxAbsVx(double* pmaxabsvx, bool process_units);{{{1*/
     790void  Beam::MaxAbsVx(double* pmaxabsvx, bool process_units){
     791
     792        int i;
     793        int dim;
     794        const int numgrids=2;
     795        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     796        double  vx_values[numgrids];
     797        double  maxabsvx;
     798
     799        /*retrieve dim parameter: */
     800        parameters->FindParam(&dim,DimEnum);
     801
     802        /*retrive velocity values at nodes */
     803        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     804
     805        /*now, compute maximum:*/
     806        maxabsvx=fabs(vx_values[0]);
     807        for(i=1;i<numgrids;i++){
     808                if (fabs(vx_values[i])>maxabsvx)maxabsvx=fabs(vx_values[i]);
     809        }
     810
     811        /*Assign output pointers:*/
     812        *pmaxabsvx=maxabsvx;
     813}
     814/*}}}*/
     815/*FUNCTION Beam::MinVy(double* pminvy, bool process_units);{{{1*/
     816void  Beam::MinVy(double* pminvy, bool process_units){
     817
     818        int i;
     819        int dim;
     820        const int numgrids=2;
     821        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     822        double  vy_values[numgrids];
     823        double  minvy;
     824
     825        /*retrieve dim parameter: */
     826        parameters->FindParam(&dim,DimEnum);
     827
     828        /*retrive velocity values at nodes */
     829        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     830
     831        /*now, compute minimum:*/
     832        minvy=vy_values[0];
     833        for(i=1;i<numgrids;i++){
     834                if (vy_values[i]<minvy)minvy=vy_values[i];
     835        }
     836
     837        /*Assign output pointers:*/
     838        *pminvy=minvy;
     839
     840}
     841/*}}}*/
     842/*FUNCTION Beam::MaxVy(double* pmaxvy, bool process_units);{{{1*/
     843void  Beam::MaxVy(double* pmaxvy, bool process_units){
     844
     845        int i;
     846        int dim;
     847        const int numgrids=2;
     848        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     849        double  vy_values[numgrids];
     850        double  maxvy;
     851
     852        /*retrieve dim parameter: */
     853        parameters->FindParam(&dim,DimEnum);
     854
     855        /*retrive velocity values at nodes */
     856        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     857
     858        /*now, compute maximum:*/
     859        maxvy=vy_values[0];
     860        for(i=1;i<numgrids;i++){
     861                if (vy_values[i]>maxvy)maxvy=vy_values[i];
     862        }
     863
     864        /*Assign output pointers:*/
     865        *pmaxvy=maxvy;
     866
     867}
     868/*}}}*/
     869/*FUNCTION Beam::MaxAbsVy(double* pmaxabsvy, bool process_units);{{{1*/
     870void  Beam::MaxAbsVy(double* pmaxabsvy, bool process_units){
     871
     872        int i;
     873        int dim;
     874        const int numgrids=2;
     875        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     876        double  vy_values[numgrids];
     877        double  maxabsvy;
     878
     879        /*retrieve dim parameter: */
     880        parameters->FindParam(&dim,DimEnum);
     881
     882        /*retrive velocity values at nodes */
     883        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     884
     885        /*now, compute maximum:*/
     886        maxabsvy=fabs(vy_values[0]);
     887        for(i=1;i<numgrids;i++){
     888                if (fabs(vy_values[i])>maxabsvy)maxabsvy=fabs(vy_values[i]);
     889        }
     890
     891        /*Assign output pointers:*/
     892        *pmaxabsvy=maxabsvy;
     893}
     894/*}}}*/
     895/*FUNCTION Beam::MinVz(double* pminvz, bool process_units);{{{1*/
     896void  Beam::MinVz(double* pminvz, bool process_units){
     897
     898        int i;
     899        int dim;
     900        const int numgrids=2;
     901        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     902        double  vz_values[numgrids];
     903        double  minvz;
     904
     905        /*retrieve dim parameter: */
     906        parameters->FindParam(&dim,DimEnum);
     907
     908        /*retrive velocity values at nodes */
     909        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     910
     911        /*now, compute minimum:*/
     912        minvz=vz_values[0];
     913        for(i=1;i<numgrids;i++){
     914                if (vz_values[i]<minvz)minvz=vz_values[i];
     915        }
     916
     917        /*Assign output pointers:*/
     918        *pminvz=minvz;
     919
     920}
     921/*}}}*/
     922/*FUNCTION Beam::MaxVz(double* pmaxvz, bool process_units);{{{1*/
     923void  Beam::MaxVz(double* pmaxvz, bool process_units){
     924
     925        int i;
     926        int dim;
     927        const int numgrids=2;
     928        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     929        double  vz_values[numgrids];
     930        double  maxvz;
     931
     932        /*retrieve dim parameter: */
     933        parameters->FindParam(&dim,DimEnum);
     934
     935        /*retrive velocity values at nodes */
     936        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     937
     938        /*now, compute maximum:*/
     939        maxvz=vz_values[0];
     940        for(i=1;i<numgrids;i++){
     941                if (vz_values[i]>maxvz)maxvz=vz_values[i];
     942        }
     943
     944        /*Assign output pointers:*/
     945        *pmaxvz=maxvz;
     946
     947}
     948/*}}}*/
     949/*FUNCTION Beam::MaxAbsVz(double* pmaxabsvz, bool process_units);{{{1*/
     950void  Beam::MaxAbsVz(double* pmaxabsvz, bool process_units){
     951
     952        int i;
     953        int dim;
     954        const int numgrids=2;
     955        double  gaussgrids[numgrids][2]={{0,1},{1,0}};
     956        double  vz_values[numgrids];
     957        double  maxabsvz;
     958
     959        /*retrieve dim parameter: */
     960        parameters->FindParam(&dim,DimEnum);
     961
     962        /*retrive velocity values at nodes */
     963        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     964
     965        /*now, compute maximum:*/
     966        maxabsvz=fabs(vz_values[0]);
     967        for(i=1;i<numgrids;i++){
     968                if (fabs(vz_values[i])>maxabsvz)maxabsvz=fabs(vz_values[i]);
     969        }
     970
     971        /*Assign output pointers:*/
     972        *pmaxabsvz=maxabsvz;
     973}
     974/*}}}*/
     975/*FUNCTION Beam::ReinitializeInput(int reinitialized_enum,int original_enum){{{1*/
     976void  Beam::ReinitializeInput(int reinitialized_enum,int original_enum){
     977
     978        Input* original=NULL;
     979        Input* copy=NULL;
     980
     981        /*Make a copy of the original input: */
     982        original=(Input*)this->inputs->GetInput(original_enum);
     983        copy=(Input*)original->copy();
     984
     985        /*Change copy enum to reinitialized_enum: */
     986        copy->ChangeEnum(reinitialized_enum);
     987
     988        /*Add copy into inputs, it will wipe off the one already there: */
     989        inputs->AddObject((Input*)copy);
     990}
     991/*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Elements/Beam.h

    r4042 r4043  
    6161                void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    63                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
     63                void  UpdateInputsFromSolution(double* solution);
    6464                void  DepthAverageInputAtBase(int enum_type){ISSMERROR("not implemented yet");};
    6565                void  InputToResult(int enum_type,int step,double time);
    … …  
    6767                /*}}}*/
    6868                /*numerics: {{{1*/
    69                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    70                 void  CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type);
    71                 void  GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type);
     69                void  CreateKMatrix(Mat Kgg);
     70                void  CreatePVector(Vec pg);
     71                void  GetSolutionFromInputs(Vec solution);
    7272                void  GetDofList(int* doflist,int* pnumberofdofs);
    7373                void  GetDofList1(int* doflist);
    74                 void  CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type);
     74                void  CreateKMatrixDiagnosticHutter(Mat Kgg);
    7575                void  GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
    76                 void  CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type);
     76                void  CreatePVectorDiagnosticHutter(Vec pg);
    7777                void* GetMatPar();
    7878
    79                 void  ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type);
    80                 void  ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type);
    81                 void  ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type);
     79                void  ComputeBasalStress(Vec sigma_bg);
     80                void  ComputePressure(Vec p_gg);
     81                void  ComputeStrainRate(Vec epsg);
    8282                void  GetNodes(void** vpnodes);
    8383                void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    … …  
    8585                void  MinVel(double* pminvel, bool process_units);
    8686                void  MaxVel(double* pmaxvel, bool process_units);
     87                void  MinVx(double* pminvx, bool process_units);
     88                void  MaxVx(double* pmaxvx, bool process_units);
     89                void  MaxAbsVx(double* pmaxabsvx, bool process_units);
     90                void  MinVy(double* pminvy, bool process_units);
     91                void  MaxVy(double* pmaxvy, bool process_units);
     92                void  MaxAbsVy(double* pmaxabsvy, bool process_units);
     93                void  MinVz(double* pminvz, bool process_units);
     94                void  MaxVz(double* pmaxvz, bool process_units);
     95                void  MaxAbsVz(double* pmaxabsvz, bool process_units);
     96                void  ReinitializeInput(int reinitialized_enum,int original_enum);
     97
    8798                /*}}}*/
    8899                /*not implemented: {{{1*/
    … …  
    91102                void  GetBedList(double*);
    92103                void  GetThicknessList(double* thickness_list);
    93                 void  Du(Vec, int,int);
    94                 void  Gradj(Vec,  int, int,int);
    95                 void  GradjDrag(Vec,  int,int );
    96                 void  GradjB(Vec,  int,int );
    97                 double Misfit(int,int);
    98                 double SurfaceArea(int,int);
    99                 double CostFunction(int,int);
     104                void  Du(Vec);
     105                void  Gradj(Vec,  int control_type);
     106                void  GradjDrag(Vec);
     107                void  GradjB(Vec);
     108                double Misfit(void);
     109                double SurfaceArea(void);
     110                double CostFunction(void);
    100111                void  GetNodalFunctions(double* l1l2, double gauss_coord);
    101112                void  GetParameterValue(double* pvalue, double* value_list,double gauss_coord);
    102113                void  GetJacobianDeterminant(double* pJdet,double* z_list, double gauss_coord);
    103                 double MassFlux(double* segment,double* ug);
     114                double MassFlux(double* segment);
    104115                /*}}}*/
    105116

  • TabularUnified issm/trunk/src/c/objects/Elements/Element.h

    r4042 r4043  
    2727                virtual void   Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* materials,Parameters* parameters)=0;
    2828               
    29                 virtual void   CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type)=0;
    30                 virtual void   CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type)=0;
    31                 virtual void   GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type)=0;
     29                virtual void   CreateKMatrix(Mat Kgg)=0;
     30                virtual void   CreatePVector(Vec pg)=0;
     31                virtual void   GetSolutionFromInputs(Vec solution)=0;
    3232                virtual void   GetNodes(void** nodes)=0;
    3333                virtual void*  GetMatPar()=0;
    … …  
    3636                virtual void   GetThicknessList(double* thickness_list)=0;
    3737                virtual void   GetBedList(double* bed_list)=0;
    38                 virtual void   Du(Vec du_g,int analysis_type,int sub_analysis_type)=0;
    39                 virtual void   Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type)=0;
    40                 virtual void   GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type)=0;
    41                 virtual void   GradjB(Vec grad_g,int analysis_type,int sub_analysis_type)=0;
    42                 virtual double Misfit(int analysis_type,int sub_analysis_type)=0;
    43                 virtual double CostFunction(int analysis_type,int sub_analysis_type)=0;
    44                 virtual double SurfaceArea(int analysis_type,int sub_analysis_type)=0;
     38                virtual void   Du(Vec du_g)=0;
     39                virtual void   Gradj(Vec grad_g,int control_type)=0;
     40                virtual void   GradjDrag(Vec grad_g)=0;
     41                virtual void   GradjB(Vec grad_g)=0;
     42                virtual double Misfit(void)=0;
     43                virtual double CostFunction(void)=0;
     44                virtual double SurfaceArea(void)=0;
    4545                virtual void   DepthAverageInputAtBase(int enum_type)=0;
    46                 virtual void   ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type)=0;
    47                 virtual void   ComputePressure(Vec p_g,       int analysis_type,int sub_analysis_type)=0;
    48                 virtual void   ComputeStrainRate(Vec eps,     int analysis_type,int sub_analysis_type)=0;
    49                 virtual double MassFlux(double* segment,double* ug)=0;
     46                virtual void   ComputeBasalStress(Vec sigma_b)=0;
     47                virtual void   ComputePressure(Vec p_g)=0;
     48                virtual void   ComputeStrainRate(Vec eps)=0;
     49                virtual double MassFlux(double* segment)=0;
    5050                virtual void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes)=0;
    5151                virtual void   PatchFill(int* pcount, Patch* patch)=0;
    … …  
    5555                virtual void   MinVel(double* pminvel, bool process_units)=0;
    5656                virtual void   MaxVel(double* pmaxvel, bool process_units)=0;
     57                virtual void   MinVx(double* pminvx, bool process_units)=0;
     58                virtual void   MaxVx(double* pmaxvx, bool process_units)=0;
     59                virtual void   MaxAbsVx(double* pmaxabsvx, bool process_units)=0;
     60                virtual void   MinVy(double* pminvy, bool process_units)=0;
     61                virtual void   MaxVy(double* pmaxvy, bool process_units)=0;
     62                virtual void   MaxAbsVy(double* pmaxabsvy, bool process_units)=0;
     63                virtual void   MinVz(double* pminvz, bool process_units)=0;
     64                virtual void   MaxVz(double* pmaxvz, bool process_units)=0;
     65                virtual void   MaxAbsVz(double* pmaxabsvz, bool process_units)=0;
     66                virtual void   ReinitializeInput(int reinitialized_enum,int original_enum)=0;
     67
    5768
    5869                /*Implementation: */

  • TabularUnified issm/trunk/src/c/objects/Elements/Penta.cpp

    r4042 r4043  
    632632/*}}}*/
    633633/*FUNCTION Penta::UpdateInputsFromSolution {{{1*/
    634 void  Penta::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){
     634void  Penta::UpdateInputsFromSolution(double* solution){
     635
     636        int analysis_type,sub_analysis_type;
     637
     638        /*retrive parameters: */
     639        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     640        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    635641
    636642        /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */
    637643        if (analysis_type==ControlAnalysisEnum){
    638644               
    639                 UpdateInputsFromSolutionDiagnosticHoriz( solution,analysis_type,sub_analysis_type);
     645                UpdateInputsFromSolutionDiagnosticHoriz( solution);
    640646        }
    641647        else if (analysis_type==DiagnosticAnalysisEnum){
    … …  
    643649                if (sub_analysis_type==HorizAnalysisEnum){
    644650
    645                         UpdateInputsFromSolutionDiagnosticHoriz( solution,analysis_type,sub_analysis_type);
     651                        UpdateInputsFromSolutionDiagnosticHoriz( solution);
    646652                }
    647653                else if (sub_analysis_type==StokesAnalysisEnum){
    648654
    649                         UpdateInputsFromSolutionDiagnosticStokes( solution,analysis_type,sub_analysis_type);
     655                        UpdateInputsFromSolutionDiagnosticStokes( solution);
    650656                }
    651657                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    … …  
    654660        else if (analysis_type==SlopeComputeAnalysisEnum){
    655661
    656                 UpdateInputsFromSolutionSlopeCompute( solution,analysis_type,sub_analysis_type);
     662                UpdateInputsFromSolutionSlopeCompute( solution);
    657663        }
    658664        else if (analysis_type==PrognosticAnalysisEnum){
    659665
    660                 UpdateInputsFromSolutionPrognostic( solution,analysis_type,sub_analysis_type);
     666                UpdateInputsFromSolutionPrognostic( solution);
    661667        }
    662668        else if (analysis_type==Prognostic2AnalysisEnum){
    663669
    664                 UpdateInputsFromSolutionPrognostic2(solution,analysis_type,sub_analysis_type);
     670                UpdateInputsFromSolutionPrognostic2(solution);
    665671        }
    666672        else if (analysis_type==BalancedthicknessAnalysisEnum){
    667673
    668                 UpdateInputsFromSolutionBalancedthickness( solution,analysis_type,sub_analysis_type);
     674                UpdateInputsFromSolutionBalancedthickness( solution);
    669675        }
    670676        else if (analysis_type==Balancedthickness2AnalysisEnum){
    671677
    672                 UpdateInputsFromSolutionBalancedthickness2( solution,analysis_type,sub_analysis_type);
     678                UpdateInputsFromSolutionBalancedthickness2( solution);
    673679        }
    674680        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    675681
    676                 UpdateInputsFromSolutionBalancedvelocities( solution,analysis_type,sub_analysis_type);
     682                UpdateInputsFromSolutionBalancedvelocities( solution);
    677683        }
    678684        else{
    … …  
    683689/*Object functions*/
    684690/*FUNCTION Penta::UpdateInputsFromSolutionDiagnosticHoriz {{{1*/
    685 void  Penta::UpdateInputsFromSolutionDiagnosticHoriz(double* solution, int analysis_type, int sub_analysis_type){
     691void  Penta::UpdateInputsFromSolutionDiagnosticHoriz(double* solution){
    686692       
    687693       
    … …  
    744750/*}}}*/
    745751/*FUNCTION Penta::UpdateInputsFromSolutionDiagnosticStokes {{{1*/
    746 void  Penta::UpdateInputsFromSolutionDiagnosticStokes(double* solution, int analysis_type, int sub_analysis_type){
     752void  Penta::UpdateInputsFromSolutionDiagnosticStokes(double* solution){
    747753       
    748754       
    … …  
    801807/*}}}*/
    802808/*FUNCTION Penta::UpdateInputsFromSolutionSlopeCompute {{{1*/
    803 void  Penta::UpdateInputsFromSolutionSlopeCompute(double* solution, int analysis_type, int sub_analysis_type){
     809void  Penta::UpdateInputsFromSolutionSlopeCompute(double* solution){
    804810        ISSMERROR(" not supported yet!");
    805811}
    806812/*}}}*/
    807813/*FUNCTION Penta::UpdateInputsFromSolutionPrognostic {{{1*/
    808 void  Penta::UpdateInputsFromSolutionPrognostic(double* solution, int analysis_type, int sub_analysis_type){
     814void  Penta::UpdateInputsFromSolutionPrognostic(double* solution){
    809815        ISSMERROR(" not supported yet!");
    810816}
    811817/*}}}*/
    812818/*FUNCTION Penta::UpdateInputsFromSolutionPrognostic2 {{{1*/
    813 void  Penta::UpdateInputsFromSolutionPrognostic2(double* solution, int analysis_type, int sub_analysis_type){
     819void  Penta::UpdateInputsFromSolutionPrognostic2(double* solution){
    814820        ISSMERROR(" not supported yet!");
    815821}
    816822/*}}}*/
    817823/*FUNCTION Penta::UpdateInputsFromSolutionBalancedthickness {{{1*/
    818 void  Penta::UpdateInputsFromSolutionBalancedthickness(double* solution, int analysis_type, int sub_analysis_type){
     824void  Penta::UpdateInputsFromSolutionBalancedthickness(double* solution){
    819825        ISSMERROR(" not supported yet!");
    820826}
    821827/*}}}*/
    822828/*FUNCTION Penta::UpdateInputsFromSolutionBalancedthickness2 {{{1*/
    823 void  Penta::UpdateInputsFromSolutionBalancedthickness2(double* solution, int analysis_type, int sub_analysis_type){
     829void  Penta::UpdateInputsFromSolutionBalancedthickness2(double* solution){
    824830        ISSMERROR(" not supported yet!");
    825831}
    826832/*}}}*/
    827833/*FUNCTION Penta::UpdateInputsFromSolutionBalancedvelocities {{{1*/
    828 void  Penta::UpdateInputsFromSolutionBalancedvelocities(double* solution, int analysis_type, int sub_analysis_type){
     834void  Penta::UpdateInputsFromSolutionBalancedvelocities(double* solution){
    829835        ISSMERROR(" not supported yet!");
    830836}
    831837/*}}}*/
    832 /*FUNCTION Penta::GetSolutionFromInputs(Vec solution,int analysis_type,int sub_analysis_type){{{1*/
    833 void  Penta::GetSolutionFromInputs(Vec solution,int analysis_type,int sub_analysis_type){
     838/*FUNCTION Penta::GetSolutionFromInputs(Vec solution){{{1*/
     839void  Penta::GetSolutionFromInputs(Vec solution){
     840
     841        int analysis_type,sub_analysis_type;
     842
     843        /*retrive parameters: */
     844        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     845        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
     846
     847
    834848        /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */
    835849        if (analysis_type==DiagnosticAnalysisEnum){
    836850                if (sub_analysis_type==HorizAnalysisEnum){
    837                         GetSolutionFromInputsDiagnosticHoriz(solution,analysis_type,sub_analysis_type);
     851                        GetSolutionFromInputsDiagnosticHoriz(solution);
    838852                }
    839853                else if(sub_analysis_type==VertAnalysisEnum){
    840                         GetSolutionFromInputsDiagnosticVert(solution,analysis_type,sub_analysis_type);
     854                        GetSolutionFromInputsDiagnosticVert(solution);
    841855                }
    842856                else if(sub_analysis_type==StokesAnalysisEnum){
    843                         GetSolutionFromInputsDiagnosticStokes(solution,analysis_type,sub_analysis_type);
     857                        GetSolutionFromInputsDiagnosticStokes(solution);
    844858                }
    845859                else ISSMERROR("sub_analysis: %i (%s) not supported yet",sub_analysis_type,EnumAsString(sub_analysis_type));
    … …  
    850864}
    851865/*}}}*/
    852 /*FUNCTION Penta::GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type){{{1*/
    853 void  Penta::GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type){
     866/*FUNCTION Penta::GetSolutionFromInputsDiagnosticHoriz(Vec solution){{{1*/
     867void  Penta::GetSolutionFromInputsDiagnosticHoriz(Vec solution){
    854868
    855869        int i;
    … …  
    886900}
    887901/*}}}*/
    888 /*FUNCTION Penta::GetSolutionFromInputsDiagnosticVert(Vec solution,int analysis_type,int sub_analysis_type){{{1*/
    889 void  Penta::GetSolutionFromInputsDiagnosticVert(Vec solution,int analysis_type,int sub_analysis_type){
     902/*FUNCTION Penta::GetSolutionFromInputsDiagnosticVert(Vec solution){{{1*/
     903void  Penta::GetSolutionFromInputsDiagnosticVert(Vec solution){
    890904
    891905        int i;
    … …  
    918932}
    919933/*}}}*/
    920 /*FUNCTION Penta::GetSolutionFromInputsDiagnosticStokes(Vec solution,int analysis_type,int sub_analysis_type){{{1*/
    921 void  Penta::GetSolutionFromInputsDiagnosticStokes(Vec solution,int analysis_type,int sub_analysis_type){
     934/*FUNCTION Penta::GetSolutionFromInputsDiagnosticStokes(Vec solution){{{1*/
     935void  Penta::GetSolutionFromInputsDiagnosticStokes(Vec solution){
    922936
    923937        int i;
    … …  
    10011015/*}}}*/
    10021016/*FUNCTION Penta::ComputeBasalStress {{{1*/
    1003 void  Penta::ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type){
     1017void  Penta::ComputeBasalStress(Vec sigma_b){
    10041018
    10051019        int i,j;
    … …  
    10191033        double stresstensor[6]={0.0};
    10201034        double viscosity;
     1035        int analysis_type,sub_analysis_type;
    10211036
    10221037        int  dofv[3]={0,1,2};
    … …  
    10471062        double stokesreconditioning;
    10481063
     1064
     1065        /*retrive parameters: */
     1066        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     1067        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
     1068
    10491069        /*Check analysis_types*/
    10501070        if (analysis_type!=DiagnosticAnalysisEnum || sub_analysis_type!=StokesAnalysisEnum) ISSMERROR("Not supported yet!");
    … …  
    11231143/*}}}*/
    11241144/*FUNCTION Penta::ComputePressure {{{1*/
    1125 void  Penta::ComputePressure(Vec pg,int analysis_type,int sub_analysis_type){
     1145void  Penta::ComputePressure(Vec pg){
    11261146
    11271147        int i;
    … …  
    11681188/*}}}*/
    11691189/*FUNCTION Penta::ComputeStrainRate {{{1*/
    1170 void  Penta::ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type){
     1190void  Penta::ComputeStrainRate(Vec eps){
    11711191
    11721192        ISSMERROR("Not implemented yet");
    … …  
    11751195/*}}}*/
    11761196/*FUNCTION Penta::CostFunction {{{1*/
    1177 double Penta::CostFunction(int analysis_type,int sub_analysis_type){
     1197double Penta::CostFunction(void){
    11781198
    11791199        double J;
    … …  
    12061226                 * and compute CostFunction*/
    12071227                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face).
    1208                 J=tria->CostFunction(analysis_type,sub_analysis_type);
     1228                J=tria->CostFunction();
    12091229                delete tria;
    12101230                return J;
    … …  
    12131233
    12141234                tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face).
    1215                 J=tria->CostFunction(analysis_type,sub_analysis_type);
     1235                J=tria->CostFunction();
    12161236                delete tria;
    12171237                return J;
    … …  
    12201240/*}}}*/
    12211241/*FUNCTION Penta::CreateKMatrix {{{1*/
    1222 void  Penta::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     1242void  Penta::CreateKMatrix(Mat Kgg){
     1243
     1244        int analysis_type,sub_analysis_type;
     1245
     1246        /*retrive parameters: */
     1247        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     1248        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    12231249
    12241250        /*if debugging mode, check that all pointers exist*/
    … …  
    12271253        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    12281254        if (analysis_type==ControlAnalysisEnum){
    1229                 CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type);
     1255                CreateKMatrixDiagnosticHoriz( Kgg);
    12301256        }
    12311257        else if (analysis_type==DiagnosticAnalysisEnum){
    12321258                if (sub_analysis_type==HorizAnalysisEnum){
    1233                         CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type);
     1259                        CreateKMatrixDiagnosticHoriz( Kgg);
    12341260                }
    12351261                else if (sub_analysis_type==HutterAnalysisEnum){
    1236                         CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type);
     1262                        CreateKMatrixDiagnosticHutter( Kgg);
    12371263                }
    12381264                else if (sub_analysis_type==VertAnalysisEnum){
    1239                         CreateKMatrixDiagnosticVert( Kgg,analysis_type,sub_analysis_type);
     1265                        CreateKMatrixDiagnosticVert( Kgg);
    12401266                }
    12411267                else if (sub_analysis_type==StokesAnalysisEnum){
    1242                         CreateKMatrixDiagnosticStokes( Kgg,analysis_type,sub_analysis_type);
     1268                        CreateKMatrixDiagnosticStokes( Kgg);
    12431269                }
    12441270                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    12451271        }
    12461272        else if (analysis_type==SlopeComputeAnalysisEnum){
    1247                 CreateKMatrixSlopeCompute( Kgg,analysis_type,sub_analysis_type);
     1273                CreateKMatrixSlopeCompute( Kgg);
    12481274        }
    12491275        else if (analysis_type==PrognosticAnalysisEnum){
    1250                 CreateKMatrixPrognostic( Kgg,analysis_type,sub_analysis_type);
     1276                CreateKMatrixPrognostic( Kgg);
    12511277        }
    12521278        else if (analysis_type==BalancedthicknessAnalysisEnum){
    1253                 CreateKMatrixBalancedthickness( Kgg,analysis_type,sub_analysis_type);
     1279                CreateKMatrixBalancedthickness( Kgg);
    12541280        }
    12551281        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    1256                 CreateKMatrixBalancedvelocities( Kgg,analysis_type,sub_analysis_type);
     1282                CreateKMatrixBalancedvelocities( Kgg);
    12571283        }
    12581284        else if (analysis_type==ThermalAnalysisEnum){
    1259                 CreateKMatrixThermal( Kgg,analysis_type,sub_analysis_type);
     1285                CreateKMatrixThermal( Kgg);
    12601286        }
    12611287        else if (analysis_type==MeltingAnalysisEnum){
    1262                 CreateKMatrixMelting( Kgg,analysis_type,sub_analysis_type);
     1288                CreateKMatrixMelting( Kgg);
    12631289        }
    12641290        else ISSMERROR("%s%i%s\n","analysis: ",analysis_type," not supported yet");
    … …  
    12681294/*FUNCTION Penta::CreateKMatrixBalancedthickness {{{1*/
    12691295
    1270 void  Penta::CreateKMatrixBalancedthickness(Mat Kgg,int analysis_type,int sub_analysis_type){
     1296void  Penta::CreateKMatrixBalancedthickness(Mat Kgg){
    12711297
    12721298        /*Collapsed formulation: */
    … …  
    12891315        /*Spawn Tria element from the base of the Penta: */
    12901316        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    1291         tria->CreateKMatrix(Kgg, analysis_type,sub_analysis_type);
     1317        tria->CreateKMatrix(Kgg);
    12921318        delete tria;
    12931319        return;
    … …  
    12971323/*FUNCTION Penta::CreateKMatrixBalancedvelocities {{{1*/
    12981324
    1299 void  Penta::CreateKMatrixBalancedvelocities(Mat Kgg,int analysis_type,int sub_analysis_type){
     1325void  Penta::CreateKMatrixBalancedvelocities(Mat Kgg){
    13001326
    13011327        /*Collapsed formulation: */
    … …  
    13181344        /*Spawn Tria element from the base of the Penta: */
    13191345        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    1320         tria->CreateKMatrix(Kgg,analysis_type,sub_analysis_type);
     1346        tria->CreateKMatrix(Kgg);
    13211347        delete tria;
    13221348        return;
    … …  
    13251351/*}}}*/
    13261352/*FUNCTION Penta::CreateKMatrixDiagnosticHoriz {{{1*/
    1327 void Penta::CreateKMatrixDiagnosticHoriz( Mat Kgg,  int analysis_type,int sub_analysis_type){
     1353void Penta::CreateKMatrixDiagnosticHoriz( Mat Kgg){
    13281354
    13291355        /* local declarations */
    … …  
    14371463                 *and use its CreateKMatrix functionality to fill the global stiffness matrix: */
    14381464                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    1439                 tria->CreateKMatrix(Kgg, analysis_type,sub_analysis_type);
     1465                tria->CreateKMatrix(Kgg);
    14401466                delete tria;
    14411467                return;
    … …  
    15281554
    15291555                        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    1530                         tria->CreateKMatrixDiagnosticHorizFriction(Kgg,analysis_type,sub_analysis_type);
     1556                        tria->CreateKMatrixDiagnosticHorizFriction(Kgg);
    15311557                        delete tria;
    15321558                }
    … …  
    15481574/*}}}*/
    15491575/*FUNCTION Penta::CreateKMatrixDiagnosticHutter{{{1*/
    1550 void  Penta::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){
     1576void  Penta::CreateKMatrixDiagnosticHutter(Mat Kgg){
    15511577
    15521578        /*Collapsed formulation: */
    … …  
    15661592        for(i=0;i<3;i++){
    15671593                beam=(Beam*)SpawnBeam(i,i+3); //[0 3], [1 4] and [2 5] are the four vertical edges of the Penta
    1568                 beam->CreateKMatrix(Kgg,analysis_type,sub_analysis_type);
     1594                beam->CreateKMatrix(Kgg);
    15691595        }
    15701596
    … …  
    15751601/*}}}*/
    15761602/*FUNCTION Penta::CreateKMatrixDiagnosticStokes {{{1*/
    1577 void Penta::CreateKMatrixDiagnosticStokes( Mat Kgg,  int analysis_type,int sub_analysis_type){
     1603void Penta::CreateKMatrixDiagnosticStokes( Mat Kgg){
    15781604
    15791605        int i,j;
    … …  
    16491675        /*parameters: */
    16501676        double stokesreconditioning;
     1677        int analysis_type;
    16511678
    16521679        /*inputs: */
    … …  
    16541681        bool onbed;
    16551682        bool shelf;
     1683
     1684        /*retrive parameters: */
     1685        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    16561686
    16571687        /*retrieve inputs :*/
    … …  
    18401870/*}}}*/
    18411871/*FUNCTION Penta::CreateKMatrixDiagnosticVert {{{1*/
    1842 void Penta::CreateKMatrixDiagnosticVert( Mat Kgg,  int analysis_type,int sub_analysis_type){
     1872void Penta::CreateKMatrixDiagnosticVert( Mat Kgg){
    18431873
    18441874        /* local declarations */
    … …  
    18951925        if(onsurface){
    18961926                tria=(Tria*)SpawnTria(3,4,5); //nodes 3,4 and 5 are on the surface
    1897                 tria->CreateKMatrixDiagnosticSurfaceVert(Kgg, analysis_type,sub_analysis_type);
     1927                tria->CreateKMatrixDiagnosticSurfaceVert(Kgg);
    18981928                delete tria;
    18991929        }
    … …  
    19651995/*}}}*/
    19661996/*FUNCTION Penta::CreateKMatrixMelting {{{1*/
    1967 void  Penta::CreateKMatrixMelting(Mat Kgg,int analysis_type,int sub_analysis_type){
     1997void  Penta::CreateKMatrixMelting(Mat Kgg){
    19681998
    19691999        Tria* tria=NULL;
    … …  
    19862016
    19872017                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    1988                 tria->CreateKMatrixMelting(Kgg, analysis_type,sub_analysis_type);
     2018                tria->CreateKMatrixMelting(Kgg);
    19892019                delete tria;
    19902020                return;
    … …  
    19942024/*FUNCTION Penta::CreateKMatrixPrognostic {{{1*/
    19952025
    1996 void  Penta::CreateKMatrixPrognostic(Mat Kgg,int analysis_type,int sub_analysis_type){
     2026void  Penta::CreateKMatrixPrognostic(Mat Kgg){
    19972027
    19982028        /*Collapsed formulation: */
    … …  
    20152045        /*Spawn Tria element from the base of the Penta: */
    20162046        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    2017         tria->CreateKMatrix(Kgg, analysis_type,sub_analysis_type);
     2047        tria->CreateKMatrix(Kgg);
    20182048        delete tria;
    20192049        return;
    … …  
    20232053/*FUNCTION Penta::CreateKMatrixSlopeCompute {{{1*/
    20242054
    2025 void  Penta::CreateKMatrixSlopeCompute(Mat Kgg,int analysis_type,int sub_analysis_type){
     2055void  Penta::CreateKMatrixSlopeCompute(Mat Kgg){
    20262056
    20272057        /*Collapsed formulation: */
    … …  
    20452075        /*Spawn Tria element from the base of the Penta: */
    20462076        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    2047         tria->CreateKMatrix(Kgg, analysis_type,sub_analysis_type);
     2077        tria->CreateKMatrix(Kgg);
    20482078        delete tria;
    20492079        return;
    … …  
    20522082/*}}}*/
    20532083/*FUNCTION Penta::CreateKMatrixThermal {{{1*/
    2054 void  Penta::CreateKMatrixThermal(Mat Kgg,int analysis_type,int sub_analysis_type){
     2084void  Penta::CreateKMatrixThermal(Mat Kgg){
    20552085
    20562086        /* local declarations */
    … …  
    22912321
    22922322                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    2293                 tria->CreateKMatrixThermal(Kgg, analysis_type,sub_analysis_type);
     2323                tria->CreateKMatrixThermal(Kgg);
    22942324                delete tria;
    22952325        }
    … …  
    22972327/*}}}*/
    22982328/*FUNCTION Penta::CreatePVector {{{1*/
    2299 void  Penta::CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type){
     2329void  Penta::CreatePVector(Vec pg){
     2330
     2331        int analysis_type,sub_analysis_type;
     2332
     2333        /*retrive parameters: */
     2334        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     2335        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    23002336
    23012337        /*if debugging mode, check that all pointers exist*/
    … …  
    23042340        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    23052341        if (analysis_type==ControlAnalysisEnum){
    2306                 CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type);
     2342                CreatePVectorDiagnosticHoriz( pg);
    23072343        }
    23082344        else if (analysis_type==DiagnosticAnalysisEnum){
    23092345                if (sub_analysis_type==HorizAnalysisEnum){
    2310                         CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type);
     2346                        CreatePVectorDiagnosticHoriz( pg);
    23112347                }
    23122348                else if (sub_analysis_type==HutterAnalysisEnum){
    2313                         CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type);
     2349                        CreatePVectorDiagnosticHutter( pg);
    23142350                }
    23152351                else if (sub_analysis_type==VertAnalysisEnum){
    2316                         CreatePVectorDiagnosticVert( pg,analysis_type,sub_analysis_type);
     2352                        CreatePVectorDiagnosticVert( pg);
    23172353                }
    23182354                else if (sub_analysis_type==StokesAnalysisEnum){
    2319                         CreatePVectorDiagnosticStokes( pg,analysis_type,sub_analysis_type);
     2355                        CreatePVectorDiagnosticStokes( pg);
    23202356                }
    23212357                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    23222358        }
    23232359        else if (analysis_type==SlopeComputeAnalysisEnum){
    2324                 CreatePVectorSlopeCompute( pg,analysis_type,sub_analysis_type);
     2360                CreatePVectorSlopeCompute( pg);
    23252361        }
    23262362        else if (analysis_type==PrognosticAnalysisEnum){
    2327                 CreatePVectorPrognostic( pg,analysis_type,sub_analysis_type);
     2363                CreatePVectorPrognostic( pg);
    23282364        }
    23292365        else if (analysis_type==BalancedthicknessAnalysisEnum){
    2330                 CreatePVectorBalancedthickness( pg,analysis_type,sub_analysis_type);
     2366                CreatePVectorBalancedthickness( pg);
    23312367        }
    23322368        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    2333                 CreatePVectorBalancedvelocities( pg,analysis_type,sub_analysis_type);
     2369                CreatePVectorBalancedvelocities( pg);
    23342370        }
    23352371        else if (analysis_type==ThermalAnalysisEnum){
    2336                 CreatePVectorThermal( pg,analysis_type,sub_analysis_type);
     2372                CreatePVectorThermal( pg);
    23372373        }
    23382374        else if (analysis_type==MeltingAnalysisEnum){
    2339                 CreatePVectorMelting( pg,analysis_type,sub_analysis_type);
     2375                CreatePVectorMelting( pg);
    23402376        }
    23412377        else ISSMERROR("%s%i%s\n","analysis: ",analysis_type," not supported yet");
    … …  
    23442380/*}}}*/
    23452381/*FUNCTION Penta::CreatePVectorBalancedthickness {{{1*/
    2346 void Penta::CreatePVectorBalancedthickness( Vec pg, int analysis_type,int sub_analysis_type){
     2382void Penta::CreatePVectorBalancedthickness( Vec pg){
    23472383
    23482384        /*Collapsed formulation: */
    … …  
    23652401        /*Spawn Tria element from the base of the Penta: */
    23662402        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    2367         tria->CreatePVector(pg, analysis_type,sub_analysis_type);
     2403        tria->CreatePVector(pg);
    23682404        delete tria;
    23692405        return;
    … …  
    23712407/*}}}*/
    23722408/*FUNCTION Penta::CreatePVectorBalancedvelocities {{{1*/
    2373 void Penta::CreatePVectorBalancedvelocities( Vec pg, int analysis_type,int sub_analysis_type){
     2409void Penta::CreatePVectorBalancedvelocities( Vec pg){
    23742410
    23752411        /*Collapsed formulation: */
    … …  
    23922428        /*Spawn Tria element from the base of the Penta: */
    23932429        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    2394         tria->CreatePVector(pg, analysis_type,sub_analysis_type);
     2430        tria->CreatePVector(pg);
    23952431        delete tria;
    23962432        return;
    … …  
    23982434/*}}}*/
    23992435/*FUNCTION Penta::CreatePVectorDiagnosticHoriz {{{1*/
    2400 void Penta::CreatePVectorDiagnosticHoriz( Vec pg, int analysis_type,int sub_analysis_type){
     2436void Penta::CreatePVectorDiagnosticHoriz( Vec pg){
    24012437
    24022438        int i,j;
    … …  
    24712507                 *and use its CreatePVector functionality to return an elementary load vector: */
    24722508                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    2473                 tria->CreatePVector(pg, analysis_type,sub_analysis_type);
     2509                tria->CreatePVector(pg);
    24742510                delete tria;
    24752511                return;
    … …  
    25462582/*}}}*/
    25472583/*FUNCTION Penta::CreatePVectorDiagnosticHutter{{{1*/
    2548 void  Penta::CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type){
     2584void  Penta::CreatePVectorDiagnosticHutter(Vec pg){
    25492585
    25502586        /*Collapsed formulation: */
    … …  
    25642600        for(i=0;i<3;i++){
    25652601                beam=(Beam*)SpawnBeam(i,i+3); //[0 3], [1 4] and [2 5] are the four vertical edges of the Penta
    2566                 beam->CreatePVector(pg,analysis_type,sub_analysis_type);
     2602                beam->CreatePVector(pg);
    25672603        }
    25682604
    … …  
    25732609/*}}}*/
    25742610/*FUNCTION Penta::CreatePVectorDiagnosticStokes {{{1*/
    2575 void Penta::CreatePVectorDiagnosticStokes( Vec pg, int analysis_type,int sub_analysis_type){
     2611void Penta::CreatePVectorDiagnosticStokes( Vec pg){
    25762612
    25772613        /*indexing: */
    … …  
    28142850/*}}}*/
    28152851/*FUNCTION Penta::CreatePVectorDiagnosticVert {{{1*/
    2816 void  Penta::CreatePVectorDiagnosticVert( Vec pg, int analysis_type,int sub_analysis_type){
     2852void  Penta::CreatePVectorDiagnosticVert( Vec pg){
    28172853
    28182854        int i;
    … …  
    28752911        if(onbed){
    28762912                tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 are on the bedrock
    2877                 tria->CreatePVectorDiagnosticBaseVert(pg, analysis_type,sub_analysis_type);
     2913                tria->CreatePVectorDiagnosticBaseVert(pg);
    28782914                delete tria;
    28792915        }
    … …  
    29402976/*}}}*/
    29412977/*FUNCTION Penta::CreatePVectorMelting {{{1*/
    2942 void Penta::CreatePVectorMelting( Vec pg, int analysis_type,int sub_analysis_type){
     2978void Penta::CreatePVectorMelting( Vec pg){
    29432979        return;
    29442980}
    … …  
    29462982/*FUNCTION Penta::CreatePVectorPrognostic {{{1*/
    29472983
    2948 void Penta::CreatePVectorPrognostic( Vec pg,  int analysis_type,int sub_analysis_type){
     2984void Penta::CreatePVectorPrognostic( Vec pg){
    29492985
    29502986        /*Collapsed formulation: */
    … …  
    29673003        /*Spawn Tria element from the base of the Penta: */
    29683004        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    2969         tria->CreatePVector(pg, analysis_type,sub_analysis_type);
     3005        tria->CreatePVector(pg);
    29703006        delete tria;
    29713007        return;
    … …  
    29743010/*FUNCTION Penta::CreatePVectorSlopeCompute {{{1*/
    29753011
    2976 void Penta::CreatePVectorSlopeCompute( Vec pg,  int analysis_type,int sub_analysis_type){
     3012void Penta::CreatePVectorSlopeCompute( Vec pg){
    29773013
    29783014        /*Collapsed formulation: */
    … …  
    29953031        /*Spawn Tria element from the base of the Penta: */
    29963032        tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    2997         tria->CreatePVector(pg, analysis_type,sub_analysis_type);
     3033        tria->CreatePVector(pg);
    29983034        delete tria;
    29993035        return;
    … …  
    30013037/*}}}*/
    30023038/*FUNCTION Penta::CreatePVectorThermal {{{1*/
    3003 void Penta::CreatePVectorThermal( Vec pg, int analysis_type,int sub_analysis_type){
     3039void Penta::CreatePVectorThermal( Vec pg){
    30043040
    30053041        /*indexing: */
    … …  
    31603196
    31613197                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    3162                 tria->CreatePVectorThermalShelf(pg, analysis_type,sub_analysis_type);
     3198                tria->CreatePVectorThermalShelf(pg);
    31633199                delete tria;
    31643200        }
    … …  
    31683204
    31693205                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    3170                 tria->CreatePVectorThermalSheet(pg, analysis_type,sub_analysis_type);
     3206                tria->CreatePVectorThermalSheet(pg);
    31713207                delete tria;
    31723208        }
    … …  
    31833219/*}}}*/
    31843220/*FUNCTION Penta::Du {{{1*/
    3185 void  Penta::Du(Vec du_g,int analysis_type,int sub_analysis_type){
     3221void  Penta::Du(Vec du_g){
    31863222
    31873223        int i;
    … …  
    32143250                 * and compute Du*/
    32153251                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face).
    3216                 tria->Du(du_g,analysis_type,sub_analysis_type);
     3252                tria->Du(du_g);
    32173253                delete tria;
    32183254                return;
    … …  
    32213257
    32223258                tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face).
    3223                 tria->Du(du_g,analysis_type,sub_analysis_type);
     3259                tria->Du(du_g);
    32243260                delete tria;
    32253261                return;
    … …  
    45194555/*}}}*/
    45204556/*FUNCTION Penta::Gradj {{{1*/
    4521 void  Penta::Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type){
     4557void  Penta::Gradj(Vec grad_g,int control_type){
    45224558
    45234559        /*inputs: */
    … …  
    45314567
    45324568        if (control_type==DragCoefficientEnum){
    4533                 GradjDrag( grad_g,analysis_type,sub_analysis_type);
     4569                GradjDrag( grad_g);
    45344570        }
    45354571        else if (control_type=RheologyBEnum){
    4536                 GradjB( grad_g, analysis_type,sub_analysis_type);
     4572                GradjB( grad_g);
    45374573        }
    45384574        else ISSMERROR("%s%i","control type not supported yet: ",control_type);
    … …  
    45404576/*}}}*/
    45414577/*FUNCTION Penta::GradjDrag {{{1*/
    4542 void  Penta::GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type){
     4578void  Penta::GradjDrag(Vec grad_g){
    45434579
    45444580        Tria* tria=NULL;
    … …  
    45484584        bool onbed;
    45494585        bool shelf;
     4586        int analysis_type,sub_analysis_type;
     4587
     4588        /*retrive parameters: */
     4589        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     4590        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    45504591
    45514592        /*retrieve inputs :*/
    … …  
    45674608                /*MacAyeal or Pattyn*/
    45684609                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    4569                 tria->GradjDrag( grad_g,analysis_type,sub_analysis_type);
     4610                tria->GradjDrag( grad_g);
    45704611                delete tria;
    45714612                return;
    … …  
    45754616                /*Stokes*/
    45764617                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria.
    4577                 tria->GradjDragStokes( grad_g,analysis_type,sub_analysis_type);
     4618                tria->GradjDragStokes( grad_g);
    45784619                delete tria;
    45794620                return;
    … …  
    45834624/*}}}*/
    45844625/*FUNCTION Penta::GradjB {{{1*/
    4585 void  Penta::GradjB(Vec grad_g,int analysis_type,int sub_analysis_type){
     4626void  Penta::GradjB(Vec grad_g){
    45864627
    45874628        Tria* tria=NULL;
    … …  
    46074648                 * and compute gardj*/
    46084649                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face).
    4609                 tria->GradjB(grad_g,analysis_type,sub_analysis_type);
     4650                tria->GradjB(grad_g);
    46104651                delete tria;
    46114652                return;
    … …  
    46144655                /*B is a 2d field, use MacAyeal(2d) gradient even if it is Stokes or Pattyn*/
    46154656                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face).
    4616                 tria->GradjB(grad_g,analysis_type,sub_analysis_type);
     4657                tria->GradjB(grad_g);
    46174658                delete tria;
    46184659                return;
    … …  
    46214662/*}}}*/
    46224663/*FUNCTION Penta::MassFlux {{{1*/
    4623 double Penta::MassFlux( double* segment,double* ug){
     4664double Penta::MassFlux( double* segment){
    46244665        ISSMERROR(" not supported yet!");
    46254666}
    46264667/*}}}*/
    46274668/*FUNCTION Penta::Misfit {{{1*/
    4628 double Penta::Misfit(int analysis_type,int sub_analysis_type){
     4669double Penta::Misfit(void){
    46294670
    46304671        double J;
    … …  
    46574698                 * and compute Misfit*/
    46584699                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face).
    4659                 J=tria->Misfit(analysis_type,sub_analysis_type);
     4700                J=tria->Misfit();
    46604701                delete tria;
    46614702                return J;
    … …  
    46644705
    46654706                tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face).
    4666                 J=tria->Misfit(analysis_type,sub_analysis_type);
     4707                J=tria->Misfit();
    46674708                delete tria;
    46684709                return J;
    … …  
    47714812/*}}}1*/
    47724813/*FUNCTION Penta::SurfaceArea {{{1*/
    4773 double Penta::SurfaceArea(int analysis_type,int sub_analysis_type){
     4814double Penta::SurfaceArea(void){
    47744815
    47754816        double S;
    … …  
    48024843                 * and compute SurfaceArea*/
    48034844                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face).
    4804                 S=tria->SurfaceArea(analysis_type,sub_analysis_type);
     4845                S=tria->SurfaceArea();
    48054846                delete tria;
    48064847                return S;
    … …  
    48094850
    48104851                tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face).
    4811                 S=tria->SurfaceArea(analysis_type,sub_analysis_type);
     4852                S=tria->SurfaceArea();
    48124853                delete tria;
    48134854                return S;
    … …  
    49534994void  Penta::MinVel(double* pminvel, bool process_units){
    49544995
     4996        int i;
     4997        int dim;
    49554998        const int numgrids=6;
    49564999        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    … …  
    49715014        /*now, compute minimum of velocity :*/
    49725015        if(dim==2){
    4973                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
     5016                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
    49745017        }
    49755018        else{
    4976                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
     5019                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
    49775020        }
    49785021
    … …  
    49915034void  Penta::MaxVel(double* pmaxvel, bool process_units){
    49925035
     5036        int i;
     5037        int dim;
    49935038        const int numgrids=6;
    49945039        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    … …  
    50095054        /*now, compute maximum of velocity :*/
    50105055        if(dim==2){
    5011                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
     5056                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
    50125057        }
    50135058        else{
    5014                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
     5059                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
    50155060        }
    50165061
    … …  
    50265071}
    50275072/*}}}*/
     5073/*FUNCTION Penta::MinVx(double* pminvx, bool process_units);{{{1*/
     5074void  Penta::MinVx(double* pminvx, bool process_units){
     5075
     5076        int i;
     5077        int dim;
     5078        const int numgrids=6;
     5079        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5080        double  vx_values[numgrids];
     5081        double  minvx;
     5082
     5083        /*retrieve dim parameter: */
     5084        parameters->FindParam(&dim,DimEnum);
     5085
     5086        /*retrive velocity values at nodes */
     5087        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     5088
     5089        /*now, compute minimum:*/
     5090        minvx=vx_values[0];
     5091        for(i=1;i<numgrids;i++){
     5092                if (vx_values[i]<minvx)minvx=vx_values[i];
     5093        }
     5094
     5095        /*Assign output pointers:*/
     5096        *pminvx=minvx;
     5097
     5098}
     5099/*}}}*/
     5100/*FUNCTION Penta::MaxVx(double* pmaxvx, bool process_units);{{{1*/
     5101void  Penta::MaxVx(double* pmaxvx, bool process_units){
     5102
     5103        int i;
     5104        int dim;
     5105        const int numgrids=6;
     5106        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5107        double  vx_values[numgrids];
     5108        double  maxvx;
     5109
     5110        /*retrieve dim parameter: */
     5111        parameters->FindParam(&dim,DimEnum);
     5112
     5113        /*retrive velocity values at nodes */
     5114        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     5115
     5116        /*now, compute maximum:*/
     5117        maxvx=vx_values[0];
     5118        for(i=1;i<numgrids;i++){
     5119                if (vx_values[i]>maxvx)maxvx=vx_values[i];
     5120        }
     5121
     5122        /*Assign output pointers:*/
     5123        *pmaxvx=maxvx;
     5124
     5125}
     5126/*}}}*/
     5127/*FUNCTION Penta::MaxAbsVx(double* pmaxabsvx, bool process_units);{{{1*/
     5128void  Penta::MaxAbsVx(double* pmaxabsvx, bool process_units){
     5129
     5130        int i;
     5131        int dim;
     5132        const int numgrids=6;
     5133        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5134        double  vx_values[numgrids];
     5135        double  maxabsvx;
     5136
     5137        /*retrieve dim parameter: */
     5138        parameters->FindParam(&dim,DimEnum);
     5139
     5140        /*retrive velocity values at nodes */
     5141        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     5142
     5143        /*now, compute maximum:*/
     5144        maxabsvx=fabs(vx_values[0]);
     5145        for(i=1;i<numgrids;i++){
     5146                if (fabs(vx_values[i])>maxabsvx)maxabsvx=fabs(vx_values[i]);
     5147        }
     5148
     5149        /*Assign output pointers:*/
     5150        *pmaxabsvx=maxabsvx;
     5151}
     5152/*}}}*/
     5153/*FUNCTION Penta::MinVy(double* pminvy, bool process_units);{{{1*/
     5154void  Penta::MinVy(double* pminvy, bool process_units){
     5155
     5156        int i;
     5157        int dim;
     5158        const int numgrids=6;
     5159        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5160        double  vy_values[numgrids];
     5161        double  minvy;
     5162
     5163        /*retrieve dim parameter: */
     5164        parameters->FindParam(&dim,DimEnum);
     5165
     5166        /*retrive velocity values at nodes */
     5167        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     5168
     5169        /*now, compute minimum:*/
     5170        minvy=vy_values[0];
     5171        for(i=1;i<numgrids;i++){
     5172                if (vy_values[i]<minvy)minvy=vy_values[i];
     5173        }
     5174
     5175        /*Assign output pointers:*/
     5176        *pminvy=minvy;
     5177
     5178}
     5179/*}}}*/
     5180/*FUNCTION Penta::MaxVy(double* pmaxvy, bool process_units);{{{1*/
     5181void  Penta::MaxVy(double* pmaxvy, bool process_units){
     5182
     5183        int i;
     5184        int dim;
     5185        const int numgrids=6;
     5186        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5187        double  vy_values[numgrids];
     5188        double  maxvy;
     5189
     5190        /*retrieve dim parameter: */
     5191        parameters->FindParam(&dim,DimEnum);
     5192
     5193        /*retrive velocity values at nodes */
     5194        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     5195
     5196        /*now, compute maximum:*/
     5197        maxvy=vy_values[0];
     5198        for(i=1;i<numgrids;i++){
     5199                if (vy_values[i]>maxvy)maxvy=vy_values[i];
     5200        }
     5201
     5202        /*Assign output pointers:*/
     5203        *pmaxvy=maxvy;
     5204
     5205}
     5206/*}}}*/
     5207/*FUNCTION Penta::MaxAbsVy(double* pmaxabsvy, bool process_units);{{{1*/
     5208void  Penta::MaxAbsVy(double* pmaxabsvy, bool process_units){
     5209
     5210        int i;
     5211        int dim;
     5212        const int numgrids=6;
     5213        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5214        double  vy_values[numgrids];
     5215        double  maxabsvy;
     5216
     5217        /*retrieve dim parameter: */
     5218        parameters->FindParam(&dim,DimEnum);
     5219
     5220        /*retrive velocity values at nodes */
     5221        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     5222
     5223        /*now, compute maximum:*/
     5224        maxabsvy=fabs(vy_values[0]);
     5225        for(i=1;i<numgrids;i++){
     5226                if (fabs(vy_values[i])>maxabsvy)maxabsvy=fabs(vy_values[i]);
     5227        }
     5228
     5229        /*Assign output pointers:*/
     5230        *pmaxabsvy=maxabsvy;
     5231}
     5232/*}}}*/
     5233/*FUNCTION Penta::MinVz(double* pminvz, bool process_units);{{{1*/
     5234void  Penta::MinVz(double* pminvz, bool process_units){
     5235
     5236        int i;
     5237        int dim;
     5238        const int numgrids=6;
     5239        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5240        double  vz_values[numgrids];
     5241        double  minvz;
     5242
     5243        /*retrieve dim parameter: */
     5244        parameters->FindParam(&dim,DimEnum);
     5245
     5246        /*retrive velocity values at nodes */
     5247        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     5248
     5249        /*now, compute minimum:*/
     5250        minvz=vz_values[0];
     5251        for(i=1;i<numgrids;i++){
     5252                if (vz_values[i]<minvz)minvz=vz_values[i];
     5253        }
     5254
     5255        /*Assign output pointers:*/
     5256        *pminvz=minvz;
     5257
     5258}
     5259/*}}}*/
     5260/*FUNCTION Penta::MaxVz(double* pmaxvz, bool process_units);{{{1*/
     5261void  Penta::MaxVz(double* pmaxvz, bool process_units){
     5262
     5263        int i;
     5264        int dim;
     5265        const int numgrids=6;
     5266        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5267        double  vz_values[numgrids];
     5268        double  maxvz;
     5269
     5270        /*retrieve dim parameter: */
     5271        parameters->FindParam(&dim,DimEnum);
     5272
     5273        /*retrive velocity values at nodes */
     5274        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     5275
     5276        /*now, compute maximum:*/
     5277        maxvz=vz_values[0];
     5278        for(i=1;i<numgrids;i++){
     5279                if (vz_values[i]>maxvz)maxvz=vz_values[i];
     5280        }
     5281
     5282        /*Assign output pointers:*/
     5283        *pmaxvz=maxvz;
     5284
     5285}
     5286/*}}}*/
     5287/*FUNCTION Penta::MaxAbsVz(double* pmaxabsvz, bool process_units);{{{1*/
     5288void  Penta::MaxAbsVz(double* pmaxabsvz, bool process_units){
     5289
     5290        int i;
     5291        int dim;
     5292        const int numgrids=6;
     5293        double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
     5294        double  vz_values[numgrids];
     5295        double  maxabsvz;
     5296
     5297        /*retrieve dim parameter: */
     5298        parameters->FindParam(&dim,DimEnum);
     5299
     5300        /*retrive velocity values at nodes */
     5301        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     5302
     5303        /*now, compute maximum:*/
     5304        maxabsvz=fabs(vz_values[0]);
     5305        for(i=1;i<numgrids;i++){
     5306                if (fabs(vz_values[i])>maxabsvz)maxabsvz=fabs(vz_values[i]);
     5307        }
     5308
     5309        /*Assign output pointers:*/
     5310        *pmaxabsvz=maxabsvz;
     5311}
     5312/*}}}*/
     5313/*FUNCTION Penta::ReinitializeInput(int reinitialized_enum,int original_enum){{{1*/
     5314void  Penta::ReinitializeInput(int reinitialized_enum,int original_enum){
     5315
     5316        Input* original=NULL;
     5317        Input* copy=NULL;
     5318
     5319        /*Make a copy of the original input: */
     5320        original=(Input*)this->inputs->GetInput(original_enum);
     5321        copy=(Input*)original->copy();
     5322
     5323        /*Change copy enum to reinitialized_enum: */
     5324        copy->ChangeEnum(reinitialized_enum);
     5325
     5326        /*Add copy into inputs, it will wipe off the one already there: */
     5327        inputs->AddObject((Input*)copy);
     5328}
     5329/*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Elements/Penta.h

    r4042 r4043  
    7070                /*}}}*/
    7171                /*FUNCTION element numerical routines {{{1*/
    72                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    73                 void  CreateKMatrixDiagnosticHoriz( Mat Kgg,  int analysis_type,int sub_analysis_type);
    74                 void  CreateKMatrixDiagnosticHutter( Mat Kgg,  int analysis_type,int sub_analysis_type);
    75                 void  CreateKMatrixDiagnosticVert( Mat Kgg,  int analysis_type,int sub_analysis_type);
    76                 void  CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type);
    77                 void  GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type);
    78                 void  GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type);
    79                 void  GetSolutionFromInputsDiagnosticVert(Vec solution,int analysis_type,int sub_analysis_type);
    80                 void  GetSolutionFromInputsDiagnosticStokes(Vec solution,int analysis_type,int sub_analysis_type);
     72                void  CreateKMatrix(Mat Kggg);
     73                void  CreateKMatrixDiagnosticHoriz( Mat Kgg);
     74                void  CreateKMatrixDiagnosticHutter( Mat Kgg);
     75                void  CreateKMatrixDiagnosticVert( Mat Kgg);
     76                void  CreatePVector(Vec pg);
     77                void  GetSolutionFromInputs(Vec solution);
     78                void  GetSolutionFromInputsDiagnosticHoriz(Vec solutiong);
     79                void  GetSolutionFromInputsDiagnosticVert(Vec solutiong);
     80                void  GetSolutionFromInputsDiagnosticStokes(Vec solutiong);
    8181                void  GetDofList(int* doflist,int* pnumberofdofs);
    8282                void  GetDofList1(int* doflist);
    … …  
    8585                void  GetNodes(void** nodes);
    8686                bool   GetOnBed();
    87                 void  Du(Vec du_g,int analysis_type,int sub_analysis_type);
    88                 void  Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type);
    89                 void  GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type);
    90                 void  GradjB(Vec grad_g,int analysis_type,int sub_analysis_type);
    91                 double Misfit(int analysis_type,int sub_analysis_type);
    92                 double SurfaceArea(int analysis_type,int sub_analysis_type);
    93                 double CostFunction(int analysis_type,int sub_analysis_type);
    94                
    95                 void          GetThicknessList(double* thickness_list);
    96                 void          GetBedList(double* bed_list);
    97 
     87                void  Du(Vec du_gg);
     88                void  Gradj(Vec grad_gg,int control_type);
     89                void  GradjDrag(Vec grad_gg);
     90                void  GradjB(Vec grad_gg);
     91                double Misfit(void);
     92                double SurfaceArea(void);
     93                double CostFunction(void);
     94                void  GetThicknessList(double* thickness_list);
     95                void  GetBedList(double* bed_list);
    9896                void  GetStrainRate(double* epsilon, double* velocity, double* xyz_list, double* gauss_coord);
    9997                void  GetB(double* pB, double* xyz_list, double* gauss_coord);
    … …  
    106104                void  GetNodalFunctionsDerivativesReference(double* dl1dl6,double* gauss_coord);
    107105                void  GetJacobianInvert(double*  Jinv, double* xyz_list,double* gauss_coord);
    108                 void  CreatePVectorDiagnosticHoriz( Vec pg, int analysis_type,int sub_analysis_type);
    109                 void  CreatePVectorDiagnosticHutter( Vec pg, int analysis_type,int sub_analysis_type);
    110                 void  CreatePVectorDiagnosticVert( Vec pg, int analysis_type,int sub_analysis_type);
     106                void  CreatePVectorDiagnosticHoriz( Vec pg);
     107                void  CreatePVectorDiagnosticHutter( Vec pg);
     108                void  CreatePVectorDiagnosticVert( Vec pg);
    111109                void  GetParameterValue(double* pvalue, double* v_list,double* gauss_coord);
    112110                void  GetParameterDerivativeValue(double* p, double* p_list,double* xyz_list, double* gauss_coord);
    … …  
    115113                void  InputExtrude(int enum_type);
    116114                void  DepthAverageInputAtBase(int enum_type);
    117                 void  ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type);
    118                 void  ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type);
    119                 void  ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type);
    120                 void  CreateKMatrixSlopeCompute(Mat Kgg,int analysis_type,int sub_analysis_type);
    121                 void  CreatePVectorSlopeCompute( Vec pg,  int analysis_type,int sub_analysis_type);
    122                 void  CreateKMatrixPrognostic(Mat Kgg,int analysis_type,int sub_analysis_type);
    123                 void  CreatePVectorPrognostic( Vec pg,  int analysis_type,int sub_analysis_type);
    124                 void  CreateKMatrixBalancedthickness(Mat Kgg,int analysis_type,int sub_analysis_type);
    125                 void  CreateKMatrixBalancedvelocities(Mat Kgg,int analysis_type,int sub_analysis_type);
    126                 void  CreateKMatrixDiagnosticStokes( Mat Kgg,  int analysis_type,int sub_analysis_type);
    127                 void  CreatePVectorBalancedthickness( Vec pg, int analysis_type,int sub_analysis_type);
    128                 void  CreatePVectorBalancedvelocities( Vec pg, int analysis_type,int sub_analysis_type);
    129                 void  CreatePVectorDiagnosticStokes( Vec pg, int analysis_type,int sub_analysis_type);
     115                void  ComputeBasalStress(Vec sigma_bg);
     116                void  ComputePressure(Vec p_gg);
     117                void  ComputeStrainRate(Vec epsg);
     118                void  CreateKMatrixSlopeCompute(Mat Kggg);
     119                void  CreatePVectorSlopeCompute( Vec pg);
     120                void  CreateKMatrixPrognostic(Mat Kggg);
     121                void  CreatePVectorPrognostic( Vec pg);
     122                void  CreateKMatrixBalancedthickness(Mat Kggg);
     123                void  CreateKMatrixBalancedvelocities(Mat Kggg);
     124                void  CreateKMatrixDiagnosticStokes( Mat Kgg);
     125                void  CreatePVectorBalancedthickness( Vec pg);
     126                void  CreatePVectorBalancedvelocities( Vec pg);
     127                void  CreatePVectorDiagnosticStokes( Vec pg);
    130128                void  ReduceMatrixStokes(double* Ke_reduced, double* Ke_temp);
    131129                void  GetMatrixInvert(double*  Ke_invert, double* Ke);
    … …  
    140138                void  ReduceVectorStokes(double* Pe_reduced, double* Ke_temp, double* Pe_temp);
    141139                void  GetNodalFunctionsStokes(double* l1l7, double* gauss_coord);
    142                 void  CreateKMatrixThermal(Mat Kgg,int analysis_type,int sub_analysis_type);
     140                void  CreateKMatrixThermal(Mat Kggg);
    143141                void  GetB_conduct(double* B_conduct, double* xyz_list, double* gauss_coord);
    144142                void  GetB_advec(double* B_advec, double* xyz_list, double* gauss_coord);
    145143                void  GetBprime_advec(double* Bprime_advec, double* xyz_list, double* gauss_coord);
    146144                void  GetB_artdiff(double* B_artdiff, double* xyz_list, double* gauss_coord);
    147                 void  CreateKMatrixMelting(Mat Kgg,int analysis_type,int sub_analysis_type);
    148                 void  CreatePVectorThermal( Vec pg, int analysis_type,int sub_analysis_type);
    149                 void  CreatePVectorMelting( Vec pg, int analysis_type,int sub_analysis_type);
     145                void  CreateKMatrixMelting(Mat Kggg);
     146                void  CreatePVectorThermal( Vec pg);
     147                void  CreatePVectorMelting( Vec pg);
    150148                void  GetPhi(double* phi, double*  epsilon, double viscosity);
    151                 double MassFlux(double* segment,double* ug);
     149                double MassFlux(double* segment);
    152150                void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    153151                void  PatchFill(int* pcount, Patch* patch);
    154152                void  MinVel(double* pminvel, bool process_units);
    155153                void  MaxVel(double* pmaxvel, bool process_units);
     154                void  MinVx(double* pminvx, bool process_units);
     155                void  MaxVx(double* pmaxvx, bool process_units);
     156                void  MaxAbsVx(double* pmaxabsvx, bool process_units);
     157                void  MinVy(double* pminvy, bool process_units);
     158                void  MaxVy(double* pmaxvy, bool process_units);
     159                void  MaxAbsVy(double* pmaxabsvy, bool process_units);
     160                void  MinVz(double* pminvz, bool process_units);
     161                void  MaxVz(double* pmaxvz, bool process_units);
     162                void  MaxAbsVz(double* pmaxabsvz, bool process_units);
     163                void  ReinitializeInput(int reinitialized_enum,int original_enum);
     164
    156165
    157166                /*updates: */
    158167                void  UpdateFromDakota(void* inputs);
    159                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
    160                 void  UpdateInputsFromSolutionDiagnosticHoriz( double* solution,int analysis_type,int sub_analysis_type);
    161                 void  UpdateInputsFromSolutionDiagnosticStokes( double* solution,int analysis_type,int sub_analysis_type);
    162                 void  UpdateInputsFromSolutionSlopeCompute( double* solution,int analysis_type,int sub_analysis_type);
    163                 void  UpdateInputsFromSolutionPrognostic( double* solution,int analysis_type,int sub_analysis_type);
    164                 void  UpdateInputsFromSolutionPrognostic2(double* solution,int analysis_type,int sub_analysis_type);
    165                 void  UpdateInputsFromSolutionBalancedthickness( double* solution,int analysis_type,int sub_analysis_type);
    166                 void  UpdateInputsFromSolutionBalancedthickness2( double* solution,int analysis_type,int sub_analysis_type);
    167                 void  UpdateInputsFromSolutionBalancedvelocities( double* solution,int analysis_type,int sub_analysis_type);
     168                void  UpdateInputsFromSolution(double* solutiong);
     169                void  UpdateInputsFromSolutionDiagnosticHoriz( double* solutiong);
     170                void  UpdateInputsFromSolutionDiagnosticStokes( double* solutiong);
     171                void  UpdateInputsFromSolutionSlopeCompute( double* solutiong);
     172                void  UpdateInputsFromSolutionPrognostic( double* solutiong);
     173                void  UpdateInputsFromSolutionPrognostic2(double* solutiong);
     174                void  UpdateInputsFromSolutionBalancedthickness( double* solutiong);
     175                void  UpdateInputsFromSolutionBalancedthickness2( double* solutiong);
     176                void  UpdateInputsFromSolutionBalancedvelocities( double* solutiong);
    168177                void  UpdateInputsFromVector(double* vector, int name, int type);
    169178                void  UpdateInputsFromVector(int* vector, int name, int type);

  • TabularUnified issm/trunk/src/c/objects/Elements/Sing.cpp

    r4042 r4043  
    128128/*}}}*/
    129129/*FUNCTION Sing::UpdateInputsFromSolution {{{1*/
    130 void  Sing::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){
    131         ISSMERROR(" not supported yet!");
    132 }
    133 /*}}}*/
    134 /*FUNCTION Sing::GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type);{{{1*/
    135 void  Sing::GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type){
     130void  Sing::UpdateInputsFromSolution(double* solution){
     131        ISSMERROR(" not supported yet!");
     132}
     133/*}}}*/
     134/*FUNCTION Sing::GetSolutionFromInputs(Vec solution);{{{1*/
     135void  Sing::GetSolutionFromInputs(Vec solution){
    136136        ISSMERROR(" not supported yet!");
    137137}
    … …  
    150150/*Object functions*/
    151151/*FUNCTION Sing::ComputeBasalStress {{{1*/
    152 void  Sing::ComputeBasalStress(Vec p_g,int analysis_type,int sub_analysis_type){
     152void  Sing::ComputeBasalStress(Vec p_g){
    153153
    154154        ISSMERROR("Not implemented yet");
    … …  
    157157/*}}}*/
    158158/*FUNCTION Sing::ComputePressure {{{1*/
    159 void  Sing::ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type){
     159void  Sing::ComputePressure(Vec p_g){
    160160
    161161        int    dof;
    … …  
    179179/*}}}*/
    180180/*FUNCTION Sing::ComputeStrainRate {{{1*/
    181 void  Sing::ComputeStrainRate(Vec p_g,int analysis_type,int sub_analysis_type){
     181void  Sing::ComputeStrainRate(Vec p_g){
    182182
    183183        ISSMERROR("Not implemented yet");
    … …  
    186186/*}}}*/
    187187/*FUNCTION Sing::CostFunction {{{1*/
    188 double Sing::CostFunction( int,int){
     188double Sing::CostFunction(){
    189189        ISSMERROR(" not supported yet!");
    190190}
    … …  
    192192/*FUNCTION Sing::CreateKMatrix {{{1*/
    193193
    194 void  Sing::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     194void  Sing::CreateKMatrix(Mat Kgg){
     195
     196        int analysis_type,sub_analysis_type;
     197
     198        /*retrive parameters: */
     199        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     200        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    195201
    196202        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    197203        if ((analysis_type==DiagnosticAnalysisEnum) && (sub_analysis_type==HutterAnalysisEnum)){
    198204
    199                 CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type);
     205                CreateKMatrixDiagnosticHutter( Kgg);
    200206
    201207        }
    … …  
    207213/*}}}*/
    208214/*FUNCTION Sing::CreateKMatrixDiagnosticHutter {{{1*/
    209 void  Sing::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){
     215void  Sing::CreateKMatrixDiagnosticHutter(Mat Kgg){
    210216       
    211217        const int numgrids=1;
    … …  
    229235/*}}}*/
    230236/*FUNCTION Sing::CreatePVector {{{1*/
    231 void  Sing::CreatePVector(Vec pg,int analysis_type,int sub_analysis_type){
     237void  Sing::CreatePVector(Vec pg){
     238
     239        int analysis_type,sub_analysis_type;
     240
     241        /*retrive parameters: */
     242        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     243        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    232244       
    233245        /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */
    234246        if ((analysis_type==DiagnosticAnalysisEnum) && (sub_analysis_type==HutterAnalysisEnum)){
    235247       
    236                         CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type);
     248                        CreatePVectorDiagnosticHutter( pg);
    237249
    238250        }
    … …  
    244256/*}}}*/
    245257/*FUNCTION Sing::CreatePVectorDiagnosticHutter {{{1*/
    246 void Sing::CreatePVectorDiagnosticHutter( Vec pg,  int analysis_type,int sub_analysis_type){
     258void Sing::CreatePVectorDiagnosticHutter( Vec pg){
    247259       
    248260        const int numgrids=1;
    … …  
    294306/*}}}*/
    295307/*FUNCTION Sing::Du {{{1*/
    296 void  Sing::Du(Vec,int,int){
     308void  Sing::Du(Vec){
    297309        ISSMERROR(" not supported yet!");
    298310}
    … …  
    371383/*}}}*/
    372384/*FUNCTION Sing::Gradj {{{1*/
    373 void  Sing::Gradj(Vec,  int, int ,int){
     385void  Sing::Gradj(Vec,  int control_type){
    374386        ISSMERROR(" not supported yet!");
    375387}
    376388/*}}}*/
    377389/*FUNCTION Sing::GradB {{{1*/
    378 void  Sing::GradjB(Vec,  int,int){
     390void  Sing::GradjB(Vec){
    379391        ISSMERROR(" not supported yet!");
    380392}
    381393/*}}}*/
    382394/*FUNCTION Sing::GradjDrag {{{1*/
    383 void  Sing::GradjDrag(Vec,  int,int){
     395void  Sing::GradjDrag(Vec){
    384396        ISSMERROR(" not supported yet!");
    385397}
    386398/*}}}*/
    387399/*FUNCTION Sing::MassFlux {{{1*/
    388 double Sing::MassFlux( double* segment,double* ug){
     400double Sing::MassFlux( double* segment){
    389401        ISSMERROR(" not supported yet!");
    390402}
    391403/*}}}*/
    392404/*FUNCTION Sing::Misfit {{{1*/
    393 double Sing::Misfit( int,int){
     405double Sing::Misfit(void){
    394406        ISSMERROR(" not supported yet!");
    395407}
    … …  
    402414/*}}}*/
    403415/*FUNCTION Sing::SurfaceArea {{{1*/
    404 double Sing::SurfaceArea( int,int){
     416double Sing::SurfaceArea( void){
    405417        ISSMERROR(" not supported yet!");
    406418}
    … …  
    463475void  Sing::MinVel(double* pminvel, bool process_units){
    464476
     477        int dim;
    465478        double  vx;
    466479        double  vy;
    … …  
    489502void  Sing::MaxVel(double* pmaxvel, bool process_units){
    490503
     504        int dim;
    491505        double  vx;
    492506        double  vy;
    … …  
    512526}
    513527/*}}}*/
     528/*FUNCTION Sing::MinVx(double* pminvx, bool process_units);{{{1*/
     529void  Sing::MinVx(double* pminvx, bool process_units){
     530
     531        int dim;
     532        double  minvx;
     533
     534        /*retrieve dim parameter: */
     535        parameters->FindParam(&dim,DimEnum);
     536
     537        /*retrive velocity values at nodes */
     538        inputs->GetParameterValue(&minvx,VxEnum);
     539
     540        /*Assign output pointers:*/
     541        *pminvx=minvx;
     542
     543}
     544/*}}}*/
     545/*FUNCTION Sing::MaxVx(double* pmaxvx, bool process_units);{{{1*/
     546void  Sing::MaxVx(double* pmaxvx, bool process_units){
     547
     548        int dim;
     549        double  maxvx;
     550
     551        /*retrieve dim parameter: */
     552        parameters->FindParam(&dim,DimEnum);
     553
     554        /*retrive velocity values at nodes */
     555        inputs->GetParameterValue(&maxvx,VxEnum);
     556
     557        /*Assign output pointers:*/
     558        *pmaxvx=maxvx;
     559
     560}
     561/*}}}*/
     562/*FUNCTION Sing::MaxAbsVx(double* pmaxabsvx, bool process_units);{{{1*/
     563void  Sing::MaxAbsVx(double* pmaxabsvx, bool process_units){
     564
     565        int dim;
     566        double  maxabsvx;
     567
     568        /*retrieve dim parameter: */
     569        parameters->FindParam(&dim,DimEnum);
     570
     571        /*retrive velocity values at nodes */
     572        inputs->GetParameterValue(&maxabsvx,VxEnum);
     573        maxabsvx=fabs(maxabsvx);
     574
     575        /*Assign output pointers:*/
     576        *pmaxabsvx=maxabsvx;
     577}
     578/*}}}*/
     579/*FUNCTION Sing::MinVy(double* pminvy, bool process_units);{{{1*/
     580void  Sing::MinVy(double* pminvy, bool process_units){
     581
     582        int dim;
     583        double  minvy;
     584
     585        /*retrieve dim parameter: */
     586        parameters->FindParam(&dim,DimEnum);
     587
     588        /*retrive velocity values at nodes */
     589        inputs->GetParameterValue(&minvy,VyEnum);
     590
     591        /*Assign output pointers:*/
     592        *pminvy=minvy;
     593
     594}
     595/*}}}*/
     596/*FUNCTION Sing::MaxVy(double* pmaxvy, bool process_units);{{{1*/
     597void  Sing::MaxVy(double* pmaxvy, bool process_units){
     598
     599        int dim;
     600        double  maxvy;
     601
     602        /*retrieve dim parameter: */
     603        parameters->FindParam(&dim,DimEnum);
     604
     605        /*retrive velocity values at nodes */
     606        inputs->GetParameterValue(&maxvy,VyEnum);
     607
     608        /*Assign output pointers:*/
     609        *pmaxvy=maxvy;
     610
     611}
     612/*}}}*/
     613/*FUNCTION Sing::MaxAbsVy(double* pmaxabsvy, bool process_units);{{{1*/
     614void  Sing::MaxAbsVy(double* pmaxabsvy, bool process_units){
     615
     616        int dim;
     617        double  maxabsvy;
     618
     619        /*retrieve dim parameter: */
     620        parameters->FindParam(&dim,DimEnum);
     621
     622        /*retrive velocity values at nodes */
     623        inputs->GetParameterValue(&maxabsvy,VyEnum);
     624        maxabsvy=fabs(maxabsvy);
     625
     626        /*Assign output pointers:*/
     627        *pmaxabsvy=maxabsvy;
     628}
     629/*}}}*/
     630/*FUNCTION Sing::MinVz(double* pminvz, bool process_units);{{{1*/
     631void  Sing::MinVz(double* pminvz, bool process_units){
     632
     633        int dim;
     634        double  minvz;
     635
     636        /*retrieve dim parameter: */
     637        parameters->FindParam(&dim,DimEnum);
     638
     639        /*retrive velocity values at nodes */
     640        inputs->GetParameterValue(&minvz,VzEnum);
     641
     642        /*Assign output pointers:*/
     643        *pminvz=minvz;
     644
     645}
     646/*}}}*/
     647/*FUNCTION Sing::MaxVz(double* pmaxvz, bool process_units);{{{1*/
     648void  Sing::MaxVz(double* pmaxvz, bool process_units){
     649
     650        int dim;
     651        double  maxvz;
     652
     653        /*retrieve dim parameter: */
     654        parameters->FindParam(&dim,DimEnum);
     655
     656        /*retrive velocity values at nodes */
     657        inputs->GetParameterValue(&maxvz,VzEnum);
     658
     659        /*Assign output pointers:*/
     660        *pmaxvz=maxvz;
     661
     662}
     663/*}}}*/
     664/*FUNCTION Sing::MaxAbsVz(double* pmaxabsvz, bool process_units);{{{1*/
     665void  Sing::MaxAbsVz(double* pmaxabsvz, bool process_units){
     666
     667        int dim;
     668        double  maxabsvz;
     669
     670        /*retrieve dim parameter: */
     671        parameters->FindParam(&dim,DimEnum);
     672
     673        /*retrive velocity values at nodes */
     674        inputs->GetParameterValue(&maxabsvz,VzEnum);
     675        maxabsvz=fabs(maxabsvz);
     676
     677        /*Assign output pointers:*/
     678        *pmaxabsvz=maxabsvz;
     679}
     680/*}}}*/
     681/*FUNCTION Sing::ReinitializeInput(int reinitialized_enum,int original_enum){{{1*/
     682void  Sing::ReinitializeInput(int reinitialized_enum,int original_enum){
     683
     684        Input* original=NULL;
     685        Input* copy=NULL;
     686
     687        /*Make a copy of the original input: */
     688        original=(Input*)this->inputs->GetInput(original_enum);
     689        copy=(Input*)original->copy();
     690
     691        /*Change copy enum to reinitialized_enum: */
     692        copy->ChangeEnum(reinitialized_enum);
     693
     694        /*Add copy into inputs, it will wipe off the one already there: */
     695        inputs->AddObject((Input*)copy);
     696}
     697/*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Elements/Sing.h

    r4042 r4043  
    6161                void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    63                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
     63                void  UpdateInputsFromSolution(double* solutiong);
    6464                void  DepthAverageInputAtBase(int enum_type){ISSMERROR("not implemented yet");};
    6565                void  InputToResult(int enum_type,int step,double time);
    … …  
    6767                /*}}}*/
    6868                /*numerics: {{{1*/
    69                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    70                 void  CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type);
     69                void  CreateKMatrix(Mat Kggg);
     70                void  CreatePVector(Vec pg);
    7171                void  GetDofList(int* doflist,int* pnumberofdofs);
    72                 void  GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type);
     72                void  GetSolutionFromInputs(Vec solution);
    7373                void  GetDofList1(int* doflist);
    74                 void  CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type);
     74                void  CreateKMatrixDiagnosticHutter(Mat Kggg);
    7575                void  GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
    76                 void  CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type);
     76                void  CreatePVectorDiagnosticHutter(Vec pgg);
    7777                void* GetMatPar();
    78                 void  ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type);
    79                 void  ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type);
    80                 void  ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type);
     78                void  ComputeBasalStress(Vec sigma_bg);
     79                void  ComputePressure(Vec p_gg);
     80                void  ComputeStrainRate(Vec epsg);
    8181                void  GetNodes(void** vpnodes);
    8282                void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    … …  
    8484                void  MinVel(double* pminvel, bool process_units);
    8585                void  MaxVel(double* pmaxvel, bool process_units);
     86                void  MinVx(double* pminvx, bool process_units);
     87                void  MaxVx(double* pmaxvx, bool process_units);
     88                void  MaxAbsVx(double* pmaxabsvx, bool process_units);
     89                void  MinVy(double* pminvy, bool process_units);
     90                void  MaxVy(double* pmaxvy, bool process_units);
     91                void  MaxAbsVy(double* pmaxabsvy, bool process_units);
     92                void  MinVz(double* pminvz, bool process_units);
     93                void  MaxVz(double* pmaxvz, bool process_units);
     94                void  MaxAbsVz(double* pmaxabsvz, bool process_units);
     95                void  ReinitializeInput(int reinitialized_enum,int original_enum);
     96
    8697
    8798                /*}}}*/
    … …  
    91102                void  GetBedList(double*);
    92103                void  GetThicknessList(double* thickness_list);
    93                 void  Du(Vec,int,int);
    94                 void  Gradj(Vec, int, int,int);
    95                 void  GradjDrag(Vec , int,int);
    96                 void  GradjB(Vec,  int,int);
    97                 double Misfit(int,int);
    98                 double SurfaceArea(int,int);
    99                 double CostFunction(int,int);
    100                 double MassFlux(double* segment,double* ug);
     104                void  Du(Vec);
     105                void  Gradj(Vec, int control_type);
     106                void  GradjDrag(Vec);
     107                void  GradjB(Vec);
     108                double Misfit(void);
     109                double SurfaceArea(void);
     110                double CostFunction(void);
     111                double MassFlux(double* segment);
    101112                /*}}}*/
    102113

  • TabularUnified issm/trunk/src/c/objects/Elements/Tria.cpp

    r4042 r4043  
    551551/*}}}*/
    552552/*FUNCTION Tria::UpdateInputsFromSolution {{{1*/
    553 void  Tria::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){
     553void  Tria::UpdateInputsFromSolution(double* solution){
     554
     555        int analysis_type,sub_analysis_type;
     556
     557        /*retrive parameters: */
     558        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     559        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    554560
    555561        /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */
    556562        if (analysis_type==ControlAnalysisEnum){
    557                 UpdateInputsFromSolutionDiagnosticHoriz( solution,analysis_type,sub_analysis_type);
     563                UpdateInputsFromSolutionDiagnosticHoriz( solution);
    558564        }
    559565        else if (analysis_type==DiagnosticAnalysisEnum){
    560566                if (sub_analysis_type==HorizAnalysisEnum){
    561                         UpdateInputsFromSolutionDiagnosticHoriz( solution,analysis_type,sub_analysis_type);
     567                        UpdateInputsFromSolutionDiagnosticHoriz( solution);
    562568                }
    563569                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    564570        }
    565571        else if (analysis_type==SlopeComputeAnalysisEnum){
    566                 UpdateInputsFromSolutionSlopeCompute( solution,analysis_type,sub_analysis_type);
     572                UpdateInputsFromSolutionSlopeCompute( solution);
    567573        }
    568574        else if (analysis_type==PrognosticAnalysisEnum){
    569                 UpdateInputsFromSolutionPrognostic( solution,analysis_type,sub_analysis_type);
     575                UpdateInputsFromSolutionPrognostic( solution);
    570576        }
    571577        else if (analysis_type==Prognostic2AnalysisEnum){
    572                 UpdateInputsFromSolutionPrognostic2(solution,analysis_type,sub_analysis_type);
     578                UpdateInputsFromSolutionPrognostic2(solution);
    573579        }
    574580        else if (analysis_type==BalancedthicknessAnalysisEnum){
    575                 UpdateInputsFromSolutionBalancedthickness( solution,analysis_type,sub_analysis_type);
     581                UpdateInputsFromSolutionBalancedthickness( solution);
    576582        }
    577583        else if (analysis_type==Balancedthickness2AnalysisEnum){
    578                 UpdateInputsFromSolutionBalancedthickness2( solution,analysis_type,sub_analysis_type);
     584                UpdateInputsFromSolutionBalancedthickness2( solution);
    579585        }
    580586        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    581                 UpdateInputsFromSolutionBalancedvelocities( solution,analysis_type,sub_analysis_type);
     587                UpdateInputsFromSolutionBalancedvelocities( solution);
    582588        }
    583589        else{
    … …  
    587593/*}}}*/
    588594/*FUNCTION Tria::UpdateInputsFromSolutionDiagnosticHoriz {{{1*/
    589 void  Tria::UpdateInputsFromSolutionDiagnosticHoriz(double* solution, int analysis_type, int sub_analysis_type){
     595void  Tria::UpdateInputsFromSolutionDiagnosticHoriz(double* solution){
    590596       
    591597        int i;
    … …  
    647653/*}}}*/
    648654/*FUNCTION Tria::UpdateInputsFromSolutionSlopeCompute {{{1*/
    649 void  Tria::UpdateInputsFromSolutionSlopeCompute(double* solution, int analysis_type, int sub_analysis_type){
     655void  Tria::UpdateInputsFromSolutionSlopeCompute(double* solution){
    650656        ISSMERROR(" not supported yet!");
    651657}
    652658/*}}}*/
    653659/*FUNCTION Tria::UpdateInputsFromSolutionPrognostic {{{1*/
    654 void  Tria::UpdateInputsFromSolutionPrognostic(double* solution, int analysis_type, int sub_analysis_type){
     660void  Tria::UpdateInputsFromSolutionPrognostic(double* solution){
    655661
    656662        int i;
    … …  
    679685/*}}}*/
    680686/*FUNCTION Tria::UpdateInputsFromSolutionPrognostic2 {{{1*/
    681 void  Tria::UpdateInputsFromSolutionPrognostic2(double* solution, int analysis_type, int sub_analysis_type){
     687void  Tria::UpdateInputsFromSolutionPrognostic2(double* solution){
    682688        ISSMERROR(" not supported yet!");
    683689}
    684690/*}}}*/
    685691/*FUNCTION Tria::UpdateInputsFromSolutionBalancedthickness {{{1*/
    686 void  Tria::UpdateInputsFromSolutionBalancedthickness(double* solution, int analysis_type, int sub_analysis_type){
     692void  Tria::UpdateInputsFromSolutionBalancedthickness(double* solution){
    687693
    688694        int i;
    … …  
    711717/*}}}*/
    712718/*FUNCTION Tria::UpdateInputsFromSolutionBalancedthickness2 {{{1*/
    713 void  Tria::UpdateInputsFromSolutionBalancedthickness2(double* solution, int analysis_type, int sub_analysis_type){
     719void  Tria::UpdateInputsFromSolutionBalancedthickness2(double* solution){
    714720        ISSMERROR(" not supported yet!");
    715721}
    716722/*}}}*/
    717723/*FUNCTION Tria::UpdateInputsFromSolutionBalancedvelocities {{{1*/
    718 void  Tria::UpdateInputsFromSolutionBalancedvelocities(double* solution, int analysis_type, int sub_analysis_type){
     724void  Tria::UpdateInputsFromSolutionBalancedvelocities(double* solution){
    719725        ISSMERROR(" not supported yet!");
    720726}
    721727/*}}}*/
    722 /*FUNCTION Tria::GetSolutionFromInputs(Vec solution,int analysis_type,int sub_analysis_type){{{1*/
    723 void  Tria::GetSolutionFromInputs(Vec solution,int analysis_type,int sub_analysis_type){
     728/*FUNCTION Tria::GetSolutionFromInputs(Vec solution){{{1*/
     729void  Tria::GetSolutionFromInputs(Vec solution){
     730
     731        int analysis_type,sub_analysis_type;
     732
     733        /*retrive parameters: */
     734        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     735        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
     736       
    724737        /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */
    725738        if (analysis_type==DiagnosticAnalysisEnum){
    726739                if (sub_analysis_type==HorizAnalysisEnum){
    727                         GetSolutionFromInputsDiagnosticHoriz(solution,analysis_type,sub_analysis_type);
     740                        GetSolutionFromInputsDiagnosticHoriz(solution);
    728741                }
    729742                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    … …  
    734747}
    735748/*}}}*/
    736 /*FUNCTION Tria::GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type){{{1*/
    737 void  Tria::GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type){
     749/*FUNCTION Tria::GetSolutionFromInputsDiagnosticHoriz(Vec solution){{{1*/
     750void  Tria::GetSolutionFromInputsDiagnosticHoriz(Vec solution){
    738751
    739752        int i;
    … …  
    782795/*}}}*/
    783796/*FUNCTION Tria::ComputeBasalStress {{{1*/
    784 void  Tria::ComputeBasalStress(Vec eps,int analysis_type,int sub_analysis_type){
     797void  Tria::ComputeBasalStress(Vec eps){
    785798
    786799        int i;
    … …  
    796809/*}}}*/
    797810/*FUNCTION Tria::ComputePressure {{{1*/
    798 void  Tria::ComputePressure(Vec pg,int analysis_type,int sub_analysis_type){
     811void  Tria::ComputePressure(Vec pg){
    799812
    800813        int i;
    … …  
    826839/*}}}*/
    827840/*FUNCTION Tria::ComputeStrainRate {{{1*/
    828 void  Tria::ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type){
     841void  Tria::ComputeStrainRate(Vec eps){
    829842
    830843        int i;
    … …  
    840853/*}}}*/
    841854/*FUNCTION Tria::CostFunction {{{1*/
    842 double Tria::CostFunction(int analysis_type,int sub_analysis_type){
     855double Tria::CostFunction(void){
    843856
    844857        int i;
    … …  
    897910
    898911        /*First, get Misfit*/
    899         Jelem=Misfit(analysis_type,sub_analysis_type);
     912        Jelem=Misfit();
    900913
    901914          /* Get gaussian points and weights (make this a statically initialized list of points? fstd): */
    … …  
    941954/*}}}*/
    942955/*FUNCTION Tria::CreateKMatrix {{{1*/
    943 void  Tria::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     956void  Tria::CreateKMatrix(Mat Kgg){
     957
     958        int analysis_type,sub_analysis_type;
     959
     960        /*retrive parameters: */
     961        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     962        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    944963
    945964        /*asserts: {{{2*/
    … …  
    949968        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    950969        if (analysis_type==ControlAnalysisEnum){
    951                 CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type);
     970                CreateKMatrixDiagnosticHoriz( Kgg);
    952971        }
    953972        else if (analysis_type==DiagnosticAnalysisEnum){
    954973                if (sub_analysis_type==HorizAnalysisEnum){
    955                         CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type);
     974                        CreateKMatrixDiagnosticHoriz( Kgg);
    956975                }
    957976                else if (sub_analysis_type==HutterAnalysisEnum){
    958                         CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type);
     977                        CreateKMatrixDiagnosticHutter( Kgg);
    959978                }
    960979                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    961980        }
    962981        else if (analysis_type==SlopeComputeAnalysisEnum){
    963                 CreateKMatrixSlopeCompute( Kgg,analysis_type,sub_analysis_type);
     982                CreateKMatrixSlopeCompute( Kgg);
    964983        }
    965984        else if (analysis_type==PrognosticAnalysisEnum){
    966                 CreateKMatrixPrognostic( Kgg,analysis_type,sub_analysis_type);
     985                CreateKMatrixPrognostic( Kgg);
    967986        }
    968987        else if (analysis_type==Prognostic2AnalysisEnum){
    969                 CreateKMatrixPrognostic2(Kgg,analysis_type,sub_analysis_type);
     988                CreateKMatrixPrognostic2(Kgg);
    970989        }
    971990        else if (analysis_type==BalancedthicknessAnalysisEnum){
    972                 CreateKMatrixBalancedthickness( Kgg,analysis_type,sub_analysis_type);
     991                CreateKMatrixBalancedthickness( Kgg);
    973992        }
    974993        else if (analysis_type==Balancedthickness2AnalysisEnum){
    975                 CreateKMatrixBalancedthickness2( Kgg,analysis_type,sub_analysis_type);
     994                CreateKMatrixBalancedthickness2( Kgg);
    976995        }
    977996        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    978                 CreateKMatrixBalancedvelocities( Kgg,analysis_type,sub_analysis_type);
     997                CreateKMatrixBalancedvelocities( Kgg);
    979998        }
    980999        else{
    … …  
    9851004/*}}}*/
    9861005/*FUNCTION Tria::CreateKMatrixBalancedthickness {{{1*/
    987 void  Tria::CreateKMatrixBalancedthickness(Mat Kgg,int analysis_type,int sub_analysis_type){
     1006void  Tria::CreateKMatrixBalancedthickness(Mat Kgg){
    9881007
    9891008        /* local declarations */
    … …  
    11411160/*}}}*/
    11421161/*FUNCTION Tria::CreateKMatrixBalancedthickness2 {{{1*/
    1143 void  Tria::CreateKMatrixBalancedthickness2(Mat Kgg,int analysis_type,int sub_analysis_type){
     1162void  Tria::CreateKMatrixBalancedthickness2(Mat Kgg){
    11441163
    11451164        /* local declarations */
    … …  
    12331252/*}}}*/
    12341253/*FUNCTION Tria::CreateKMatrixBalancedvelocities {{{1*/
    1235 void  Tria::CreateKMatrixBalancedvelocities(Mat Kgg,int analysis_type,int sub_analysis_type){
     1254void  Tria::CreateKMatrixBalancedvelocities(Mat Kgg){
    12361255
    12371256        /* local declarations */
    … …  
    14011420/*}}}*/
    14021421/*FUNCTION Tria::CreateKMatrixDiagnosticHoriz {{{1*/
    1403 void  Tria::CreateKMatrixDiagnosticHoriz(Mat Kgg,int analysis_type,int sub_analysis_type){
     1422void  Tria::CreateKMatrixDiagnosticHoriz(Mat Kgg){
    14041423
    14051424        /* local declarations */
    … …  
    15221541        /*Do not forget to include friction: */
    15231542        if(!shelf){
    1524                 CreateKMatrixDiagnosticHorizFriction(Kgg,analysis_type,sub_analysis_type);
     1543                CreateKMatrixDiagnosticHorizFriction(Kgg);
    15251544        }
    15261545
    … …  
    15341553/*}}}*/
    15351554/*FUNCTION Tria::CreateKMatrixDiagnosticHorizFriction {{{1*/
    1536 void  Tria::CreateKMatrixDiagnosticHorizFriction(Mat Kgg,int analysis_type,int sub_analysis_type){
     1555void  Tria::CreateKMatrixDiagnosticHorizFriction(Mat Kgg){
    15371556
    15381557
    15391558        /* local declarations */
    15401559        int             i,j;
     1560        int analysis_type;
    15411561
    15421562        /* node data: */
    … …  
    15821602        int  drag_type;
    15831603
     1604        /*retrive parameters: */
     1605        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     1606
    15841607        /*retrieve inputs :*/
    15851608        inputs->GetParameterValue(&shelf,ElementOnIceShelfEnum);
    … …  
    16571680/*}}}*/
    16581681/*FUNCTION Tria::CreateKMatrixDiagnosticHutter{{{1*/
    1659 void  Tria::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){
     1682void  Tria::CreateKMatrixDiagnosticHutter(Mat Kgg){
    16601683
    16611684        /*Collapsed formulation: */
    … …  
    16751698        for(i=0;i<3;i++){
    16761699                sing=(Sing*)SpawnSing(i);
    1677                 sing->CreateKMatrix(Kgg,analysis_type,sub_analysis_type);
     1700                sing->CreateKMatrix(Kgg);
    16781701        }
    16791702
    … …  
    16841707/*}}}*/
    16851708/*FUNCTION Tria::CreateKMatrixDiagnosticSurfaceVert {{{1*/
    1686 void  Tria::CreateKMatrixDiagnosticSurfaceVert(Mat Kgg,int analysis_type,int sub_analysis_type){
     1709void  Tria::CreateKMatrixDiagnosticSurfaceVert(Mat Kgg){
    16871710
    16881711        int i,j;
    … …  
    18021825/*}}}*/
    18031826/*FUNCTION Tria::CreateKMatrixMelting {{{1*/
    1804 void  Tria::CreateKMatrixMelting(Mat Kgg,int analysis_type,int sub_analysis_type){
     1827void  Tria::CreateKMatrixMelting(Mat Kgg){
    18051828
    18061829        /*indexing: */
    … …  
    18861909/*}}}*/
    18871910/*FUNCTION Tria::CreateKMatrixPrognostic {{{1*/
    1888 void  Tria::CreateKMatrixPrognostic(Mat Kgg,int analysis_type,int sub_analysis_type){
     1911void  Tria::CreateKMatrixPrognostic(Mat Kgg){
    18891912
    18901913        /* local declarations */
    … …  
    20562079/*}}}*/
    20572080/*FUNCTION Tria::CreateKMatrixPrognostic2 {{{1*/
    2058 void  Tria::CreateKMatrixPrognostic2(Mat Kgg,int analysis_type,int sub_analysis_type){
     2081void  Tria::CreateKMatrixPrognostic2(Mat Kgg){
    20592082
    20602083        /* local declarations */
    … …  
    21712194/*FUNCTION Tria::CreateKMatrixSlopeCompute {{{1*/
    21722195
    2173 void  Tria::CreateKMatrixSlopeCompute(Mat Kgg,int analysis_type,int sub_analysis_type){
     2196void  Tria::CreateKMatrixSlopeCompute(Mat Kgg){
    21742197
    21752198        /* local declarations */
    … …  
    22482271/*}}}*/
    22492272/*FUNCTION Tria::CreateKMatrixThermal {{{1*/
    2250 void  Tria::CreateKMatrixThermal(Mat Kgg,int analysis_type,int sub_analysis_type){
     2273void  Tria::CreateKMatrixThermal(Mat Kgg){
    22512274
    22522275        int i,j;
    … …  
    23452368/*}}}*/
    23462369/*FUNCTION Tria::CreatePVector {{{1*/
    2347 void  Tria::CreatePVector(Vec pg,int analysis_type,int sub_analysis_type){
    2348        
     2370void  Tria::CreatePVector(Vec pg){
     2371
     2372        int analysis_type,sub_analysis_type;
     2373
     2374        /*retrive parameters: */
     2375        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     2376        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
     2377
     2378        /*asserts: {{{*/
    23492379        /*if debugging mode, check that all pointers exist*/
    23502380        ISSMASSERT(this->nodes && this->matice && this->matpar && this->parameters && this->inputs);
     2381        /*}}}*/
    23512382
    23522383        /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */
    23532384        if (analysis_type==ControlAnalysisEnum){
    2354                 CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type);
     2385                CreatePVectorDiagnosticHoriz( pg);
    23552386        }
    23562387        else if (analysis_type==DiagnosticAnalysisEnum){
    23572388                if (sub_analysis_type==HorizAnalysisEnum){
    2358                         CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type);
     2389                        CreatePVectorDiagnosticHoriz( pg);
    23592390                }
    23602391                else if (sub_analysis_type==HutterAnalysisEnum){
    2361                         CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type);
     2392                        CreatePVectorDiagnosticHutter( pg);
    23622393                }
    23632394                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    23642395        }
    23652396        else if (analysis_type==SlopeComputeAnalysisEnum){
    2366                 CreatePVectorSlopeCompute( pg,analysis_type,sub_analysis_type);
     2397                CreatePVectorSlopeCompute( pg);
    23672398        }
    23682399        else if (analysis_type==PrognosticAnalysisEnum){
    2369                 CreatePVectorPrognostic( pg,analysis_type,sub_analysis_type);
     2400                CreatePVectorPrognostic( pg);
    23702401        }
    23712402        else if (analysis_type==Prognostic2AnalysisEnum){
    2372                 CreatePVectorPrognostic2( pg,analysis_type,sub_analysis_type);
     2403                CreatePVectorPrognostic2( pg);
    23732404        }
    23742405        else if (analysis_type==BalancedthicknessAnalysisEnum){
    2375                 CreatePVectorBalancedthickness( pg,analysis_type,sub_analysis_type);
     2406                CreatePVectorBalancedthickness( pg);
    23762407        }
    23772408        else if (analysis_type==Balancedthickness2AnalysisEnum){
    2378                 CreatePVectorBalancedthickness2( pg,analysis_type,sub_analysis_type);
     2409                CreatePVectorBalancedthickness2( pg);
    23792410        }
    23802411        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    2381                 CreatePVectorBalancedvelocities( pg,analysis_type,sub_analysis_type);
     2412                CreatePVectorBalancedvelocities( pg);
    23822413        }
    23832414        else{
    … …  
    23882419/*}}}*/
    23892420/*FUNCTION Tria::CreatePVectorBalancedthickness {{{1*/
    2390 void  Tria::CreatePVectorBalancedthickness(Vec pg ,int analysis_type,int sub_analysis_type){
     2421void  Tria::CreatePVectorBalancedthickness(Vec pg ){
    23912422
    23922423
    … …  
    24622493/*}}}*/
    24632494/*FUNCTION Tria::CreatePVectorBalancedthickness2 {{{1*/
    2464 void  Tria::CreatePVectorBalancedthickness2(Vec pg ,int analysis_type,int sub_analysis_type){
     2495void  Tria::CreatePVectorBalancedthickness2(Vec pg){
    24652496
    24662497
    … …  
    25382569/*}}}*/
    25392570/*FUNCTION Tria::CreatePVectorBalancedvelocities {{{1*/
    2540 void  Tria::CreatePVectorBalancedvelocities(Vec pg ,int analysis_type,int sub_analysis_type){
     2571void  Tria::CreatePVectorBalancedvelocities(Vec pg){
    25412572
    25422573
    … …  
    26122643/*}}}*/
    26132644/*FUNCTION Tria::CreatePVectorDiagnosticBaseVert {{{1*/
    2614 void  Tria::CreatePVectorDiagnosticBaseVert(Vec pg,int analysis_type,int sub_analysis_type){
     2645void  Tria::CreatePVectorDiagnosticBaseVert(Vec pg){
    26152646
    26162647        int             i,j;
    … …  
    27102741/*}}}*/
    27112742/*FUNCTION Tria::CreatePVectorDiagnosticHoriz {{{1*/
    2712 void Tria::CreatePVectorDiagnosticHoriz( Vec pg,  int analysis_type,int sub_analysis_type){
     2743void Tria::CreatePVectorDiagnosticHoriz( Vec pg){
    27132744
    27142745        int             i,j;
    … …  
    28282859/*}}}*/
    28292860/*FUNCTION Tria::CreatePVectorDiagnosticHutter{{{1*/
    2830 void  Tria::CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type){
     2861void  Tria::CreatePVectorDiagnosticHutter(Vec pg){
    28312862
    28322863        /*Collapsed formulation: */
    … …  
    28462877        for(i=0;i<3;i++){
    28472878                sing=(Sing*)SpawnSing(i);
    2848                 sing->CreatePVector(pg,analysis_type,sub_analysis_type);
     2879                sing->CreatePVector(pg);
    28492880        }
    28502881
    … …  
    28552886/*}}}*/
    28562887/*FUNCTION Tria::CreatePVectorPrognostic {{{1*/
    2857 void  Tria::CreatePVectorPrognostic(Vec pg ,int analysis_type,int sub_analysis_type){
     2888void  Tria::CreatePVectorPrognostic(Vec pg){
    28582889
    28592890
    … …  
    29372968/*}}}*/
    29382969/*FUNCTION Tria::CreatePVectorPrognostic2 {{{1*/
    2939 void  Tria::CreatePVectorPrognostic2(Vec pg ,int analysis_type,int sub_analysis_type){
     2970void  Tria::CreatePVectorPrognostic2(Vec pg){
    29402971
    29412972        /* local declarations */
    … …  
    30173048/*FUNCTION Tria::CreatePVectorSlopeCompute {{{1*/
    30183049
    3019 void Tria::CreatePVectorSlopeCompute( Vec pg,  int analysis_type,int sub_analysis_type){
     3050void Tria::CreatePVectorSlopeCompute( Vec pg){
    30203051
    30213052        int             i,j;
    … …  
    30483079        double  pe_g_gaussian[numdof];
    30493080        double  slope[2];
     3081        int sub_analysis_type;
     3082
     3083        /*retrive parameters: */
     3084        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    30503085
    30513086        /* Get node coordinates and dof list: */
    … …  
    31043139/*}}}*/
    31053140/*FUNCTION Tria::CreatePVectorThermalShelf {{{1*/
    3106 void Tria::CreatePVectorThermalShelf( Vec pg,  int analysis_type,int sub_analysis_type){
     3141void Tria::CreatePVectorThermalShelf( Vec pg){
    31073142
    31083143        int i,found;
    … …  
    32053240/*}}}*/
    32063241/*FUNCTION Tria::CreatePVectorThermalSheet {{{1*/
    3207 void Tria::CreatePVectorThermalSheet( Vec pg,  int analysis_type,int sub_analysis_type){
     3242void Tria::CreatePVectorThermalSheet( Vec pg){
    32083243
    32093244        int i,found;
    … …  
    32433278        double  l1l2l3[numgrids];
    32443279        double  scalar;
     3280
     3281        int analysis_type;
     3282
     3283        /*retrive parameters: */
     3284        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    32453285
    32463286       
    … …  
    33093349/*}}}*/
    33103350/*FUNCTION Tria::Du {{{1*/
    3311 void Tria::Du(Vec du_g,int analysis_type,int sub_analysis_type){
     3351void Tria::Du(Vec du_g){
    33123352
    33133353        int i;
    … …  
    40854125/*}}}*/
    40864126/*FUNCTION Tria::Gradj {{{1*/
    4087 void  Tria::Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type){
     4127void  Tria::Gradj(Vec grad_g,int control_type){
    40884128
    40894129        /*inputs: */
    … …  
    40974137
    40984138        if (control_type==DragCoefficientEnum){
    4099                 GradjDrag( grad_g,analysis_type,sub_analysis_type);
     4139                GradjDrag( grad_g);
    41004140        }
    41014141        else if (control_type==RheologyBEnum){
    4102                 GradjB( grad_g,analysis_type,sub_analysis_type);
     4142                GradjB( grad_g);
    41034143        }
    41044144        else ISSMERROR("%s%i","control type not supported yet: ",control_type);
    … …  
    41064146/*}}}*/
    41074147/*FUNCTION Tria::GradjB{{{1*/
    4108 void  Tria::GradjB(Vec grad_g,int analysis_type,int sub_analysis_type){
     4148void  Tria::GradjB(Vec grad_g){
    41094149
    41104150        int i;
    … …  
    42524292/*}}}*/
    42534293/*FUNCTION Tria::GradjDrag {{{1*/
    4254 void  Tria::GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type){
     4294void  Tria::GradjDrag(Vec grad_g){
    42554295
    42564296
    … …  
    43114351        double  cm_maxdmp_slope;
    43124352
     4353        int analysis_type;
     4354
     4355        /*retrive parameters: */
     4356        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     4357
    43134358        /*retrieve inputs :*/
    43144359        inputs->GetParameterValue(&shelf,ElementOnIceShelfEnum);
    … …  
    44084453/*}}}*/
    44094454/*FUNCTION Tria::GradjDragStokes {{{1*/
    4410 void  Tria::GradjDragStokes(Vec grad_g,int analysis_type,int sub_analysis_type){
     4455void  Tria::GradjDragStokes(Vec grad_g){
    44114456
    44124457        int i;
    … …  
    44664511        double  cm_maxdmp_slope;
    44674512
     4513        int analysis_type;
     4514
     4515        /*retrive parameters: */
     4516        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     4517
    44684518        /*retrieve inputs :*/
    44694519        inputs->GetParameterValue(&shelf,ElementOnIceShelfEnum);
    … …  
    45734623/*}}}*/
    45744624/*FUNCTION Tria::MassFlux {{{1*/
    4575 double Tria::MassFlux( double* segment,double* ug){
     4625double Tria::MassFlux( double* segment){
    45764626
    45774627        int i;
    … …  
    45814631        int          numberofdofspernode;
    45824632        double mass_flux=0;
    4583         int    doflist[numgrids*numdofs];
    4584         double vx_list[3];
    4585         double vy_list[3];
    45864633        double xyz_list[numgrids][3];
    45874634        double gauss_1[3];
    … …  
    46064653        GetVerticesCoordinates(&xyz_list[0][0], nodes, numgrids);
    46074654
    4608         /*recover velocity at three element nodes: */
    4609         this->GetDofList(&doflist[0],&numberofdofspernode);
    4610         for(i=0;i<3;i++){
    4611                 vx_list[i]=ug[doflist[numberofdofspernode*i+0]];
    4612                 vy_list[i]=ug[doflist[numberofdofspernode*i+1]];
    4613         }
    4614 
    46154655        /*get area coordinates of 0 and 1 locations: */
    46164656        for(i=0;i<3;i++){
    … …  
    46424682/*}}}*/
    46434683/*FUNCTION Tria::Misfit {{{1*/
    4644 double Tria::Misfit(int analysis_type,int sub_analysis_type){
     4684double Tria::Misfit(void){
    46454685
    46464686        int i;
    … …  
    48734913/*}}}*/
    48744914/*FUNCTION Tria::SurfaceArea {{{1*/
    4875 double Tria::SurfaceArea(int analysis_type,int sub_analysis_type){
     4915double Tria::SurfaceArea(void){
    48764916
    48774917        int i;
    … …  
    50635103void  Tria::MinVel(double* pminvel, bool process_units){
    50645104
     5105        int i;
     5106        int dim;
    50655107        const int numgrids=3;
    50665108        double  gaussgrids[numgrids][3]={{1,0,0},{0,1,0},{0,0,1}};
    … …  
    50815123        /*now, compute minimum of velocity :*/
    50825124        if(dim==2){
    5083                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
     5125                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
    50845126        }
    50855127        else{
    5086                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
     5128                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
    50875129        }
    50885130
    … …  
    51015143void  Tria::MaxVel(double* pmaxvel, bool process_units){
    51025144
     5145        int i;
     5146        int dim;
    51035147        const int numgrids=3;
    51045148        double  gaussgrids[numgrids][3]={{1,0,0},{0,1,0},{0,0,1}};
    … …  
    51195163        /*now, compute maximum of velocity :*/
    51205164        if(dim==2){
    5121                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
     5165                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2));
    51225166        }
    51235167        else{
    5124                 for(i=0;i<numgrids;i++)vel_values=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
     5168                for(i=0;i<numgrids;i++)vel_values[i]=sqrt(pow(vx_values[i],2)+pow(vy_values[i],2)+pow(vz_values[i],2));
    51255169        }
    51265170
    … …  
    51365180}
    51375181/*}}}*/
     5182/*FUNCTION Tria::MinVx(double* pminvx, bool process_units);{{{1*/
     5183void  Tria::MinVx(double* pminvx, bool process_units){
     5184
     5185        int i;
     5186        int dim;
     5187        const int numgrids=3;
     5188        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5189        double  vx_values[numgrids];
     5190        double  minvx;
     5191
     5192        /*retrieve dim parameter: */
     5193        parameters->FindParam(&dim,DimEnum);
     5194
     5195        /*retrive velocity values at nodes */
     5196        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     5197
     5198        /*now, compute minimum:*/
     5199        minvx=vx_values[0];
     5200        for(i=1;i<numgrids;i++){
     5201                if (vx_values[i]<minvx)minvx=vx_values[i];
     5202        }
     5203
     5204        /*Assign output pointers:*/
     5205        *pminvx=minvx;
     5206
     5207}
     5208/*}}}*/
     5209/*FUNCTION Tria::MaxVx(double* pmaxvx, bool process_units);{{{1*/
     5210void  Tria::MaxVx(double* pmaxvx, bool process_units){
     5211
     5212        int i;
     5213        int dim;
     5214        const int numgrids=3;
     5215        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5216        double  vx_values[numgrids];
     5217        double  maxvx;
     5218
     5219        /*retrieve dim parameter: */
     5220        parameters->FindParam(&dim,DimEnum);
     5221
     5222        /*retrive velocity values at nodes */
     5223        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     5224
     5225        /*now, compute maximum:*/
     5226        maxvx=vx_values[0];
     5227        for(i=1;i<numgrids;i++){
     5228                if (vx_values[i]>maxvx)maxvx=vx_values[i];
     5229        }
     5230
     5231        /*Assign output pointers:*/
     5232        *pmaxvx=maxvx;
     5233
     5234}
     5235/*}}}*/
     5236/*FUNCTION Tria::MaxAbsVx(double* pmaxabsvx, bool process_units);{{{1*/
     5237void  Tria::MaxAbsVx(double* pmaxabsvx, bool process_units){
     5238
     5239        int i;
     5240        int dim;
     5241        const int numgrids=3;
     5242        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5243        double  vx_values[numgrids];
     5244        double  maxabsvx;
     5245
     5246        /*retrieve dim parameter: */
     5247        parameters->FindParam(&dim,DimEnum);
     5248
     5249        /*retrive velocity values at nodes */
     5250        inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     5251
     5252        /*now, compute maximum:*/
     5253        maxabsvx=fabs(vx_values[0]);
     5254        for(i=1;i<numgrids;i++){
     5255                if (fabs(vx_values[i])>maxabsvx)maxabsvx=fabs(vx_values[i]);
     5256        }
     5257
     5258        /*Assign output pointers:*/
     5259        *pmaxabsvx=maxabsvx;
     5260}
     5261/*}}}*/
     5262/*FUNCTION Tria::MinVy(double* pminvy, bool process_units);{{{1*/
     5263void  Tria::MinVy(double* pminvy, bool process_units){
     5264
     5265        int i;
     5266        int dim;
     5267        const int numgrids=3;
     5268        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5269        double  vy_values[numgrids];
     5270        double  minvy;
     5271
     5272        /*retrieve dim parameter: */
     5273        parameters->FindParam(&dim,DimEnum);
     5274
     5275        /*retrive velocity values at nodes */
     5276        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     5277
     5278        /*now, compute minimum:*/
     5279        minvy=vy_values[0];
     5280        for(i=1;i<numgrids;i++){
     5281                if (vy_values[i]<minvy)minvy=vy_values[i];
     5282        }
     5283
     5284        /*Assign output pointers:*/
     5285        *pminvy=minvy;
     5286
     5287}
     5288/*}}}*/
     5289/*FUNCTION Tria::MaxVy(double* pmaxvy, bool process_units);{{{1*/
     5290void  Tria::MaxVy(double* pmaxvy, bool process_units){
     5291
     5292        int i;
     5293        int dim;
     5294        const int numgrids=3;
     5295        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5296        double  vy_values[numgrids];
     5297        double  maxvy;
     5298
     5299        /*retrieve dim parameter: */
     5300        parameters->FindParam(&dim,DimEnum);
     5301
     5302        /*retrive velocity values at nodes */
     5303        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     5304
     5305        /*now, compute maximum:*/
     5306        maxvy=vy_values[0];
     5307        for(i=1;i<numgrids;i++){
     5308                if (vy_values[i]>maxvy)maxvy=vy_values[i];
     5309        }
     5310
     5311        /*Assign output pointers:*/
     5312        *pmaxvy=maxvy;
     5313
     5314}
     5315/*}}}*/
     5316/*FUNCTION Tria::MaxAbsVy(double* pmaxabsvy, bool process_units);{{{1*/
     5317void  Tria::MaxAbsVy(double* pmaxabsvy, bool process_units){
     5318
     5319        int i;
     5320        int dim;
     5321        const int numgrids=3;
     5322        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5323        double  vy_values[numgrids];
     5324        double  maxabsvy;
     5325
     5326        /*retrieve dim parameter: */
     5327        parameters->FindParam(&dim,DimEnum);
     5328
     5329        /*retrive velocity values at nodes */
     5330        inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     5331
     5332        /*now, compute maximum:*/
     5333        maxabsvy=fabs(vy_values[0]);
     5334        for(i=1;i<numgrids;i++){
     5335                if (fabs(vy_values[i])>maxabsvy)maxabsvy=fabs(vy_values[i]);
     5336        }
     5337
     5338        /*Assign output pointers:*/
     5339        *pmaxabsvy=maxabsvy;
     5340}
     5341/*}}}*/
     5342/*FUNCTION Tria::MinVz(double* pminvz, bool process_units);{{{1*/
     5343void  Tria::MinVz(double* pminvz, bool process_units){
     5344
     5345        int i;
     5346        int dim;
     5347        const int numgrids=3;
     5348        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5349        double  vz_values[numgrids];
     5350        double  minvz;
     5351
     5352        /*retrieve dim parameter: */
     5353        parameters->FindParam(&dim,DimEnum);
     5354
     5355        /*retrive velocity values at nodes */
     5356        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     5357
     5358        /*now, compute minimum:*/
     5359        minvz=vz_values[0];
     5360        for(i=1;i<numgrids;i++){
     5361                if (vz_values[i]<minvz)minvz=vz_values[i];
     5362        }
     5363
     5364        /*Assign output pointers:*/
     5365        *pminvz=minvz;
     5366
     5367}
     5368/*}}}*/
     5369/*FUNCTION Tria::MaxVz(double* pmaxvz, bool process_units);{{{1*/
     5370void  Tria::MaxVz(double* pmaxvz, bool process_units){
     5371
     5372        int i;
     5373        int dim;
     5374        const int numgrids=3;
     5375        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5376        double  vz_values[numgrids];
     5377        double  maxvz;
     5378
     5379        /*retrieve dim parameter: */
     5380        parameters->FindParam(&dim,DimEnum);
     5381
     5382        /*retrive velocity values at nodes */
     5383        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     5384
     5385        /*now, compute maximum:*/
     5386        maxvz=vz_values[0];
     5387        for(i=1;i<numgrids;i++){
     5388                if (vz_values[i]>maxvz)maxvz=vz_values[i];
     5389        }
     5390
     5391        /*Assign output pointers:*/
     5392        *pmaxvz=maxvz;
     5393
     5394}
     5395/*}}}*/
     5396/*FUNCTION Tria::MaxAbsVz(double* pmaxabsvz, bool process_units);{{{1*/
     5397void  Tria::MaxAbsVz(double* pmaxabsvz, bool process_units){
     5398
     5399        int i;
     5400        int dim;
     5401        const int numgrids=3;
     5402        double  gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}};
     5403        double  vz_values[numgrids];
     5404        double  maxabsvz;
     5405
     5406        /*retrieve dim parameter: */
     5407        parameters->FindParam(&dim,DimEnum);
     5408
     5409        /*retrive velocity values at nodes */
     5410        inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     5411
     5412        /*now, compute maximum:*/
     5413        maxabsvz=fabs(vz_values[0]);
     5414        for(i=1;i<numgrids;i++){
     5415                if (fabs(vz_values[i])>maxabsvz)maxabsvz=fabs(vz_values[i]);
     5416        }
     5417
     5418        /*Assign output pointers:*/
     5419        *pmaxabsvz=maxabsvz;
     5420}
     5421/*}}}*/
     5422/*FUNCTION Tria::ReinitializeInput(int reinitialized_enum,int original_enum){{{1*/
     5423void  Tria::ReinitializeInput(int reinitialized_enum,int original_enum){
     5424
     5425        Input* original=NULL;
     5426        Input* copy=NULL;
     5427
     5428        /*Make a copy of the original input: */
     5429        original=(Input*)this->inputs->GetInput(original_enum);
     5430        copy=(Input*)original->copy();
     5431
     5432        /*Change copy enum to reinitialized_enum: */
     5433        copy->ChangeEnum(reinitialized_enum);
     5434
     5435        /*Add copy into inputs, it will wipe off the one already there: */
     5436        inputs->AddObject((Input*)copy);
     5437}
     5438/*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Elements/Tria.h

    r4042 r4043  
    4545                void  Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* materials,Parameters* parameters);
    4646                Object* copy();
    47                 void  DeepEcho();
     47                void  DeepEcho(void);
    4848                void  Demarshall(char** pmarshalled_dataset);
    49                 void  Echo();
    50                 int   Enum();
    51                 int   Id();
     49                void  Echo(void);
     50                int   Enum(void);
     51                int   Id(void);
    5252                bool  IsInput(int name);
    5353                void  Marshall(char** pmarshalled_dataset);
    54                 int   MarshallSize();
    55                 int   MyRank();
     54                int   MarshallSize(void);
     55                int   MyRank(void);
    5656                void  SetClone(int* minranks);
    5757                void  DepthAverageInputAtBase(int enum_type);
    … …  
    6262                /*}}}*/
    6363                /*FUNCTION element numerical routines {{{1*/
    64                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    65                 void  CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type);
    66                 void  GetSolutionFromInputs(Vec solution,  int analysis_type,int sub_analysis_type);
    67                 void  GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type);
     64                void  CreateKMatrix(Mat Kgg);
     65                void  CreatePVector(Vec pg);
     66                void  GetSolutionFromInputs(Vec solution);
     67                void  GetSolutionFromInputsDiagnosticHoriz(Vec solution);
    6868                void  GetDofList(int* doflist,int* pnumberofdofs);
    6969                void  GetDofList1(int* doflist);
    70                 void  CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type);
    71                 void  CreateKMatrixDiagnosticHoriz(Mat Kgg,int analysis_type,int sub_analysis_type);
    72                 void  CreateKMatrixDiagnosticHorizFriction(Mat Kgg,int analysis_type,int sub_analysis_type);
    73                 void  CreateKMatrixDiagnosticSurfaceVert(Mat Kgg,int analysis_type,int sub_analysis_type);
    74                 void  CreateKMatrixSlopeCompute(Mat Kgg,int analysis_type,int sub_analysis_type);
     70                void  CreateKMatrixDiagnosticHutter(Mat Kgg);
     71                void  CreateKMatrixDiagnosticHoriz(Mat Kgg);
     72                void  CreateKMatrixDiagnosticHorizFriction(Mat Kgg);
     73                void  CreateKMatrixDiagnosticSurfaceVert(Mat Kgg);
     74                void  CreateKMatrixSlopeCompute(Mat Kgg);
    7575                void  GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
    7676                void  GetParameterDerivativeValue(double* p, double* plist,double* xyz_list, double* gauss_l1l2l3);
    … …  
    8787                void  GetJacobianInvert(double*  Jinv, double* xyz_list,double* gauss_l1l2l3);
    8888                void  GetJacobian(double* J, double* xyz_list,double* gauss_l1l2l3);
    89                 void  Du(Vec du_g,int analysis_type,int sub_analysis_type);
    90                 void  Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type);
    91                 void  GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type);
    92                 void  GradjDragStokes(Vec grad_g,int analysis_type,int sub_analysis_type);
     89                void  Du(Vec du_g);
     90                void  Gradj(Vec grad_g,int control_type);
     91                void  GradjDrag(Vec grad_g);
     92                void  GradjDragStokes(Vec grad_g);
    9393                void  SurfaceNormal(double* surface_normal, double xyz_list[3][3]);
    94                 void  GradjB(Vec grad_g,int analysis_type,int sub_analysis_type);
    95                 double Misfit(int analysis_type,int sub_analysis_type);
    96                 double SurfaceArea(int analysis_type,int sub_analysis_type);
    97                 double CostFunction(int analysis_type,int sub_analysis_type);
    98                 void  CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type);
    99                 void  CreatePVectorDiagnosticHoriz(Vec pg,int analysis_type,int sub_analysis_type);
    100                 void  CreatePVectorDiagnosticBaseVert(Vec pg,int analysis_type,int sub_analysis_type);
    101                 void  CreatePVectorSlopeCompute( Vec pg,  int analysis_type,int sub_analysis_type);
    102                 void* GetMatPar();
    103                 bool  GetShelf();
     94                void  GradjB(Vec grad_g);
     95                double Misfit(void);
     96                double SurfaceArea(void);
     97                double CostFunction(void);
     98                void  CreatePVectorDiagnosticHutter(Vec pg);
     99                void  CreatePVectorDiagnosticHoriz(Vec pg);
     100                void  CreatePVectorDiagnosticBaseVert(Vec pg);
     101                void  CreatePVectorSlopeCompute( Vec pg);
     102                void* GetMatPar(void);
     103                bool  GetShelf(void);
    104104                void  GetNodes(void** nodes);
    105                 bool  GetOnBed();
     105                bool  GetOnBed(void);
    106106                void  GetThicknessList(double* thickness_list);
    107107                void  GetBedList(double* bed_list);
    108                 void  ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type);
    109                 void  ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type);
    110                 void  ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type);
    111                 void  CreateKMatrixThermal(Mat Kgg,int analysis_type,int sub_analysis_type);
    112                 void  CreateKMatrixMelting(Mat Kgg,int analysis_type,int sub_analysis_type);
    113                 void  CreatePVectorThermalShelf( Vec pg,  int analysis_type,int sub_analysis_type);
    114                 void  CreatePVectorThermalSheet( Vec pg,  int analysis_type,int sub_analysis_type);
    115                 void  CreateKMatrixPrognostic(Mat Kgg,int analysis_type,int sub_analysis_type);
    116                 void  CreatePVectorPrognostic(Vec pg,int analysis_type,int sub_analysis_type);
    117                 void  CreateKMatrixPrognostic2(Mat Kgg,int analysis_type,int sub_analysis_type);
    118                 void  CreatePVectorPrognostic2(Vec pg,int analysis_type,int sub_analysis_type);
    119                 void  CreateKMatrixBalancedthickness(Mat Kgg,int analysis_type,int sub_analysis_type);
    120                 void  CreatePVectorBalancedthickness(Vec pg,int analysis_type,int sub_analysis_type);
    121                 void  CreateKMatrixBalancedthickness2(Mat Kgg,int analysis_type,int sub_analysis_type);
    122                 void  CreatePVectorBalancedthickness2(Vec pg,int analysis_type,int sub_analysis_type);
    123                 void  CreateKMatrixBalancedvelocities(Mat Kgg,int analysis_type,int sub_analysis_type);
    124                 void  CreatePVectorBalancedvelocities(Vec pg,int analysis_type,int sub_analysis_type);
    125                 double MassFlux(double* segment,double* ug);
     108                void  ComputeBasalStress(Vec sigma_b);
     109                void  ComputePressure(Vec p_g);
     110                void  ComputeStrainRate(Vec eps);
     111                void  CreateKMatrixThermal(Mat Kgg);
     112                void  CreateKMatrixMelting(Mat Kgg);
     113                void  CreatePVectorThermalShelf( Vec pg);
     114                void  CreatePVectorThermalSheet( Vec pg);
     115                void  CreateKMatrixPrognostic(Mat Kgg);
     116                void  CreatePVectorPrognostic(Vec pg);
     117                void  CreateKMatrixPrognostic2(Mat Kgg);
     118                void  CreatePVectorPrognostic2(Vec pg);
     119                void  CreateKMatrixBalancedthickness(Mat Kgg);
     120                void  CreatePVectorBalancedthickness(Vec pg);
     121                void  CreateKMatrixBalancedthickness2(Mat Kgg);
     122                void  CreatePVectorBalancedthickness2(Vec pg);
     123                void  CreateKMatrixBalancedvelocities(Mat Kgg);
     124                void  CreatePVectorBalancedvelocities(Vec pg);
     125                double MassFlux(double* segment);
    126126                double GetArea(void);
    127127                double GetAreaCoordinate(double x, double y, int which_one);
    … …  
    130130                void  MinVel(double* pminvel, bool process_units);
    131131                void  MaxVel(double* pmaxvel, bool process_units);
     132                void  MinVx(double* pminvx, bool process_units);
     133                void  MaxVx(double* pmaxvx, bool process_units);
     134                void  MaxAbsVx(double* pmaxabsvx, bool process_units);
     135                void  MinVy(double* pminvy, bool process_units);
     136                void  MaxVy(double* pmaxvy, bool process_units);
     137                void  MaxAbsVy(double* pmaxabsvy, bool process_units);
     138                void  MinVz(double* pminvz, bool process_units);
     139                void  MaxVz(double* pmaxvz, bool process_units);
     140                void  MaxAbsVz(double* pmaxabsvz, bool process_units);
     141                void  ReinitializeInput(int reinitialized_enum,int original_enum);
     142
    132143
    133144                /*}}}*/
    134145                /*FUNCTION updates{{{1*/
    135146                void  UpdateFromDakota(void* inputs);
    136                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
    137                 void  UpdateInputsFromSolutionDiagnosticHoriz( double* solution,int analysis_type,int sub_analysis_type);
    138                 void  UpdateInputsFromSolutionSlopeCompute( double* solution,int analysis_type,int sub_analysis_type);
    139                 void  UpdateInputsFromSolutionPrognostic( double* solution,int analysis_type,int sub_analysis_type);
    140                 void  UpdateInputsFromSolutionPrognostic2(double* solution,int analysis_type,int sub_analysis_type);
    141                 void  UpdateInputsFromSolutionBalancedthickness( double* solution,int analysis_type,int sub_analysis_type);
    142                 void  UpdateInputsFromSolutionBalancedthickness2( double* solution,int analysis_type,int sub_analysis_type);
    143                 void  UpdateInputsFromSolutionBalancedvelocities( double* solution,int analysis_type,int sub_analysis_type);
     147                void  UpdateInputsFromSolution(double* solutiong);
     148                void  UpdateInputsFromSolutionDiagnosticHoriz( double* solution);
     149                void  UpdateInputsFromSolutionSlopeCompute( double* solution);
     150                void  UpdateInputsFromSolutionPrognostic( double* solution);
     151                void  UpdateInputsFromSolutionPrognostic2(double* solution);
     152                void  UpdateInputsFromSolutionBalancedthickness( double* solution);
     153                void  UpdateInputsFromSolutionBalancedthickness2( double* solution);
     154                void  UpdateInputsFromSolutionBalancedvelocities( double* solution);
    144155                void  UpdateInputsFromVector(double* vector, int name, int type);
    145156                void  UpdateInputsFromVector(int* vector, int name, int type);

  • TabularUnified issm/trunk/src/c/objects/Inputs/BeamVertexInput.cpp

    r4042 r4043  
    239239
    240240        /*Process units if requested: */
    241         if(process)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters);
     241        if(process_units)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters);
    242242
    243243        /*Now, figure out minimum of valuescopy: */

  • TabularUnified issm/trunk/src/c/objects/Inputs/BeamVertexInput.h

    r4042 r4043  
    4343                void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    45                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     45                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4646
    4747                Input* SpawnSingInput(int  index);

  • TabularUnified issm/trunk/src/c/objects/Inputs/BoolInput.h

    r4042 r4043  
    4343                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    45                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     45                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4646
    4747                Input* SpawnSingInput(int  index);

  • TabularUnified issm/trunk/src/c/objects/Inputs/DoubleInput.h

    r4042 r4043  
    4444                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4545                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     46                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4747
    4848                Input* SpawnSingInput(int  index);

  • TabularUnified issm/trunk/src/c/objects/Inputs/IntInput.h

    r4042 r4043  
    4343                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    45                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     45                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4646
    4747                Input* SpawnSingInput(int  index);

  • TabularUnified issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp

    r4042 r4043  
    888888
    889889        /*Process units if requested: */
    890         if(process)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters);
     890        if(process_units)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters);
    891891
    892892        /*Now, figure out minimum of valuescopy: */

  • TabularUnified issm/trunk/src/c/objects/Inputs/PentaVertexInput.h

    r4042 r4043  
    4242                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4343
    44                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     44                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4545
    4646                Input* SpawnSingInput(int  index);

  • TabularUnified issm/trunk/src/c/objects/Inputs/SingVertexInput.cpp

    r4042 r4043  
    215215
    216216        /*Process units if requested: */
    217         if(process)NodalValuesUnitConversion(&valuecopy,1,enum_type,parameters);
     217        if(process_units)NodalValuesUnitConversion(&valuecopy,1,enum_type,parameters);
    218218
    219219        /*Now, return square of value, because it is the minimum: */

  • TabularUnified issm/trunk/src/c/objects/Inputs/SingVertexInput.h

    r4042 r4043  
    4242                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4343
    44                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     44                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4545
    4646                Input* SpawnSingInput(int  index);

  • TabularUnified issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp

    r4042 r4043  
    462462
    463463        /*Process units if requested: */
    464         if(process)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters);
     464        if(process_units)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters);
    465465
    466466        /*Now, figure out minimum of valuescopy: */

  • TabularUnified issm/trunk/src/c/objects/Inputs/TriaVertexInput.h

    r4042 r4043  
    4242                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4343                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     44                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4545
    4646                Input* SpawnSingInput(int  index);

  • TabularUnified issm/trunk/src/c/objects/Loads/Icefront.cpp

    r4021 r4043  
    278278/*FUNCTION Icefront::CreateKMatrix {{{1*/
    279279
    280 void  Icefront::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     280void  Icefront::CreateKMatrix(Mat Kgg){
    281281
    282282        /*No stiffness loads applied, do nothing: */
    … …  
    287287/*}}}*/
    288288/*FUNCTION Icefront::CreatePVector {{{1*/
    289 void  Icefront::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){
     289void  Icefront::CreatePVector(Vec pg){
     290
     291        int analysis_type,sub_analysis_type;
     292
     293        /*Retrieve parameters: */
     294        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     295        this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
    290296
    291297        /*Just branch to the correct element icefront vector generator, according to the type of analysis we are carrying out: */
    292298        if (analysis_type==ControlAnalysisEnum){
    293299               
    294                 CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type);
     300                CreatePVectorDiagnosticHoriz( pg);
    295301
    296302        }
    … …  
    299305                if (sub_analysis_type==HorizAnalysisEnum){
    300306               
    301                         CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type);
     307                        CreatePVectorDiagnosticHoriz( pg);
    302308
    303309                }
    304310                else if (sub_analysis_type==StokesAnalysisEnum){
    305311                       
    306                         CreatePVectorDiagnosticStokes( pg,analysis_type,sub_analysis_type);
     312                        CreatePVectorDiagnosticStokes( pg);
    307313
    308314                }
    … …  
    316322/*}}}*/
    317323/*FUNCTION Icefront::CreatePVectorDiagnosticHoriz {{{1*/
    318 void Icefront::CreatePVectorDiagnosticHoriz( Vec pg,  int analysis_type,int sub_analysis_type){
     324void Icefront::CreatePVectorDiagnosticHoriz( Vec pg){
    319325       
    320326        int type;
    … …  
    323329        /*Branck on the type of icefront: */
    324330        if (type==SegmentIcefrontEnum){
    325                 CreatePVectorDiagnosticHorizSegment(pg,analysis_type,sub_analysis_type);
     331                CreatePVectorDiagnosticHorizSegment(pg);
    326332        }
    327333        else if (type==QuadIceFrontEnum){
    328                 CreatePVectorDiagnosticHorizQuad(pg,analysis_type,sub_analysis_type);
     334                CreatePVectorDiagnosticHorizQuad(pg);
    329335        }
    330336        else ISSMERROR("type %i not supported",type);
    … …  
    332338/*}}}*/
    333339/*FUNCTION Icefront::CreatePVectorDiagnosticHorizSegment{{{1*/
    334 void Icefront::CreatePVectorDiagnosticHorizSegment( Vec pg,int analysis_type,int sub_analysis_type){
     340void Icefront::CreatePVectorDiagnosticHorizSegment( Vec pg){
    335341
    336342        int i,j;
    … …  
    425431/*}}}*/
    426432/*FUNCTION Icefront::CreatePVectorDiagnosticHorizQuad {{{1*/
    427 void Icefront::CreatePVectorDiagnosticHorizQuad( Vec pg,int analysis_type,int sub_analysis_type){
     433void Icefront::CreatePVectorDiagnosticHorizQuad( Vec pg){
    428434
    429435        int i,j;
    … …  
    563569/*}}}*/
    564570/*FUNCTION Icefront::CreatePVectorDiagnosticStokes {{{1*/
    565 void Icefront::CreatePVectorDiagnosticStokes( Vec pg,int analysis_type,int sub_analysis_type){
     571void Icefront::CreatePVectorDiagnosticStokes( Vec pg){
    566572
    567573        int i,j;
    … …  
    699705}
    700706/*}}}*/
    701 /*FUNCTION Icefront::DistributeNumDofs {{{1*/
    702 void  Icefront::DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type){return;}
    703                
    704 /*}}}*/
    705707/*FUNCTION Icefront::GetDofList{{{1*/
    706708
    … …  
    740742/*}}}*/
    741743/*FUNCTION Icefront::PenaltyCreateKMatrix {{{1*/
    742 void  Icefront::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
     744void  Icefront::PenaltyCreateKMatrix(Mat Kgg,double kmax){
    743745        /*do nothing: */
    744746}
    745747/*}}}*/
    746748/*FUNCTION Icefront::PenaltyCreatePVector{{{1*/
    747 void  Icefront::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){
     749void  Icefront::PenaltyCreatePVector(Vec pg,double kmax){
    748750        /*do nothing: */
    749751}
    … …  
    13741376}
    13751377/*}}}*/
    1376 /*FUNCTION Icefront::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type) {{{1*/
    1377 void  Icefront::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){
     1378/*FUNCTION Icefront::UpdateInputsFromSolution(double* solution) {{{1*/
     1379void  Icefront::UpdateInputsFromSolution(double* solution){
    13781380        /*Nothing updated yet*/
    13791381}

  • TabularUnified issm/trunk/src/c/objects/Loads/Icefront.h

    r4007 r4043  
    5555                void  UpdateInputsFromConstant(int constant, int name);
    5656                void  UpdateInputsFromConstant(bool constant, int name);
    57                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
     57                void  UpdateInputsFromSolution(double* solution);
    5858                bool  InAnalysis(int analysis_type);
    5959                /*}}}*/
    6060                /*numerics: {{{1*/
    61                 void  DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type);
    62                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    63                 void  CreatePVector(Vec pg, int analysis_type,int sub_analysis_type);
    64                 void  CreatePVectorDiagnosticHoriz( Vec pg,  int analysis_type,int sub_analysis_type);
    65                 void  CreatePVectorDiagnosticHorizSegment( Vec pg, int analysis_type,int sub_analysis_type);
    66                 void  CreatePVectorDiagnosticHorizQuad( Vec pg, int analysis_type,int sub_analysis_type);
    67                 void  CreatePVectorDiagnosticStokes( Vec pg, int analysis_type,int sub_analysis_type);
     61                void  CreateKMatrix(Mat Kgg);
     62                void  CreatePVector(Vec pg);
     63                void  CreatePVectorDiagnosticHoriz( Vec pg);
     64                void  CreatePVectorDiagnosticHorizSegment( Vec pg);
     65                void  CreatePVectorDiagnosticHorizQuad( Vec pg);
     66                void  CreatePVectorDiagnosticStokes( Vec pg);
    6867                void  GetDofList(int* doflist,int* pnumberofdofs);
    6968                void  SegmentPressureLoad(double* pe_g,double rho_water,double rho_ice,double gravity, double* thickness_list, double* bed_list, double* normal,double length);
    … …  
    7271                void  QuadPressureLoadStokes(double* pe_g,double rho_water,double rho_ice,double gravity, double* thickness_list, double* bed_list,
    7372                                              double* normal1,double* normal2,double* normal3,double* normal4,double* xyz_list);
    74                 void  PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
    75                 void  PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type);
     73                void  PenaltyCreateKMatrix(Mat Kgg,double kmax);
     74                void  PenaltyCreatePVector(Vec pg,double kmax);
    7675                /*}}}*/
    7776};

  • TabularUnified issm/trunk/src/c/objects/Loads/Load.h

    r4004 r4043  
    3030                virtual void  Demarshall(char** pmarshalled_dataset)=0;
    3131                virtual void  Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* vertices,DataSet* materials,Parameters* parameters)=0;
    32                 virtual void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type)=0;
    33                 virtual void  CreatePVector(Vec pg, int analysis_type,int sub_analysis_type)=0;
    34                 virtual void  PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type)=0;
    35                 virtual void  PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type)=0;
     32                virtual void  CreateKMatrix(Mat Kgg)=0;
     33                virtual void  CreatePVector(Vec pg)=0;
     34                virtual void  PenaltyCreateKMatrix(Mat Kgg,double kmax)=0;
     35                virtual void  PenaltyCreatePVector(Vec pg,double kmax)=0;
    3636                virtual bool  InAnalysis(int analysis_type);
    3737};

  • TabularUnified issm/trunk/src/c/objects/Loads/Numericalflux.cpp

    r4021 r4043  
    283283/*Object functions*/
    284284/*FUNCTION Numericalflux::CreateKMatrix {{{1*/
    285 void  Numericalflux::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     285void  Numericalflux::CreateKMatrix(Mat Kgg){
    286286
    287287        int type;
    … …  
    292292        if (type==InternalEnum){
    293293
    294                 CreateKMatrixInternal(Kgg,analysis_type,sub_analysis_type);
     294                CreateKMatrixInternal(Kgg);
    295295        }
    296296        else if (type==BoundaryEnum){
    297297
    298                 CreateKMatrixBoundary(Kgg,analysis_type,sub_analysis_type);
     298                CreateKMatrixBoundary(Kgg);
    299299        }
    300300        else ISSMERROR("type not supported yet");
    … …  
    303303/*}}}*/
    304304/*FUNCTION Numericalflux::CreateKMatrixInternal {{{1*/
    305 void  Numericalflux::CreateKMatrixInternal(Mat Kgg,int analysis_type,int sub_analysis_type){
     305void  Numericalflux::CreateKMatrixInternal(Mat Kgg){
    306306
    307307        /* local declarations */
    308308        int             i,j;
     309        int analysis_type,sub_analysis_type;
    309310
    310311        /* node data: */
    … …  
    342343        Node**  nodes=NULL;
    343344        Tria**  trias=NULL;
     345
     346        /*Retrieve parameters: */
     347        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     348        this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
    344349
    345350        /*recover objects from hooks: */
    … …  
    417422/*}}}*/
    418423/*FUNCTION Numericalflux::CreateKMatrixBoundary {{{1*/
    419 void  Numericalflux::CreateKMatrixBoundary(Mat Kgg,int analysis_type,int sub_analysis_type){
     424void  Numericalflux::CreateKMatrixBoundary(Mat Kgg){
    420425
    421426        /* local declarations */
    422427        int             i,j;
     428        int analysis_type,sub_analysis_type;
    423429
    424430        /* node data: */
    … …  
    458464        Tria**  trias=NULL;
    459465
     466        /*Retrieve parameters: */
     467        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     468        this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
     469
    460470        /*recover objects from hooks: */
    461471        nodes=(Node**)hnodes.deliverp();
    … …  
    534544/*}}}*/
    535545/*FUNCTION Numericalflux::CreatePVector {{{1*/
    536 void  Numericalflux::CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type){
     546void  Numericalflux::CreatePVector(Vec pg){
    537547
    538548        int type;
    … …  
    543553        if (type==InternalEnum){
    544554
    545                 CreatePVectorInternal(pg,analysis_type,sub_analysis_type);
     555                CreatePVectorInternal(pg);
    546556        }
    547557        else if (type==BoundaryEnum){
    548558
    549                 CreatePVectorBoundary(pg,analysis_type,sub_analysis_type);
     559                CreatePVectorBoundary(pg);
    550560        }
    551561        else ISSMERROR("type not supported yet");
    … …  
    554564/*}}}*/
    555565/*FUNCTION Numericalflux::CreatePVectorInternal{{{1*/
    556 void  Numericalflux::CreatePVectorInternal(Vec pg,int analysis_type,int sub_analysis_type){
     566void  Numericalflux::CreatePVectorInternal(Vec pg){
    557567
    558568        /*Nothing added to PVector*/
    … …  
    562572/*}}}*/
    563573/*FUNCTION Numericalflux::CreatePVectorBoundary{{{1*/
    564 void  Numericalflux::CreatePVectorBoundary(Vec pg,int analysis_type,int sub_analysis_type){
     574void  Numericalflux::CreatePVectorBoundary(Vec pg){
    565575
    566576        /* local declarations */
    567577        int             i,j;
     578        int analysis_type,sub_analysis_type;
    568579
    569580        /* node data: */
    … …  
    607618        trias=(Tria**)helements.deliverp();
    608619
     620        /*Retrieve parameters: */
     621        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     622        this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
     623
    609624        /*recover parameters: */
    610625        if (analysis_type==Prognostic2AnalysisEnum){
    … …  
    673688}
    674689/*}}}*/
    675 /*FUNCTION Numericalflux::DistributeNumDofs {{{1*/
    676 void  Numericalflux::DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type){
    677         return;
    678 }
    679690/*}}}*/
    680691/*FUNCTION Numericalflux::GetB {{{1*/
    … …  
    825836/*}}}*/
    826837/*FUNCTION Numericalflux::PenaltyCreateKMatrix {{{1*/
    827 void  Numericalflux::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
     838void  Numericalflux::PenaltyCreateKMatrix(Mat Kgg,double kmax){
    828839
    829840        /*No stiffness loads applied, do nothing: */
    … …  
    833844/*}}}*/
    834845/*FUNCTION Numericalflux::PenaltyCreatePVector{{{1*/
    835 void  Numericalflux::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){
     846void  Numericalflux::PenaltyCreatePVector(Vec pg,double kmax){
    836847
    837848        /*No penalty loads applied, do nothing: */

  • TabularUnified issm/trunk/src/c/objects/Loads/Numericalflux.h

    r4007 r4043  
    5050                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    5151                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    52                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     52                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5353                bool    InAnalysis(int analysis_type);
    5454
    … …  
    5757                void  GetJacobianDeterminant(double* pJdet,double xyz_list[4][3], double gauss_coord);
    5858                void  GetNodalFunctions(double* l1l4, double gauss_coord);
    59                 void  DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type);
    6059                void  GetB(double* B, double gauss_coord);
    6160                void  GetL(double* L, double gauss_coord,int numdof);
    … …  
    6564                void  UpdateFromInputs(void* inputs);
    6665               
    67                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    68                 void  CreateKMatrixInternal(Mat Kgg,int analysis_type,int sub_analysis_type);
    69                 void  CreateKMatrixBoundary(Mat Kgg,int analysis_type,int sub_analysis_type);
    70                 void  CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type);
    71                 void  CreatePVectorInternal(Vec pg,int analysis_type,int sub_analysis_type);
    72                 void  CreatePVectorBoundary(Vec pg,int analysis_type,int sub_analysis_type);
    73                 void  PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
    74                 void  PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type);
     66                void  CreateKMatrix(Mat Kgg);
     67                void  CreateKMatrixInternal(Mat Kgg);
     68                void  CreateKMatrixBoundary(Mat Kgg);
     69                void  CreatePVector(Vec pg);
     70                void  CreatePVectorInternal(Vec pg);
     71                void  CreatePVectorBoundary(Vec pg);
     72                void  PenaltyCreateKMatrix(Mat Kgg,double kmax);
     73                void  PenaltyCreatePVector(Vec pg,double kmax);
    7574                /*}}}*/
    7675

  • TabularUnified issm/trunk/src/c/objects/Loads/Pengrid.cpp

    r4021 r4043  
    249249/*FUNCTION Pengrid::CreateKMatrix {{{1*/
    250250
    251 void  Pengrid::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     251void  Pengrid::CreateKMatrix(Mat Kgg){
    252252
    253253        /*No loads applied, do nothing: */
    … …  
    257257/*}}}1*/
    258258/*FUNCTION Pengrid::CreatePVector {{{1*/
    259 void  Pengrid::CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type){
     259void  Pengrid::CreatePVector(Vec pg){
    260260
    261261        /*No loads applied, do nothing: */
    … …  
    263263
    264264}
    265 /*}}}1*/
    266 /*FUNCTION Pengrid::DistributenumDofs {{{1*/
    267 void  Pengrid::DistributeNumDofs(int* numdofpernode,int analysis_type,int sub_analysis_type){return;}
    268265/*}}}1*/
    269266/*FUNCTION Pengrid::GetDofList {{{1*/
    … …  
    291288/*}}}*/
    292289/*FUNCTION Pengrid::PenaltyConstrain {{{1*/
    293 void  Pengrid::PenaltyConstrain(int* punstable,int analysis_type,int sub_analysis_type){
     290void  Pengrid::PenaltyConstrain(int* punstable){
     291
     292        int analysis_type,sub_analysis_type;
     293
     294        /*Retrieve parameters: */
     295        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     296        this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
    294297
    295298        if ((analysis_type==DiagnosticAnalysisEnum) && ((sub_analysis_type==StokesAnalysisEnum))){
    … …  
    301304        else if (analysis_type==ThermalAnalysisEnum){
    302305               
    303                 PenaltyConstrainThermal(punstable,analysis_type,sub_analysis_type);
     306                PenaltyConstrainThermal(punstable);
    304307               
    305308        }
    … …  
    317320/*}}}1*/
    318321/*FUNCTION Pengrid::PenaltyConstrainThermal {{{1*/
    319 void  Pengrid::PenaltyConstrainThermal(int* punstable,int analysis_type,int sub_analysis_type){
     322void  Pengrid::PenaltyConstrainThermal(int* punstable){
    320323
    321324        //   The penalty is stable if it doesn't change during to successive iterations.   
    … …  
    401404/*}}}1*/
    402405/*FUNCTION Pengrid::PenaltyCreateMatrix {{{1*/
    403 void  Pengrid::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
     406void  Pengrid::PenaltyCreateKMatrix(Mat Kgg,double kmax){
     407
     408        int analysis_type,sub_analysis_type;
     409
     410        /*Retrieve parameters: */
     411        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     412        this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
    404413
    405414        if ((analysis_type==DiagnosticAnalysisEnum) && ((sub_analysis_type==StokesAnalysisEnum))){
    406415
    407                 PenaltyCreateKMatrixDiagnosticStokes( Kgg,kmax,analysis_type,sub_analysis_type);
     416                PenaltyCreateKMatrixDiagnosticStokes( Kgg,kmax);
    408417        }
    409418        else if (analysis_type==ThermalAnalysisEnum){
    410419               
    411                 PenaltyCreateKMatrixThermal( Kgg,kmax,analysis_type,sub_analysis_type);
     420                PenaltyCreateKMatrixThermal( Kgg,kmax);
    412421               
    413422        }
    414423        else if (analysis_type==MeltingAnalysisEnum){
    415424                       
    416                 PenaltyCreateKMatrixMelting( Kgg,kmax,analysis_type,sub_analysis_type);
     425                PenaltyCreateKMatrixMelting( Kgg,kmax);
    417426
    418427        }
    … …  
    424433/*}}}1*/
    425434/*FUNCTION Pengrid::PenaltyCreateKMatrixDiagnosticStokes {{{1*/
    426 void  Pengrid::PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
     435void  Pengrid::PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax){
    427436       
    428437        const int numgrids=1;
    … …  
    467476/*}}}1*/
    468477/*FUNCTION Pengrid::PenaltyCreateKMatrixMelting {{{1*/
    469 void  Pengrid::PenaltyCreateKMatrixMelting(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
     478void  Pengrid::PenaltyCreateKMatrixMelting(Mat Kgg,double kmax){
    470479
    471480        int found=0;
    … …  
    526535/*}}}1*/
    527536/*FUNCTION Pengrid::PenaltyCreateKMatrixThermal {{{1*/
    528 void  Pengrid::PenaltyCreateKMatrixThermal(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
     537void  Pengrid::PenaltyCreateKMatrixThermal(Mat Kgg,double kmax){
    529538
    530539        int found=0;
    … …  
    553562/*}}}1*/
    554563/*FUNCTION Pengrid::PenaltyCreatePVector {{{1*/
    555 void  Pengrid::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){
     564void  Pengrid::PenaltyCreatePVector(Vec pg,double kmax){
     565
     566        int analysis_type,sub_analysis_type;
     567
     568        /*Retrieve parameters: */
     569        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     570        this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum);
    556571
    557572        if (analysis_type==ThermalAnalysisEnum){
    558573               
    559                 PenaltyCreatePVectorThermal( pg,kmax,analysis_type,sub_analysis_type);
     574                PenaltyCreatePVectorThermal( pg,kmax);
    560575               
    561576        }
    562577        else if (analysis_type==MeltingAnalysisEnum){
    563578                       
    564                 PenaltyCreatePVectorMelting( pg,kmax,analysis_type,sub_analysis_type);
     579                PenaltyCreatePVectorMelting( pg,kmax);
    565580
    566581        }
    … …  
    578593/*}}}1*/
    579594/*FUNCTION Pengrid::PenaltyCreatePVectorMelting {{{1*/
    580 void  Pengrid::PenaltyCreatePVectorMelting(Vec pg, double kmax,int analysis_type,int sub_analysis_type){
     595void  Pengrid::PenaltyCreatePVectorMelting(Vec pg, double kmax){
    581596       
    582597        const int numgrids=1;
    … …  
    654669/*}}}1*/
    655670/*FUNCTION Pengrid::PenaltyCreatePVectorThermal {{{1*/
    656 void  Pengrid::PenaltyCreatePVectorThermal(Vec pg,  double kmax,int analysis_type,int sub_analysis_type){
     671void  Pengrid::PenaltyCreatePVectorThermal(Vec pg,  double kmax){
    657672
    658673        const int numgrids=1;
    … …  
    714729/*}}}1*/
    715730/*FUNCTION Pengrid::UpdateInputs {{{1*/
    716 void  Pengrid::UpdateInputs(double* solution, int analysis_type, int sub_analysis_type){
     731void  Pengrid::UpdateInputs(double* solution){
    717732        ISSMERROR("not supported yet!");
    718733}
    … …  
    761776}
    762777/*}}}*/
    763 /*FUNCTION Pengrid::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type) {{{1*/
    764 void  Pengrid::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){
     778/*FUNCTION Pengrid::UpdateInputsFromSolution(double* solution) {{{1*/
     779void  Pengrid::UpdateInputsFromSolution(double* solution){
    765780        /*Nothing updated yet*/
    766781}

  • TabularUnified issm/trunk/src/c/objects/Loads/Pengrid.h

    r4007 r4043  
    5656                void  UpdateInputsFromConstant(int constant, int name);
    5757                void  UpdateInputsFromConstant(bool constant, int name);
    58                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
     58                void  UpdateInputsFromSolution(double* solution);
    5959                bool  InAnalysis(int analysis_type);
    6060
    6161                /*}}}*/
    6262                /*FUNCTION element numerical routines {{{1*/
    63                 void  DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type);
    64                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    65                 void  CreatePVector(Vec pg, int analysis_type,int sub_analysis_type);
    66                 void  PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
    67                 void  PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type);
    68                 void  PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
     63                void  CreateKMatrix(Mat Kgg);
     64                void  CreatePVector(Vec pg);
     65                void  PenaltyCreateKMatrix(Mat Kgg,double kmax);
     66                void  PenaltyCreatePVector(Vec pg,double kmax);
     67                void  PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax);
    6968                void  GetDofList(int* doflist,int* pnumberofdofspernode);
    70                 void  PenaltyCreateKMatrixThermal(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
    71                 void  PenaltyCreateKMatrixMelting(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
    72                 void  PenaltyCreatePVectorThermal(Vec pg, double kmax,int analysis_type,int sub_analysis_type);
    73                 void  PenaltyCreatePVectorMelting(Vec pg, double kmax,int analysis_type,int sub_analysis_type);
    74                 void  PenaltyConstrain(int* punstable,int analysis_type,int sub_analysis_type);
    75                 void  PenaltyConstrainThermal(int* punstable,int analysis_type,int sub_analysis_type);
     69                void  PenaltyCreateKMatrixThermal(Mat Kgg,double kmax);
     70                void  PenaltyCreateKMatrixMelting(Mat Kgg,double kmax);
     71                void  PenaltyCreatePVectorThermal(Vec pg, double kmax);
     72                void  PenaltyCreatePVectorMelting(Vec pg, double kmax);
     73                void  PenaltyConstrain(int* punstable);
     74                void  PenaltyConstrainThermal(int* punstable);
    7675               
    7776                /*updates:*/
    7877                void  UpdateFromDakota(void* inputs);
    79                 void  UpdateInputs(double* solution, int analysis_type, int sub_analysis_type);
     78                void  UpdateInputs(double* solution);
    8079                /*}}}*/
    8180

  • TabularUnified issm/trunk/src/c/objects/Loads/Penpair.cpp

    r4021 r4043  
    181181/*FUNCTION Penpair::CreateKMatrix {{{1*/
    182182
    183 void  Penpair::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     183void  Penpair::CreateKMatrix(Mat Kgg){
    184184
    185185        /*No loads applied, do nothing: */
    … …  
    189189/*}}}1*/
    190190/*FUNCTION Penpair::CreatePVector {{{1*/
    191 void  Penpair::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){
     191void  Penpair::CreatePVector(Vec pg){
    192192
    193193        /*No loads applied, do nothing: */
    … …  
    197197/*}}}1*/
    198198/*FUNCTION Penpair::PenaltyCreateKMatrix {{{1*/
    199 void  Penpair::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
     199void  Penpair::PenaltyCreateKMatrix(Mat Kgg,double kmax){
    200200       
    201201        /*If you code this piece, don't forget that a penalty will be inactive if it is dealing with clone nodes*/
    … …  
    205205/*}}}1*/
    206206/*FUNCTION Penpair::PenaltyCreatePVector {{{1*/
    207 void  Penpair::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){
     207void  Penpair::PenaltyCreatePVector(Vec pg,double kmax){
    208208        /*No loads applied, do nothing: */
    209209        return;

  • TabularUnified issm/trunk/src/c/objects/Loads/Penpair.h

    r4007 r4043  
    4747                void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4848                void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    49                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     49                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5050                bool  InAnalysis(int analysis_type);
    5151                /*}}}*/
    5252                /*numerics: {{{1*/
    53                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    54                 void  CreatePVector(Vec pg, int analysis_type,int sub_analysis_type);
    55                 void  PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
    56                 void  PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type);
     53                void  CreateKMatrix(Mat Kgg);
     54                void  CreatePVector(Vec pg);
     55                void  PenaltyCreateKMatrix(Mat Kgg,double kmax);
     56                void  PenaltyCreatePVector(Vec pg,double kmax);
    5757                /*}}}*/
    5858};

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

    r4021 r4043  
    290290#define _ZIGZAGCOUNTER_
    291291
    292 int   Riftfront::Constrain(int* punstable,  int analysis_type){
     292int   Riftfront::Constrain(int* punstable){
    293293
    294294        const int   numgrids        = 2;
    … …  
    374374/*}}}1*/
    375375/*FUNCTION Riftfront::CreateKMatrix {{{1*/
    376 void  Riftfront::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     376void  Riftfront::CreateKMatrix(Mat Kgg){
    377377        /*do nothing: */
    378378}
    379379/*}}}1*/
    380380/*FUNCTION Riftfront::CreatePVector {{{1*/
    381 void  Riftfront::CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type){
     381void  Riftfront::CreatePVector(Vec pg){
    382382        /*do nothing: */
    383383}
    384384/*}}}1*/
    385385/*FUNCTION Riftfront::FreezeConstraints{{{1*/
    386 void   Riftfront::FreezeConstraints( int analysis_type){
     386void   Riftfront::FreezeConstraints(void){
    387387
    388388        /*Just set frozen flag to 1: */
    … …  
    422422/*}}}1*/
    423423/*FUNCTION Riftfront::IsMaterialStable {{{1*/
    424 int   Riftfront::IsMaterialStable( int analysis_type){
     424int   Riftfront::IsMaterialStable(void){
    425425
    426426        int found=0;
    … …  
    440440/*}}}1*/
    441441/*FUNCTION Riftfront::MaxPenetration {{{1*/
    442 int   Riftfront::MaxPenetration(double* ppenetration,  int analysis_type){
     442int   Riftfront::MaxPenetration(double* ppenetration){
    443443
    444444        const int     numgrids=2;
    … …  
    506506/*}}}1*/
    507507/*FUNCTION Riftfront::PenaltyCreateKMatrix {{{1*/
    508 void  Riftfront::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
     508void  Riftfront::PenaltyCreateKMatrix(Mat Kgg,double kmax){
    509509
    510510        int         i;
    … …  
    618618/*}}}1*/
    619619/*FUNCTION Riftfront::PenaltyCreatePVector {{{1*/
    620 void  Riftfront::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){
     620void  Riftfront::PenaltyCreatePVector(Vec pg,double kmax){
    621621
    622622        int         i                     ,j;
    … …  
    745745/*}}}1*/
    746746/*FUNCTION Riftfront::Penetration {{{1*/
    747 int   Riftfront::Penetration(double* ppenetration,  int analysis_type){
     747int   Riftfront::Penetration(double* ppenetration){
    748748
    749749        double    vx1;
    … …  
    790790/*}}}1*/
    791791/*FUNCTION Riftfront::PotentialUnstableConstraint {{{1*/
    792 int   Riftfront::PotentialUnstableConstraint(int* punstable,  int analysis_type){
     792int   Riftfront::PotentialUnstableConstraint(int* punstable){
    793793
    794794
    … …  
    849849/*}}}1*/
    850850/*FUNCTION Riftfront::PreConstrain {{{1*/
    851 int   Riftfront::PreConstrain(int* punstable,  int analysis_type){
     851int   Riftfront::PreConstrain(int* punstable){
    852852
    853853        const int   numgrids    = 2;

  • TabularUnified issm/trunk/src/c/objects/Loads/Riftfront.h

    r4003 r4043  
    6565                void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6666                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    67                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     67                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6868                bool    InAnalysis(int analysis_type);
    6969
    … …  
    7373                /*numerics: {{{1*/
    7474                void  GetDofList(int* doflist,int* pnumberofdofs);
    75                 void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    76                 void  CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type);
    77                 void  PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
    78                 void  PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type);
     75                void  CreateKMatrix(Mat Kgg);
     76                void  CreatePVector(Vec pg);
     77                void  PenaltyCreateKMatrix(Mat Kgg,double kmax);
     78                void  PenaltyCreatePVector(Vec pg,double kmax);
    7979                bool  PreStable();
    8080                void  SetPreStable();
    81                 int   PreConstrain(int* punstable,  int analysis_type);
    82                 int   Constrain(int* punstable,  int analysis_type);
    83                 void  FreezeConstraints( int analysis_type);
     81                int   PreConstrain(int* punstable);
     82                int   Constrain(int* punstable);
     83                void  FreezeConstraints(void);
    8484                bool  IsFrozen(void);
    85                 int   Penetration(double* ppenetration,  int analysis_type);
    86                 int   MaxPenetration(double* ppenetration,  int analysis_type);
    87                 int   PotentialUnstableConstraint(int* punstable,  int analysis_type);
    88                 int   IsMaterialStable( int analysis_type);
     85                int   Penetration(double* ppenetration);
     86                int   MaxPenetration(double* ppenetration);
     87                int   PotentialUnstableConstraint(int* punstable);
     88                int   IsMaterialStable(void);
    8989                void  OutputProperties(Vec riftproperties);
    9090                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Materials/Material.h

    r3751 r4043  
    2929                virtual void  UpdateInputsFromVector(int* vector, int name, int type)=0;
    3030                virtual void  UpdateInputsFromVector(bool* vector, int name, int type)=0;
    31                 virtual void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type)=0;
     31                virtual void  UpdateInputsFromSolution(double* solution)=0;
    3232               
    3333};

  • TabularUnified issm/trunk/src/c/objects/Materials/Matice.cpp

    r4021 r4043  
    146146        return;
    147147}               
    148 /*}}}*/
    149 /*FUNCTION Matice::DistributeNumDofs {{{1*/
    150 void  Matice::DistributeNumDofs(int* numdofspernode,int analysis_type){return;}
    151148/*}}}*/
    152149/*FUNCTION Matice::Echo {{{1*/
    … …  
    461458}
    462459/*}}}*/
    463 /*FUNCTION Matice::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type) {{{1*/
    464 void  Matice::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){
    465         /*Nothing updated yet*/
    466 }
    467 /*}}}*/
     460/*FUNCTION Matice::UpdateInputsFromSolution(double* solution) {{{1*/
     461void  Matice::UpdateInputsFromSolution(double* solution){
     462        /*Nothing updated yet*/
     463}
     464/*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Materials/Matice.h

    r3984 r4043  
    3535                int   Id();
    3636                int   MyRank();
    37                 void  DistributeNumDofs(int* numdofspernode,int analysis_type);
    3837                void  UpdateFromInputs(void* inputs);
    3938                void  SetB(double B_param);
    … …  
    5150                void  UpdateInputsFromConstant(int constant, int name);
    5251                void  UpdateInputsFromConstant(bool constant, int name);
    53                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
     52                void  UpdateInputsFromSolution(double* solution);
    5453
    5554};

  • TabularUnified issm/trunk/src/c/objects/Materials/Matpar.cpp

    r3863 r4043  
    187187}               
    188188/*}}}1*/
    189 /*FUNCTION Matpar::DistributeNumDofs {{{1*/
    190 void  Matpar::DistributeNumDofs(int* numdofspernode,int analysis_type){return;}
    191 /*}}}1*/
    192189/*FUNCTION Matpar::Echo {{{1*/
    193190void Matpar::Echo(void){
    … …  
    312309}
    313310/*}}}*/
    314 /*FUNCTION Matpar::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type) {{{1*/
    315 void   Matpar::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){
    316         /*Nothing updated yet*/
    317 }
    318 /*}}}*/
     311/*FUNCTION Matpar::UpdateInputsFromSolution(double* solution) {{{1*/
     312void   Matpar::UpdateInputsFromSolution(double* solution){
     313        /*Nothing updated yet*/
     314}
     315/*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Materials/Matpar.h

    r3863 r4043  
    4444                int   Id();
    4545                int   MyRank();
    46                 void  DistributeNumDofs(int* numdofspernode,int analysis_type);
    4746                void  UpdateFromInputs(void* inputs);
    4847                double GetG();
    … …  
    6362                void   UpdateInputsFromConstant(int constant, int name);
    6463                void   UpdateInputsFromConstant(bool constant, int name);
    65                 void   UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
     64                void   UpdateInputsFromSolution(double* solution);
    6665
    6766

  • TabularUnified issm/trunk/src/c/objects/Node.h

    r4002 r4043  
    5959                void  UpdateInputsFromConstant(int constant, int name);
    6060                void  UpdateInputsFromConstant(bool constant, int name);
    61                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     61                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6262                bool  InAnalysis(int analysis_type);
    6363

  • TabularUnified issm/trunk/src/c/objects/Object.h

    r3751 r4043  
    3131                virtual void  UpdateInputsFromConstant(int constant, int name)=0;
    3232                virtual void  UpdateInputsFromConstant(bool constant, int name)=0;
    33                 virtual void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type)=0;
     33                virtual void  UpdateInputsFromSolution(double* solution)=0;
    3434       
    3535};

  • TabularUnified issm/trunk/src/c/objects/Params/BoolParam.h

    r3842 r4043  
    5656                void  UpdateInputsFromConstant(int constant, int name);
    5757                void  UpdateInputsFromConstant(bool constant, int name);
    58 
    59                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     58                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6059
    6160                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Params/DoubleMatParam.h

    r3842 r4043  
    6060                void  UpdateInputsFromConstant(bool constant, int name);
    6161
    62                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     62                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6363
    6464                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Params/DoubleParam.h

    r3888 r4043  
    5858                void  UpdateInputsFromConstant(bool constant, int name);
    5959
    60                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     60                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6161
    6262                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Params/DoubleVecParam.h

    r3842 r4043  
    5959                void  UpdateInputsFromConstant(bool constant, int name);
    6060
    61                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     61                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6262                /*}}}*/
    6363                /*Param methods: {{{1*/

  • TabularUnified issm/trunk/src/c/objects/Params/IntParam.h

    r3842 r4043  
    5757                void  UpdateInputsFromConstant(int constant, int name);
    5858                void  UpdateInputsFromConstant(bool constant, int name);
    59 
    60                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     59                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6160
    6261                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Params/PetscMatParam.h

    r3842 r4043  
    5757                void  UpdateInputsFromConstant(int constant, int name);
    5858                void  UpdateInputsFromConstant(bool constant, int name);
    59 
    60                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     59                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6160
    6261                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Params/PetscVecParam.h

    r3842 r4043  
    5757                void  UpdateInputsFromConstant(int constant, int name);
    5858                void  UpdateInputsFromConstant(bool constant, int name);
    59 
    60                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     59                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6160
    6261                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Params/StringArrayParam.h

    r3842 r4043  
    5959                void  UpdateInputsFromConstant(int constant, int name);
    6060                void  UpdateInputsFromConstant(bool constant, int name);
    61 
    62                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     61                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6362
    6463                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Params/StringParam.h

    r3842 r4043  
    5757                void  UpdateInputsFromConstant(int constant, int name);
    5858                void  UpdateInputsFromConstant(bool constant, int name);
    59 
    60                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     59                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6160
    6261                /*}}}*/

  • TabularUnified issm/trunk/src/c/objects/Results/Result.h

    r4039 r4043  
    2626
    2727};
     28
     29
     30void NodalValuesUnitConversion(double* nodal_values, int num_nodal_values,int enum_type,Parameters* parameters);
    2831#endif

  • TabularUnified issm/trunk/src/c/objects/SolPar.h

    r3751 r4043  
    4646                void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4747
    48                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     48                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4949
    5050                /*functionality: */

  • TabularUnified issm/trunk/src/c/objects/Vertex.h

    r3863 r4043  
    5757                void  UpdateInputsFromConstant(bool constant, int name);
    5858
    59                 void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     59                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060
    6161

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

    r4042 r4043  
    5757#include "./Results/SingVertexResult.h"
    5858#include "./Results/BeamVertexResult.h"
    59 #include "./Results/NodalValuesUnitConversion.h"
    6059
    6160/*Materials: */

  • TabularUnified issm/trunk/src/c/solutions/balancedthickness2_core.cpp

    r3941 r4043  
    1010#include "./solutions.h"
    1111#include "../modules/modules.h"
     12#include "../solvers/solvers.h"
    1213
    1314Results* balancedthickness2_core(Model* model){

  • TabularUnified issm/trunk/src/c/solutions/balancedthickness_core.cpp

    r3941 r4043  
    1010#include "./solutions.h"
    1111#include "../modules/modules.h"
     12#include "../solvers/solvers.h"
    1213
    1314Results* balancedthickness_core(Model* model){

  • TabularUnified issm/trunk/src/c/solutions/balancedvelocities_core.cpp

    r3941 r4043  
    99#include "./solutions.h"
    1010#include "../modules/modules.h"
     11#include "../solvers/solvers.h"
    1112
    1213Results* balancedvelocities_core(Model* model){

  • TabularUnified issm/trunk/src/c/solutions/bedslope_core.cpp

    r4037 r4043  
    88#include "../EnumDefinitions/EnumDefinitions.h"
    99#include "../modules/modules.h"
     10#include "../solvers/solvers.h"
    1011
    1112void bedslope_core(FemModel* femmodel){

  • TabularUnified issm/trunk/src/c/solutions/control_core.cpp

    r3938 r4043  
    66#include "../modules/modules.h"
    77#include "../EnumDefinitions/EnumDefinitions.h"
     8#include "../solvers/solvers.h"
    89
    910Results* control_core(Model* model){

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

    r4037 r4043  
    1010#include "../modules/modules.h"
    1111#include "../include/include.h"
     12#include "../solvers/solvers.h"
    1213
    1314void diagnostic_core(FemModel* femmodel){
    … …  
    3334        /*for qmu analysis, reinitialize velocity so that fake sensitivities do not show up as a result of a different restart of the convergence at each trial.*/
    3435        if(qmu_analysis){
    35                 ReinitializeInputx(femmodel,VxEnum,QmuVxEnum);
    36                 ReinitializeInputx(femmodel,VyEnum,QmuVyEnum);
    37                 ReinitializeInputx(femmodel,VzEnum,QmuVzEnum);
    38                 ReinitializeInputx(femmodel,PressureEnum,QmuPressureEnum);
     36                ReinitializeInputx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,QmuVxEnum);
     37                ReinitializeInputx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,QmuVyEnum);
     38                ReinitializeInputx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzEnum,QmuVzEnum);
     39                ReinitializeInputx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,PressureEnum,QmuPressureEnum);
    3940        }
    4041

  • TabularUnified issm/trunk/src/c/solutions/gradjcompute_core.cpp

    r3959 r4043  
    1212#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
    1313#endif
     14
     15#include "../solvers/solvers.h"
    1416
    1517Results* gradjcompute_core(Model* model){

  • TabularUnified issm/trunk/src/c/solutions/prognostic2_core.cpp

    r3941 r4043  
    99#include "./solutions.h"
    1010#include "../modules/modules.h"
     11#include "../solvers/solvers.h"
    1112
    1213Results* prognostic2_core(Model* model){

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

    r3941 r4043  
    99#include "./solutions.h"
    1010#include "../modules/modules.h"
     11#include "../solvers/solvers.h"
    1112
    1213Results* prognostic_core(Model* model){

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

    r4029 r4043  
    2727Results* transient_core_3d(FemModel* model);
    2828Results* thermal_core(FemModel* model);
    29 void slope_core(FemModel* fem,int sub_analysis_type);
     29void surfaceslope_core(FemModel* femmodel);
     30void bedslope_core(FemModel* femmodel);
    3031
    3132//int GradJOrth(WorkspaceParams* workspaceparams);

  • TabularUnified issm/trunk/src/c/solutions/steadystate_core.cpp

    r3938 r4043  
    99#include "./solutions.h"
    1010#include "../modules/modules.h"
     11#include "../solvers/solvers.h"
    1112
    1213Results* steadystate_core(Model* model){

  • TabularUnified issm/trunk/src/c/solutions/surfaceslope_core.cpp

    r4037 r4043  
    77#include "../objects/objects.h"
    88#include "../EnumDefinitions/EnumDefinitions.h"
     9#include "../solvers/solvers.h"
    910#include "../modules/modules.h"
    1011

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

    r4037 r4043  
    1010#include "../modules/modules.h"
    1111#include "../include/include.h"
     12#include "../solvers/solvers.h"
    1213
    1314void thermal_core(FemModel* femmodel){

  • TabularUnified issm/trunk/src/c/solutions/transient_core.cpp

    r3938 r4043  
    99#include "./solutions.h"
    1010#include "../modules/modules.h"
     11#include "../solvers/solvers.h"
    1112
    1213Results* transient_core(Model* model){

  • TabularUnified issm/trunk/src/m/enum/BeamVertexResultEnum.m

    r4039 r4043  
    99%      macro=BeamVertexResultEnum()
    1010
    11 macro=190;
     11macro=195;

  • TabularUnified issm/trunk/src/m/enum/BetaEnum.m

    r4039 r4043  
    99%      macro=BetaEnum()
    1010
    11 macro=191;
     11macro=196;

  • TabularUnified issm/trunk/src/m/enum/CmGradientEnum.m

    r4039 r4043  
    99%      macro=CmGradientEnum()
    1010
    11 macro=192;
     11macro=197;

  • TabularUnified issm/trunk/src/m/enum/CmJumpEnum.m

    r4039 r4043  
    99%      macro=CmJumpEnum()
    1010
    11 macro=193;
     11macro=198;

  • TabularUnified issm/trunk/src/m/enum/CmMaxEnum.m

    r4039 r4043  
    99%      macro=CmMaxEnum()
    1010
    11 macro=194;
     11macro=199;

  • TabularUnified issm/trunk/src/m/enum/CmMinEnum.m

    r4039 r4043  
    99%      macro=CmMinEnum()
    1010
    11 macro=195;
     11macro=200;

  • TabularUnified issm/trunk/src/m/enum/ConnectivityEnum.m

    r4039 r4043  
    99%      macro=ConnectivityEnum()
    1010
    11 macro=196;
     11macro=201;

  • TabularUnified issm/trunk/src/m/enum/ControlParameterEnum.m

    r4039 r4043  
    99%      macro=ControlParameterEnum()
    1010
    11 macro=197;
     11macro=202;

  • TabularUnified issm/trunk/src/m/enum/ControlSteadyEnum.m

    r4039 r4043  
    99%      macro=ControlSteadyEnum()
    1010
    11 macro=198;
     11macro=203;

  • TabularUnified issm/trunk/src/m/enum/DakotaParameterEnum.m

    r4039 r4043  
    99%      macro=DakotaParameterEnum()
    1010
    11 macro=199;
     11macro=204;

  • TabularUnified issm/trunk/src/m/enum/DimEnum.m

    r4039 r4043  
    99%      macro=DimEnum()
    1010
    11 macro=200;
     11macro=205;

  • TabularUnified issm/trunk/src/m/enum/DoubleResultEnum.m

    r4039 r4043  
    99%      macro=DoubleResultEnum()
    1010
    11 macro=186;
     11macro=191;

  • TabularUnified issm/trunk/src/m/enum/EnumAsString.m

    r4039 r4043  
    167167        case PressureEnum(), string='Pressure'; return
    168168        case PressureOldEnum(), string='PressureOld'; return
     169        case QmuPressureEnum(), string='QmuPressure'; return
     170        case StokesPressureEnum(), string='StokesPressure'; return
    169171        case ResetPenaltiesEnum(), string='ResetPenalties'; return
    170172        case RheologyBEnum(), string='RheologyB'; return
    … …  
    186188        case VxObsEnum(), string='VxObs'; return
    187189        case VxOldEnum(), string='VxOld'; return
     190        case QmuVxEnum(), string='QmuVx'; return
    188191        case VyAverageEnum(), string='VyAverage'; return
    189192        case VyEnum(), string='Vy'; return
    190193        case VyObsEnum(), string='VyObs'; return
    191194        case VyOldEnum(), string='VyOld'; return
     195        case QmuVyEnum(), string='QmuVy'; return
    192196        case VzAverageEnum(), string='VzAverage'; return
    193197        case VzEnum(), string='Vz'; return
    194198        case VzObsEnum(), string='VzObs'; return
    195199        case VzOldEnum(), string='VzOld'; return
     200        case QmuVzEnum(), string='QmuVz'; return
    196201        case WeightsEnum(), string='Weights'; return
    197202        case P0Enum(), string='P0'; return

  • TabularUnified issm/trunk/src/m/enum/EpsAbsEnum.m

    r4039 r4043  
    99%      macro=EpsAbsEnum()
    1010
    11 macro=201;
     11macro=206;

  • TabularUnified issm/trunk/src/m/enum/EpsCmEnum.m

    r4039 r4043  
    99%      macro=EpsCmEnum()
    1010
    11 macro=202;
     11macro=207;

  • TabularUnified issm/trunk/src/m/enum/EpsRelEnum.m

    r4039 r4043  
    99%      macro=EpsRelEnum()
    1010
    11 macro=203;
     11macro=208;

  • TabularUnified issm/trunk/src/m/enum/EpsResEnum.m

    r4039 r4043  
    99%      macro=EpsResEnum()
    1010
    11 macro=204;
     11macro=209;

  • TabularUnified issm/trunk/src/m/enum/ExtrudeParamEnum.m

    r4039 r4043  
    99%      macro=ExtrudeParamEnum()
    1010
    11 macro=205;
     11macro=210;

  • TabularUnified issm/trunk/src/m/enum/HeatCapacityEnum.m

    r4039 r4043  
    99%      macro=HeatCapacityEnum()
    1010
    11 macro=206;
     11macro=211;

  • TabularUnified issm/trunk/src/m/enum/IsHutterEnum.m

    r4039 r4043  
    99%      macro=IsHutterEnum()
    1010
    11 macro=207;
     11macro=212;

  • TabularUnified issm/trunk/src/m/enum/IsMacAyealPattynEnum.m

    r4039 r4043  
    99%      macro=IsMacAyealPattynEnum()
    1010
    11 macro=208;
     11macro=213;

  • TabularUnified issm/trunk/src/m/enum/IsStokesEnum.m

    r4039 r4043  
    99%      macro=IsStokesEnum()
    1010
    11 macro=209;
     11macro=214;

  • TabularUnified issm/trunk/src/m/enum/LatentHeatEnum.m

    r4039 r4043  
    99%      macro=LatentHeatEnum()
    1010
    11 macro=210;
     11macro=215;

  • TabularUnified issm/trunk/src/m/enum/LowmemEnum.m

    r4039 r4043  
    99%      macro=LowmemEnum()
    1010
    11 macro=211;
     11macro=216;

  • TabularUnified issm/trunk/src/m/enum/MaxIterEnum.m

    r4039 r4043  
    99%      macro=MaxIterEnum()
    1010
    11 macro=212;
     11macro=217;

  • TabularUnified issm/trunk/src/m/enum/MaxNonlinearIterationsEnum.m

    r4039 r4043  
    99%      macro=MaxNonlinearIterationsEnum()
    1010
    11 macro=213;
     11macro=218;

  • TabularUnified issm/trunk/src/m/enum/MeltingPointEnum.m

    r4039 r4043  
    99%      macro=MeltingPointEnum()
    1010
    11 macro=214;
     11macro=219;

  • TabularUnified issm/trunk/src/m/enum/MinMechanicalConstraintsEnum.m

    r4039 r4043  
    99%      macro=MinMechanicalConstraintsEnum()
    1010
    11 macro=215;
     11macro=220;

  • TabularUnified issm/trunk/src/m/enum/MinThermalConstraintsEnum.m

    r4039 r4043  
    99%      macro=MinThermalConstraintsEnum()
    1010
    11 macro=216;
     11macro=221;

  • TabularUnified issm/trunk/src/m/enum/NStepsEnum.m

    r4039 r4043  
    99%      macro=NStepsEnum()
    1010
    11 macro=217;
     11macro=222;

  • TabularUnified issm/trunk/src/m/enum/NdtEnum.m

    r4039 r4043  
    99%      macro=NdtEnum()
    1010
    11 macro=218;
     11macro=223;

  • TabularUnified issm/trunk/src/m/enum/NumOutputEnum.m

    r4039 r4043  
    99%      macro=NumOutputEnum()
    1010
    11 macro=219;
     11macro=224;

  • TabularUnified issm/trunk/src/m/enum/NumRiftsEnum.m

    r4039 r4043  
    99%      macro=NumRiftsEnum()
    1010
    11 macro=220;
     11macro=225;

  • TabularUnified issm/trunk/src/m/enum/NumberOfDofsPerNodeEnum.m

    r4039 r4043  
    99%      macro=NumberOfDofsPerNodeEnum()
    1010
    11 macro=221;
     11macro=226;

  • TabularUnified issm/trunk/src/m/enum/NumberOfElementsEnum.m

    r4039 r4043  
    99%      macro=NumberOfElementsEnum()
    1010
    11 macro=222;
     11macro=227;

  • TabularUnified issm/trunk/src/m/enum/NumberOfNodesEnum.m

    r4039 r4043  
    99%      macro=NumberOfNodesEnum()
    1010
    11 macro=223;
     11macro=228;

  • TabularUnified issm/trunk/src/m/enum/NumberOfVerticesEnum.m

    r4039 r4043  
    99%      macro=NumberOfVerticesEnum()
    1010
    11 macro=224;
     11macro=229;

  • TabularUnified issm/trunk/src/m/enum/OptScalEnum.m

    r4039 r4043  
    99%      macro=OptScalEnum()
    1010
    11 macro=225;
     11macro=230;

  • TabularUnified issm/trunk/src/m/enum/OutputFileNameEnum.m

    r4039 r4043  
    99%      macro=OutputFileNameEnum()
    1010
    11 macro=226;
     11macro=231;

  • TabularUnified issm/trunk/src/m/enum/P0Enum.m

    r4039 r4043  
    99%      macro=P0Enum()
    1010
    11 macro=184;
     11macro=189;

  • TabularUnified issm/trunk/src/m/enum/P1Enum.m

    r4039 r4043  
    99%      macro=P1Enum()
    1010
    11 macro=185;
     11macro=190;

  • TabularUnified issm/trunk/src/m/enum/ParameterOutputEnum.m

    r4039 r4043  
    99%      macro=ParameterOutputEnum()
    1010
    11 macro=227;
     11macro=232;

  • TabularUnified issm/trunk/src/m/enum/PenaltyMeltingEnum.m

    r4039 r4043  
    99%      macro=PenaltyMeltingEnum()
    1010
    11 macro=228;
     11macro=233;

  • TabularUnified issm/trunk/src/m/enum/PentaVertexResultEnum.m

    r4039 r4043  
    99%      macro=PentaVertexResultEnum()
    1010
    11 macro=188;
     11macro=193;

  • TabularUnified issm/trunk/src/m/enum/QmuAnalysisEnum.m

    r4039 r4043  
    99%      macro=QmuAnalysisEnum()
    1010
    11 macro=229;
     11macro=234;

  • TabularUnified issm/trunk/src/m/enum/QmuErrNameEnum.m

    r4039 r4043  
    99%      macro=QmuErrNameEnum()
    1010
    11 macro=230;
     11macro=235;

  • TabularUnified issm/trunk/src/m/enum/QmuInNameEnum.m

    r4039 r4043  
    99%      macro=QmuInNameEnum()
    1010
    11 macro=231;
     11macro=236;

  • TabularUnified issm/trunk/src/m/enum/QmuMassFluxSegmentsEnum.m

    r4039 r4043  
    99%      macro=QmuMassFluxSegmentsEnum()
    1010
    11 macro=232;
     11macro=237;

  • TabularUnified issm/trunk/src/m/enum/QmuNPartEnum.m

    r4039 r4043  
    99%      macro=QmuNPartEnum()
    1010
    11 macro=233;
     11macro=238;

  • TabularUnified issm/trunk/src/m/enum/QmuOutNameEnum.m

    r4039 r4043  
    99%      macro=QmuOutNameEnum()
    1010
    11 macro=234;
     11macro=239;

  • TabularUnified issm/trunk/src/m/enum/QmuPartEnum.m

    r4039 r4043  
    99%      macro=QmuPartEnum()
    1010
    11 macro=235;
     11macro=240;

  • TabularUnified issm/trunk/src/m/enum/ResetPenaltiesEnum.m

    r4039 r4043  
    99%      macro=ResetPenaltiesEnum()
    1010
    11 macro=156;
     11macro=158;

  • TabularUnified issm/trunk/src/m/enum/ResponseDescriptorsEnum.m

    r4039 r4043  
    99%      macro=ResponseDescriptorsEnum()
    1010
    11 macro=236;
     11macro=241;

  • TabularUnified issm/trunk/src/m/enum/RheologyBEnum.m

    r4039 r4043  
    99%      macro=RheologyBEnum()
    1010
    11 macro=157;
     11macro=159;

  • TabularUnified issm/trunk/src/m/enum/RheologyNEnum.m

    r4039 r4043  
    99%      macro=RheologyNEnum()
    1010
    11 macro=158;
     11macro=160;

  • TabularUnified issm/trunk/src/m/enum/SegmentOnIceShelfEnum.m

    r4039 r4043  
    99%      macro=SegmentOnIceShelfEnum()
    1010
    11 macro=159;
     11macro=161;

  • TabularUnified issm/trunk/src/m/enum/SingVertexResultEnum.m

    r4039 r4043  
    99%      macro=SingVertexResultEnum()
    1010
    11 macro=189;
     11macro=194;

  • TabularUnified issm/trunk/src/m/enum/SolverStringEnum.m

    r4039 r4043  
    99%      macro=SolverStringEnum()
    1010
    11 macro=237;
     11macro=242;

  • TabularUnified issm/trunk/src/m/enum/SparsityEnum.m

    r4039 r4043  
    99%      macro=SparsityEnum()
    1010
    11 macro=238;
     11macro=243;

  • TabularUnified issm/trunk/src/m/enum/StabilizeConstraintsEnum.m

    r4039 r4043  
    99%      macro=StabilizeConstraintsEnum()
    1010
    11 macro=160;
     11macro=162;

  • TabularUnified issm/trunk/src/m/enum/StokesReconditioningEnum.m

    r4039 r4043  
    99%      macro=StokesReconditioningEnum()
    1010
    11 macro=161;
     11macro=163;

  • TabularUnified issm/trunk/src/m/enum/StringAsEnum.m

    r4039 r4043  
    165165elseif (strcmpi(name,'Pressure')), enum=PressureEnum(); return
    166166elseif (strcmpi(name,'PressureOld')), enum=PressureOldEnum(); return
     167elseif (strcmpi(name,'QmuPressure')), enum=QmuPressureEnum(); return
     168elseif (strcmpi(name,'StokesPressure')), enum=StokesPressureEnum(); return
    167169elseif (strcmpi(name,'ResetPenalties')), enum=ResetPenaltiesEnum(); return
    168170elseif (strcmpi(name,'RheologyB')), enum=RheologyBEnum(); return
    … …  
    184186elseif (strcmpi(name,'VxObs')), enum=VxObsEnum(); return
    185187elseif (strcmpi(name,'VxOld')), enum=VxOldEnum(); return
     188elseif (strcmpi(name,'QmuVx')), enum=QmuVxEnum(); return
    186189elseif (strcmpi(name,'VyAverage')), enum=VyAverageEnum(); return
    187190elseif (strcmpi(name,'Vy')), enum=VyEnum(); return
    188191elseif (strcmpi(name,'VyObs')), enum=VyObsEnum(); return
    189192elseif (strcmpi(name,'VyOld')), enum=VyOldEnum(); return
     193elseif (strcmpi(name,'QmuVy')), enum=QmuVyEnum(); return
    190194elseif (strcmpi(name,'VzAverage')), enum=VzAverageEnum(); return
    191195elseif (strcmpi(name,'Vz')), enum=VzEnum(); return
    192196elseif (strcmpi(name,'VzObs')), enum=VzObsEnum(); return
    193197elseif (strcmpi(name,'VzOld')), enum=VzOldEnum(); return
     198elseif (strcmpi(name,'QmuVz')), enum=QmuVzEnum(); return
    194199elseif (strcmpi(name,'Weights')), enum=WeightsEnum(); return
    195200elseif (strcmpi(name,'P0')), enum=P0Enum(); return

  • TabularUnified issm/trunk/src/m/enum/SurfaceAreaEnum.m

    r4039 r4043  
    99%      macro=SurfaceAreaEnum()
    1010
    11 macro=162;
     11macro=164;

  • TabularUnified issm/trunk/src/m/enum/SurfaceEnum.m

    r4039 r4043  
    99%      macro=SurfaceEnum()
    1010
    11 macro=163;
     11macro=165;

  • TabularUnified issm/trunk/src/m/enum/SurfaceSlopeXEnum.m

    r4039 r4043  
    99%      macro=SurfaceSlopeXEnum()
    1010
    11 macro=164;
     11macro=166;

  • TabularUnified issm/trunk/src/m/enum/SurfaceSlopeYEnum.m

    r4039 r4043  
    99%      macro=SurfaceSlopeYEnum()
    1010
    11 macro=165;
     11macro=167;

  • TabularUnified issm/trunk/src/m/enum/TemperatureAverageEnum.m

    r4039 r4043  
    99%      macro=TemperatureAverageEnum()
    1010
    11 macro=167;
     11macro=169;

  • TabularUnified issm/trunk/src/m/enum/TemperatureEnum.m

    r4039 r4043  
    99%      macro=TemperatureEnum()
    1010
    11 macro=166;
     11macro=168;

  • TabularUnified issm/trunk/src/m/enum/ThicknessEnum.m

    r4039 r4043  
    99%      macro=ThicknessEnum()
    1010
    11 macro=168;
     11macro=170;

  • TabularUnified issm/trunk/src/m/enum/TolXEnum.m

    r4039 r4043  
    99%      macro=TolXEnum()
    1010
    11 macro=239;
     11macro=244;

  • TabularUnified issm/trunk/src/m/enum/TriaVertexResultEnum.m

    r4039 r4043  
    99%      macro=TriaVertexResultEnum()
    1010
    11 macro=187;
     11macro=192;

  • TabularUnified issm/trunk/src/m/enum/TypeEnum.m

    r4039 r4043  
    99%      macro=TypeEnum()
    1010
    11 macro=169;
     11macro=171;

  • TabularUnified issm/trunk/src/m/enum/VariableDescriptorsEnum.m

    r4039 r4043  
    99%      macro=VariableDescriptorsEnum()
    1010
    11 macro=240;
     11macro=245;

  • TabularUnified issm/trunk/src/m/enum/VerboseEnum.m

    r4039 r4043  
    99%      macro=VerboseEnum()
    1010
    11 macro=241;
     11macro=246;

  • TabularUnified issm/trunk/src/m/enum/ViscosityOvershootEnum.m

    r4039 r4043  
    99%      macro=ViscosityOvershootEnum()
    1010
    11 macro=170;
     11macro=172;

  • TabularUnified issm/trunk/src/m/enum/VxAverageEnum.m

    r4039 r4043  
    99%      macro=VxAverageEnum()
    1010
    11 macro=171;
     11macro=173;

  • TabularUnified issm/trunk/src/m/enum/VxEnum.m

    r4039 r4043  
    99%      macro=VxEnum()
    1010
    11 macro=172;
     11macro=174;

  • TabularUnified issm/trunk/src/m/enum/VxObsEnum.m

    r4039 r4043  
    99%      macro=VxObsEnum()
    1010
    11 macro=173;
     11macro=175;

  • TabularUnified issm/trunk/src/m/enum/VxOldEnum.m

    r4039 r4043  
    99%      macro=VxOldEnum()
    1010
    11 macro=174;
     11macro=176;

  • TabularUnified issm/trunk/src/m/enum/VyAverageEnum.m

    r4039 r4043  
    99%      macro=VyAverageEnum()
    1010
    11 macro=175;
     11macro=178;

  • TabularUnified issm/trunk/src/m/enum/VyEnum.m

    r4039 r4043  
    99%      macro=VyEnum()
    1010
    11 macro=176;
     11macro=179;

  • TabularUnified issm/trunk/src/m/enum/VyObsEnum.m

    r4039 r4043  
    99%      macro=VyObsEnum()
    1010
    11 macro=177;
     11macro=180;

  • TabularUnified issm/trunk/src/m/enum/VyOldEnum.m

    r4039 r4043  
    99%      macro=VyOldEnum()
    1010
    11 macro=178;
     11macro=181;

  • TabularUnified issm/trunk/src/m/enum/VzAverageEnum.m

    r4039 r4043  
    99%      macro=VzAverageEnum()
    1010
    11 macro=179;
     11macro=183;

  • TabularUnified issm/trunk/src/m/enum/VzEnum.m

    r4039 r4043  
    99%      macro=VzEnum()
    1010
    11 macro=180;
     11macro=184;

  • TabularUnified issm/trunk/src/m/enum/VzObsEnum.m

    r4039 r4043  
    99%      macro=VzObsEnum()
    1010
    11 macro=181;
     11macro=185;

  • TabularUnified issm/trunk/src/m/enum/VzOldEnum.m

    r4039 r4043  
    99%      macro=VzOldEnum()
    1010
    11 macro=182;
     11macro=186;

  • TabularUnified issm/trunk/src/m/enum/WaitOnLockEnum.m

    r4039 r4043  
    99%      macro=WaitOnLockEnum()
    1010
    11 macro=242;
     11macro=247;

  • TabularUnified issm/trunk/src/m/enum/WeightsEnum.m

    r4039 r4043  
    99%      macro=WeightsEnum()
    1010
    11 macro=183;
     11macro=188;

  • TabularUnified issm/trunk/src/m/enum/YtsEnum.m

    r4039 r4043  
    99%      macro=YtsEnum()
    1010
    11 macro=243;
     11macro=248;

  • TabularUnified issm/trunk/src/m/solutions/jpl/SpawnCore.m

    r3839 r4043  
    1 function responses=SpawnCore(models,variables,variabledescriptors,analysis_type,sub_analysis_type,counter);
     1function responses=SpawnCore(models,variables,variabledescriptors,counter);
    22%SPAWNCORE - for Qmu analysis, using Dakota. Spawn the core solution.
    33%
Note: See TracChangeset for help on using the changeset viewer.