Index: /issm/trunk/src/c/DataSet/DataSet.cpp =================================================================== --- /issm/trunk/src/c/DataSet/DataSet.cpp (revision 4042) +++ /issm/trunk/src/c/DataSet/DataSet.cpp (revision 4043) @@ -835,5 +835,5 @@ /*}}}*/ /*FUNCTION DataSet::MeltingConstraints{{{1*/ -void DataSet::MeltingConstraints(int* pconverged, int* pnum_unstable_constraints,int analysis_type,int sub_analysis_type){ +void DataSet::MeltingConstraints(int* pconverged, int* pnum_unstable_constraints){ /* generic object pointer: */ @@ -855,5 +855,5 @@ pengrid=(Pengrid*)(*object); - pengrid->PenaltyConstrain(&unstable,analysis_type,sub_analysis_type); + pengrid->PenaltyConstrain(&unstable); num_unstable_constraints+=unstable; Index: /issm/trunk/src/c/DataSet/DataSet.h =================================================================== --- /issm/trunk/src/c/DataSet/DataSet.h (revision 4042) +++ /issm/trunk/src/c/DataSet/DataSet.h (revision 4043) @@ -55,5 +55,4 @@ void DistributeDofs(int numberofnodes,int numdofspernode); void CreatePartitioningVector(Vec* ppartition,int numobjects); - void DistributeNumDofs(int** pnumdofspernode,int numberofnodes,int analysis_type,int sub_analysis_type); void FlagClones(int numberofnodes); int NumberOfDofs(int analysis_type); @@ -77,5 +76,5 @@ int RiftIsPresent(); int MeltingIsPresent(); - void MeltingConstraints(int* pconverged, int* pnum_unstable_constraints,int analysis_type,int sub_analysis_type); + void MeltingConstraints(int* pconverged, int* pnum_unstable_constraints); DataSet* Copy(void); void InputExtrude(int enum_type); Index: /issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp (revision 4042) +++ /issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp (revision 4043) @@ -172,4 +172,6 @@ case PressureEnum : return "Pressure"; case PressureOldEnum : return "PressureOld"; + case QmuPressureEnum : return "QmuPressure"; + case StokesPressureEnum : return "StokesPressure"; case ResetPenaltiesEnum : return "ResetPenalties"; case RheologyBEnum : return "RheologyB"; @@ -191,12 +193,15 @@ case VxObsEnum : return "VxObs"; case VxOldEnum : return "VxOld"; + case QmuVxEnum : return "QmuVx"; case VyAverageEnum : return "VyAverage"; case VyEnum : return "Vy"; case VyObsEnum : return "VyObs"; case VyOldEnum : return "VyOld"; + case QmuVyEnum : return "QmuVy"; case VzAverageEnum : return "VzAverage"; case VzEnum : return "Vz"; case VzObsEnum : return "VzObs"; case VzOldEnum : return "VzOld"; + case QmuVzEnum : return "QmuVz"; case WeightsEnum : return "Weights"; case P0Enum : return "P0"; Index: /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h (revision 4042) +++ /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h (revision 4043) @@ -201,4 +201,6 @@ PressureEnum, PressureOldEnum, + QmuPressureEnum, + StokesPressureEnum, ResetPenaltiesEnum, RheologyBEnum, @@ -220,12 +222,15 @@ VxObsEnum, VxOldEnum, + QmuVxEnum, VyAverageEnum, VyEnum, VyObsEnum, VyOldEnum, + QmuVyEnum, VzAverageEnum, VzEnum, VzObsEnum, VzOldEnum, + QmuVzEnum, WeightsEnum, /*}}}*/ Index: /issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp (revision 4042) +++ /issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp (revision 4043) @@ -170,4 +170,6 @@ else if (strcmp(name,"Pressure")==0) return PressureEnum; else if (strcmp(name,"PressureOld")==0) return PressureOldEnum; + else if (strcmp(name,"QmuPressure")==0) return QmuPressureEnum; + else if (strcmp(name,"StokesPressure")==0) return StokesPressureEnum; else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum; else if (strcmp(name,"RheologyB")==0) return RheologyBEnum; @@ -189,12 +191,15 @@ else if (strcmp(name,"VxObs")==0) return VxObsEnum; else if (strcmp(name,"VxOld")==0) return VxOldEnum; + else if (strcmp(name,"QmuVx")==0) return QmuVxEnum; else if (strcmp(name,"VyAverage")==0) return VyAverageEnum; else if (strcmp(name,"Vy")==0) return VyEnum; else if (strcmp(name,"VyObs")==0) return VyObsEnum; else if (strcmp(name,"VyOld")==0) return VyOldEnum; + else if (strcmp(name,"QmuVy")==0) return QmuVyEnum; else if (strcmp(name,"VzAverage")==0) return VzAverageEnum; else if (strcmp(name,"Vz")==0) return VzEnum; else if (strcmp(name,"VzObs")==0) return VzObsEnum; else if (strcmp(name,"VzOld")==0) return VzOldEnum; + else if (strcmp(name,"QmuVz")==0) return QmuVzEnum; else if (strcmp(name,"Weights")==0) return WeightsEnum; else if (strcmp(name,"P0")==0) return P0Enum; Index: /issm/trunk/src/c/issm.h =================================================================== --- /issm/trunk/src/c/issm.h (revision 4042) +++ /issm/trunk/src/c/issm.h (revision 4043) @@ -12,4 +12,6 @@ #include "./EnumDefinitions/EnumDefinitions.h" #include "./toolkits/toolkits.h" +#include "./solutions/solutions.h" +#include "./solvers/solvers.h" #endif //ifndef _ISSM_H_ Index: /issm/trunk/src/c/modules/ComputeBasalStressx/ComputeBasalStressx.cpp =================================================================== --- /issm/trunk/src/c/modules/ComputeBasalStressx/ComputeBasalStressx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/ComputeBasalStressx/ComputeBasalStressx.cpp (revision 4043) @@ -10,6 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void ComputeBasalStressx( Vec* psigma,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters, - int analysis_type,int sub_analysis_type){ +void ComputeBasalStressx( Vec* psigma,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters){ /*Intermediary*/ @@ -37,5 +36,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->ComputeBasalStress(sigma,analysis_type,sub_analysis_type); + element->ComputeBasalStress(sigma); } Index: /issm/trunk/src/c/modules/ComputePressurex/ComputePressurex.cpp =================================================================== --- /issm/trunk/src/c/modules/ComputePressurex/ComputePressurex.cpp (revision 4042) +++ /issm/trunk/src/c/modules/ComputePressurex/ComputePressurex.cpp (revision 4043) @@ -10,6 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void ComputePressurex( Vec* pp_g,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters, - int analysis_type,int sub_analysis_type){ +void ComputePressurex( Vec* pp_g,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters){ /*intermediary*/ @@ -36,5 +35,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->ComputePressure(p_g,analysis_type,sub_analysis_type); + element->ComputePressure(p_g); } Index: /issm/trunk/src/c/modules/ComputeStrainRatex/ComputeStrainRatex.cpp =================================================================== --- /issm/trunk/src/c/modules/ComputeStrainRatex/ComputeStrainRatex.cpp (revision 4042) +++ /issm/trunk/src/c/modules/ComputeStrainRatex/ComputeStrainRatex.cpp (revision 4043) @@ -10,6 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void ComputeStrainRatex( Vec* peps,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters, - int analysis_type,int sub_analysis_type){ +void ComputeStrainRatex( Vec* peps,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,Parameters* parameters){ /*Intermediary*/ @@ -36,5 +35,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->ComputeStrainRate(eps,analysis_type,sub_analysis_type); + element->ComputeStrainRate(eps); } Index: /issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.cpp =================================================================== --- /issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.cpp (revision 4043) @@ -11,6 +11,5 @@ #include "../SurfaceAreax/SurfaceAreax.h" -void CostFunctionx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters, - int analysis_type,int sub_analysis_type){ +void CostFunctionx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ /*Intermediary*/ @@ -30,5 +29,5 @@ /*Compute surface area: */ - SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters,analysis_type,sub_analysis_type); + SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters); /*add surface area to elements :*/ @@ -38,5 +37,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - J+=element->CostFunction(analysis_type,sub_analysis_type); + J+=element->CostFunction(); } Index: /issm/trunk/src/c/modules/Dux/Dux.cpp =================================================================== --- /issm/trunk/src/c/modules/Dux/Dux.cpp (revision 4042) +++ /issm/trunk/src/c/modules/Dux/Dux.cpp (revision 4043) @@ -11,6 +11,5 @@ #include "../SurfaceAreax/SurfaceAreax.h" -void Dux( Vec* pdu_g, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, - DataSet* materials, Parameters* parameters,int analysis_type,int sub_analysis_type){ +void Dux( Vec* pdu_g, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters){ /*Intermediary*/ @@ -22,6 +21,11 @@ Element* element=NULL; + int analysis_type; + /*output: */ Vec du_g=NULL; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); /*First, get elements and loads configured: */ @@ -31,5 +35,5 @@ /*Compute surface area: */ - SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters,analysis_type,sub_analysis_type); + SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters); /*add surface area to elements :*/ @@ -45,5 +49,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->Du(du_g,analysis_type,sub_analysis_type); + element->Du(du_g); } Index: /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp =================================================================== --- /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp (revision 4043) @@ -9,5 +9,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void GetSolutionFromInputsx( Vec* psolution, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials, Parameters* parameters, int analysis_type, int sub_analysis_type){ +void GetSolutionFromInputsx( Vec* psolution, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials, Parameters* parameters){ /*intermediary: */ @@ -16,6 +16,11 @@ Element* element=NULL; + int analysis_type; + /*output: */ Vec solution=NULL; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); /*First, get elements and loads configured: */ @@ -34,5 +39,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->GetSolutionFromInputs(solution,analysis_type,sub_analysis_type); + element->GetSolutionFromInputs(solution); } Index: /issm/trunk/src/c/modules/Gradjx/Gradjx.cpp =================================================================== --- /issm/trunk/src/c/modules/Gradjx/Gradjx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/Gradjx/Gradjx.cpp (revision 4043) @@ -10,6 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void Gradjx( Vec* pgrad_g, int numberofnodes, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters, - int analysis_type,int sub_analysis_type,int control_type){ +void Gradjx( Vec* pgrad_g, int numberofnodes, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,int control_type){ /*Intermediary*/ @@ -31,5 +30,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->Gradj(grad_g,analysis_type,sub_analysis_type,control_type); + element->Gradj(grad_g,control_type); } Index: /issm/trunk/src/c/modules/InputToResultx/InputToResultx.cpp =================================================================== --- /issm/trunk/src/c/modules/InputToResultx/InputToResultx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/InputToResultx/InputToResultx.cpp (revision 4043) @@ -4,5 +4,4 @@ #include "./InputToResultx.h" - #include "../../shared/shared.h" #include "../../include/include.h" @@ -10,5 +9,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void InputToResultx(DataSet* elements,DataSet* nodes,DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters,int enum_type,int step=1, double time=0){ +void InputToResultx(DataSet* elements,DataSet* nodes,DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters,int enum_type,int step, double time){ /*intermediary:*/ Index: /issm/trunk/src/c/modules/MassFluxx/MassFluxx.cpp =================================================================== --- /issm/trunk/src/c/modules/MassFluxx/MassFluxx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/MassFluxx/MassFluxx.cpp (revision 4043) @@ -10,5 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters, double* segments,int num_segments,double* ug){ +void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters, double* segments,int num_segments){ int i,j; @@ -38,5 +38,5 @@ if (element->Id()==element_id){ /*We found the element which owns this segment, use it to compute the mass flux: */ - mass_flux+=element->MassFlux(segments+5*i+0,ug); + mass_flux+=element->MassFlux(segments+5*i+0); break; } Index: /issm/trunk/src/c/modules/MassFluxx/MassFluxx.h =================================================================== --- /issm/trunk/src/c/modules/MassFluxx/MassFluxx.h (revision 4042) +++ /issm/trunk/src/c/modules/MassFluxx/MassFluxx.h (revision 4043) @@ -10,5 +10,5 @@ /* local prototypes: */ -void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters,double* segments,int num_segments,double* ug); +void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters,double* segments,int num_segments); Index: /issm/trunk/src/c/modules/MaxAbsVxx/MaxAbsVxx.cpp =================================================================== --- /issm/trunk/src/c/modules/MaxAbsVxx/MaxAbsVxx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MaxAbsVxx/MaxAbsVxx.cpp (revision 4043) @@ -0,0 +1,47 @@ +/*!\file MaxAbsVxx + */ + +#include "./MaxAbsVxx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MaxAbsVxx( double* pmaxabsvx, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double maxabsvx; + double node_maxabsvx; + bool process_units=true; + double element_maxabsvx; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MaxAbsVx(&element_maxabsvx,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)maxabsvx=element_maxabsvx; //initialize maxabsvx + else{ + if(element_maxabsvx>maxabsvx)maxabsvx=element_maxabsvx; + } + } + /*A safeguard in case: */ + if(elements->Size()==0){ + maxabsvx=-INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&maxabsvx,&node_maxabsvx,1,MPI_DOUBLE,MPI_MIN,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_maxabsvx,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + maxabsvx=node_maxabsvx; + #endif + + /*Assign output pointers:*/ + *pmaxabsvx=maxabsvx; +} Index: /issm/trunk/src/c/modules/MaxAbsVxx/MaxAbsVxx.h =================================================================== --- /issm/trunk/src/c/modules/MaxAbsVxx/MaxAbsVxx.h (revision 4043) +++ /issm/trunk/src/c/modules/MaxAbsVxx/MaxAbsVxx.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: MaxAbsVxx.h + * \brief header file for inverse methods misfit computation + */ + +#ifndef _MAXABSVXX_H +#define _MAXABSVXX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MaxAbsVxx( double* pmaxabsvx, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MAXABSVXX_H */ + Index: /issm/trunk/src/c/modules/MaxAbsVyx/MaxAbsVyx.cpp =================================================================== --- /issm/trunk/src/c/modules/MaxAbsVyx/MaxAbsVyx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MaxAbsVyx/MaxAbsVyx.cpp (revision 4043) @@ -0,0 +1,47 @@ +/*!\file MaxAbsVyx + */ + +#include "./MaxAbsVyx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MaxAbsVyx( double* pmaxabsvy, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double maxabsvy; + double node_maxabsvy; + bool process_units=true; + double element_maxabsvy; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MaxAbsVy(&element_maxabsvy,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)maxabsvy=element_maxabsvy; //initialize maxabsvy + else{ + if(element_maxabsvy>maxabsvy)maxabsvy=element_maxabsvy; + } + } + /*A safeguard in case: */ + if(elements->Size()==0){ + maxabsvy=-INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&maxabsvy,&node_maxabsvy,1,MPI_DOUBLE,MPI_MAX,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_maxabsvy,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + maxabsvy=node_maxabsvy; + #endif + + /*Assign output pointers:*/ + *pmaxabsvy=maxabsvy; +} Index: /issm/trunk/src/c/modules/MaxAbsVyx/MaxAbsVyx.h =================================================================== --- /issm/trunk/src/c/modules/MaxAbsVyx/MaxAbsVyx.h (revision 4043) +++ /issm/trunk/src/c/modules/MaxAbsVyx/MaxAbsVyx.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: MaxAbsVyx.h + * \brief header file for inverse methods misfit computation + */ + +#ifndef _MAXABSVYX_H +#define _MAXABSVYX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MaxAbsVyx( double* pmaxabsvy, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MAXABSVYX_H */ + Index: /issm/trunk/src/c/modules/MaxAbsVzx/MaxAbsVzx.cpp =================================================================== --- /issm/trunk/src/c/modules/MaxAbsVzx/MaxAbsVzx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MaxAbsVzx/MaxAbsVzx.cpp (revision 4043) @@ -0,0 +1,47 @@ +/*!\file MaxAbsVzx + */ + +#include "./MaxAbsVzx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MaxAbsVzx( double* pmaxabsvz, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double maxabsvz; + double node_maxabsvz; + bool process_units=true; + double element_maxabsvz; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MaxAbsVz(&element_maxabsvz,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)maxabsvz=element_maxabsvz; //initialize maxabsvz + else{ + if(element_maxabsvz>maxabsvz)maxabsvz=element_maxabsvz; + } + } + /*A safeguard in case: */ + if(elements->Size()==0){ + maxabsvz=-INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&maxabsvz,&node_maxabsvz,1,MPI_DOUBLE,MPI_MAX,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_maxabsvz,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + maxabsvz=node_maxabsvz; + #endif + + /*Assign output pointers:*/ + *pmaxabsvz=maxabsvz; +} Index: /issm/trunk/src/c/modules/MaxAbsVzx/MaxAbsVzx.h =================================================================== --- /issm/trunk/src/c/modules/MaxAbsVzx/MaxAbsVzx.h (revision 4043) +++ /issm/trunk/src/c/modules/MaxAbsVzx/MaxAbsVzx.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: MaxAbsVzx.h + * \brief header file for inverse methods misfit computation + */ + +#ifndef _MAXABSVZX_H +#define _MAXABSVZX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MaxAbsVzx( double* pmaxabsvz, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MAXABSVZX_H */ + Index: /issm/trunk/src/c/modules/MaxVelx/MaxVelx.cpp =================================================================== --- /issm/trunk/src/c/modules/MaxVelx/MaxVelx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/MaxVelx/MaxVelx.cpp (revision 4043) @@ -17,4 +17,5 @@ double node_maxvel; bool process_units=true; + double element_maxvel; /*First, configure elements:*/ Index: /issm/trunk/src/c/modules/MaxVxx/MaxVxx.cpp =================================================================== --- /issm/trunk/src/c/modules/MaxVxx/MaxVxx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MaxVxx/MaxVxx.cpp (revision 4043) @@ -0,0 +1,47 @@ +/*!\file MaxVxx + */ + +#include "./MaxVxx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MaxVxx( double* pmaxvx, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double maxvx; + double node_maxvx; + bool process_units=true; + double element_maxvx; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MaxVx(&element_maxvx,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)maxvx=element_maxvx; //initialize maxvx + else{ + if(element_maxvx>maxvx)maxvx=element_maxvx; + } + } + /*A safeguard in case: */ + if(elements->Size()==0){ + maxvx=-INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&maxvx,&node_maxvx,1,MPI_DOUBLE,MPI_MAX,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_maxvx,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + maxvx=node_maxvx; + #endif + + /*Assign output pointers:*/ + *pmaxvx=maxvx; +} Index: /issm/trunk/src/c/modules/MaxVxx/MaxVxx.h =================================================================== --- /issm/trunk/src/c/modules/MaxVxx/MaxVxx.h (revision 4043) +++ /issm/trunk/src/c/modules/MaxVxx/MaxVxx.h (revision 4043) @@ -0,0 +1,14 @@ +/*!\file: MaxVxx.h + */ + +#ifndef _MAXVXX_H +#define _MAXVXX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MaxVxx( double* pmaxvx, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MAXVXX_H */ + Index: /issm/trunk/src/c/modules/MaxVyx/MaxVyx.cpp =================================================================== --- /issm/trunk/src/c/modules/MaxVyx/MaxVyx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MaxVyx/MaxVyx.cpp (revision 4043) @@ -0,0 +1,47 @@ +/*!\file MaxVyx + */ + +#include "./MaxVyx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MaxVyx( double* pmaxvy, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double maxvy; + double node_maxvy; + bool process_units=true; + double element_maxvy; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MaxVy(&element_maxvy,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)maxvy=element_maxvy; //initialize maxvy + else{ + if(element_maxvy>maxvy)maxvy=element_maxvy; + } + } + /*A safeguard in case: */ + if(elements->Size()==0){ + maxvy=-INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&maxvy,&node_maxvy,1,MPI_DOUBLE,MPI_MAX,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_maxvy,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + maxvy=node_maxvy; + #endif + + /*Assign output pointers:*/ + *pmaxvy=maxvy; +} Index: /issm/trunk/src/c/modules/MaxVyx/MaxVyx.h =================================================================== --- /issm/trunk/src/c/modules/MaxVyx/MaxVyx.h (revision 4043) +++ /issm/trunk/src/c/modules/MaxVyx/MaxVyx.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: MaxVyx.h + * \brief header file for inverse methods misfit computation + */ + +#ifndef _MAXVYX_H +#define _MAXVYX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MaxVyx( double* pmaxvy, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MAXVYX_H */ + Index: /issm/trunk/src/c/modules/MaxVzx/MaxVzx.cpp =================================================================== --- /issm/trunk/src/c/modules/MaxVzx/MaxVzx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MaxVzx/MaxVzx.cpp (revision 4043) @@ -0,0 +1,48 @@ +/*!\file MaxVzx + * \brief: compute misfit between observations and model + */ + +#include "./MaxVzx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MaxVzx( double* pmaxvz, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double maxvz; + double node_maxvz; + bool process_units=true; + double element_maxvz; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MaxVz(&element_maxvz,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)maxvz=element_maxvz; //initialize maxvz + else{ + if(element_maxvz>maxvz)maxvz=element_maxvz; + } + } + /*A safeguard in case: */ + if(elements->Size()==0){ + maxvz=-INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&maxvz,&node_maxvz,1,MPI_DOUBLE,MPI_MAX,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_maxvz,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + maxvz=node_maxvz; + #endif + + /*Assign output pointers:*/ + *pmaxvz=maxvz; +} Index: /issm/trunk/src/c/modules/MaxVzx/MaxVzx.h =================================================================== --- /issm/trunk/src/c/modules/MaxVzx/MaxVzx.h (revision 4043) +++ /issm/trunk/src/c/modules/MaxVzx/MaxVzx.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: MaxVzx.h + * \brief header file for inverse methods misfit computation + */ + +#ifndef _MAXVZX_H +#define _MAXVZX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MaxVzx( double* pmaxvz, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MAXVZX_H */ + Index: /issm/trunk/src/c/modules/MinVelx/MinVelx.cpp =================================================================== --- /issm/trunk/src/c/modules/MinVelx/MinVelx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/MinVelx/MinVelx.cpp (revision 4043) @@ -17,4 +17,5 @@ double node_minvel; bool process_units=true; + double element_minvel; /*First, configure elements:*/ Index: /issm/trunk/src/c/modules/MinVxx/MinVxx.cpp =================================================================== --- /issm/trunk/src/c/modules/MinVxx/MinVxx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MinVxx/MinVxx.cpp (revision 4043) @@ -0,0 +1,47 @@ +/*!\file MinVxx + */ + +#include "./MinVxx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MinVxx( double* pminvx, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double minvx; + double node_minvx; + bool process_units=true; + double element_minvx; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MinVx(&element_minvx,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)minvx=element_minvx; //initialize minvx + else{ + if(element_minvxSize()==0){ + minvx=INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&minvx,&node_minvx,1,MPI_DOUBLE,MPI_MIN,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_minvx,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + minvx=node_minvx; + #endif + + /*Assign output pointers:*/ + *pminvx=minvx; +} Index: /issm/trunk/src/c/modules/MinVxx/MinVxx.h =================================================================== --- /issm/trunk/src/c/modules/MinVxx/MinVxx.h (revision 4043) +++ /issm/trunk/src/c/modules/MinVxx/MinVxx.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: MinVxx.h + * \brief header file for inverse methods misfit computation + */ + +#ifndef _MINVX_H +#define _MINVX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MinVxx( double* pminvx, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MINVX_H */ + Index: /issm/trunk/src/c/modules/MinVyx/MinVyx.cpp =================================================================== --- /issm/trunk/src/c/modules/MinVyx/MinVyx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MinVyx/MinVyx.cpp (revision 4043) @@ -0,0 +1,47 @@ +/*!\file MinVyx + */ + +#include "./MinVyx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MinVyx( double* pminvy, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double minvy; + double node_minvy; + bool process_units=true; + double element_minvy; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MinVy(&element_minvy,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)minvy=element_minvy; //initialize minvy + else{ + if(element_minvySize()==0){ + minvy=INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&minvy,&node_minvy,1,MPI_DOUBLE,MPI_MIN,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_minvy,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + minvy=node_minvy; + #endif + + /*Assign output pointers:*/ + *pminvy=minvy; +} Index: /issm/trunk/src/c/modules/MinVyx/MinVyx.h =================================================================== --- /issm/trunk/src/c/modules/MinVyx/MinVyx.h (revision 4043) +++ /issm/trunk/src/c/modules/MinVyx/MinVyx.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: MinVyx.h + * \brief header file for inverse methods misfit computation + */ + +#ifndef _MINVYX_H +#define _MINVYX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MinVyx( double* pminvy, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MINVYX_H */ + Index: /issm/trunk/src/c/modules/MinVzx/MinVzx.cpp =================================================================== --- /issm/trunk/src/c/modules/MinVzx/MinVzx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/MinVzx/MinVzx.cpp (revision 4043) @@ -0,0 +1,47 @@ +/*!\file MinVzx + */ + +#include "./MinVzx.h" + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" +#include "../SurfaceAreax/SurfaceAreax.h" + +void MinVzx( double* pminvz, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ + + int i; + double minvz; + double node_minvz; + bool process_units=true; + double element_minvz; + + /*First, configure elements:*/ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elements, and request velocity: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->MinVz(&element_minvz,process_units); //go pick up the minimum velocity in the inputs + + if(i==0)minvz=element_minvz; //initialize minvz + else{ + if(element_minvzSize()==0){ + minvz=INFINITY; + } + + #ifdef _PARALLEL_ + /*Figure out minimum across the cluster: */ + MPI_Reduce (&minvz,&node_minvz,1,MPI_DOUBLE,MPI_MIN,0,MPI_COMM_WORLD ); + MPI_Bcast(&node_minvz,1,MPI_DOUBLE,0,MPI_COMM_WORLD); + minvz=node_minvz; + #endif + + /*Assign output pointers:*/ + *pminvz=minvz; +} Index: /issm/trunk/src/c/modules/MinVzx/MinVzx.h =================================================================== --- /issm/trunk/src/c/modules/MinVzx/MinVzx.h (revision 4043) +++ /issm/trunk/src/c/modules/MinVzx/MinVzx.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: MinVzx.h + * \brief header file for inverse methods misfit computation + */ + +#ifndef _MINVZX_H +#define _MINVZX_H + +#include "../../DataSet/DataSet.h" +#include "../../objects/objects.h" + +/* local prototypes: */ +void MinVzx( double* pminvz, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); + +#endif /* _MINVZX_H */ + Index: /issm/trunk/src/c/modules/Misfitx/Misfitx.cpp =================================================================== --- /issm/trunk/src/c/modules/Misfitx/Misfitx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/Misfitx/Misfitx.cpp (revision 4043) @@ -11,6 +11,5 @@ #include "../SurfaceAreax/SurfaceAreax.h" -void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters, - int analysis_type,int sub_analysis_type){ +void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ /*Intermediary*/ @@ -30,5 +29,5 @@ /*Compute surface area: */ - SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters,analysis_type,sub_analysis_type); + SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters); /*add surface area to elements :*/ @@ -38,5 +37,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - J+=element->Misfit(analysis_type,sub_analysis_type); + J+=element->Misfit(); } Index: /issm/trunk/src/c/modules/Misfitx/Misfitx.h =================================================================== --- /issm/trunk/src/c/modules/Misfitx/Misfitx.h (revision 4042) +++ /issm/trunk/src/c/modules/Misfitx/Misfitx.h (revision 4043) @@ -10,6 +10,5 @@ /* local prototypes: */ -void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters, - int analysis_type,int sub_analysis_type); +void Misfitx( double* pJ, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); #endif /* _MISFITX_H */ Index: /issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.cpp =================================================================== --- /issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.cpp (revision 4043) @@ -10,6 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices, - DataSet* loads,DataSet* materials, Parameters* parameters,int analysis_type,int sub_analysis_type){ +void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads,DataSet* materials, Parameters* parameters){ int i; @@ -34,8 +33,8 @@ * management routine, otherwise, skip : */ if (RiftIsPresent(loads)){ - RiftConstraints(&converged,&num_unstable_constraints,loads,min_mechanical_constraints,analysis_type,sub_analysis_type); + RiftConstraints(&converged,&num_unstable_constraints,loads,min_mechanical_constraints); } else if(loads->MeltingIsPresent()){ - loads->MeltingConstraints(&converged,&num_unstable_constraints,analysis_type,sub_analysis_type); + loads->MeltingConstraints(&converged,&num_unstable_constraints); } else{ Index: /issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.h =================================================================== --- /issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.h (revision 4042) +++ /issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.h (revision 4043) @@ -10,6 +10,5 @@ /* local prototypes: */ -void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices, - DataSet* loads,DataSet* materials, Parameters* parameters,int analysis_type,int sub_analysis_type); +void PenaltyConstraintsx(int* pconverged, int* pnum_unstable_constraints, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads,DataSet* materials, Parameters* parameters); #endif /* _PENALTYCONSTRAINTSX_H */ Index: /issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.cpp =================================================================== --- /issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.cpp (revision 4042) +++ /issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.cpp (revision 4043) @@ -10,5 +10,5 @@ #define _ZIGZAGCOUNTER_ -int RiftConstraints(int* pconverged, int* pnum_unstable_constraints,DataSet* loads,int min_mechanical_constraints,int analysis_type,int sub_analysis_type){ +int RiftConstraints(int* pconverged, int* pnum_unstable_constraints,DataSet* loads,int min_mechanical_constraints){ int num_unstable_constraints=0; @@ -17,5 +17,5 @@ extern int my_rank; - Constrain(&num_unstable_constraints,loads,analysis_type); + Constrain(&num_unstable_constraints,loads); if(num_unstable_constraints==0)converged=1; @@ -27,5 +27,5 @@ else if(num_unstable_constraints<=min_mechanical_constraints){ _printf_(" freezing constraints\n"); - FreezeConstraints(loads,analysis_type); + FreezeConstraints(loads); } @@ -35,5 +35,5 @@ } -int IsMaterialStable(DataSet* loads,int analysis_type){ +int IsMaterialStable(DataSet* loads){ int i; @@ -50,5 +50,5 @@ riftfront=(Riftfront*)loads->GetObjectByOffset(i); - if (riftfront->IsMaterialStable(analysis_type)){ + if (riftfront->IsMaterialStable()){ found=1; /*do not break! all penalties should get informed the non-linearity converged!*/ @@ -150,5 +150,5 @@ } -int PreConstrain(int* pnum_unstable_constraints,DataSet* loads,int analysis_type){ +int PreConstrain(int* pnum_unstable_constraints,DataSet* loads){ int i; @@ -168,5 +168,5 @@ riftfront=(Riftfront*)loads->GetObjectByOffset(i); - riftfront->PreConstrain(&unstable,analysis_type); + riftfront->PreConstrain(&unstable); num_unstable_constraints+=unstable; @@ -185,5 +185,5 @@ } -int Constrain(int* pnum_unstable_constraints,DataSet* loads,int analysis_type){ +int Constrain(int* pnum_unstable_constraints,DataSet* loads){ int i; @@ -203,5 +203,5 @@ riftfront=(Riftfront*)loads->GetObjectByOffset(i); - riftfront->Constrain(&unstable,analysis_type); + riftfront->Constrain(&unstable); num_unstable_constraints+=unstable; @@ -220,5 +220,5 @@ } -void FreezeConstraints(DataSet* loads,int analysis_type){ +void FreezeConstraints(DataSet* loads){ int i; @@ -234,5 +234,5 @@ riftfront=(Riftfront*)loads->GetObjectByOffset(i); - riftfront->FreezeConstraints(analysis_type); + riftfront->FreezeConstraints(); } @@ -273,5 +273,5 @@ } -int MaxPenetrationInInputs(DataSet* loads,int analysis_type){ +int MaxPenetrationInInputs(DataSet* loads){ int i; @@ -295,5 +295,5 @@ riftfront=(Riftfront*)loads->GetObjectByOffset(i); - riftfront->MaxPenetration(&penetration,analysis_type); + riftfront->MaxPenetration(&penetration); if (penetration>max_penetration)max_penetration=penetration; @@ -311,5 +311,5 @@ } -int PotentialUnstableConstraints(DataSet* loads,int analysis_type){ +int PotentialUnstableConstraints(DataSet* loads){ int i; @@ -330,5 +330,5 @@ riftfront=(Riftfront*)loads->GetObjectByOffset(i); - riftfront->PotentialUnstableConstraint(&unstable,analysis_type); + riftfront->PotentialUnstableConstraint(&unstable); num_unstable_constraints+=unstable; Index: /issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.h =================================================================== --- /issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.h (revision 4042) +++ /issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.h (revision 4043) @@ -10,5 +10,5 @@ #include "../../DataSet/DataSet.h" -int RiftConstraints(int* pconverged, int* pnum_unstable_constraints,DataSet* loads,int min_mechanical_constraints,int analysis_type,int sub_analysis_type); +int RiftConstraints(int* pconverged, int* pnum_unstable_constraints,DataSet* loads,int min_mechanical_constraints); int RiftIsPresent(DataSet* loads); @@ -18,15 +18,15 @@ int SetPreStable(DataSet* loads); -int PreConstrain(int* pnum_unstable_constraints,DataSet* loads,int analysis_type_enum); +int PreConstrain(int* pnum_unstable_constraints,DataSet* loads); -int Constrain(int* pnum_unstable_constraints,DataSet* loads,int analysis_type_enum); +int Constrain(int* pnum_unstable_constraints,DataSet* loads); -void FreezeConstraints(DataSet* loads,int analysis_type); +void FreezeConstraints(DataSet* loads); -int MaxPenetrationInInputs(DataSet* loads,int analysis_type_enum); +int MaxPenetrationInInputs(DataSet* loads); -int PotentialUnstableConstraints(DataSet* loads,int analysis_type_enum); +int PotentialUnstableConstraints(DataSet* loads); -int IsMaterialStable(DataSet* loads,int analysis_type_enum); +int IsMaterialStable(DataSet* loads); int IsFrozen(DataSet* loads); Index: /issm/trunk/src/c/modules/PenaltySystemMatricesx/PenaltySystemMatricesx.cpp =================================================================== --- /issm/trunk/src/c/modules/PenaltySystemMatricesx/PenaltySystemMatricesx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/PenaltySystemMatricesx/PenaltySystemMatricesx.cpp (revision 4043) @@ -10,6 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void PenaltySystemMatricesx(Mat Kgg, Vec pg,double* pkmax,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters, - int kflag,int pflag,int analysis_type,int sub_analysis_type){ +void PenaltySystemMatricesx(Mat Kgg, Vec pg,double* pkmax,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters, int kflag,int pflag){ int i; @@ -32,5 +31,5 @@ for (i=0;iSize();i++){ load=(Load*)loads->GetObjectByOffset(i); - load->PenaltyCreateKMatrix(Kgg,kmax,analysis_type,sub_analysis_type); + load->PenaltyCreateKMatrix(Kgg,kmax); } @@ -47,5 +46,5 @@ for (i=0;iSize();i++){ load=(Load*)loads->GetObjectByOffset(i); - load->PenaltyCreatePVector(pg,kmax,analysis_type,sub_analysis_type); + load->PenaltyCreatePVector(pg,kmax); } Index: /issm/trunk/src/c/modules/Qmux/DakotaResponses.cpp =================================================================== --- /issm/trunk/src/c/modules/Qmux/DakotaResponses.cpp (revision 4042) +++ /issm/trunk/src/c/modules/Qmux/DakotaResponses.cpp (revision 4043) @@ -13,6 +13,4 @@ #include "../../include/include.h" #include "../../EnumDefinitions/EnumDefinitions.h" -#include "../MassFluxx/MassFluxx.h" -#include "../Misfitx/Misfitx.h" #include "../modules.h" @@ -20,4 +18,5 @@ int i; + int dummy; extern int my_rank; @@ -70,5 +69,17 @@ } else if(strcmp(response_descriptor,"mass_flux")==0){ - MassFlux(&femmodel_response,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); + + double* segments=NULL; + int num_segments; + + /*retrieve qmu_mass_flux_segments: */ + femmodel->parameters->FindParam(&segments,&num_segments,&dummy,QmuMassFluxSegmentsEnum); + + /*call mass flux module: */ + MassFluxx(&femmodel_response,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,segments,num_segments); + + /*Free ressources:*/ + xfree((void**)&segments); + } else{ @@ -81,2 +92,6 @@ } + + + + Index: /issm/trunk/src/c/modules/Qmux/Qmux.h =================================================================== --- /issm/trunk/src/c/modules/Qmux/Qmux.h (revision 4042) +++ /issm/trunk/src/c/modules/Qmux/Qmux.h (revision 4043) @@ -10,12 +10,12 @@ /* local prototypes: */ -int SpawnCore(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, void* femmodel,int analysis_type,int sub_analysis_type,int counter); +int SpawnCore(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, void* femmodel,int counter); #ifdef _SERIAL_ -void Qmux(mxArray* femmodel,int analysis_type,int sub_analysis_type,char* dakota_input_file,char* dakota_output_file,char* dakota_error_file); -void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* femmodel,int analysis_type,int sub_analysis_type,int counter); +void Qmux(mxArray* femmodel,char* dakota_input_file,char* dakota_output_file,char* dakota_error_file); +void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* femmodel,int counter); #else -void Qmux(FemModel* femmodel,int analysis_type,int sub_analysis_type); -void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, FemModel* femmodel,int analysis_type,int sub_analysis_type,int counter); -void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,FemModel* femmodel,int analysis_type,int sub_analysis_type); +void Qmux(FemModel* femmodel); +void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, FemModel* femmodel,int counter); +void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,FemModel* femmodel); #endif Index: /issm/trunk/src/c/modules/Qmux/SpawnCore.cpp =================================================================== --- /issm/trunk/src/c/modules/Qmux/SpawnCore.cpp (revision 4042) +++ /issm/trunk/src/c/modules/Qmux/SpawnCore.cpp (revision 4043) @@ -26,5 +26,5 @@ MPI_Bcast(&counter,1,MPI_INT,0,MPI_COMM_WORLD); if(counter==-1)return 0; - SpawnCoreParallel(responses, numresponses, variables, variables_descriptors,numvariables, (FemModel*)femmodel); + SpawnCoreParallel(responses, numresponses, variables, variables_descriptors,numvariables, (FemModel*)femmodel,counter); #endif Index: /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp =================================================================== --- /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp (revision 4042) +++ /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp (revision 4043) @@ -33,4 +33,5 @@ #include "../../include/include.h" #include "../../solutions/solutions.h" +#include "../modules.h" void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, FemModel* femmodel,int counter){ @@ -59,6 +60,6 @@ /*Recover partitioning for dakota: */ - femmodel->FindParam(&qmu_npart,QmuNPartEnum); - femmodel->FindParam(&qmu_part,&dummy,QmuPartEnum); + femmodel->parameters->FindParam(&qmu_npart,QmuNPartEnum); + femmodel->parameters->FindParam(&qmu_part,&dummy,QmuPartEnum); /*broadcast variables: only cpu 0 has correct values*/ @@ -88,5 +89,5 @@ /*Modify core inputs in objects contained in femmodel, to reflect the dakota variables inputs: */ - UpdateFromDakota(variables,variables_descriptors,numvariables,femmodel,qmu_part,qmu_npart); + UpdateInputsFromDakotax(variables,variables_descriptors,numvariables,femmodel,qmu_part,qmu_npart); /*Run the analysis core solution sequence: */ @@ -120,5 +121,5 @@ /*compute responses on cpu 0: dummy for now! */ if(verbose)_printf_("compute dakota responses:\n"); - DakotaResponses(responses,responses_descriptors,numresponses,femmodel,results,processed_results); + DakotaResponses(responses,responses_descriptors,numresponses,femmodel); /*Free ressources:*/ Index: /issm/trunk/src/c/modules/Qmux/SpawnCoreSerial.cpp =================================================================== --- /issm/trunk/src/c/modules/Qmux/SpawnCoreSerial.cpp (revision 4042) +++ /issm/trunk/src/c/modules/Qmux/SpawnCoreSerial.cpp (revision 4043) @@ -19,5 +19,5 @@ #include "../../include/include.h" -void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* model,int analysis_type,int sub_analysis_type,int counter){ +void SpawnCoreSerial(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, mxArray* modelint counter){ int i; @@ -27,6 +27,4 @@ double* variables_copy=NULL; mxArray* mxvariabledescriptors=NULL; - mxArray* mxanalysis_type=NULL; - mxArray* mxsub_analysis_type=NULL; mxArray* mxcounter=NULL; mwSize dims[2]={0}; @@ -51,6 +49,4 @@ } - mxanalysis_type=mxCreateDoubleScalar((double)analysis_type); - mxsub_analysis_type=mxCreateDoubleScalar((double)sub_analysis_type); mxcounter=mxCreateDoubleScalar((double)counter); @@ -59,9 +55,7 @@ array[2]=mxvariables; array[3]=mxvariabledescriptors; - array[4]=mxanalysis_type; - array[5]=mxsub_analysis_type; - array[6]=mxcounter; + array[4]=mxcounter; - mexCallMATLAB(1,&mxresponses,7,array,"SpawnCore"); + mexCallMATLAB(1,&mxresponses,5,array,"SpawnCore"); /*copy responses back to dakota: */ @@ -72,6 +66,4 @@ mxDestroyArray(mxvariabledescriptors); mxDestroyArray(mxresponses); - mxDestroyArray(mxanalysis_type); - mxDestroyArray(mxsub_analysis_type); mxDestroyArray(mxcounter); Index: /issm/trunk/src/c/modules/ReinitializeInputx/ReinitializeInputx.cpp =================================================================== --- /issm/trunk/src/c/modules/ReinitializeInputx/ReinitializeInputx.cpp (revision 4043) +++ /issm/trunk/src/c/modules/ReinitializeInputx/ReinitializeInputx.cpp (revision 4043) @@ -0,0 +1,25 @@ +/*!\file ReinitializeInputx + * \brief: reinitialize an input inside the elements, so that QMU runs can be carried out. + */ + +#include "./ReinitializeInputx.h" +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" + +void ReinitializeInputx(DataSet* elements,DataSet* nodes,DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters,int reinitialized_enum, int original_enum){ + + /*intermediary:*/ + int i; + + /*First, get elements and nodes configured: */ + elements->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*Go through elemnets, and ask to reinitialie the input: */ + for(i=0;iSize();i++){ + Element* element=(Element*)elements->GetObjectByOffset(i); + element->ReinitializeInput(reinitialized_enum,original_enum); + } + +} Index: /issm/trunk/src/c/modules/ReinitializeInputx/ReinitializeInputx.h =================================================================== --- /issm/trunk/src/c/modules/ReinitializeInputx/ReinitializeInputx.h (revision 4043) +++ /issm/trunk/src/c/modules/ReinitializeInputx/ReinitializeInputx.h (revision 4043) @@ -0,0 +1,14 @@ +/*!\file: ReinitializeInputx.h + * \brief header file for field extrusion + */ + +#ifndef _REINITIALIZEINPUTX_H +#define _REINITIALIZEINPUTX_H + +#include "../../DataSet/DataSet.h" + +/* local prototypes: */ +void ReinitializeInputx(DataSet* elements,DataSet* nodes,DataSet* vertices,DataSet* loads,DataSet* materials,Parameters* parameters,int reinitialized_enum, int original_enum); + +#endif /* _REINITIALIZEINPUTX_H */ + Index: /issm/trunk/src/c/modules/SurfaceAreax/SurfaceAreax.cpp =================================================================== --- /issm/trunk/src/c/modules/SurfaceAreax/SurfaceAreax.cpp (revision 4042) +++ /issm/trunk/src/c/modules/SurfaceAreax/SurfaceAreax.cpp (revision 4043) @@ -10,6 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters, - int analysis_type,int sub_analysis_type){ +void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials,Parameters* parameters){ /*Intermediary*/ @@ -28,5 +27,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - S+=element->SurfaceArea(analysis_type,sub_analysis_type); + S+=element->SurfaceArea(); } Index: /issm/trunk/src/c/modules/SurfaceAreax/SurfaceAreax.h =================================================================== --- /issm/trunk/src/c/modules/SurfaceAreax/SurfaceAreax.h (revision 4042) +++ /issm/trunk/src/c/modules/SurfaceAreax/SurfaceAreax.h (revision 4043) @@ -10,6 +10,5 @@ /* local prototypes: */ -void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters, - int analysis_type,int sub_analysis_type); +void SurfaceAreax( double* pS, DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters); #endif /* _SURFACEAREAX_H */ Index: /issm/trunk/src/c/modules/SystemMatricesx/SystemMatricesx.cpp =================================================================== --- /issm/trunk/src/c/modules/SystemMatricesx/SystemMatricesx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/SystemMatricesx/SystemMatricesx.cpp (revision 4043) @@ -10,6 +10,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void SystemMatricesx(Mat* pKgg, Vec* ppg,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters, - int kflag,int pflag,int analysis_type,int sub_analysis_type){ +void SystemMatricesx(Mat* pKgg, Vec* ppg,DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads,DataSet* materials, Parameters* parameters, int kflag,int pflag){ /*intermediary: */ @@ -25,4 +24,6 @@ Vec pg=NULL; + int analysis_type; + /*First, get elements and loads configured: */ elements-> Configure(elements,loads, nodes,vertices, materials,parameters); @@ -30,4 +31,7 @@ loads-> Configure(elements, loads, nodes,vertices, materials,parameters); parameters->Configure(elements,loads, nodes,vertices, materials,parameters); + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); /*Recover parameters: */ @@ -47,5 +51,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->CreateKMatrix(Kgg,analysis_type,sub_analysis_type); + element->CreateKMatrix(Kgg); } @@ -53,5 +57,5 @@ for (i=0;iSize();i++){ load=(Load*)loads->GetObjectByOffset(i); - load->CreateKMatrix(Kgg,analysis_type,sub_analysis_type); + load->CreateKMatrix(Kgg); } @@ -71,5 +75,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->CreatePVector(pg,analysis_type,sub_analysis_type); + element->CreatePVector(pg); } @@ -77,5 +81,5 @@ for (i=0;iSize();i++){ load=(Load*)loads->GetObjectByOffset(i); - load->CreatePVector(pg,analysis_type,sub_analysis_type); + load->CreatePVector(pg); } Index: /issm/trunk/src/c/modules/UpdateInputsFromDakotax/UpdateInputsFromDakotax.cpp =================================================================== --- /issm/trunk/src/c/modules/UpdateInputsFromDakotax/UpdateInputsFromDakotax.cpp (revision 4043) +++ /issm/trunk/src/c/modules/UpdateInputsFromDakotax/UpdateInputsFromDakotax.cpp (revision 4043) @@ -0,0 +1,14 @@ +/*!\file UpdateInputsFromDakotax + * \brief: update datasets using parameter inputs + */ + +#include "./UpdateInputsFromDakotax.h" +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "../../toolkits/toolkits.h" +#include "../../EnumDefinitions/EnumDefinitions.h" + +void UpdateInputsFromDakotax(double* variables,char** variables_descriptors,int numvariables,FemModel* femmodel,double* qmu_part,int qmu_npart){ + + ISSMERROR(" not supported yet!"); +} Index: /issm/trunk/src/c/modules/UpdateInputsFromDakotax/UpdateInputsFromDakotax.h =================================================================== --- /issm/trunk/src/c/modules/UpdateInputsFromDakotax/UpdateInputsFromDakotax.h (revision 4043) +++ /issm/trunk/src/c/modules/UpdateInputsFromDakotax/UpdateInputsFromDakotax.h (revision 4043) @@ -0,0 +1,15 @@ +/*!\file: UpdateInputsFromDakotax.h + * \brief header file for updating datasets from inputs + */ + +#ifndef _UPDATEINPUTSFROMDAKOTAXX_H +#define _UPDATEINPUTSFROMDAKOTAXX_H + +#include "../../objects/objects.h" +#include "../../DataSet/DataSet.h" + + +void UpdateInputsFromDakotax(double* variables,char** variables_descriptors,int numvariables,FemModel* femmodel,double* qmu_part,int qmu_npart); + +#endif /* _UPDATEINPUTSFROMDAKOTAXX_H */ + Index: /issm/trunk/src/c/modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.cpp =================================================================== --- /issm/trunk/src/c/modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.cpp (revision 4042) +++ /issm/trunk/src/c/modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.cpp (revision 4043) @@ -9,5 +9,5 @@ #include "../../EnumDefinitions/EnumDefinitions.h" -void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,Vec solution, int analysis_type, int sub_analysis_type){ +void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,Vec solution){ double* serial_solution=NULL; @@ -17,5 +17,5 @@ /*Call overloaded form of UpdateInputsFromSolutionx: */ - UpdateInputsFromSolutionx( elements, nodes, vertices, loads, materials, parameters,serial_solution, analysis_type, sub_analysis_type); + UpdateInputsFromSolutionx( elements, nodes, vertices, loads, materials, parameters,serial_solution); /*Free ressources:*/ @@ -25,5 +25,5 @@ -void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int analysis_type, int sub_analysis_type){ +void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution){ /*Intermediary*/ @@ -40,5 +40,5 @@ for (i=0;iSize();i++){ element=(Element*)elements->GetObjectByOffset(i); - element->UpdateInputsFromSolution(solution,analysis_type,sub_analysis_type); + element->UpdateInputsFromSolution(solution); } Index: /issm/trunk/src/c/modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h =================================================================== --- /issm/trunk/src/c/modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h (revision 4042) +++ /issm/trunk/src/c/modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h (revision 4043) @@ -10,10 +10,10 @@ /* local prototypes: */ -void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials, Parameters* parameters,Vec solution, int analysis_type, int sub_analysis_type); -void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int analysis_type, int sub_analysis_type); +void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials, Parameters* parameters,Vec solution); +void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution); //with timestep -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); -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); +void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials, Parameters* parameters,Vec solution,int timestep); +void UpdateInputsFromSolutionx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double* solution, int timestep); #endif /* _UPDATEINPUTSFROMSOLUTIONXX_H */ Index: /issm/trunk/src/c/modules/modules.h =================================================================== --- /issm/trunk/src/c/modules/modules.h (revision 4042) +++ /issm/trunk/src/c/modules/modules.h (revision 4043) @@ -30,4 +30,5 @@ #include "./UpdateInputsFromConstantx/UpdateInputsFromConstantx.h" #include "./UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h" +#include "./UpdateInputsFromDakotax/UpdateInputsFromDakotax.h" #include "./UpdateInputsFromVectorx/UpdateInputsFromVectorx.h" #include "./UpdateGeometryx/UpdateGeometryx.h" @@ -68,3 +69,14 @@ #include "./MinVelx/MinVelx.h" #include "./MaxVelx/MaxVelx.h" +#include "./MinVxx/MinVxx.h" +#include "./MaxVxx/MaxVxx.h" +#include "./MaxAbsVxx/MaxAbsVxx.h" +#include "./MinVyx/MinVyx.h" +#include "./MaxVyx/MaxVyx.h" +#include "./MaxAbsVyx/MaxAbsVyx.h" +#include "./MinVzx/MinVzx.h" +#include "./MaxVzx/MaxVzx.h" +#include "./MaxAbsVzx/MaxAbsVzx.h" +#include "./ReinitializeInputx/ReinitializeInputx.h" + #endif Index: /issm/trunk/src/c/objects/Constraints/Rgb.h =================================================================== --- /issm/trunk/src/c/objects/Constraints/Rgb.h (revision 4042) +++ /issm/trunk/src/c/objects/Constraints/Rgb.h (revision 4043) @@ -41,6 +41,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Index: /issm/trunk/src/c/objects/Constraints/Spc.cpp =================================================================== --- /issm/trunk/src/c/objects/Constraints/Spc.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Constraints/Spc.cpp (revision 4043) @@ -122,7 +122,4 @@ } /*}}}1*/ -/*FUNCTION Spc::DistributeNumDofs {{{1*/ -void Spc::DistributeNumDofs(int* numdofspernode,int analysis_type){return;} -/*}}}1*/ /*FUNCTION Spc::Echo {{{1*/ void Spc::Echo(void){ Index: /issm/trunk/src/c/objects/Constraints/Spc.h =================================================================== --- /issm/trunk/src/c/objects/Constraints/Spc.h (revision 4042) +++ /issm/trunk/src/c/objects/Constraints/Spc.h (revision 4043) @@ -35,5 +35,4 @@ int Id(); int MyRank(); - void DistributeNumDofs(int* numdofspernode,int analysis_type); int GetNodeId(); int GetDof(); @@ -46,5 +45,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} bool InAnalysis(int analysis_type); Index: /issm/trunk/src/c/objects/DofVec.h =================================================================== --- /issm/trunk/src/c/objects/DofVec.h (revision 4042) +++ /issm/trunk/src/c/objects/DofVec.h (revision 4043) @@ -53,5 +53,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Object* copy(); Index: /issm/trunk/src/c/objects/Elements/Beam.cpp =================================================================== --- /issm/trunk/src/c/objects/Elements/Beam.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Beam.cpp (revision 4043) @@ -131,10 +131,10 @@ /*}}}*/ /*FUNCTION Beam::UpdateInputsFromSolution {{{1*/ -void Beam::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ - ISSMERROR(" not supported yet!"); -} -/*}}}*/ -/*FUNCTION Beam::GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type);{{{1*/ -void Beam::GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type){ +void Beam::UpdateInputsFromSolution(double* solution){ + ISSMERROR(" not supported yet!"); +} +/*}}}*/ +/*FUNCTION Beam::GetSolutionFromInputs(Vec solution);{{{1*/ +void Beam::GetSolutionFromInputs(Vec solution){ ISSMERROR(" not supported yet!"); } @@ -153,5 +153,5 @@ /*Object functions*/ /*FUNCTION Beam::ComputeBasalStress{{{1*/ -void Beam::ComputeBasalStress(Vec eps,int analysis_type,int sub_analysis_type){ +void Beam::ComputeBasalStress(Vec eps){ ISSMERROR("Not implemented yet"); @@ -160,5 +160,5 @@ /*}}}*/ /*FUNCTION Beam::ComputePressure{{{1*/ -void Beam::ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type){ +void Beam::ComputePressure(Vec p_g){ int i; @@ -170,4 +170,9 @@ double xyz_list[numgrids][3]; double gauss[numgrids][numgrids]={{1,0},{0,1}}; + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*Get dof list on which we will plug the pressure values: */ @@ -196,5 +201,5 @@ /*}}}*/ /*FUNCTION Beam::ComputeStrainRate{{{1*/ -void Beam::ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type){ +void Beam::ComputeStrainRate(Vec eps){ ISSMERROR("Not implemented yet"); @@ -203,10 +208,16 @@ /*}}}*/ /*FUNCTION Beam::CostFunction{{{1*/ -double Beam::CostFunction(int,int){ +double Beam::CostFunction(void){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Beam::CreateKMatrix{{{1*/ -void Beam::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Beam::CreateKMatrix(Mat Kgg){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ @@ -215,5 +226,5 @@ if (sub_analysis_type==HutterAnalysisEnum) { - CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHutter( Kgg); } else @@ -228,5 +239,5 @@ /*FUNCTION Beam::CreateKMatrixDiagnosticHutter{{{1*/ -void Beam::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Beam::CreateKMatrixDiagnosticHutter(Mat Kgg){ @@ -279,10 +290,16 @@ /*}}}*/ /*FUNCTION Beam::CreatePVector{{{1*/ -void Beam::CreatePVector(Vec pg,int analysis_type,int sub_analysis_type){ +void Beam::CreatePVector(Vec pg){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */ if (analysis_type==DiagnosticAnalysisEnum) { if (sub_analysis_type==HutterAnalysisEnum) { - CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHutter( pg); } else @@ -297,5 +314,5 @@ /*FUNCTION Beam::CreatePVectorDiagnosticHutter{{{1*/ -void Beam::CreatePVectorDiagnosticHutter( Vec pg, int analysis_type,int sub_analysis_type){ +void Beam::CreatePVectorDiagnosticHutter( Vec pg){ int i,j,k; @@ -425,5 +442,5 @@ /*}}}*/ /*FUNCTION Beam::Du{{{1*/ -void Beam::Du(Vec,int,int){ +void Beam::Du(Vec){ ISSMERROR(" not supported yet!"); } @@ -545,25 +562,25 @@ /*}}}*/ /*FUNCTION Beam::Gradj{{{1*/ -void Beam::Gradj(Vec, int, int,int){ +void Beam::Gradj(Vec, int control_type){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Beam::GradjB{{{1*/ -void Beam::GradjB(Vec, int, int){ +void Beam::GradjB(Vec){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Beam::GradjDrag{{{1*/ -void Beam::GradjDrag(Vec, int,int ){ +void Beam::GradjDrag(Vec){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Beam::MassFlux{{{1*/ -double Beam::MassFlux( double* segment,double* ug){ +double Beam::MassFlux( double* segment){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Beam::Misfit{{{1*/ -double Beam::Misfit(int,int){ +double Beam::Misfit(void){ ISSMERROR(" not supported yet!"); } @@ -576,5 +593,5 @@ /*}}}*/ /*FUNCTION Beam::SurfaceArea{{{1*/ -double Beam::SurfaceArea(int,int){ +double Beam::SurfaceArea(void){ ISSMERROR(" not supported yet!"); } @@ -639,4 +656,6 @@ void Beam::MinVel(double* pminvel, bool process_units){ + int i; + int dim; const int numgrids=2; double gaussgrids[numgrids][2]={{0,1},{1,0}}; @@ -657,8 +676,8 @@ /*now, compute minimum of velocity :*/ if(dim==2){ - for(i=0;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute minimum:*/ + minvx=vx_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute maximum:*/ + maxvx=vx_values[0]; + for(i=1;imaxvx)maxvx=vx_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvx=maxvx; + +} +/*}}}*/ +/*FUNCTION Beam::MaxAbsVx(double* pmaxabsvx, bool process_units);{{{1*/ +void Beam::MaxAbsVx(double* pmaxabsvx, bool process_units){ + + int i; + int dim; + const int numgrids=2; + double gaussgrids[numgrids][2]={{0,1},{1,0}}; + double vx_values[numgrids]; + double maxabsvx; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute maximum:*/ + maxabsvx=fabs(vx_values[0]); + for(i=1;imaxabsvx)maxabsvx=fabs(vx_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvx=maxabsvx; +} +/*}}}*/ +/*FUNCTION Beam::MinVy(double* pminvy, bool process_units);{{{1*/ +void Beam::MinVy(double* pminvy, bool process_units){ + + int i; + int dim; + const int numgrids=2; + double gaussgrids[numgrids][2]={{0,1},{1,0}}; + double vy_values[numgrids]; + double minvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute minimum:*/ + minvy=vy_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute maximum:*/ + maxvy=vy_values[0]; + for(i=1;imaxvy)maxvy=vy_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvy=maxvy; + +} +/*}}}*/ +/*FUNCTION Beam::MaxAbsVy(double* pmaxabsvy, bool process_units);{{{1*/ +void Beam::MaxAbsVy(double* pmaxabsvy, bool process_units){ + + int i; + int dim; + const int numgrids=2; + double gaussgrids[numgrids][2]={{0,1},{1,0}}; + double vy_values[numgrids]; + double maxabsvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute maximum:*/ + maxabsvy=fabs(vy_values[0]); + for(i=1;imaxabsvy)maxabsvy=fabs(vy_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvy=maxabsvy; +} +/*}}}*/ +/*FUNCTION Beam::MinVz(double* pminvz, bool process_units);{{{1*/ +void Beam::MinVz(double* pminvz, bool process_units){ + + int i; + int dim; + const int numgrids=2; + double gaussgrids[numgrids][2]={{0,1},{1,0}}; + double vz_values[numgrids]; + double minvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute minimum:*/ + minvz=vz_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute maximum:*/ + maxvz=vz_values[0]; + for(i=1;imaxvz)maxvz=vz_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvz=maxvz; + +} +/*}}}*/ +/*FUNCTION Beam::MaxAbsVz(double* pmaxabsvz, bool process_units);{{{1*/ +void Beam::MaxAbsVz(double* pmaxabsvz, bool process_units){ + + int i; + int dim; + const int numgrids=2; + double gaussgrids[numgrids][2]={{0,1},{1,0}}; + double vz_values[numgrids]; + double maxabsvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute maximum:*/ + maxabsvz=fabs(vz_values[0]); + for(i=1;imaxabsvz)maxabsvz=fabs(vz_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvz=maxabsvz; +} +/*}}}*/ +/*FUNCTION Beam::ReinitializeInput(int reinitialized_enum,int original_enum){{{1*/ +void Beam::ReinitializeInput(int reinitialized_enum,int original_enum){ + + Input* original=NULL; + Input* copy=NULL; + + /*Make a copy of the original input: */ + original=(Input*)this->inputs->GetInput(original_enum); + copy=(Input*)original->copy(); + + /*Change copy enum to reinitialized_enum: */ + copy->ChangeEnum(reinitialized_enum); + + /*Add copy into inputs, it will wipe off the one already there: */ + inputs->AddObject((Input*)copy); +} +/*}}}*/ Index: /issm/trunk/src/c/objects/Elements/Beam.h =================================================================== --- /issm/trunk/src/c/objects/Elements/Beam.h (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Beam.h (revision 4043) @@ -61,5 +61,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type); + void UpdateInputsFromSolution(double* solution); void DepthAverageInputAtBase(int enum_type){ISSMERROR("not implemented yet");}; void InputToResult(int enum_type,int step,double time); @@ -67,17 +67,17 @@ /*}}}*/ /*numerics: {{{1*/ - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); - void GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kgg); + void CreatePVector(Vec pg); + void GetSolutionFromInputs(Vec solution); void GetDofList(int* doflist,int* pnumberofdofs); void GetDofList1(int* doflist); - void CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type); + void CreateKMatrixDiagnosticHutter(Mat Kgg); void GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3); - void CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type); + void CreatePVectorDiagnosticHutter(Vec pg); void* GetMatPar(); - void ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type); - void ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type); - void ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type); + void ComputeBasalStress(Vec sigma_bg); + void ComputePressure(Vec p_gg); + void ComputeStrainRate(Vec epsg); void GetNodes(void** vpnodes); void PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes); @@ -85,4 +85,15 @@ void MinVel(double* pminvel, bool process_units); void MaxVel(double* pmaxvel, bool process_units); + void MinVx(double* pminvx, bool process_units); + void MaxVx(double* pmaxvx, bool process_units); + void MaxAbsVx(double* pmaxabsvx, bool process_units); + void MinVy(double* pminvy, bool process_units); + void MaxVy(double* pmaxvy, bool process_units); + void MaxAbsVy(double* pmaxabsvy, bool process_units); + void MinVz(double* pminvz, bool process_units); + void MaxVz(double* pmaxvz, bool process_units); + void MaxAbsVz(double* pmaxabsvz, bool process_units); + void ReinitializeInput(int reinitialized_enum,int original_enum); + /*}}}*/ /*not implemented: {{{1*/ @@ -91,15 +102,15 @@ void GetBedList(double*); void GetThicknessList(double* thickness_list); - void Du(Vec, int,int); - void Gradj(Vec, int, int,int); - void GradjDrag(Vec, int,int ); - void GradjB(Vec, int,int ); - double Misfit(int,int); - double SurfaceArea(int,int); - double CostFunction(int,int); + void Du(Vec); + void Gradj(Vec, int control_type); + void GradjDrag(Vec); + void GradjB(Vec); + double Misfit(void); + double SurfaceArea(void); + double CostFunction(void); void GetNodalFunctions(double* l1l2, double gauss_coord); void GetParameterValue(double* pvalue, double* value_list,double gauss_coord); void GetJacobianDeterminant(double* pJdet,double* z_list, double gauss_coord); - double MassFlux(double* segment,double* ug); + double MassFlux(double* segment); /*}}}*/ Index: /issm/trunk/src/c/objects/Elements/Element.h =================================================================== --- /issm/trunk/src/c/objects/Elements/Element.h (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Element.h (revision 4043) @@ -27,7 +27,7 @@ virtual void Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* materials,Parameters* parameters)=0; - virtual void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type)=0; - virtual void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type)=0; - virtual void GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type)=0; + virtual void CreateKMatrix(Mat Kgg)=0; + virtual void CreatePVector(Vec pg)=0; + virtual void GetSolutionFromInputs(Vec solution)=0; virtual void GetNodes(void** nodes)=0; virtual void* GetMatPar()=0; @@ -36,16 +36,16 @@ virtual void GetThicknessList(double* thickness_list)=0; virtual void GetBedList(double* bed_list)=0; - virtual void Du(Vec du_g,int analysis_type,int sub_analysis_type)=0; - virtual void Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type)=0; - virtual void GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type)=0; - virtual void GradjB(Vec grad_g,int analysis_type,int sub_analysis_type)=0; - virtual double Misfit(int analysis_type,int sub_analysis_type)=0; - virtual double CostFunction(int analysis_type,int sub_analysis_type)=0; - virtual double SurfaceArea(int analysis_type,int sub_analysis_type)=0; + virtual void Du(Vec du_g)=0; + virtual void Gradj(Vec grad_g,int control_type)=0; + virtual void GradjDrag(Vec grad_g)=0; + virtual void GradjB(Vec grad_g)=0; + virtual double Misfit(void)=0; + virtual double CostFunction(void)=0; + virtual double SurfaceArea(void)=0; virtual void DepthAverageInputAtBase(int enum_type)=0; - virtual void ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type)=0; - virtual void ComputePressure(Vec p_g, int analysis_type,int sub_analysis_type)=0; - virtual void ComputeStrainRate(Vec eps, int analysis_type,int sub_analysis_type)=0; - virtual double MassFlux(double* segment,double* ug)=0; + virtual void ComputeBasalStress(Vec sigma_b)=0; + virtual void ComputePressure(Vec p_g)=0; + virtual void ComputeStrainRate(Vec eps)=0; + virtual double MassFlux(double* segment)=0; virtual void PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes)=0; virtual void PatchFill(int* pcount, Patch* patch)=0; @@ -55,4 +55,15 @@ virtual void MinVel(double* pminvel, bool process_units)=0; virtual void MaxVel(double* pmaxvel, bool process_units)=0; + virtual void MinVx(double* pminvx, bool process_units)=0; + virtual void MaxVx(double* pmaxvx, bool process_units)=0; + virtual void MaxAbsVx(double* pmaxabsvx, bool process_units)=0; + virtual void MinVy(double* pminvy, bool process_units)=0; + virtual void MaxVy(double* pmaxvy, bool process_units)=0; + virtual void MaxAbsVy(double* pmaxabsvy, bool process_units)=0; + virtual void MinVz(double* pminvz, bool process_units)=0; + virtual void MaxVz(double* pmaxvz, bool process_units)=0; + virtual void MaxAbsVz(double* pmaxabsvz, bool process_units)=0; + virtual void ReinitializeInput(int reinitialized_enum,int original_enum)=0; + /*Implementation: */ Index: /issm/trunk/src/c/objects/Elements/Penta.cpp =================================================================== --- /issm/trunk/src/c/objects/Elements/Penta.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Penta.cpp (revision 4043) @@ -632,10 +632,16 @@ /*}}}*/ /*FUNCTION Penta::UpdateInputsFromSolution {{{1*/ -void Penta::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolution(double* solution){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */ if (analysis_type==ControlAnalysisEnum){ - UpdateInputsFromSolutionDiagnosticHoriz( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionDiagnosticHoriz( solution); } else if (analysis_type==DiagnosticAnalysisEnum){ @@ -643,9 +649,9 @@ if (sub_analysis_type==HorizAnalysisEnum){ - UpdateInputsFromSolutionDiagnosticHoriz( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionDiagnosticHoriz( solution); } else if (sub_analysis_type==StokesAnalysisEnum){ - UpdateInputsFromSolutionDiagnosticStokes( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionDiagnosticStokes( solution); } else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet"); @@ -654,25 +660,25 @@ else if (analysis_type==SlopeComputeAnalysisEnum){ - UpdateInputsFromSolutionSlopeCompute( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionSlopeCompute( solution); } else if (analysis_type==PrognosticAnalysisEnum){ - UpdateInputsFromSolutionPrognostic( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionPrognostic( solution); } else if (analysis_type==Prognostic2AnalysisEnum){ - UpdateInputsFromSolutionPrognostic2(solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionPrognostic2(solution); } else if (analysis_type==BalancedthicknessAnalysisEnum){ - UpdateInputsFromSolutionBalancedthickness( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionBalancedthickness( solution); } else if (analysis_type==Balancedthickness2AnalysisEnum){ - UpdateInputsFromSolutionBalancedthickness2( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionBalancedthickness2( solution); } else if (analysis_type==BalancedvelocitiesAnalysisEnum){ - UpdateInputsFromSolutionBalancedvelocities( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionBalancedvelocities( solution); } else{ @@ -683,5 +689,5 @@ /*Object functions*/ /*FUNCTION Penta::UpdateInputsFromSolutionDiagnosticHoriz {{{1*/ -void Penta::UpdateInputsFromSolutionDiagnosticHoriz(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolutionDiagnosticHoriz(double* solution){ @@ -744,5 +750,5 @@ /*}}}*/ /*FUNCTION Penta::UpdateInputsFromSolutionDiagnosticStokes {{{1*/ -void Penta::UpdateInputsFromSolutionDiagnosticStokes(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolutionDiagnosticStokes(double* solution){ @@ -801,45 +807,53 @@ /*}}}*/ /*FUNCTION Penta::UpdateInputsFromSolutionSlopeCompute {{{1*/ -void Penta::UpdateInputsFromSolutionSlopeCompute(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolutionSlopeCompute(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Penta::UpdateInputsFromSolutionPrognostic {{{1*/ -void Penta::UpdateInputsFromSolutionPrognostic(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolutionPrognostic(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Penta::UpdateInputsFromSolutionPrognostic2 {{{1*/ -void Penta::UpdateInputsFromSolutionPrognostic2(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolutionPrognostic2(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Penta::UpdateInputsFromSolutionBalancedthickness {{{1*/ -void Penta::UpdateInputsFromSolutionBalancedthickness(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolutionBalancedthickness(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Penta::UpdateInputsFromSolutionBalancedthickness2 {{{1*/ -void Penta::UpdateInputsFromSolutionBalancedthickness2(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolutionBalancedthickness2(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Penta::UpdateInputsFromSolutionBalancedvelocities {{{1*/ -void Penta::UpdateInputsFromSolutionBalancedvelocities(double* solution, int analysis_type, int sub_analysis_type){ +void Penta::UpdateInputsFromSolutionBalancedvelocities(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ -/*FUNCTION Penta::GetSolutionFromInputs(Vec solution,int analysis_type,int sub_analysis_type){{{1*/ -void Penta::GetSolutionFromInputs(Vec solution,int analysis_type,int sub_analysis_type){ +/*FUNCTION Penta::GetSolutionFromInputs(Vec solution){{{1*/ +void Penta::GetSolutionFromInputs(Vec solution){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); + + /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */ if (analysis_type==DiagnosticAnalysisEnum){ if (sub_analysis_type==HorizAnalysisEnum){ - GetSolutionFromInputsDiagnosticHoriz(solution,analysis_type,sub_analysis_type); + GetSolutionFromInputsDiagnosticHoriz(solution); } else if(sub_analysis_type==VertAnalysisEnum){ - GetSolutionFromInputsDiagnosticVert(solution,analysis_type,sub_analysis_type); + GetSolutionFromInputsDiagnosticVert(solution); } else if(sub_analysis_type==StokesAnalysisEnum){ - GetSolutionFromInputsDiagnosticStokes(solution,analysis_type,sub_analysis_type); + GetSolutionFromInputsDiagnosticStokes(solution); } else ISSMERROR("sub_analysis: %i (%s) not supported yet",sub_analysis_type,EnumAsString(sub_analysis_type)); @@ -850,6 +864,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type){{{1*/ -void Penta::GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type){ +/*FUNCTION Penta::GetSolutionFromInputsDiagnosticHoriz(Vec solution){{{1*/ +void Penta::GetSolutionFromInputsDiagnosticHoriz(Vec solution){ int i; @@ -886,6 +900,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetSolutionFromInputsDiagnosticVert(Vec solution,int analysis_type,int sub_analysis_type){{{1*/ -void Penta::GetSolutionFromInputsDiagnosticVert(Vec solution,int analysis_type,int sub_analysis_type){ +/*FUNCTION Penta::GetSolutionFromInputsDiagnosticVert(Vec solution){{{1*/ +void Penta::GetSolutionFromInputsDiagnosticVert(Vec solution){ int i; @@ -918,6 +932,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetSolutionFromInputsDiagnosticStokes(Vec solution,int analysis_type,int sub_analysis_type){{{1*/ -void Penta::GetSolutionFromInputsDiagnosticStokes(Vec solution,int analysis_type,int sub_analysis_type){ +/*FUNCTION Penta::GetSolutionFromInputsDiagnosticStokes(Vec solution){{{1*/ +void Penta::GetSolutionFromInputsDiagnosticStokes(Vec solution){ int i; @@ -1001,5 +1015,5 @@ /*}}}*/ /*FUNCTION Penta::ComputeBasalStress {{{1*/ -void Penta::ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type){ +void Penta::ComputeBasalStress(Vec sigma_b){ int i,j; @@ -1019,4 +1033,5 @@ double stresstensor[6]={0.0}; double viscosity; + int analysis_type,sub_analysis_type; int dofv[3]={0,1,2}; @@ -1047,4 +1062,9 @@ double stokesreconditioning; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); + /*Check analysis_types*/ if (analysis_type!=DiagnosticAnalysisEnum || sub_analysis_type!=StokesAnalysisEnum) ISSMERROR("Not supported yet!"); @@ -1123,5 +1143,5 @@ /*}}}*/ /*FUNCTION Penta::ComputePressure {{{1*/ -void Penta::ComputePressure(Vec pg,int analysis_type,int sub_analysis_type){ +void Penta::ComputePressure(Vec pg){ int i; @@ -1168,5 +1188,5 @@ /*}}}*/ /*FUNCTION Penta::ComputeStrainRate {{{1*/ -void Penta::ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type){ +void Penta::ComputeStrainRate(Vec eps){ ISSMERROR("Not implemented yet"); @@ -1175,5 +1195,5 @@ /*}}}*/ /*FUNCTION Penta::CostFunction {{{1*/ -double Penta::CostFunction(int analysis_type,int sub_analysis_type){ +double Penta::CostFunction(void){ double J; @@ -1206,5 +1226,5 @@ * and compute CostFunction*/ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face). - J=tria->CostFunction(analysis_type,sub_analysis_type); + J=tria->CostFunction(); delete tria; return J; @@ -1213,5 +1233,5 @@ tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face). - J=tria->CostFunction(analysis_type,sub_analysis_type); + J=tria->CostFunction(); delete tria; return J; @@ -1220,5 +1240,11 @@ /*}}}*/ /*FUNCTION Penta::CreateKMatrix {{{1*/ -void Penta::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrix(Mat Kgg){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*if debugging mode, check that all pointers exist*/ @@ -1227,38 +1253,38 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ if (analysis_type==ControlAnalysisEnum){ - CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHoriz( Kgg); } else if (analysis_type==DiagnosticAnalysisEnum){ if (sub_analysis_type==HorizAnalysisEnum){ - CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHoriz( Kgg); } else if (sub_analysis_type==HutterAnalysisEnum){ - CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHutter( Kgg); } else if (sub_analysis_type==VertAnalysisEnum){ - CreateKMatrixDiagnosticVert( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticVert( Kgg); } else if (sub_analysis_type==StokesAnalysisEnum){ - CreateKMatrixDiagnosticStokes( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticStokes( Kgg); } else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet"); } else if (analysis_type==SlopeComputeAnalysisEnum){ - CreateKMatrixSlopeCompute( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixSlopeCompute( Kgg); } else if (analysis_type==PrognosticAnalysisEnum){ - CreateKMatrixPrognostic( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixPrognostic( Kgg); } else if (analysis_type==BalancedthicknessAnalysisEnum){ - CreateKMatrixBalancedthickness( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixBalancedthickness( Kgg); } else if (analysis_type==BalancedvelocitiesAnalysisEnum){ - CreateKMatrixBalancedvelocities( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixBalancedvelocities( Kgg); } else if (analysis_type==ThermalAnalysisEnum){ - CreateKMatrixThermal( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixThermal( Kgg); } else if (analysis_type==MeltingAnalysisEnum){ - CreateKMatrixMelting( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixMelting( Kgg); } else ISSMERROR("%s%i%s\n","analysis: ",analysis_type," not supported yet"); @@ -1268,5 +1294,5 @@ /*FUNCTION Penta::CreateKMatrixBalancedthickness {{{1*/ -void Penta::CreateKMatrixBalancedthickness(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixBalancedthickness(Mat Kgg){ /*Collapsed formulation: */ @@ -1289,5 +1315,5 @@ /*Spawn Tria element from the base of the Penta: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreateKMatrix(Kgg, analysis_type,sub_analysis_type); + tria->CreateKMatrix(Kgg); delete tria; return; @@ -1297,5 +1323,5 @@ /*FUNCTION Penta::CreateKMatrixBalancedvelocities {{{1*/ -void Penta::CreateKMatrixBalancedvelocities(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixBalancedvelocities(Mat Kgg){ /*Collapsed formulation: */ @@ -1318,5 +1344,5 @@ /*Spawn Tria element from the base of the Penta: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreateKMatrix(Kgg,analysis_type,sub_analysis_type); + tria->CreateKMatrix(Kgg); delete tria; return; @@ -1325,5 +1351,5 @@ /*}}}*/ /*FUNCTION Penta::CreateKMatrixDiagnosticHoriz {{{1*/ -void Penta::CreateKMatrixDiagnosticHoriz( Mat Kgg, int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixDiagnosticHoriz( Mat Kgg){ /* local declarations */ @@ -1437,5 +1463,5 @@ *and use its CreateKMatrix functionality to fill the global stiffness matrix: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreateKMatrix(Kgg, analysis_type,sub_analysis_type); + tria->CreateKMatrix(Kgg); delete tria; return; @@ -1528,5 +1554,5 @@ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreateKMatrixDiagnosticHorizFriction(Kgg,analysis_type,sub_analysis_type); + tria->CreateKMatrixDiagnosticHorizFriction(Kgg); delete tria; } @@ -1548,5 +1574,5 @@ /*}}}*/ /*FUNCTION Penta::CreateKMatrixDiagnosticHutter{{{1*/ -void Penta::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixDiagnosticHutter(Mat Kgg){ /*Collapsed formulation: */ @@ -1566,5 +1592,5 @@ for(i=0;i<3;i++){ beam=(Beam*)SpawnBeam(i,i+3); //[0 3], [1 4] and [2 5] are the four vertical edges of the Penta - beam->CreateKMatrix(Kgg,analysis_type,sub_analysis_type); + beam->CreateKMatrix(Kgg); } @@ -1575,5 +1601,5 @@ /*}}}*/ /*FUNCTION Penta::CreateKMatrixDiagnosticStokes {{{1*/ -void Penta::CreateKMatrixDiagnosticStokes( Mat Kgg, int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixDiagnosticStokes( Mat Kgg){ int i,j; @@ -1649,4 +1675,5 @@ /*parameters: */ double stokesreconditioning; + int analysis_type; /*inputs: */ @@ -1654,4 +1681,7 @@ bool onbed; bool shelf; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); /*retrieve inputs :*/ @@ -1840,5 +1870,5 @@ /*}}}*/ /*FUNCTION Penta::CreateKMatrixDiagnosticVert {{{1*/ -void Penta::CreateKMatrixDiagnosticVert( Mat Kgg, int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixDiagnosticVert( Mat Kgg){ /* local declarations */ @@ -1895,5 +1925,5 @@ if(onsurface){ tria=(Tria*)SpawnTria(3,4,5); //nodes 3,4 and 5 are on the surface - tria->CreateKMatrixDiagnosticSurfaceVert(Kgg, analysis_type,sub_analysis_type); + tria->CreateKMatrixDiagnosticSurfaceVert(Kgg); delete tria; } @@ -1965,5 +1995,5 @@ /*}}}*/ /*FUNCTION Penta::CreateKMatrixMelting {{{1*/ -void Penta::CreateKMatrixMelting(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixMelting(Mat Kgg){ Tria* tria=NULL; @@ -1986,5 +2016,5 @@ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreateKMatrixMelting(Kgg, analysis_type,sub_analysis_type); + tria->CreateKMatrixMelting(Kgg); delete tria; return; @@ -1994,5 +2024,5 @@ /*FUNCTION Penta::CreateKMatrixPrognostic {{{1*/ -void Penta::CreateKMatrixPrognostic(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixPrognostic(Mat Kgg){ /*Collapsed formulation: */ @@ -2015,5 +2045,5 @@ /*Spawn Tria element from the base of the Penta: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreateKMatrix(Kgg, analysis_type,sub_analysis_type); + tria->CreateKMatrix(Kgg); delete tria; return; @@ -2023,5 +2053,5 @@ /*FUNCTION Penta::CreateKMatrixSlopeCompute {{{1*/ -void Penta::CreateKMatrixSlopeCompute(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixSlopeCompute(Mat Kgg){ /*Collapsed formulation: */ @@ -2045,5 +2075,5 @@ /*Spawn Tria element from the base of the Penta: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreateKMatrix(Kgg, analysis_type,sub_analysis_type); + tria->CreateKMatrix(Kgg); delete tria; return; @@ -2052,5 +2082,5 @@ /*}}}*/ /*FUNCTION Penta::CreateKMatrixThermal {{{1*/ -void Penta::CreateKMatrixThermal(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penta::CreateKMatrixThermal(Mat Kgg){ /* local declarations */ @@ -2291,5 +2321,5 @@ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreateKMatrixThermal(Kgg, analysis_type,sub_analysis_type); + tria->CreateKMatrixThermal(Kgg); delete tria; } @@ -2297,5 +2327,11 @@ /*}}}*/ /*FUNCTION Penta::CreatePVector {{{1*/ -void Penta::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVector(Vec pg){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*if debugging mode, check that all pointers exist*/ @@ -2304,38 +2340,38 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ if (analysis_type==ControlAnalysisEnum){ - CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHoriz( pg); } else if (analysis_type==DiagnosticAnalysisEnum){ if (sub_analysis_type==HorizAnalysisEnum){ - CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHoriz( pg); } else if (sub_analysis_type==HutterAnalysisEnum){ - CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHutter( pg); } else if (sub_analysis_type==VertAnalysisEnum){ - CreatePVectorDiagnosticVert( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticVert( pg); } else if (sub_analysis_type==StokesAnalysisEnum){ - CreatePVectorDiagnosticStokes( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticStokes( pg); } else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet"); } else if (analysis_type==SlopeComputeAnalysisEnum){ - CreatePVectorSlopeCompute( pg,analysis_type,sub_analysis_type); + CreatePVectorSlopeCompute( pg); } else if (analysis_type==PrognosticAnalysisEnum){ - CreatePVectorPrognostic( pg,analysis_type,sub_analysis_type); + CreatePVectorPrognostic( pg); } else if (analysis_type==BalancedthicknessAnalysisEnum){ - CreatePVectorBalancedthickness( pg,analysis_type,sub_analysis_type); + CreatePVectorBalancedthickness( pg); } else if (analysis_type==BalancedvelocitiesAnalysisEnum){ - CreatePVectorBalancedvelocities( pg,analysis_type,sub_analysis_type); + CreatePVectorBalancedvelocities( pg); } else if (analysis_type==ThermalAnalysisEnum){ - CreatePVectorThermal( pg,analysis_type,sub_analysis_type); + CreatePVectorThermal( pg); } else if (analysis_type==MeltingAnalysisEnum){ - CreatePVectorMelting( pg,analysis_type,sub_analysis_type); + CreatePVectorMelting( pg); } else ISSMERROR("%s%i%s\n","analysis: ",analysis_type," not supported yet"); @@ -2344,5 +2380,5 @@ /*}}}*/ /*FUNCTION Penta::CreatePVectorBalancedthickness {{{1*/ -void Penta::CreatePVectorBalancedthickness( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorBalancedthickness( Vec pg){ /*Collapsed formulation: */ @@ -2365,5 +2401,5 @@ /*Spawn Tria element from the base of the Penta: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreatePVector(pg, analysis_type,sub_analysis_type); + tria->CreatePVector(pg); delete tria; return; @@ -2371,5 +2407,5 @@ /*}}}*/ /*FUNCTION Penta::CreatePVectorBalancedvelocities {{{1*/ -void Penta::CreatePVectorBalancedvelocities( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorBalancedvelocities( Vec pg){ /*Collapsed formulation: */ @@ -2392,5 +2428,5 @@ /*Spawn Tria element from the base of the Penta: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreatePVector(pg, analysis_type,sub_analysis_type); + tria->CreatePVector(pg); delete tria; return; @@ -2398,5 +2434,5 @@ /*}}}*/ /*FUNCTION Penta::CreatePVectorDiagnosticHoriz {{{1*/ -void Penta::CreatePVectorDiagnosticHoriz( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorDiagnosticHoriz( Vec pg){ int i,j; @@ -2471,5 +2507,5 @@ *and use its CreatePVector functionality to return an elementary load vector: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreatePVector(pg, analysis_type,sub_analysis_type); + tria->CreatePVector(pg); delete tria; return; @@ -2546,5 +2582,5 @@ /*}}}*/ /*FUNCTION Penta::CreatePVectorDiagnosticHutter{{{1*/ -void Penta::CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorDiagnosticHutter(Vec pg){ /*Collapsed formulation: */ @@ -2564,5 +2600,5 @@ for(i=0;i<3;i++){ beam=(Beam*)SpawnBeam(i,i+3); //[0 3], [1 4] and [2 5] are the four vertical edges of the Penta - beam->CreatePVector(pg,analysis_type,sub_analysis_type); + beam->CreatePVector(pg); } @@ -2573,5 +2609,5 @@ /*}}}*/ /*FUNCTION Penta::CreatePVectorDiagnosticStokes {{{1*/ -void Penta::CreatePVectorDiagnosticStokes( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorDiagnosticStokes( Vec pg){ /*indexing: */ @@ -2814,5 +2850,5 @@ /*}}}*/ /*FUNCTION Penta::CreatePVectorDiagnosticVert {{{1*/ -void Penta::CreatePVectorDiagnosticVert( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorDiagnosticVert( Vec pg){ int i; @@ -2875,5 +2911,5 @@ if(onbed){ tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 are on the bedrock - tria->CreatePVectorDiagnosticBaseVert(pg, analysis_type,sub_analysis_type); + tria->CreatePVectorDiagnosticBaseVert(pg); delete tria; } @@ -2940,5 +2976,5 @@ /*}}}*/ /*FUNCTION Penta::CreatePVectorMelting {{{1*/ -void Penta::CreatePVectorMelting( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorMelting( Vec pg){ return; } @@ -2946,5 +2982,5 @@ /*FUNCTION Penta::CreatePVectorPrognostic {{{1*/ -void Penta::CreatePVectorPrognostic( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorPrognostic( Vec pg){ /*Collapsed formulation: */ @@ -2967,5 +3003,5 @@ /*Spawn Tria element from the base of the Penta: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreatePVector(pg, analysis_type,sub_analysis_type); + tria->CreatePVector(pg); delete tria; return; @@ -2974,5 +3010,5 @@ /*FUNCTION Penta::CreatePVectorSlopeCompute {{{1*/ -void Penta::CreatePVectorSlopeCompute( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorSlopeCompute( Vec pg){ /*Collapsed formulation: */ @@ -2995,5 +3031,5 @@ /*Spawn Tria element from the base of the Penta: */ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreatePVector(pg, analysis_type,sub_analysis_type); + tria->CreatePVector(pg); delete tria; return; @@ -3001,5 +3037,5 @@ /*}}}*/ /*FUNCTION Penta::CreatePVectorThermal {{{1*/ -void Penta::CreatePVectorThermal( Vec pg, int analysis_type,int sub_analysis_type){ +void Penta::CreatePVectorThermal( Vec pg){ /*indexing: */ @@ -3160,5 +3196,5 @@ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreatePVectorThermalShelf(pg, analysis_type,sub_analysis_type); + tria->CreatePVectorThermalShelf(pg); delete tria; } @@ -3168,5 +3204,5 @@ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->CreatePVectorThermalSheet(pg, analysis_type,sub_analysis_type); + tria->CreatePVectorThermalSheet(pg); delete tria; } @@ -3183,5 +3219,5 @@ /*}}}*/ /*FUNCTION Penta::Du {{{1*/ -void Penta::Du(Vec du_g,int analysis_type,int sub_analysis_type){ +void Penta::Du(Vec du_g){ int i; @@ -3214,5 +3250,5 @@ * and compute Du*/ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face). - tria->Du(du_g,analysis_type,sub_analysis_type); + tria->Du(du_g); delete tria; return; @@ -3221,5 +3257,5 @@ tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face). - tria->Du(du_g,analysis_type,sub_analysis_type); + tria->Du(du_g); delete tria; return; @@ -4519,5 +4555,5 @@ /*}}}*/ /*FUNCTION Penta::Gradj {{{1*/ -void Penta::Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type){ +void Penta::Gradj(Vec grad_g,int control_type){ /*inputs: */ @@ -4531,8 +4567,8 @@ if (control_type==DragCoefficientEnum){ - GradjDrag( grad_g,analysis_type,sub_analysis_type); + GradjDrag( grad_g); } else if (control_type=RheologyBEnum){ - GradjB( grad_g, analysis_type,sub_analysis_type); + GradjB( grad_g); } else ISSMERROR("%s%i","control type not supported yet: ",control_type); @@ -4540,5 +4576,5 @@ /*}}}*/ /*FUNCTION Penta::GradjDrag {{{1*/ -void Penta::GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type){ +void Penta::GradjDrag(Vec grad_g){ Tria* tria=NULL; @@ -4548,4 +4584,9 @@ bool onbed; bool shelf; + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*retrieve inputs :*/ @@ -4567,5 +4608,5 @@ /*MacAyeal or Pattyn*/ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->GradjDrag( grad_g,analysis_type,sub_analysis_type); + tria->GradjDrag( grad_g); delete tria; return; @@ -4575,5 +4616,5 @@ /*Stokes*/ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria. - tria->GradjDragStokes( grad_g,analysis_type,sub_analysis_type); + tria->GradjDragStokes( grad_g); delete tria; return; @@ -4583,5 +4624,5 @@ /*}}}*/ /*FUNCTION Penta::GradjB {{{1*/ -void Penta::GradjB(Vec grad_g,int analysis_type,int sub_analysis_type){ +void Penta::GradjB(Vec grad_g){ Tria* tria=NULL; @@ -4607,5 +4648,5 @@ * and compute gardj*/ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face). - tria->GradjB(grad_g,analysis_type,sub_analysis_type); + tria->GradjB(grad_g); delete tria; return; @@ -4614,5 +4655,5 @@ /*B is a 2d field, use MacAyeal(2d) gradient even if it is Stokes or Pattyn*/ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face). - tria->GradjB(grad_g,analysis_type,sub_analysis_type); + tria->GradjB(grad_g); delete tria; return; @@ -4621,10 +4662,10 @@ /*}}}*/ /*FUNCTION Penta::MassFlux {{{1*/ -double Penta::MassFlux( double* segment,double* ug){ +double Penta::MassFlux( double* segment){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Penta::Misfit {{{1*/ -double Penta::Misfit(int analysis_type,int sub_analysis_type){ +double Penta::Misfit(void){ double J; @@ -4657,5 +4698,5 @@ * and compute Misfit*/ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face). - J=tria->Misfit(analysis_type,sub_analysis_type); + J=tria->Misfit(); delete tria; return J; @@ -4664,5 +4705,5 @@ tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face). - J=tria->Misfit(analysis_type,sub_analysis_type); + J=tria->Misfit(); delete tria; return J; @@ -4771,5 +4812,5 @@ /*}}}1*/ /*FUNCTION Penta::SurfaceArea {{{1*/ -double Penta::SurfaceArea(int analysis_type,int sub_analysis_type){ +double Penta::SurfaceArea(void){ double S; @@ -4802,5 +4843,5 @@ * and compute SurfaceArea*/ tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face). - S=tria->SurfaceArea(analysis_type,sub_analysis_type); + S=tria->SurfaceArea(); delete tria; return S; @@ -4809,5 +4850,5 @@ tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face). - S=tria->SurfaceArea(analysis_type,sub_analysis_type); + S=tria->SurfaceArea(); delete tria; return S; @@ -4953,4 +4994,6 @@ void Penta::MinVel(double* pminvel, bool process_units){ + int i; + int dim; const int numgrids=6; 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}}; @@ -4971,8 +5014,8 @@ /*now, compute minimum of velocity :*/ if(dim==2){ - for(i=0;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute minimum:*/ + minvx=vx_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute maximum:*/ + maxvx=vx_values[0]; + for(i=1;imaxvx)maxvx=vx_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvx=maxvx; + +} +/*}}}*/ +/*FUNCTION Penta::MaxAbsVx(double* pmaxabsvx, bool process_units);{{{1*/ +void Penta::MaxAbsVx(double* pmaxabsvx, bool process_units){ + + int i; + int dim; + const int numgrids=6; + 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}}; + double vx_values[numgrids]; + double maxabsvx; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute maximum:*/ + maxabsvx=fabs(vx_values[0]); + for(i=1;imaxabsvx)maxabsvx=fabs(vx_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvx=maxabsvx; +} +/*}}}*/ +/*FUNCTION Penta::MinVy(double* pminvy, bool process_units);{{{1*/ +void Penta::MinVy(double* pminvy, bool process_units){ + + int i; + int dim; + const int numgrids=6; + 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}}; + double vy_values[numgrids]; + double minvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute minimum:*/ + minvy=vy_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute maximum:*/ + maxvy=vy_values[0]; + for(i=1;imaxvy)maxvy=vy_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvy=maxvy; + +} +/*}}}*/ +/*FUNCTION Penta::MaxAbsVy(double* pmaxabsvy, bool process_units);{{{1*/ +void Penta::MaxAbsVy(double* pmaxabsvy, bool process_units){ + + int i; + int dim; + const int numgrids=6; + 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}}; + double vy_values[numgrids]; + double maxabsvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute maximum:*/ + maxabsvy=fabs(vy_values[0]); + for(i=1;imaxabsvy)maxabsvy=fabs(vy_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvy=maxabsvy; +} +/*}}}*/ +/*FUNCTION Penta::MinVz(double* pminvz, bool process_units);{{{1*/ +void Penta::MinVz(double* pminvz, bool process_units){ + + int i; + int dim; + const int numgrids=6; + 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}}; + double vz_values[numgrids]; + double minvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute minimum:*/ + minvz=vz_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute maximum:*/ + maxvz=vz_values[0]; + for(i=1;imaxvz)maxvz=vz_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvz=maxvz; + +} +/*}}}*/ +/*FUNCTION Penta::MaxAbsVz(double* pmaxabsvz, bool process_units);{{{1*/ +void Penta::MaxAbsVz(double* pmaxabsvz, bool process_units){ + + int i; + int dim; + const int numgrids=6; + 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}}; + double vz_values[numgrids]; + double maxabsvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute maximum:*/ + maxabsvz=fabs(vz_values[0]); + for(i=1;imaxabsvz)maxabsvz=fabs(vz_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvz=maxabsvz; +} +/*}}}*/ +/*FUNCTION Penta::ReinitializeInput(int reinitialized_enum,int original_enum){{{1*/ +void Penta::ReinitializeInput(int reinitialized_enum,int original_enum){ + + Input* original=NULL; + Input* copy=NULL; + + /*Make a copy of the original input: */ + original=(Input*)this->inputs->GetInput(original_enum); + copy=(Input*)original->copy(); + + /*Change copy enum to reinitialized_enum: */ + copy->ChangeEnum(reinitialized_enum); + + /*Add copy into inputs, it will wipe off the one already there: */ + inputs->AddObject((Input*)copy); +} +/*}}}*/ Index: /issm/trunk/src/c/objects/Elements/Penta.h =================================================================== --- /issm/trunk/src/c/objects/Elements/Penta.h (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Penta.h (revision 4043) @@ -70,13 +70,13 @@ /*}}}*/ /*FUNCTION element numerical routines {{{1*/ - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixDiagnosticHoriz( Mat Kgg, int analysis_type,int sub_analysis_type); - void CreateKMatrixDiagnosticHutter( Mat Kgg, int analysis_type,int sub_analysis_type); - void CreateKMatrixDiagnosticVert( Mat Kgg, int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); - void GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type); - void GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type); - void GetSolutionFromInputsDiagnosticVert(Vec solution,int analysis_type,int sub_analysis_type); - void GetSolutionFromInputsDiagnosticStokes(Vec solution,int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kggg); + void CreateKMatrixDiagnosticHoriz( Mat Kgg); + void CreateKMatrixDiagnosticHutter( Mat Kgg); + void CreateKMatrixDiagnosticVert( Mat Kgg); + void CreatePVector(Vec pg); + void GetSolutionFromInputs(Vec solution); + void GetSolutionFromInputsDiagnosticHoriz(Vec solutiong); + void GetSolutionFromInputsDiagnosticVert(Vec solutiong); + void GetSolutionFromInputsDiagnosticStokes(Vec solutiong); void GetDofList(int* doflist,int* pnumberofdofs); void GetDofList1(int* doflist); @@ -85,15 +85,13 @@ void GetNodes(void** nodes); bool GetOnBed(); - void Du(Vec du_g,int analysis_type,int sub_analysis_type); - void Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type); - void GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type); - void GradjB(Vec grad_g,int analysis_type,int sub_analysis_type); - double Misfit(int analysis_type,int sub_analysis_type); - double SurfaceArea(int analysis_type,int sub_analysis_type); - double CostFunction(int analysis_type,int sub_analysis_type); - - void GetThicknessList(double* thickness_list); - void GetBedList(double* bed_list); - + void Du(Vec du_gg); + void Gradj(Vec grad_gg,int control_type); + void GradjDrag(Vec grad_gg); + void GradjB(Vec grad_gg); + double Misfit(void); + double SurfaceArea(void); + double CostFunction(void); + void GetThicknessList(double* thickness_list); + void GetBedList(double* bed_list); void GetStrainRate(double* epsilon, double* velocity, double* xyz_list, double* gauss_coord); void GetB(double* pB, double* xyz_list, double* gauss_coord); @@ -106,7 +104,7 @@ void GetNodalFunctionsDerivativesReference(double* dl1dl6,double* gauss_coord); void GetJacobianInvert(double* Jinv, double* xyz_list,double* gauss_coord); - void CreatePVectorDiagnosticHoriz( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticHutter( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticVert( Vec pg, int analysis_type,int sub_analysis_type); + void CreatePVectorDiagnosticHoriz( Vec pg); + void CreatePVectorDiagnosticHutter( Vec pg); + void CreatePVectorDiagnosticVert( Vec pg); void GetParameterValue(double* pvalue, double* v_list,double* gauss_coord); void GetParameterDerivativeValue(double* p, double* p_list,double* xyz_list, double* gauss_coord); @@ -115,17 +113,17 @@ void InputExtrude(int enum_type); void DepthAverageInputAtBase(int enum_type); - void ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type); - void ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type); - void ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type); - void CreateKMatrixSlopeCompute(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorSlopeCompute( Vec pg, int analysis_type,int sub_analysis_type); - void CreateKMatrixPrognostic(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorPrognostic( Vec pg, int analysis_type,int sub_analysis_type); - void CreateKMatrixBalancedthickness(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixBalancedvelocities(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixDiagnosticStokes( Mat Kgg, int analysis_type,int sub_analysis_type); - void CreatePVectorBalancedthickness( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorBalancedvelocities( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticStokes( Vec pg, int analysis_type,int sub_analysis_type); + void ComputeBasalStress(Vec sigma_bg); + void ComputePressure(Vec p_gg); + void ComputeStrainRate(Vec epsg); + void CreateKMatrixSlopeCompute(Mat Kggg); + void CreatePVectorSlopeCompute( Vec pg); + void CreateKMatrixPrognostic(Mat Kggg); + void CreatePVectorPrognostic( Vec pg); + void CreateKMatrixBalancedthickness(Mat Kggg); + void CreateKMatrixBalancedvelocities(Mat Kggg); + void CreateKMatrixDiagnosticStokes( Mat Kgg); + void CreatePVectorBalancedthickness( Vec pg); + void CreatePVectorBalancedvelocities( Vec pg); + void CreatePVectorDiagnosticStokes( Vec pg); void ReduceMatrixStokes(double* Ke_reduced, double* Ke_temp); void GetMatrixInvert(double* Ke_invert, double* Ke); @@ -140,30 +138,41 @@ void ReduceVectorStokes(double* Pe_reduced, double* Ke_temp, double* Pe_temp); void GetNodalFunctionsStokes(double* l1l7, double* gauss_coord); - void CreateKMatrixThermal(Mat Kgg,int analysis_type,int sub_analysis_type); + void CreateKMatrixThermal(Mat Kggg); void GetB_conduct(double* B_conduct, double* xyz_list, double* gauss_coord); void GetB_advec(double* B_advec, double* xyz_list, double* gauss_coord); void GetBprime_advec(double* Bprime_advec, double* xyz_list, double* gauss_coord); void GetB_artdiff(double* B_artdiff, double* xyz_list, double* gauss_coord); - void CreateKMatrixMelting(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorThermal( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorMelting( Vec pg, int analysis_type,int sub_analysis_type); + void CreateKMatrixMelting(Mat Kggg); + void CreatePVectorThermal( Vec pg); + void CreatePVectorMelting( Vec pg); void GetPhi(double* phi, double* epsilon, double viscosity); - double MassFlux(double* segment,double* ug); + double MassFlux(double* segment); void PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes); void PatchFill(int* pcount, Patch* patch); void MinVel(double* pminvel, bool process_units); void MaxVel(double* pmaxvel, bool process_units); + void MinVx(double* pminvx, bool process_units); + void MaxVx(double* pmaxvx, bool process_units); + void MaxAbsVx(double* pmaxabsvx, bool process_units); + void MinVy(double* pminvy, bool process_units); + void MaxVy(double* pmaxvy, bool process_units); + void MaxAbsVy(double* pmaxabsvy, bool process_units); + void MinVz(double* pminvz, bool process_units); + void MaxVz(double* pmaxvz, bool process_units); + void MaxAbsVz(double* pmaxabsvz, bool process_units); + void ReinitializeInput(int reinitialized_enum,int original_enum); + /*updates: */ void UpdateFromDakota(void* inputs); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type); - void UpdateInputsFromSolutionDiagnosticHoriz( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionDiagnosticStokes( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionSlopeCompute( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionPrognostic( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionPrognostic2(double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionBalancedthickness( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionBalancedthickness2( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionBalancedvelocities( double* solution,int analysis_type,int sub_analysis_type); + void UpdateInputsFromSolution(double* solutiong); + void UpdateInputsFromSolutionDiagnosticHoriz( double* solutiong); + void UpdateInputsFromSolutionDiagnosticStokes( double* solutiong); + void UpdateInputsFromSolutionSlopeCompute( double* solutiong); + void UpdateInputsFromSolutionPrognostic( double* solutiong); + void UpdateInputsFromSolutionPrognostic2(double* solutiong); + void UpdateInputsFromSolutionBalancedthickness( double* solutiong); + void UpdateInputsFromSolutionBalancedthickness2( double* solutiong); + void UpdateInputsFromSolutionBalancedvelocities( double* solutiong); void UpdateInputsFromVector(double* vector, int name, int type); void UpdateInputsFromVector(int* vector, int name, int type); Index: /issm/trunk/src/c/objects/Elements/Sing.cpp =================================================================== --- /issm/trunk/src/c/objects/Elements/Sing.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Sing.cpp (revision 4043) @@ -128,10 +128,10 @@ /*}}}*/ /*FUNCTION Sing::UpdateInputsFromSolution {{{1*/ -void Sing::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ - ISSMERROR(" not supported yet!"); -} -/*}}}*/ -/*FUNCTION Sing::GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type);{{{1*/ -void Sing::GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type){ +void Sing::UpdateInputsFromSolution(double* solution){ + ISSMERROR(" not supported yet!"); +} +/*}}}*/ +/*FUNCTION Sing::GetSolutionFromInputs(Vec solution);{{{1*/ +void Sing::GetSolutionFromInputs(Vec solution){ ISSMERROR(" not supported yet!"); } @@ -150,5 +150,5 @@ /*Object functions*/ /*FUNCTION Sing::ComputeBasalStress {{{1*/ -void Sing::ComputeBasalStress(Vec p_g,int analysis_type,int sub_analysis_type){ +void Sing::ComputeBasalStress(Vec p_g){ ISSMERROR("Not implemented yet"); @@ -157,5 +157,5 @@ /*}}}*/ /*FUNCTION Sing::ComputePressure {{{1*/ -void Sing::ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type){ +void Sing::ComputePressure(Vec p_g){ int dof; @@ -179,5 +179,5 @@ /*}}}*/ /*FUNCTION Sing::ComputeStrainRate {{{1*/ -void Sing::ComputeStrainRate(Vec p_g,int analysis_type,int sub_analysis_type){ +void Sing::ComputeStrainRate(Vec p_g){ ISSMERROR("Not implemented yet"); @@ -186,5 +186,5 @@ /*}}}*/ /*FUNCTION Sing::CostFunction {{{1*/ -double Sing::CostFunction( int,int){ +double Sing::CostFunction(){ ISSMERROR(" not supported yet!"); } @@ -192,10 +192,16 @@ /*FUNCTION Sing::CreateKMatrix {{{1*/ -void Sing::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Sing::CreateKMatrix(Mat Kgg){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ if ((analysis_type==DiagnosticAnalysisEnum) && (sub_analysis_type==HutterAnalysisEnum)){ - CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHutter( Kgg); } @@ -207,5 +213,5 @@ /*}}}*/ /*FUNCTION Sing::CreateKMatrixDiagnosticHutter {{{1*/ -void Sing::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Sing::CreateKMatrixDiagnosticHutter(Mat Kgg){ const int numgrids=1; @@ -229,10 +235,16 @@ /*}}}*/ /*FUNCTION Sing::CreatePVector {{{1*/ -void Sing::CreatePVector(Vec pg,int analysis_type,int sub_analysis_type){ +void Sing::CreatePVector(Vec pg){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */ if ((analysis_type==DiagnosticAnalysisEnum) && (sub_analysis_type==HutterAnalysisEnum)){ - CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHutter( pg); } @@ -244,5 +256,5 @@ /*}}}*/ /*FUNCTION Sing::CreatePVectorDiagnosticHutter {{{1*/ -void Sing::CreatePVectorDiagnosticHutter( Vec pg, int analysis_type,int sub_analysis_type){ +void Sing::CreatePVectorDiagnosticHutter( Vec pg){ const int numgrids=1; @@ -294,5 +306,5 @@ /*}}}*/ /*FUNCTION Sing::Du {{{1*/ -void Sing::Du(Vec,int,int){ +void Sing::Du(Vec){ ISSMERROR(" not supported yet!"); } @@ -371,25 +383,25 @@ /*}}}*/ /*FUNCTION Sing::Gradj {{{1*/ -void Sing::Gradj(Vec, int, int ,int){ +void Sing::Gradj(Vec, int control_type){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Sing::GradB {{{1*/ -void Sing::GradjB(Vec, int,int){ +void Sing::GradjB(Vec){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Sing::GradjDrag {{{1*/ -void Sing::GradjDrag(Vec, int,int){ +void Sing::GradjDrag(Vec){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Sing::MassFlux {{{1*/ -double Sing::MassFlux( double* segment,double* ug){ +double Sing::MassFlux( double* segment){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Sing::Misfit {{{1*/ -double Sing::Misfit( int,int){ +double Sing::Misfit(void){ ISSMERROR(" not supported yet!"); } @@ -402,5 +414,5 @@ /*}}}*/ /*FUNCTION Sing::SurfaceArea {{{1*/ -double Sing::SurfaceArea( int,int){ +double Sing::SurfaceArea( void){ ISSMERROR(" not supported yet!"); } @@ -463,4 +475,5 @@ void Sing::MinVel(double* pminvel, bool process_units){ + int dim; double vx; double vy; @@ -489,4 +502,5 @@ void Sing::MaxVel(double* pmaxvel, bool process_units){ + int dim; double vx; double vy; @@ -512,2 +526,172 @@ } /*}}}*/ +/*FUNCTION Sing::MinVx(double* pminvx, bool process_units);{{{1*/ +void Sing::MinVx(double* pminvx, bool process_units){ + + int dim; + double minvx; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&minvx,VxEnum); + + /*Assign output pointers:*/ + *pminvx=minvx; + +} +/*}}}*/ +/*FUNCTION Sing::MaxVx(double* pmaxvx, bool process_units);{{{1*/ +void Sing::MaxVx(double* pmaxvx, bool process_units){ + + int dim; + double maxvx; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&maxvx,VxEnum); + + /*Assign output pointers:*/ + *pmaxvx=maxvx; + +} +/*}}}*/ +/*FUNCTION Sing::MaxAbsVx(double* pmaxabsvx, bool process_units);{{{1*/ +void Sing::MaxAbsVx(double* pmaxabsvx, bool process_units){ + + int dim; + double maxabsvx; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&maxabsvx,VxEnum); + maxabsvx=fabs(maxabsvx); + + /*Assign output pointers:*/ + *pmaxabsvx=maxabsvx; +} +/*}}}*/ +/*FUNCTION Sing::MinVy(double* pminvy, bool process_units);{{{1*/ +void Sing::MinVy(double* pminvy, bool process_units){ + + int dim; + double minvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&minvy,VyEnum); + + /*Assign output pointers:*/ + *pminvy=minvy; + +} +/*}}}*/ +/*FUNCTION Sing::MaxVy(double* pmaxvy, bool process_units);{{{1*/ +void Sing::MaxVy(double* pmaxvy, bool process_units){ + + int dim; + double maxvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&maxvy,VyEnum); + + /*Assign output pointers:*/ + *pmaxvy=maxvy; + +} +/*}}}*/ +/*FUNCTION Sing::MaxAbsVy(double* pmaxabsvy, bool process_units);{{{1*/ +void Sing::MaxAbsVy(double* pmaxabsvy, bool process_units){ + + int dim; + double maxabsvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&maxabsvy,VyEnum); + maxabsvy=fabs(maxabsvy); + + /*Assign output pointers:*/ + *pmaxabsvy=maxabsvy; +} +/*}}}*/ +/*FUNCTION Sing::MinVz(double* pminvz, bool process_units);{{{1*/ +void Sing::MinVz(double* pminvz, bool process_units){ + + int dim; + double minvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&minvz,VzEnum); + + /*Assign output pointers:*/ + *pminvz=minvz; + +} +/*}}}*/ +/*FUNCTION Sing::MaxVz(double* pmaxvz, bool process_units);{{{1*/ +void Sing::MaxVz(double* pmaxvz, bool process_units){ + + int dim; + double maxvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&maxvz,VzEnum); + + /*Assign output pointers:*/ + *pmaxvz=maxvz; + +} +/*}}}*/ +/*FUNCTION Sing::MaxAbsVz(double* pmaxabsvz, bool process_units);{{{1*/ +void Sing::MaxAbsVz(double* pmaxabsvz, bool process_units){ + + int dim; + double maxabsvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValue(&maxabsvz,VzEnum); + maxabsvz=fabs(maxabsvz); + + /*Assign output pointers:*/ + *pmaxabsvz=maxabsvz; +} +/*}}}*/ +/*FUNCTION Sing::ReinitializeInput(int reinitialized_enum,int original_enum){{{1*/ +void Sing::ReinitializeInput(int reinitialized_enum,int original_enum){ + + Input* original=NULL; + Input* copy=NULL; + + /*Make a copy of the original input: */ + original=(Input*)this->inputs->GetInput(original_enum); + copy=(Input*)original->copy(); + + /*Change copy enum to reinitialized_enum: */ + copy->ChangeEnum(reinitialized_enum); + + /*Add copy into inputs, it will wipe off the one already there: */ + inputs->AddObject((Input*)copy); +} +/*}}}*/ Index: /issm/trunk/src/c/objects/Elements/Sing.h =================================================================== --- /issm/trunk/src/c/objects/Elements/Sing.h (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Sing.h (revision 4043) @@ -61,5 +61,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type); + void UpdateInputsFromSolution(double* solutiong); void DepthAverageInputAtBase(int enum_type){ISSMERROR("not implemented yet");}; void InputToResult(int enum_type,int step,double time); @@ -67,16 +67,16 @@ /*}}}*/ /*numerics: {{{1*/ - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kggg); + void CreatePVector(Vec pg); void GetDofList(int* doflist,int* pnumberofdofs); - void GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type); + void GetSolutionFromInputs(Vec solution); void GetDofList1(int* doflist); - void CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type); + void CreateKMatrixDiagnosticHutter(Mat Kggg); void GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3); - void CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type); + void CreatePVectorDiagnosticHutter(Vec pgg); void* GetMatPar(); - void ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type); - void ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type); - void ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type); + void ComputeBasalStress(Vec sigma_bg); + void ComputePressure(Vec p_gg); + void ComputeStrainRate(Vec epsg); void GetNodes(void** vpnodes); void PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes); @@ -84,4 +84,15 @@ void MinVel(double* pminvel, bool process_units); void MaxVel(double* pmaxvel, bool process_units); + void MinVx(double* pminvx, bool process_units); + void MaxVx(double* pmaxvx, bool process_units); + void MaxAbsVx(double* pmaxabsvx, bool process_units); + void MinVy(double* pminvy, bool process_units); + void MaxVy(double* pmaxvy, bool process_units); + void MaxAbsVy(double* pmaxabsvy, bool process_units); + void MinVz(double* pminvz, bool process_units); + void MaxVz(double* pmaxvz, bool process_units); + void MaxAbsVz(double* pmaxabsvz, bool process_units); + void ReinitializeInput(int reinitialized_enum,int original_enum); + /*}}}*/ @@ -91,12 +102,12 @@ void GetBedList(double*); void GetThicknessList(double* thickness_list); - void Du(Vec,int,int); - void Gradj(Vec, int, int,int); - void GradjDrag(Vec , int,int); - void GradjB(Vec, int,int); - double Misfit(int,int); - double SurfaceArea(int,int); - double CostFunction(int,int); - double MassFlux(double* segment,double* ug); + void Du(Vec); + void Gradj(Vec, int control_type); + void GradjDrag(Vec); + void GradjB(Vec); + double Misfit(void); + double SurfaceArea(void); + double CostFunction(void); + double MassFlux(double* segment); /*}}}*/ Index: /issm/trunk/src/c/objects/Elements/Tria.cpp =================================================================== --- /issm/trunk/src/c/objects/Elements/Tria.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Tria.cpp (revision 4043) @@ -551,33 +551,39 @@ /*}}}*/ /*FUNCTION Tria::UpdateInputsFromSolution {{{1*/ -void Tria::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ +void Tria::UpdateInputsFromSolution(double* solution){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */ if (analysis_type==ControlAnalysisEnum){ - UpdateInputsFromSolutionDiagnosticHoriz( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionDiagnosticHoriz( solution); } else if (analysis_type==DiagnosticAnalysisEnum){ if (sub_analysis_type==HorizAnalysisEnum){ - UpdateInputsFromSolutionDiagnosticHoriz( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionDiagnosticHoriz( solution); } else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet"); } else if (analysis_type==SlopeComputeAnalysisEnum){ - UpdateInputsFromSolutionSlopeCompute( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionSlopeCompute( solution); } else if (analysis_type==PrognosticAnalysisEnum){ - UpdateInputsFromSolutionPrognostic( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionPrognostic( solution); } else if (analysis_type==Prognostic2AnalysisEnum){ - UpdateInputsFromSolutionPrognostic2(solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionPrognostic2(solution); } else if (analysis_type==BalancedthicknessAnalysisEnum){ - UpdateInputsFromSolutionBalancedthickness( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionBalancedthickness( solution); } else if (analysis_type==Balancedthickness2AnalysisEnum){ - UpdateInputsFromSolutionBalancedthickness2( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionBalancedthickness2( solution); } else if (analysis_type==BalancedvelocitiesAnalysisEnum){ - UpdateInputsFromSolutionBalancedvelocities( solution,analysis_type,sub_analysis_type); + UpdateInputsFromSolutionBalancedvelocities( solution); } else{ @@ -587,5 +593,5 @@ /*}}}*/ /*FUNCTION Tria::UpdateInputsFromSolutionDiagnosticHoriz {{{1*/ -void Tria::UpdateInputsFromSolutionDiagnosticHoriz(double* solution, int analysis_type, int sub_analysis_type){ +void Tria::UpdateInputsFromSolutionDiagnosticHoriz(double* solution){ int i; @@ -647,10 +653,10 @@ /*}}}*/ /*FUNCTION Tria::UpdateInputsFromSolutionSlopeCompute {{{1*/ -void Tria::UpdateInputsFromSolutionSlopeCompute(double* solution, int analysis_type, int sub_analysis_type){ +void Tria::UpdateInputsFromSolutionSlopeCompute(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Tria::UpdateInputsFromSolutionPrognostic {{{1*/ -void Tria::UpdateInputsFromSolutionPrognostic(double* solution, int analysis_type, int sub_analysis_type){ +void Tria::UpdateInputsFromSolutionPrognostic(double* solution){ int i; @@ -679,10 +685,10 @@ /*}}}*/ /*FUNCTION Tria::UpdateInputsFromSolutionPrognostic2 {{{1*/ -void Tria::UpdateInputsFromSolutionPrognostic2(double* solution, int analysis_type, int sub_analysis_type){ +void Tria::UpdateInputsFromSolutionPrognostic2(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Tria::UpdateInputsFromSolutionBalancedthickness {{{1*/ -void Tria::UpdateInputsFromSolutionBalancedthickness(double* solution, int analysis_type, int sub_analysis_type){ +void Tria::UpdateInputsFromSolutionBalancedthickness(double* solution){ int i; @@ -711,19 +717,26 @@ /*}}}*/ /*FUNCTION Tria::UpdateInputsFromSolutionBalancedthickness2 {{{1*/ -void Tria::UpdateInputsFromSolutionBalancedthickness2(double* solution, int analysis_type, int sub_analysis_type){ +void Tria::UpdateInputsFromSolutionBalancedthickness2(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ /*FUNCTION Tria::UpdateInputsFromSolutionBalancedvelocities {{{1*/ -void Tria::UpdateInputsFromSolutionBalancedvelocities(double* solution, int analysis_type, int sub_analysis_type){ +void Tria::UpdateInputsFromSolutionBalancedvelocities(double* solution){ ISSMERROR(" not supported yet!"); } /*}}}*/ -/*FUNCTION Tria::GetSolutionFromInputs(Vec solution,int analysis_type,int sub_analysis_type){{{1*/ -void Tria::GetSolutionFromInputs(Vec solution,int analysis_type,int sub_analysis_type){ +/*FUNCTION Tria::GetSolutionFromInputs(Vec solution){{{1*/ +void Tria::GetSolutionFromInputs(Vec solution){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); + /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */ if (analysis_type==DiagnosticAnalysisEnum){ if (sub_analysis_type==HorizAnalysisEnum){ - GetSolutionFromInputsDiagnosticHoriz(solution,analysis_type,sub_analysis_type); + GetSolutionFromInputsDiagnosticHoriz(solution); } else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet"); @@ -734,6 +747,6 @@ } /*}}}*/ -/*FUNCTION Tria::GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type){{{1*/ -void Tria::GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type){ +/*FUNCTION Tria::GetSolutionFromInputsDiagnosticHoriz(Vec solution){{{1*/ +void Tria::GetSolutionFromInputsDiagnosticHoriz(Vec solution){ int i; @@ -782,5 +795,5 @@ /*}}}*/ /*FUNCTION Tria::ComputeBasalStress {{{1*/ -void Tria::ComputeBasalStress(Vec eps,int analysis_type,int sub_analysis_type){ +void Tria::ComputeBasalStress(Vec eps){ int i; @@ -796,5 +809,5 @@ /*}}}*/ /*FUNCTION Tria::ComputePressure {{{1*/ -void Tria::ComputePressure(Vec pg,int analysis_type,int sub_analysis_type){ +void Tria::ComputePressure(Vec pg){ int i; @@ -826,5 +839,5 @@ /*}}}*/ /*FUNCTION Tria::ComputeStrainRate {{{1*/ -void Tria::ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type){ +void Tria::ComputeStrainRate(Vec eps){ int i; @@ -840,5 +853,5 @@ /*}}}*/ /*FUNCTION Tria::CostFunction {{{1*/ -double Tria::CostFunction(int analysis_type,int sub_analysis_type){ +double Tria::CostFunction(void){ int i; @@ -897,5 +910,5 @@ /*First, get Misfit*/ - Jelem=Misfit(analysis_type,sub_analysis_type); + Jelem=Misfit(); /* Get gaussian points and weights (make this a statically initialized list of points? fstd): */ @@ -941,5 +954,11 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrix {{{1*/ -void Tria::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrix(Mat Kgg){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /*asserts: {{{2*/ @@ -949,32 +968,32 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ if (analysis_type==ControlAnalysisEnum){ - CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHoriz( Kgg); } else if (analysis_type==DiagnosticAnalysisEnum){ if (sub_analysis_type==HorizAnalysisEnum){ - CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHoriz( Kgg); } else if (sub_analysis_type==HutterAnalysisEnum){ - CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHutter( Kgg); } else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet"); } else if (analysis_type==SlopeComputeAnalysisEnum){ - CreateKMatrixSlopeCompute( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixSlopeCompute( Kgg); } else if (analysis_type==PrognosticAnalysisEnum){ - CreateKMatrixPrognostic( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixPrognostic( Kgg); } else if (analysis_type==Prognostic2AnalysisEnum){ - CreateKMatrixPrognostic2(Kgg,analysis_type,sub_analysis_type); + CreateKMatrixPrognostic2(Kgg); } else if (analysis_type==BalancedthicknessAnalysisEnum){ - CreateKMatrixBalancedthickness( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixBalancedthickness( Kgg); } else if (analysis_type==Balancedthickness2AnalysisEnum){ - CreateKMatrixBalancedthickness2( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixBalancedthickness2( Kgg); } else if (analysis_type==BalancedvelocitiesAnalysisEnum){ - CreateKMatrixBalancedvelocities( Kgg,analysis_type,sub_analysis_type); + CreateKMatrixBalancedvelocities( Kgg); } else{ @@ -985,5 +1004,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixBalancedthickness {{{1*/ -void Tria::CreateKMatrixBalancedthickness(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixBalancedthickness(Mat Kgg){ /* local declarations */ @@ -1141,5 +1160,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixBalancedthickness2 {{{1*/ -void Tria::CreateKMatrixBalancedthickness2(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixBalancedthickness2(Mat Kgg){ /* local declarations */ @@ -1233,5 +1252,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixBalancedvelocities {{{1*/ -void Tria::CreateKMatrixBalancedvelocities(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixBalancedvelocities(Mat Kgg){ /* local declarations */ @@ -1401,5 +1420,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixDiagnosticHoriz {{{1*/ -void Tria::CreateKMatrixDiagnosticHoriz(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixDiagnosticHoriz(Mat Kgg){ /* local declarations */ @@ -1522,5 +1541,5 @@ /*Do not forget to include friction: */ if(!shelf){ - CreateKMatrixDiagnosticHorizFriction(Kgg,analysis_type,sub_analysis_type); + CreateKMatrixDiagnosticHorizFriction(Kgg); } @@ -1534,9 +1553,10 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixDiagnosticHorizFriction {{{1*/ -void Tria::CreateKMatrixDiagnosticHorizFriction(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixDiagnosticHorizFriction(Mat Kgg){ /* local declarations */ int i,j; + int analysis_type; /* node data: */ @@ -1582,4 +1602,7 @@ int drag_type; + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + /*retrieve inputs :*/ inputs->GetParameterValue(&shelf,ElementOnIceShelfEnum); @@ -1657,5 +1680,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixDiagnosticHutter{{{1*/ -void Tria::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixDiagnosticHutter(Mat Kgg){ /*Collapsed formulation: */ @@ -1675,5 +1698,5 @@ for(i=0;i<3;i++){ sing=(Sing*)SpawnSing(i); - sing->CreateKMatrix(Kgg,analysis_type,sub_analysis_type); + sing->CreateKMatrix(Kgg); } @@ -1684,5 +1707,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixDiagnosticSurfaceVert {{{1*/ -void Tria::CreateKMatrixDiagnosticSurfaceVert(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixDiagnosticSurfaceVert(Mat Kgg){ int i,j; @@ -1802,5 +1825,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixMelting {{{1*/ -void Tria::CreateKMatrixMelting(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixMelting(Mat Kgg){ /*indexing: */ @@ -1886,5 +1909,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixPrognostic {{{1*/ -void Tria::CreateKMatrixPrognostic(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixPrognostic(Mat Kgg){ /* local declarations */ @@ -2056,5 +2079,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixPrognostic2 {{{1*/ -void Tria::CreateKMatrixPrognostic2(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixPrognostic2(Mat Kgg){ /* local declarations */ @@ -2171,5 +2194,5 @@ /*FUNCTION Tria::CreateKMatrixSlopeCompute {{{1*/ -void Tria::CreateKMatrixSlopeCompute(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixSlopeCompute(Mat Kgg){ /* local declarations */ @@ -2248,5 +2271,5 @@ /*}}}*/ /*FUNCTION Tria::CreateKMatrixThermal {{{1*/ -void Tria::CreateKMatrixThermal(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Tria::CreateKMatrixThermal(Mat Kgg){ int i,j; @@ -2345,39 +2368,47 @@ /*}}}*/ /*FUNCTION Tria::CreatePVector {{{1*/ -void Tria::CreatePVector(Vec pg,int analysis_type,int sub_analysis_type){ - +void Tria::CreatePVector(Vec pg){ + + int analysis_type,sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); + + /*asserts: {{{*/ /*if debugging mode, check that all pointers exist*/ ISSMASSERT(this->nodes && this->matice && this->matpar && this->parameters && this->inputs); + /*}}}*/ /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */ if (analysis_type==ControlAnalysisEnum){ - CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHoriz( pg); } else if (analysis_type==DiagnosticAnalysisEnum){ if (sub_analysis_type==HorizAnalysisEnum){ - CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHoriz( pg); } else if (sub_analysis_type==HutterAnalysisEnum){ - CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHutter( pg); } else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet"); } else if (analysis_type==SlopeComputeAnalysisEnum){ - CreatePVectorSlopeCompute( pg,analysis_type,sub_analysis_type); + CreatePVectorSlopeCompute( pg); } else if (analysis_type==PrognosticAnalysisEnum){ - CreatePVectorPrognostic( pg,analysis_type,sub_analysis_type); + CreatePVectorPrognostic( pg); } else if (analysis_type==Prognostic2AnalysisEnum){ - CreatePVectorPrognostic2( pg,analysis_type,sub_analysis_type); + CreatePVectorPrognostic2( pg); } else if (analysis_type==BalancedthicknessAnalysisEnum){ - CreatePVectorBalancedthickness( pg,analysis_type,sub_analysis_type); + CreatePVectorBalancedthickness( pg); } else if (analysis_type==Balancedthickness2AnalysisEnum){ - CreatePVectorBalancedthickness2( pg,analysis_type,sub_analysis_type); + CreatePVectorBalancedthickness2( pg); } else if (analysis_type==BalancedvelocitiesAnalysisEnum){ - CreatePVectorBalancedvelocities( pg,analysis_type,sub_analysis_type); + CreatePVectorBalancedvelocities( pg); } else{ @@ -2388,5 +2419,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorBalancedthickness {{{1*/ -void Tria::CreatePVectorBalancedthickness(Vec pg ,int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorBalancedthickness(Vec pg ){ @@ -2462,5 +2493,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorBalancedthickness2 {{{1*/ -void Tria::CreatePVectorBalancedthickness2(Vec pg ,int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorBalancedthickness2(Vec pg){ @@ -2538,5 +2569,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorBalancedvelocities {{{1*/ -void Tria::CreatePVectorBalancedvelocities(Vec pg ,int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorBalancedvelocities(Vec pg){ @@ -2612,5 +2643,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorDiagnosticBaseVert {{{1*/ -void Tria::CreatePVectorDiagnosticBaseVert(Vec pg,int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorDiagnosticBaseVert(Vec pg){ int i,j; @@ -2710,5 +2741,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorDiagnosticHoriz {{{1*/ -void Tria::CreatePVectorDiagnosticHoriz( Vec pg, int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorDiagnosticHoriz( Vec pg){ int i,j; @@ -2828,5 +2859,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorDiagnosticHutter{{{1*/ -void Tria::CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorDiagnosticHutter(Vec pg){ /*Collapsed formulation: */ @@ -2846,5 +2877,5 @@ for(i=0;i<3;i++){ sing=(Sing*)SpawnSing(i); - sing->CreatePVector(pg,analysis_type,sub_analysis_type); + sing->CreatePVector(pg); } @@ -2855,5 +2886,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorPrognostic {{{1*/ -void Tria::CreatePVectorPrognostic(Vec pg ,int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorPrognostic(Vec pg){ @@ -2937,5 +2968,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorPrognostic2 {{{1*/ -void Tria::CreatePVectorPrognostic2(Vec pg ,int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorPrognostic2(Vec pg){ /* local declarations */ @@ -3017,5 +3048,5 @@ /*FUNCTION Tria::CreatePVectorSlopeCompute {{{1*/ -void Tria::CreatePVectorSlopeCompute( Vec pg, int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorSlopeCompute( Vec pg){ int i,j; @@ -3048,4 +3079,8 @@ double pe_g_gaussian[numdof]; double slope[2]; + int sub_analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum); /* Get node coordinates and dof list: */ @@ -3104,5 +3139,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorThermalShelf {{{1*/ -void Tria::CreatePVectorThermalShelf( Vec pg, int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorThermalShelf( Vec pg){ int i,found; @@ -3205,5 +3240,5 @@ /*}}}*/ /*FUNCTION Tria::CreatePVectorThermalSheet {{{1*/ -void Tria::CreatePVectorThermalSheet( Vec pg, int analysis_type,int sub_analysis_type){ +void Tria::CreatePVectorThermalSheet( Vec pg){ int i,found; @@ -3243,4 +3278,9 @@ double l1l2l3[numgrids]; double scalar; + + int analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); @@ -3309,5 +3349,5 @@ /*}}}*/ /*FUNCTION Tria::Du {{{1*/ -void Tria::Du(Vec du_g,int analysis_type,int sub_analysis_type){ +void Tria::Du(Vec du_g){ int i; @@ -4085,5 +4125,5 @@ /*}}}*/ /*FUNCTION Tria::Gradj {{{1*/ -void Tria::Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type){ +void Tria::Gradj(Vec grad_g,int control_type){ /*inputs: */ @@ -4097,8 +4137,8 @@ if (control_type==DragCoefficientEnum){ - GradjDrag( grad_g,analysis_type,sub_analysis_type); + GradjDrag( grad_g); } else if (control_type==RheologyBEnum){ - GradjB( grad_g,analysis_type,sub_analysis_type); + GradjB( grad_g); } else ISSMERROR("%s%i","control type not supported yet: ",control_type); @@ -4106,5 +4146,5 @@ /*}}}*/ /*FUNCTION Tria::GradjB{{{1*/ -void Tria::GradjB(Vec grad_g,int analysis_type,int sub_analysis_type){ +void Tria::GradjB(Vec grad_g){ int i; @@ -4252,5 +4292,5 @@ /*}}}*/ /*FUNCTION Tria::GradjDrag {{{1*/ -void Tria::GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type){ +void Tria::GradjDrag(Vec grad_g){ @@ -4311,4 +4351,9 @@ double cm_maxdmp_slope; + int analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + /*retrieve inputs :*/ inputs->GetParameterValue(&shelf,ElementOnIceShelfEnum); @@ -4408,5 +4453,5 @@ /*}}}*/ /*FUNCTION Tria::GradjDragStokes {{{1*/ -void Tria::GradjDragStokes(Vec grad_g,int analysis_type,int sub_analysis_type){ +void Tria::GradjDragStokes(Vec grad_g){ int i; @@ -4466,4 +4511,9 @@ double cm_maxdmp_slope; + int analysis_type; + + /*retrive parameters: */ + parameters->FindParam(&analysis_type,AnalysisTypeEnum); + /*retrieve inputs :*/ inputs->GetParameterValue(&shelf,ElementOnIceShelfEnum); @@ -4573,5 +4623,5 @@ /*}}}*/ /*FUNCTION Tria::MassFlux {{{1*/ -double Tria::MassFlux( double* segment,double* ug){ +double Tria::MassFlux( double* segment){ int i; @@ -4581,7 +4631,4 @@ int numberofdofspernode; double mass_flux=0; - int doflist[numgrids*numdofs]; - double vx_list[3]; - double vy_list[3]; double xyz_list[numgrids][3]; double gauss_1[3]; @@ -4606,11 +4653,4 @@ GetVerticesCoordinates(&xyz_list[0][0], nodes, numgrids); - /*recover velocity at three element nodes: */ - this->GetDofList(&doflist[0],&numberofdofspernode); - for(i=0;i<3;i++){ - vx_list[i]=ug[doflist[numberofdofspernode*i+0]]; - vy_list[i]=ug[doflist[numberofdofspernode*i+1]]; - } - /*get area coordinates of 0 and 1 locations: */ for(i=0;i<3;i++){ @@ -4642,5 +4682,5 @@ /*}}}*/ /*FUNCTION Tria::Misfit {{{1*/ -double Tria::Misfit(int analysis_type,int sub_analysis_type){ +double Tria::Misfit(void){ int i; @@ -4873,5 +4913,5 @@ /*}}}*/ /*FUNCTION Tria::SurfaceArea {{{1*/ -double Tria::SurfaceArea(int analysis_type,int sub_analysis_type){ +double Tria::SurfaceArea(void){ int i; @@ -5063,4 +5103,6 @@ void Tria::MinVel(double* pminvel, bool process_units){ + int i; + int dim; const int numgrids=3; double gaussgrids[numgrids][3]={{1,0,0},{0,1,0},{0,0,1}}; @@ -5081,8 +5123,8 @@ /*now, compute minimum of velocity :*/ if(dim==2){ - for(i=0;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute minimum:*/ + minvx=vx_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute maximum:*/ + maxvx=vx_values[0]; + for(i=1;imaxvx)maxvx=vx_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvx=maxvx; + +} +/*}}}*/ +/*FUNCTION Tria::MaxAbsVx(double* pmaxabsvx, bool process_units);{{{1*/ +void Tria::MaxAbsVx(double* pmaxabsvx, bool process_units){ + + int i; + int dim; + const int numgrids=3; + double gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}}; + double vx_values[numgrids]; + double maxabsvx; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum); + + /*now, compute maximum:*/ + maxabsvx=fabs(vx_values[0]); + for(i=1;imaxabsvx)maxabsvx=fabs(vx_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvx=maxabsvx; +} +/*}}}*/ +/*FUNCTION Tria::MinVy(double* pminvy, bool process_units);{{{1*/ +void Tria::MinVy(double* pminvy, bool process_units){ + + int i; + int dim; + const int numgrids=3; + double gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}}; + double vy_values[numgrids]; + double minvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute minimum:*/ + minvy=vy_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute maximum:*/ + maxvy=vy_values[0]; + for(i=1;imaxvy)maxvy=vy_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvy=maxvy; + +} +/*}}}*/ +/*FUNCTION Tria::MaxAbsVy(double* pmaxabsvy, bool process_units);{{{1*/ +void Tria::MaxAbsVy(double* pmaxabsvy, bool process_units){ + + int i; + int dim; + const int numgrids=3; + double gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}}; + double vy_values[numgrids]; + double maxabsvy; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum); + + /*now, compute maximum:*/ + maxabsvy=fabs(vy_values[0]); + for(i=1;imaxabsvy)maxabsvy=fabs(vy_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvy=maxabsvy; +} +/*}}}*/ +/*FUNCTION Tria::MinVz(double* pminvz, bool process_units);{{{1*/ +void Tria::MinVz(double* pminvz, bool process_units){ + + int i; + int dim; + const int numgrids=3; + double gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}}; + double vz_values[numgrids]; + double minvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute minimum:*/ + minvz=vz_values[0]; + for(i=1;iFindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute maximum:*/ + maxvz=vz_values[0]; + for(i=1;imaxvz)maxvz=vz_values[i]; + } + + /*Assign output pointers:*/ + *pmaxvz=maxvz; + +} +/*}}}*/ +/*FUNCTION Tria::MaxAbsVz(double* pmaxabsvz, bool process_units);{{{1*/ +void Tria::MaxAbsVz(double* pmaxabsvz, bool process_units){ + + int i; + int dim; + const int numgrids=3; + double gaussgrids[numgrids][numgrids]={{1,0,0},{0,1,0},{0,0,1}}; + double vz_values[numgrids]; + double maxabsvz; + + /*retrieve dim parameter: */ + parameters->FindParam(&dim,DimEnum); + + /*retrive velocity values at nodes */ + inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum); + + /*now, compute maximum:*/ + maxabsvz=fabs(vz_values[0]); + for(i=1;imaxabsvz)maxabsvz=fabs(vz_values[i]); + } + + /*Assign output pointers:*/ + *pmaxabsvz=maxabsvz; +} +/*}}}*/ +/*FUNCTION Tria::ReinitializeInput(int reinitialized_enum,int original_enum){{{1*/ +void Tria::ReinitializeInput(int reinitialized_enum,int original_enum){ + + Input* original=NULL; + Input* copy=NULL; + + /*Make a copy of the original input: */ + original=(Input*)this->inputs->GetInput(original_enum); + copy=(Input*)original->copy(); + + /*Change copy enum to reinitialized_enum: */ + copy->ChangeEnum(reinitialized_enum); + + /*Add copy into inputs, it will wipe off the one already there: */ + inputs->AddObject((Input*)copy); +} +/*}}}*/ Index: /issm/trunk/src/c/objects/Elements/Tria.h =================================================================== --- /issm/trunk/src/c/objects/Elements/Tria.h (revision 4042) +++ /issm/trunk/src/c/objects/Elements/Tria.h (revision 4043) @@ -45,13 +45,13 @@ void Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* materials,Parameters* parameters); Object* copy(); - void DeepEcho(); + void DeepEcho(void); void Demarshall(char** pmarshalled_dataset); - void Echo(); - int Enum(); - int Id(); + void Echo(void); + int Enum(void); + int Id(void); bool IsInput(int name); void Marshall(char** pmarshalled_dataset); - int MarshallSize(); - int MyRank(); + int MarshallSize(void); + int MyRank(void); void SetClone(int* minranks); void DepthAverageInputAtBase(int enum_type); @@ -62,15 +62,15 @@ /*}}}*/ /*FUNCTION element numerical routines {{{1*/ - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); - void GetSolutionFromInputs(Vec solution, int analysis_type,int sub_analysis_type); - void GetSolutionFromInputsDiagnosticHoriz(Vec solution,int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kgg); + void CreatePVector(Vec pg); + void GetSolutionFromInputs(Vec solution); + void GetSolutionFromInputsDiagnosticHoriz(Vec solution); void GetDofList(int* doflist,int* pnumberofdofs); void GetDofList1(int* doflist); - void CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixDiagnosticHoriz(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixDiagnosticHorizFriction(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixDiagnosticSurfaceVert(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixSlopeCompute(Mat Kgg,int analysis_type,int sub_analysis_type); + void CreateKMatrixDiagnosticHutter(Mat Kgg); + void CreateKMatrixDiagnosticHoriz(Mat Kgg); + void CreateKMatrixDiagnosticHorizFriction(Mat Kgg); + void CreateKMatrixDiagnosticSurfaceVert(Mat Kgg); + void CreateKMatrixSlopeCompute(Mat Kgg); void GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3); void GetParameterDerivativeValue(double* p, double* plist,double* xyz_list, double* gauss_l1l2l3); @@ -87,41 +87,41 @@ void GetJacobianInvert(double* Jinv, double* xyz_list,double* gauss_l1l2l3); void GetJacobian(double* J, double* xyz_list,double* gauss_l1l2l3); - void Du(Vec du_g,int analysis_type,int sub_analysis_type); - void Gradj(Vec grad_g,int analysis_type,int sub_analysis_type,int control_type); - void GradjDrag(Vec grad_g,int analysis_type,int sub_analysis_type); - void GradjDragStokes(Vec grad_g,int analysis_type,int sub_analysis_type); + void Du(Vec du_g); + void Gradj(Vec grad_g,int control_type); + void GradjDrag(Vec grad_g); + void GradjDragStokes(Vec grad_g); void SurfaceNormal(double* surface_normal, double xyz_list[3][3]); - void GradjB(Vec grad_g,int analysis_type,int sub_analysis_type); - double Misfit(int analysis_type,int sub_analysis_type); - double SurfaceArea(int analysis_type,int sub_analysis_type); - double CostFunction(int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticHoriz(Vec pg,int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticBaseVert(Vec pg,int analysis_type,int sub_analysis_type); - void CreatePVectorSlopeCompute( Vec pg, int analysis_type,int sub_analysis_type); - void* GetMatPar(); - bool GetShelf(); + void GradjB(Vec grad_g); + double Misfit(void); + double SurfaceArea(void); + double CostFunction(void); + void CreatePVectorDiagnosticHutter(Vec pg); + void CreatePVectorDiagnosticHoriz(Vec pg); + void CreatePVectorDiagnosticBaseVert(Vec pg); + void CreatePVectorSlopeCompute( Vec pg); + void* GetMatPar(void); + bool GetShelf(void); void GetNodes(void** nodes); - bool GetOnBed(); + bool GetOnBed(void); void GetThicknessList(double* thickness_list); void GetBedList(double* bed_list); - void ComputeBasalStress(Vec sigma_b,int analysis_type,int sub_analysis_type); - void ComputePressure(Vec p_g,int analysis_type,int sub_analysis_type); - void ComputeStrainRate(Vec eps,int analysis_type,int sub_analysis_type); - void CreateKMatrixThermal(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixMelting(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorThermalShelf( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorThermalSheet( Vec pg, int analysis_type,int sub_analysis_type); - void CreateKMatrixPrognostic(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorPrognostic(Vec pg,int analysis_type,int sub_analysis_type); - void CreateKMatrixPrognostic2(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorPrognostic2(Vec pg,int analysis_type,int sub_analysis_type); - void CreateKMatrixBalancedthickness(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorBalancedthickness(Vec pg,int analysis_type,int sub_analysis_type); - void CreateKMatrixBalancedthickness2(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorBalancedthickness2(Vec pg,int analysis_type,int sub_analysis_type); - void CreateKMatrixBalancedvelocities(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVectorBalancedvelocities(Vec pg,int analysis_type,int sub_analysis_type); - double MassFlux(double* segment,double* ug); + void ComputeBasalStress(Vec sigma_b); + void ComputePressure(Vec p_g); + void ComputeStrainRate(Vec eps); + void CreateKMatrixThermal(Mat Kgg); + void CreateKMatrixMelting(Mat Kgg); + void CreatePVectorThermalShelf( Vec pg); + void CreatePVectorThermalSheet( Vec pg); + void CreateKMatrixPrognostic(Mat Kgg); + void CreatePVectorPrognostic(Vec pg); + void CreateKMatrixPrognostic2(Mat Kgg); + void CreatePVectorPrognostic2(Vec pg); + void CreateKMatrixBalancedthickness(Mat Kgg); + void CreatePVectorBalancedthickness(Vec pg); + void CreateKMatrixBalancedthickness2(Mat Kgg); + void CreatePVectorBalancedthickness2(Vec pg); + void CreateKMatrixBalancedvelocities(Mat Kgg); + void CreatePVectorBalancedvelocities(Vec pg); + double MassFlux(double* segment); double GetArea(void); double GetAreaCoordinate(double x, double y, int which_one); @@ -130,16 +130,27 @@ void MinVel(double* pminvel, bool process_units); void MaxVel(double* pmaxvel, bool process_units); + void MinVx(double* pminvx, bool process_units); + void MaxVx(double* pmaxvx, bool process_units); + void MaxAbsVx(double* pmaxabsvx, bool process_units); + void MinVy(double* pminvy, bool process_units); + void MaxVy(double* pmaxvy, bool process_units); + void MaxAbsVy(double* pmaxabsvy, bool process_units); + void MinVz(double* pminvz, bool process_units); + void MaxVz(double* pmaxvz, bool process_units); + void MaxAbsVz(double* pmaxabsvz, bool process_units); + void ReinitializeInput(int reinitialized_enum,int original_enum); + /*}}}*/ /*FUNCTION updates{{{1*/ void UpdateFromDakota(void* inputs); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type); - void UpdateInputsFromSolutionDiagnosticHoriz( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionSlopeCompute( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionPrognostic( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionPrognostic2(double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionBalancedthickness( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionBalancedthickness2( double* solution,int analysis_type,int sub_analysis_type); - void UpdateInputsFromSolutionBalancedvelocities( double* solution,int analysis_type,int sub_analysis_type); + void UpdateInputsFromSolution(double* solutiong); + void UpdateInputsFromSolutionDiagnosticHoriz( double* solution); + void UpdateInputsFromSolutionSlopeCompute( double* solution); + void UpdateInputsFromSolutionPrognostic( double* solution); + void UpdateInputsFromSolutionPrognostic2(double* solution); + void UpdateInputsFromSolutionBalancedthickness( double* solution); + void UpdateInputsFromSolutionBalancedthickness2( double* solution); + void UpdateInputsFromSolutionBalancedvelocities( double* solution); void UpdateInputsFromVector(double* vector, int name, int type); void UpdateInputsFromVector(int* vector, int name, int type); Index: /issm/trunk/src/c/objects/Inputs/BeamVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/BeamVertexInput.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/BeamVertexInput.cpp (revision 4043) @@ -239,5 +239,5 @@ /*Process units if requested: */ - if(process)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters); + if(process_units)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters); /*Now, figure out minimum of valuescopy: */ Index: /issm/trunk/src/c/objects/Inputs/BeamVertexInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/BeamVertexInput.h (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/BeamVertexInput.h (revision 4043) @@ -43,5 +43,5 @@ void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Input* SpawnSingInput(int index); Index: /issm/trunk/src/c/objects/Inputs/BoolInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/BoolInput.h (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/BoolInput.h (revision 4043) @@ -43,5 +43,5 @@ void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Input* SpawnSingInput(int index); Index: /issm/trunk/src/c/objects/Inputs/DoubleInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/DoubleInput.h (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/DoubleInput.h (revision 4043) @@ -44,5 +44,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Input* SpawnSingInput(int index); Index: /issm/trunk/src/c/objects/Inputs/IntInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/IntInput.h (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/IntInput.h (revision 4043) @@ -43,5 +43,5 @@ void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Input* SpawnSingInput(int index); Index: /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp (revision 4043) @@ -888,5 +888,5 @@ /*Process units if requested: */ - if(process)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters); + if(process_units)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters); /*Now, figure out minimum of valuescopy: */ Index: /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h (revision 4043) @@ -42,5 +42,5 @@ void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Input* SpawnSingInput(int index); Index: /issm/trunk/src/c/objects/Inputs/SingVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/SingVertexInput.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/SingVertexInput.cpp (revision 4043) @@ -215,5 +215,5 @@ /*Process units if requested: */ - if(process)NodalValuesUnitConversion(&valuecopy,1,enum_type,parameters); + if(process_units)NodalValuesUnitConversion(&valuecopy,1,enum_type,parameters); /*Now, return square of value, because it is the minimum: */ Index: /issm/trunk/src/c/objects/Inputs/SingVertexInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/SingVertexInput.h (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/SingVertexInput.h (revision 4043) @@ -42,5 +42,5 @@ void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Input* SpawnSingInput(int index); Index: /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp (revision 4043) @@ -462,5 +462,5 @@ /*Process units if requested: */ - if(process)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters); + if(process_units)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters); /*Now, figure out minimum of valuescopy: */ Index: /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h (revision 4042) +++ /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h (revision 4043) @@ -42,5 +42,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Input* SpawnSingInput(int index); Index: /issm/trunk/src/c/objects/Loads/Icefront.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Icefront.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Icefront.cpp (revision 4043) @@ -278,5 +278,5 @@ /*FUNCTION Icefront::CreateKMatrix {{{1*/ -void Icefront::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Icefront::CreateKMatrix(Mat Kgg){ /*No stiffness loads applied, do nothing: */ @@ -287,10 +287,16 @@ /*}}}*/ /*FUNCTION Icefront::CreatePVector {{{1*/ -void Icefront::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){ +void Icefront::CreatePVector(Vec pg){ + + int analysis_type,sub_analysis_type; + + /*Retrieve parameters: */ + this->parameters->FindParam(&analysis_type,AnalysisTypeEnum); + this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum); /*Just branch to the correct element icefront vector generator, according to the type of analysis we are carrying out: */ if (analysis_type==ControlAnalysisEnum){ - CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHoriz( pg); } @@ -299,10 +305,10 @@ if (sub_analysis_type==HorizAnalysisEnum){ - CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHoriz( pg); } else if (sub_analysis_type==StokesAnalysisEnum){ - CreatePVectorDiagnosticStokes( pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticStokes( pg); } @@ -316,5 +322,5 @@ /*}}}*/ /*FUNCTION Icefront::CreatePVectorDiagnosticHoriz {{{1*/ -void Icefront::CreatePVectorDiagnosticHoriz( Vec pg, int analysis_type,int sub_analysis_type){ +void Icefront::CreatePVectorDiagnosticHoriz( Vec pg){ int type; @@ -323,8 +329,8 @@ /*Branck on the type of icefront: */ if (type==SegmentIcefrontEnum){ - CreatePVectorDiagnosticHorizSegment(pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHorizSegment(pg); } else if (type==QuadIceFrontEnum){ - CreatePVectorDiagnosticHorizQuad(pg,analysis_type,sub_analysis_type); + CreatePVectorDiagnosticHorizQuad(pg); } else ISSMERROR("type %i not supported",type); @@ -332,5 +338,5 @@ /*}}}*/ /*FUNCTION Icefront::CreatePVectorDiagnosticHorizSegment{{{1*/ -void Icefront::CreatePVectorDiagnosticHorizSegment( Vec pg,int analysis_type,int sub_analysis_type){ +void Icefront::CreatePVectorDiagnosticHorizSegment( Vec pg){ int i,j; @@ -425,5 +431,5 @@ /*}}}*/ /*FUNCTION Icefront::CreatePVectorDiagnosticHorizQuad {{{1*/ -void Icefront::CreatePVectorDiagnosticHorizQuad( Vec pg,int analysis_type,int sub_analysis_type){ +void Icefront::CreatePVectorDiagnosticHorizQuad( Vec pg){ int i,j; @@ -563,5 +569,5 @@ /*}}}*/ /*FUNCTION Icefront::CreatePVectorDiagnosticStokes {{{1*/ -void Icefront::CreatePVectorDiagnosticStokes( Vec pg,int analysis_type,int sub_analysis_type){ +void Icefront::CreatePVectorDiagnosticStokes( Vec pg){ int i,j; @@ -699,8 +705,4 @@ } /*}}}*/ -/*FUNCTION Icefront::DistributeNumDofs {{{1*/ -void Icefront::DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type){return;} - -/*}}}*/ /*FUNCTION Icefront::GetDofList{{{1*/ @@ -740,10 +742,10 @@ /*}}}*/ /*FUNCTION Icefront::PenaltyCreateKMatrix {{{1*/ -void Icefront::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){ +void Icefront::PenaltyCreateKMatrix(Mat Kgg,double kmax){ /*do nothing: */ } /*}}}*/ /*FUNCTION Icefront::PenaltyCreatePVector{{{1*/ -void Icefront::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){ +void Icefront::PenaltyCreatePVector(Vec pg,double kmax){ /*do nothing: */ } @@ -1374,6 +1376,6 @@ } /*}}}*/ -/*FUNCTION Icefront::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type) {{{1*/ -void Icefront::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ +/*FUNCTION Icefront::UpdateInputsFromSolution(double* solution) {{{1*/ +void Icefront::UpdateInputsFromSolution(double* solution){ /*Nothing updated yet*/ } Index: /issm/trunk/src/c/objects/Loads/Icefront.h =================================================================== --- /issm/trunk/src/c/objects/Loads/Icefront.h (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Icefront.h (revision 4043) @@ -55,15 +55,14 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type); + void UpdateInputsFromSolution(double* solution); bool InAnalysis(int analysis_type); /*}}}*/ /*numerics: {{{1*/ - void DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type); - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticHoriz( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticHorizSegment( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticHorizQuad( Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorDiagnosticStokes( Vec pg, int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kgg); + void CreatePVector(Vec pg); + void CreatePVectorDiagnosticHoriz( Vec pg); + void CreatePVectorDiagnosticHorizSegment( Vec pg); + void CreatePVectorDiagnosticHorizQuad( Vec pg); + void CreatePVectorDiagnosticStokes( Vec pg); void GetDofList(int* doflist,int* pnumberofdofs); void SegmentPressureLoad(double* pe_g,double rho_water,double rho_ice,double gravity, double* thickness_list, double* bed_list, double* normal,double length); @@ -72,6 +71,6 @@ void QuadPressureLoadStokes(double* pe_g,double rho_water,double rho_ice,double gravity, double* thickness_list, double* bed_list, double* normal1,double* normal2,double* normal3,double* normal4,double* xyz_list); - void PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type); + void PenaltyCreateKMatrix(Mat Kgg,double kmax); + void PenaltyCreatePVector(Vec pg,double kmax); /*}}}*/ }; Index: /issm/trunk/src/c/objects/Loads/Load.h =================================================================== --- /issm/trunk/src/c/objects/Loads/Load.h (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Load.h (revision 4043) @@ -30,8 +30,8 @@ virtual void Demarshall(char** pmarshalled_dataset)=0; virtual void Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* vertices,DataSet* materials,Parameters* parameters)=0; - virtual void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type)=0; - virtual void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type)=0; - virtual void PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type)=0; - virtual void PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type)=0; + virtual void CreateKMatrix(Mat Kgg)=0; + virtual void CreatePVector(Vec pg)=0; + virtual void PenaltyCreateKMatrix(Mat Kgg,double kmax)=0; + virtual void PenaltyCreatePVector(Vec pg,double kmax)=0; virtual bool InAnalysis(int analysis_type); }; Index: /issm/trunk/src/c/objects/Loads/Numericalflux.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Numericalflux.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Numericalflux.cpp (revision 4043) @@ -283,5 +283,5 @@ /*Object functions*/ /*FUNCTION Numericalflux::CreateKMatrix {{{1*/ -void Numericalflux::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Numericalflux::CreateKMatrix(Mat Kgg){ int type; @@ -292,9 +292,9 @@ if (type==InternalEnum){ - CreateKMatrixInternal(Kgg,analysis_type,sub_analysis_type); + CreateKMatrixInternal(Kgg); } else if (type==BoundaryEnum){ - CreateKMatrixBoundary(Kgg,analysis_type,sub_analysis_type); + CreateKMatrixBoundary(Kgg); } else ISSMERROR("type not supported yet"); @@ -303,8 +303,9 @@ /*}}}*/ /*FUNCTION Numericalflux::CreateKMatrixInternal {{{1*/ -void Numericalflux::CreateKMatrixInternal(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Numericalflux::CreateKMatrixInternal(Mat Kgg){ /* local declarations */ int i,j; + int analysis_type,sub_analysis_type; /* node data: */ @@ -342,4 +343,8 @@ Node** nodes=NULL; Tria** trias=NULL; + + /*Retrieve parameters: */ + this->parameters->FindParam(&analysis_type,AnalysisTypeEnum); + this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum); /*recover objects from hooks: */ @@ -417,8 +422,9 @@ /*}}}*/ /*FUNCTION Numericalflux::CreateKMatrixBoundary {{{1*/ -void Numericalflux::CreateKMatrixBoundary(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Numericalflux::CreateKMatrixBoundary(Mat Kgg){ /* local declarations */ int i,j; + int analysis_type,sub_analysis_type; /* node data: */ @@ -458,4 +464,8 @@ Tria** trias=NULL; + /*Retrieve parameters: */ + this->parameters->FindParam(&analysis_type,AnalysisTypeEnum); + this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum); + /*recover objects from hooks: */ nodes=(Node**)hnodes.deliverp(); @@ -534,5 +544,5 @@ /*}}}*/ /*FUNCTION Numericalflux::CreatePVector {{{1*/ -void Numericalflux::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){ +void Numericalflux::CreatePVector(Vec pg){ int type; @@ -543,9 +553,9 @@ if (type==InternalEnum){ - CreatePVectorInternal(pg,analysis_type,sub_analysis_type); + CreatePVectorInternal(pg); } else if (type==BoundaryEnum){ - CreatePVectorBoundary(pg,analysis_type,sub_analysis_type); + CreatePVectorBoundary(pg); } else ISSMERROR("type not supported yet"); @@ -554,5 +564,5 @@ /*}}}*/ /*FUNCTION Numericalflux::CreatePVectorInternal{{{1*/ -void Numericalflux::CreatePVectorInternal(Vec pg,int analysis_type,int sub_analysis_type){ +void Numericalflux::CreatePVectorInternal(Vec pg){ /*Nothing added to PVector*/ @@ -562,8 +572,9 @@ /*}}}*/ /*FUNCTION Numericalflux::CreatePVectorBoundary{{{1*/ -void Numericalflux::CreatePVectorBoundary(Vec pg,int analysis_type,int sub_analysis_type){ +void Numericalflux::CreatePVectorBoundary(Vec pg){ /* local declarations */ int i,j; + int analysis_type,sub_analysis_type; /* node data: */ @@ -607,4 +618,8 @@ trias=(Tria**)helements.deliverp(); + /*Retrieve parameters: */ + this->parameters->FindParam(&analysis_type,AnalysisTypeEnum); + this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum); + /*recover parameters: */ if (analysis_type==Prognostic2AnalysisEnum){ @@ -673,8 +688,4 @@ } /*}}}*/ -/*FUNCTION Numericalflux::DistributeNumDofs {{{1*/ -void Numericalflux::DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type){ - return; -} /*}}}*/ /*FUNCTION Numericalflux::GetB {{{1*/ @@ -825,5 +836,5 @@ /*}}}*/ /*FUNCTION Numericalflux::PenaltyCreateKMatrix {{{1*/ -void Numericalflux::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){ +void Numericalflux::PenaltyCreateKMatrix(Mat Kgg,double kmax){ /*No stiffness loads applied, do nothing: */ @@ -833,5 +844,5 @@ /*}}}*/ /*FUNCTION Numericalflux::PenaltyCreatePVector{{{1*/ -void Numericalflux::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){ +void Numericalflux::PenaltyCreatePVector(Vec pg,double kmax){ /*No penalty loads applied, do nothing: */ Index: /issm/trunk/src/c/objects/Loads/Numericalflux.h =================================================================== --- /issm/trunk/src/c/objects/Loads/Numericalflux.h (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Numericalflux.h (revision 4043) @@ -50,5 +50,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} bool InAnalysis(int analysis_type); @@ -57,5 +57,4 @@ void GetJacobianDeterminant(double* pJdet,double xyz_list[4][3], double gauss_coord); void GetNodalFunctions(double* l1l4, double gauss_coord); - void DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type); void GetB(double* B, double gauss_coord); void GetL(double* L, double gauss_coord,int numdof); @@ -65,12 +64,12 @@ void UpdateFromInputs(void* inputs); - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixInternal(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreateKMatrixBoundary(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); - void CreatePVectorInternal(Vec pg,int analysis_type,int sub_analysis_type); - void CreatePVectorBoundary(Vec pg,int analysis_type,int sub_analysis_type); - void PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kgg); + void CreateKMatrixInternal(Mat Kgg); + void CreateKMatrixBoundary(Mat Kgg); + void CreatePVector(Vec pg); + void CreatePVectorInternal(Vec pg); + void CreatePVectorBoundary(Vec pg); + void PenaltyCreateKMatrix(Mat Kgg,double kmax); + void PenaltyCreatePVector(Vec pg,double kmax); /*}}}*/ Index: /issm/trunk/src/c/objects/Loads/Pengrid.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Pengrid.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Pengrid.cpp (revision 4043) @@ -249,5 +249,5 @@ /*FUNCTION Pengrid::CreateKMatrix {{{1*/ -void Pengrid::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Pengrid::CreateKMatrix(Mat Kgg){ /*No loads applied, do nothing: */ @@ -257,5 +257,5 @@ /*}}}1*/ /*FUNCTION Pengrid::CreatePVector {{{1*/ -void Pengrid::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){ +void Pengrid::CreatePVector(Vec pg){ /*No loads applied, do nothing: */ @@ -263,7 +263,4 @@ } -/*}}}1*/ -/*FUNCTION Pengrid::DistributenumDofs {{{1*/ -void Pengrid::DistributeNumDofs(int* numdofpernode,int analysis_type,int sub_analysis_type){return;} /*}}}1*/ /*FUNCTION Pengrid::GetDofList {{{1*/ @@ -291,5 +288,11 @@ /*}}}*/ /*FUNCTION Pengrid::PenaltyConstrain {{{1*/ -void Pengrid::PenaltyConstrain(int* punstable,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyConstrain(int* punstable){ + + int analysis_type,sub_analysis_type; + + /*Retrieve parameters: */ + this->parameters->FindParam(&analysis_type,AnalysisTypeEnum); + this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum); if ((analysis_type==DiagnosticAnalysisEnum) && ((sub_analysis_type==StokesAnalysisEnum))){ @@ -301,5 +304,5 @@ else if (analysis_type==ThermalAnalysisEnum){ - PenaltyConstrainThermal(punstable,analysis_type,sub_analysis_type); + PenaltyConstrainThermal(punstable); } @@ -317,5 +320,5 @@ /*}}}1*/ /*FUNCTION Pengrid::PenaltyConstrainThermal {{{1*/ -void Pengrid::PenaltyConstrainThermal(int* punstable,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyConstrainThermal(int* punstable){ // The penalty is stable if it doesn't change during to successive iterations. @@ -401,18 +404,24 @@ /*}}}1*/ /*FUNCTION Pengrid::PenaltyCreateMatrix {{{1*/ -void Pengrid::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyCreateKMatrix(Mat Kgg,double kmax){ + + int analysis_type,sub_analysis_type; + + /*Retrieve parameters: */ + this->parameters->FindParam(&analysis_type,AnalysisTypeEnum); + this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum); if ((analysis_type==DiagnosticAnalysisEnum) && ((sub_analysis_type==StokesAnalysisEnum))){ - PenaltyCreateKMatrixDiagnosticStokes( Kgg,kmax,analysis_type,sub_analysis_type); + PenaltyCreateKMatrixDiagnosticStokes( Kgg,kmax); } else if (analysis_type==ThermalAnalysisEnum){ - PenaltyCreateKMatrixThermal( Kgg,kmax,analysis_type,sub_analysis_type); + PenaltyCreateKMatrixThermal( Kgg,kmax); } else if (analysis_type==MeltingAnalysisEnum){ - PenaltyCreateKMatrixMelting( Kgg,kmax,analysis_type,sub_analysis_type); + PenaltyCreateKMatrixMelting( Kgg,kmax); } @@ -424,5 +433,5 @@ /*}}}1*/ /*FUNCTION Pengrid::PenaltyCreateKMatrixDiagnosticStokes {{{1*/ -void Pengrid::PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax){ const int numgrids=1; @@ -467,5 +476,5 @@ /*}}}1*/ /*FUNCTION Pengrid::PenaltyCreateKMatrixMelting {{{1*/ -void Pengrid::PenaltyCreateKMatrixMelting(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyCreateKMatrixMelting(Mat Kgg,double kmax){ int found=0; @@ -526,5 +535,5 @@ /*}}}1*/ /*FUNCTION Pengrid::PenaltyCreateKMatrixThermal {{{1*/ -void Pengrid::PenaltyCreateKMatrixThermal(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyCreateKMatrixThermal(Mat Kgg,double kmax){ int found=0; @@ -553,14 +562,20 @@ /*}}}1*/ /*FUNCTION Pengrid::PenaltyCreatePVector {{{1*/ -void Pengrid::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyCreatePVector(Vec pg,double kmax){ + + int analysis_type,sub_analysis_type; + + /*Retrieve parameters: */ + this->parameters->FindParam(&analysis_type,AnalysisTypeEnum); + this->parameters->FindParam(&sub_analysis_type,SubAnalysisTypeEnum); if (analysis_type==ThermalAnalysisEnum){ - PenaltyCreatePVectorThermal( pg,kmax,analysis_type,sub_analysis_type); + PenaltyCreatePVectorThermal( pg,kmax); } else if (analysis_type==MeltingAnalysisEnum){ - PenaltyCreatePVectorMelting( pg,kmax,analysis_type,sub_analysis_type); + PenaltyCreatePVectorMelting( pg,kmax); } @@ -578,5 +593,5 @@ /*}}}1*/ /*FUNCTION Pengrid::PenaltyCreatePVectorMelting {{{1*/ -void Pengrid::PenaltyCreatePVectorMelting(Vec pg, double kmax,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyCreatePVectorMelting(Vec pg, double kmax){ const int numgrids=1; @@ -654,5 +669,5 @@ /*}}}1*/ /*FUNCTION Pengrid::PenaltyCreatePVectorThermal {{{1*/ -void Pengrid::PenaltyCreatePVectorThermal(Vec pg, double kmax,int analysis_type,int sub_analysis_type){ +void Pengrid::PenaltyCreatePVectorThermal(Vec pg, double kmax){ const int numgrids=1; @@ -714,5 +729,5 @@ /*}}}1*/ /*FUNCTION Pengrid::UpdateInputs {{{1*/ -void Pengrid::UpdateInputs(double* solution, int analysis_type, int sub_analysis_type){ +void Pengrid::UpdateInputs(double* solution){ ISSMERROR("not supported yet!"); } @@ -761,6 +776,6 @@ } /*}}}*/ -/*FUNCTION Pengrid::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type) {{{1*/ -void Pengrid::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ +/*FUNCTION Pengrid::UpdateInputsFromSolution(double* solution) {{{1*/ +void Pengrid::UpdateInputsFromSolution(double* solution){ /*Nothing updated yet*/ } Index: /issm/trunk/src/c/objects/Loads/Pengrid.h =================================================================== --- /issm/trunk/src/c/objects/Loads/Pengrid.h (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Pengrid.h (revision 4043) @@ -56,26 +56,25 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type); + void UpdateInputsFromSolution(double* solution); bool InAnalysis(int analysis_type); /*}}}*/ /*FUNCTION element numerical routines {{{1*/ - void DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type); - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); - void PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kgg); + void CreatePVector(Vec pg); + void PenaltyCreateKMatrix(Mat Kgg,double kmax); + void PenaltyCreatePVector(Vec pg,double kmax); + void PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax); void GetDofList(int* doflist,int* pnumberofdofspernode); - void PenaltyCreateKMatrixThermal(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreateKMatrixMelting(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreatePVectorThermal(Vec pg, double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreatePVectorMelting(Vec pg, double kmax,int analysis_type,int sub_analysis_type); - void PenaltyConstrain(int* punstable,int analysis_type,int sub_analysis_type); - void PenaltyConstrainThermal(int* punstable,int analysis_type,int sub_analysis_type); + void PenaltyCreateKMatrixThermal(Mat Kgg,double kmax); + void PenaltyCreateKMatrixMelting(Mat Kgg,double kmax); + void PenaltyCreatePVectorThermal(Vec pg, double kmax); + void PenaltyCreatePVectorMelting(Vec pg, double kmax); + void PenaltyConstrain(int* punstable); + void PenaltyConstrainThermal(int* punstable); /*updates:*/ void UpdateFromDakota(void* inputs); - void UpdateInputs(double* solution, int analysis_type, int sub_analysis_type); + void UpdateInputs(double* solution); /*}}}*/ Index: /issm/trunk/src/c/objects/Loads/Penpair.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Penpair.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Penpair.cpp (revision 4043) @@ -181,5 +181,5 @@ /*FUNCTION Penpair::CreateKMatrix {{{1*/ -void Penpair::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Penpair::CreateKMatrix(Mat Kgg){ /*No loads applied, do nothing: */ @@ -189,5 +189,5 @@ /*}}}1*/ /*FUNCTION Penpair::CreatePVector {{{1*/ -void Penpair::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){ +void Penpair::CreatePVector(Vec pg){ /*No loads applied, do nothing: */ @@ -197,5 +197,5 @@ /*}}}1*/ /*FUNCTION Penpair::PenaltyCreateKMatrix {{{1*/ -void Penpair::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){ +void Penpair::PenaltyCreateKMatrix(Mat Kgg,double kmax){ /*If you code this piece, don't forget that a penalty will be inactive if it is dealing with clone nodes*/ @@ -205,5 +205,5 @@ /*}}}1*/ /*FUNCTION Penpair::PenaltyCreatePVector {{{1*/ -void Penpair::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){ +void Penpair::PenaltyCreatePVector(Vec pg,double kmax){ /*No loads applied, do nothing: */ return; Index: /issm/trunk/src/c/objects/Loads/Penpair.h =================================================================== --- /issm/trunk/src/c/objects/Loads/Penpair.h (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Penpair.h (revision 4043) @@ -47,12 +47,12 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} bool InAnalysis(int analysis_type); /*}}}*/ /*numerics: {{{1*/ - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); - void PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kgg); + void CreatePVector(Vec pg); + void PenaltyCreateKMatrix(Mat Kgg,double kmax); + void PenaltyCreatePVector(Vec pg,double kmax); /*}}}*/ }; Index: /issm/trunk/src/c/objects/Loads/Riftfront.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Riftfront.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Riftfront.cpp (revision 4043) @@ -290,5 +290,5 @@ #define _ZIGZAGCOUNTER_ -int Riftfront::Constrain(int* punstable, int analysis_type){ +int Riftfront::Constrain(int* punstable){ const int numgrids = 2; @@ -374,15 +374,15 @@ /*}}}1*/ /*FUNCTION Riftfront::CreateKMatrix {{{1*/ -void Riftfront::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){ +void Riftfront::CreateKMatrix(Mat Kgg){ /*do nothing: */ } /*}}}1*/ /*FUNCTION Riftfront::CreatePVector {{{1*/ -void Riftfront::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){ +void Riftfront::CreatePVector(Vec pg){ /*do nothing: */ } /*}}}1*/ /*FUNCTION Riftfront::FreezeConstraints{{{1*/ -void Riftfront::FreezeConstraints( int analysis_type){ +void Riftfront::FreezeConstraints(void){ /*Just set frozen flag to 1: */ @@ -422,5 +422,5 @@ /*}}}1*/ /*FUNCTION Riftfront::IsMaterialStable {{{1*/ -int Riftfront::IsMaterialStable( int analysis_type){ +int Riftfront::IsMaterialStable(void){ int found=0; @@ -440,5 +440,5 @@ /*}}}1*/ /*FUNCTION Riftfront::MaxPenetration {{{1*/ -int Riftfront::MaxPenetration(double* ppenetration, int analysis_type){ +int Riftfront::MaxPenetration(double* ppenetration){ const int numgrids=2; @@ -506,5 +506,5 @@ /*}}}1*/ /*FUNCTION Riftfront::PenaltyCreateKMatrix {{{1*/ -void Riftfront::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){ +void Riftfront::PenaltyCreateKMatrix(Mat Kgg,double kmax){ int i; @@ -618,5 +618,5 @@ /*}}}1*/ /*FUNCTION Riftfront::PenaltyCreatePVector {{{1*/ -void Riftfront::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){ +void Riftfront::PenaltyCreatePVector(Vec pg,double kmax){ int i ,j; @@ -745,5 +745,5 @@ /*}}}1*/ /*FUNCTION Riftfront::Penetration {{{1*/ -int Riftfront::Penetration(double* ppenetration, int analysis_type){ +int Riftfront::Penetration(double* ppenetration){ double vx1; @@ -790,5 +790,5 @@ /*}}}1*/ /*FUNCTION Riftfront::PotentialUnstableConstraint {{{1*/ -int Riftfront::PotentialUnstableConstraint(int* punstable, int analysis_type){ +int Riftfront::PotentialUnstableConstraint(int* punstable){ @@ -849,5 +849,5 @@ /*}}}1*/ /*FUNCTION Riftfront::PreConstrain {{{1*/ -int Riftfront::PreConstrain(int* punstable, int analysis_type){ +int Riftfront::PreConstrain(int* punstable){ const int numgrids = 2; Index: /issm/trunk/src/c/objects/Loads/Riftfront.h =================================================================== --- /issm/trunk/src/c/objects/Loads/Riftfront.h (revision 4042) +++ /issm/trunk/src/c/objects/Loads/Riftfront.h (revision 4043) @@ -65,5 +65,5 @@ void UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");} void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} bool InAnalysis(int analysis_type); @@ -73,18 +73,18 @@ /*numerics: {{{1*/ void GetDofList(int* doflist,int* pnumberofdofs); - void CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type); - void CreatePVector(Vec pg, int analysis_type,int sub_analysis_type); - void PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type); - void PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type); + void CreateKMatrix(Mat Kgg); + void CreatePVector(Vec pg); + void PenaltyCreateKMatrix(Mat Kgg,double kmax); + void PenaltyCreatePVector(Vec pg,double kmax); bool PreStable(); void SetPreStable(); - int PreConstrain(int* punstable, int analysis_type); - int Constrain(int* punstable, int analysis_type); - void FreezeConstraints( int analysis_type); + int PreConstrain(int* punstable); + int Constrain(int* punstable); + void FreezeConstraints(void); bool IsFrozen(void); - int Penetration(double* ppenetration, int analysis_type); - int MaxPenetration(double* ppenetration, int analysis_type); - int PotentialUnstableConstraint(int* punstable, int analysis_type); - int IsMaterialStable( int analysis_type); + int Penetration(double* ppenetration); + int MaxPenetration(double* ppenetration); + int PotentialUnstableConstraint(int* punstable); + int IsMaterialStable(void); void OutputProperties(Vec riftproperties); /*}}}*/ Index: /issm/trunk/src/c/objects/Materials/Material.h =================================================================== --- /issm/trunk/src/c/objects/Materials/Material.h (revision 4042) +++ /issm/trunk/src/c/objects/Materials/Material.h (revision 4043) @@ -29,5 +29,5 @@ virtual void UpdateInputsFromVector(int* vector, int name, int type)=0; virtual void UpdateInputsFromVector(bool* vector, int name, int type)=0; - virtual void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type)=0; + virtual void UpdateInputsFromSolution(double* solution)=0; }; Index: /issm/trunk/src/c/objects/Materials/Matice.cpp =================================================================== --- /issm/trunk/src/c/objects/Materials/Matice.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Materials/Matice.cpp (revision 4043) @@ -146,7 +146,4 @@ return; } -/*}}}*/ -/*FUNCTION Matice::DistributeNumDofs {{{1*/ -void Matice::DistributeNumDofs(int* numdofspernode,int analysis_type){return;} /*}}}*/ /*FUNCTION Matice::Echo {{{1*/ @@ -461,7 +458,7 @@ } /*}}}*/ -/*FUNCTION Matice::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type) {{{1*/ -void Matice::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ - /*Nothing updated yet*/ -} -/*}}}*/ +/*FUNCTION Matice::UpdateInputsFromSolution(double* solution) {{{1*/ +void Matice::UpdateInputsFromSolution(double* solution){ + /*Nothing updated yet*/ +} +/*}}}*/ Index: /issm/trunk/src/c/objects/Materials/Matice.h =================================================================== --- /issm/trunk/src/c/objects/Materials/Matice.h (revision 4042) +++ /issm/trunk/src/c/objects/Materials/Matice.h (revision 4043) @@ -35,5 +35,4 @@ int Id(); int MyRank(); - void DistributeNumDofs(int* numdofspernode,int analysis_type); void UpdateFromInputs(void* inputs); void SetB(double B_param); @@ -51,5 +50,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type); + void UpdateInputsFromSolution(double* solution); }; Index: /issm/trunk/src/c/objects/Materials/Matpar.cpp =================================================================== --- /issm/trunk/src/c/objects/Materials/Matpar.cpp (revision 4042) +++ /issm/trunk/src/c/objects/Materials/Matpar.cpp (revision 4043) @@ -187,7 +187,4 @@ } /*}}}1*/ -/*FUNCTION Matpar::DistributeNumDofs {{{1*/ -void Matpar::DistributeNumDofs(int* numdofspernode,int analysis_type){return;} -/*}}}1*/ /*FUNCTION Matpar::Echo {{{1*/ void Matpar::Echo(void){ @@ -312,7 +309,7 @@ } /*}}}*/ -/*FUNCTION Matpar::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type) {{{1*/ -void Matpar::UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ - /*Nothing updated yet*/ -} -/*}}}*/ +/*FUNCTION Matpar::UpdateInputsFromSolution(double* solution) {{{1*/ +void Matpar::UpdateInputsFromSolution(double* solution){ + /*Nothing updated yet*/ +} +/*}}}*/ Index: /issm/trunk/src/c/objects/Materials/Matpar.h =================================================================== --- /issm/trunk/src/c/objects/Materials/Matpar.h (revision 4042) +++ /issm/trunk/src/c/objects/Materials/Matpar.h (revision 4043) @@ -44,5 +44,4 @@ int Id(); int MyRank(); - void DistributeNumDofs(int* numdofspernode,int analysis_type); void UpdateFromInputs(void* inputs); double GetG(); @@ -63,5 +62,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type); + void UpdateInputsFromSolution(double* solution); Index: /issm/trunk/src/c/objects/Node.h =================================================================== --- /issm/trunk/src/c/objects/Node.h (revision 4042) +++ /issm/trunk/src/c/objects/Node.h (revision 4043) @@ -59,5 +59,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} bool InAnalysis(int analysis_type); Index: /issm/trunk/src/c/objects/Object.h =================================================================== --- /issm/trunk/src/c/objects/Object.h (revision 4042) +++ /issm/trunk/src/c/objects/Object.h (revision 4043) @@ -31,5 +31,5 @@ virtual void UpdateInputsFromConstant(int constant, int name)=0; virtual void UpdateInputsFromConstant(bool constant, int name)=0; - virtual void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type)=0; + virtual void UpdateInputsFromSolution(double* solution)=0; }; Index: /issm/trunk/src/c/objects/Params/BoolParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/BoolParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/BoolParam.h (revision 4043) @@ -56,6 +56,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleMatParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleMatParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/DoubleMatParam.h (revision 4043) @@ -60,5 +60,5 @@ void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/DoubleParam.h (revision 4043) @@ -58,5 +58,5 @@ void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleVecParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleVecParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/DoubleVecParam.h (revision 4043) @@ -59,5 +59,5 @@ void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ /*Param methods: {{{1*/ Index: /issm/trunk/src/c/objects/Params/IntParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/IntParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/IntParam.h (revision 4043) @@ -57,6 +57,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ Index: /issm/trunk/src/c/objects/Params/PetscMatParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/PetscMatParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/PetscMatParam.h (revision 4043) @@ -57,6 +57,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ Index: /issm/trunk/src/c/objects/Params/PetscVecParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/PetscVecParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/PetscVecParam.h (revision 4043) @@ -57,6 +57,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ Index: /issm/trunk/src/c/objects/Params/StringArrayParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/StringArrayParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/StringArrayParam.h (revision 4043) @@ -59,6 +59,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ Index: /issm/trunk/src/c/objects/Params/StringParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/StringParam.h (revision 4042) +++ /issm/trunk/src/c/objects/Params/StringParam.h (revision 4043) @@ -57,6 +57,5 @@ void UpdateInputsFromConstant(int constant, int name); void UpdateInputsFromConstant(bool constant, int name); - - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*}}}*/ Index: /issm/trunk/src/c/objects/Results/Result.h =================================================================== --- /issm/trunk/src/c/objects/Results/Result.h (revision 4042) +++ /issm/trunk/src/c/objects/Results/Result.h (revision 4043) @@ -26,3 +26,6 @@ }; + + +void NodalValuesUnitConversion(double* nodal_values, int num_nodal_values,int enum_type,Parameters* parameters); #endif Index: /issm/trunk/src/c/objects/SolPar.h =================================================================== --- /issm/trunk/src/c/objects/SolPar.h (revision 4042) +++ /issm/trunk/src/c/objects/SolPar.h (revision 4043) @@ -46,5 +46,5 @@ void UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");} - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} /*functionality: */ Index: /issm/trunk/src/c/objects/Vertex.h =================================================================== --- /issm/trunk/src/c/objects/Vertex.h (revision 4042) +++ /issm/trunk/src/c/objects/Vertex.h (revision 4043) @@ -57,5 +57,5 @@ void UpdateInputsFromConstant(bool constant, int name); - void UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");} + void UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");} Index: /issm/trunk/src/c/objects/objects.h =================================================================== --- /issm/trunk/src/c/objects/objects.h (revision 4042) +++ /issm/trunk/src/c/objects/objects.h (revision 4043) @@ -57,5 +57,4 @@ #include "./Results/SingVertexResult.h" #include "./Results/BeamVertexResult.h" -#include "./Results/NodalValuesUnitConversion.h" /*Materials: */ Index: /issm/trunk/src/c/solutions/balancedthickness2_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/balancedthickness2_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/balancedthickness2_core.cpp (revision 4043) @@ -10,4 +10,5 @@ #include "./solutions.h" #include "../modules/modules.h" +#include "../solvers/solvers.h" Results* balancedthickness2_core(Model* model){ Index: /issm/trunk/src/c/solutions/balancedthickness_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/balancedthickness_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/balancedthickness_core.cpp (revision 4043) @@ -10,4 +10,5 @@ #include "./solutions.h" #include "../modules/modules.h" +#include "../solvers/solvers.h" Results* balancedthickness_core(Model* model){ Index: /issm/trunk/src/c/solutions/balancedvelocities_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/balancedvelocities_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/balancedvelocities_core.cpp (revision 4043) @@ -9,4 +9,5 @@ #include "./solutions.h" #include "../modules/modules.h" +#include "../solvers/solvers.h" Results* balancedvelocities_core(Model* model){ Index: /issm/trunk/src/c/solutions/bedslope_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/bedslope_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/bedslope_core.cpp (revision 4043) @@ -8,4 +8,5 @@ #include "../EnumDefinitions/EnumDefinitions.h" #include "../modules/modules.h" +#include "../solvers/solvers.h" void bedslope_core(FemModel* femmodel){ Index: /issm/trunk/src/c/solutions/control_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/control_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/control_core.cpp (revision 4043) @@ -6,4 +6,5 @@ #include "../modules/modules.h" #include "../EnumDefinitions/EnumDefinitions.h" +#include "../solvers/solvers.h" Results* control_core(Model* model){ Index: /issm/trunk/src/c/solutions/diagnostic_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/diagnostic_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/diagnostic_core.cpp (revision 4043) @@ -10,4 +10,5 @@ #include "../modules/modules.h" #include "../include/include.h" +#include "../solvers/solvers.h" void diagnostic_core(FemModel* femmodel){ @@ -33,8 +34,8 @@ /*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.*/ if(qmu_analysis){ - ReinitializeInputx(femmodel,VxEnum,QmuVxEnum); - ReinitializeInputx(femmodel,VyEnum,QmuVyEnum); - ReinitializeInputx(femmodel,VzEnum,QmuVzEnum); - ReinitializeInputx(femmodel,PressureEnum,QmuPressureEnum); + ReinitializeInputx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,QmuVxEnum); + ReinitializeInputx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,QmuVyEnum); + ReinitializeInputx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzEnum,QmuVzEnum); + ReinitializeInputx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,PressureEnum,QmuPressureEnum); } Index: /issm/trunk/src/c/solutions/gradjcompute_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/gradjcompute_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/gradjcompute_core.cpp (revision 4043) @@ -12,4 +12,6 @@ #error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" #endif + +#include "../solvers/solvers.h" Results* gradjcompute_core(Model* model){ Index: /issm/trunk/src/c/solutions/prognostic2_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/prognostic2_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/prognostic2_core.cpp (revision 4043) @@ -9,4 +9,5 @@ #include "./solutions.h" #include "../modules/modules.h" +#include "../solvers/solvers.h" Results* prognostic2_core(Model* model){ Index: /issm/trunk/src/c/solutions/prognostic_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/prognostic_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/prognostic_core.cpp (revision 4043) @@ -9,4 +9,5 @@ #include "./solutions.h" #include "../modules/modules.h" +#include "../solvers/solvers.h" Results* prognostic_core(Model* model){ Index: /issm/trunk/src/c/solutions/solutions.h =================================================================== --- /issm/trunk/src/c/solutions/solutions.h (revision 4042) +++ /issm/trunk/src/c/solutions/solutions.h (revision 4043) @@ -27,5 +27,6 @@ Results* transient_core_3d(FemModel* model); Results* thermal_core(FemModel* model); -void slope_core(FemModel* fem,int sub_analysis_type); +void surfaceslope_core(FemModel* femmodel); +void bedslope_core(FemModel* femmodel); //int GradJOrth(WorkspaceParams* workspaceparams); Index: /issm/trunk/src/c/solutions/steadystate_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/steadystate_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/steadystate_core.cpp (revision 4043) @@ -9,4 +9,5 @@ #include "./solutions.h" #include "../modules/modules.h" +#include "../solvers/solvers.h" Results* steadystate_core(Model* model){ Index: /issm/trunk/src/c/solutions/surfaceslope_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/surfaceslope_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/surfaceslope_core.cpp (revision 4043) @@ -7,4 +7,5 @@ #include "../objects/objects.h" #include "../EnumDefinitions/EnumDefinitions.h" +#include "../solvers/solvers.h" #include "../modules/modules.h" Index: /issm/trunk/src/c/solutions/thermal_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/thermal_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/thermal_core.cpp (revision 4043) @@ -10,4 +10,5 @@ #include "../modules/modules.h" #include "../include/include.h" +#include "../solvers/solvers.h" void thermal_core(FemModel* femmodel){ Index: /issm/trunk/src/c/solutions/transient_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/transient_core.cpp (revision 4042) +++ /issm/trunk/src/c/solutions/transient_core.cpp (revision 4043) @@ -9,4 +9,5 @@ #include "./solutions.h" #include "../modules/modules.h" +#include "../solvers/solvers.h" Results* transient_core(Model* model){ Index: /issm/trunk/src/m/enum/BeamVertexResultEnum.m =================================================================== --- /issm/trunk/src/m/enum/BeamVertexResultEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/BeamVertexResultEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=BeamVertexResultEnum() -macro=190; +macro=195; Index: /issm/trunk/src/m/enum/BetaEnum.m =================================================================== --- /issm/trunk/src/m/enum/BetaEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/BetaEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=BetaEnum() -macro=191; +macro=196; Index: /issm/trunk/src/m/enum/CmGradientEnum.m =================================================================== --- /issm/trunk/src/m/enum/CmGradientEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/CmGradientEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=CmGradientEnum() -macro=192; +macro=197; Index: /issm/trunk/src/m/enum/CmJumpEnum.m =================================================================== --- /issm/trunk/src/m/enum/CmJumpEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/CmJumpEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=CmJumpEnum() -macro=193; +macro=198; Index: /issm/trunk/src/m/enum/CmMaxEnum.m =================================================================== --- /issm/trunk/src/m/enum/CmMaxEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/CmMaxEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=CmMaxEnum() -macro=194; +macro=199; Index: /issm/trunk/src/m/enum/CmMinEnum.m =================================================================== --- /issm/trunk/src/m/enum/CmMinEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/CmMinEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=CmMinEnum() -macro=195; +macro=200; Index: /issm/trunk/src/m/enum/ConnectivityEnum.m =================================================================== --- /issm/trunk/src/m/enum/ConnectivityEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ConnectivityEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ConnectivityEnum() -macro=196; +macro=201; Index: /issm/trunk/src/m/enum/ControlParameterEnum.m =================================================================== --- /issm/trunk/src/m/enum/ControlParameterEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ControlParameterEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ControlParameterEnum() -macro=197; +macro=202; Index: /issm/trunk/src/m/enum/ControlSteadyEnum.m =================================================================== --- /issm/trunk/src/m/enum/ControlSteadyEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ControlSteadyEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ControlSteadyEnum() -macro=198; +macro=203; Index: /issm/trunk/src/m/enum/DakotaParameterEnum.m =================================================================== --- /issm/trunk/src/m/enum/DakotaParameterEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/DakotaParameterEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=DakotaParameterEnum() -macro=199; +macro=204; Index: /issm/trunk/src/m/enum/DimEnum.m =================================================================== --- /issm/trunk/src/m/enum/DimEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/DimEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=DimEnum() -macro=200; +macro=205; Index: /issm/trunk/src/m/enum/DoubleResultEnum.m =================================================================== --- /issm/trunk/src/m/enum/DoubleResultEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/DoubleResultEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=DoubleResultEnum() -macro=186; +macro=191; Index: /issm/trunk/src/m/enum/EnumAsString.m =================================================================== --- /issm/trunk/src/m/enum/EnumAsString.m (revision 4042) +++ /issm/trunk/src/m/enum/EnumAsString.m (revision 4043) @@ -167,4 +167,6 @@ case PressureEnum(), string='Pressure'; return case PressureOldEnum(), string='PressureOld'; return + case QmuPressureEnum(), string='QmuPressure'; return + case StokesPressureEnum(), string='StokesPressure'; return case ResetPenaltiesEnum(), string='ResetPenalties'; return case RheologyBEnum(), string='RheologyB'; return @@ -186,12 +188,15 @@ case VxObsEnum(), string='VxObs'; return case VxOldEnum(), string='VxOld'; return + case QmuVxEnum(), string='QmuVx'; return case VyAverageEnum(), string='VyAverage'; return case VyEnum(), string='Vy'; return case VyObsEnum(), string='VyObs'; return case VyOldEnum(), string='VyOld'; return + case QmuVyEnum(), string='QmuVy'; return case VzAverageEnum(), string='VzAverage'; return case VzEnum(), string='Vz'; return case VzObsEnum(), string='VzObs'; return case VzOldEnum(), string='VzOld'; return + case QmuVzEnum(), string='QmuVz'; return case WeightsEnum(), string='Weights'; return case P0Enum(), string='P0'; return Index: /issm/trunk/src/m/enum/EpsAbsEnum.m =================================================================== --- /issm/trunk/src/m/enum/EpsAbsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/EpsAbsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=EpsAbsEnum() -macro=201; +macro=206; Index: /issm/trunk/src/m/enum/EpsCmEnum.m =================================================================== --- /issm/trunk/src/m/enum/EpsCmEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/EpsCmEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=EpsCmEnum() -macro=202; +macro=207; Index: /issm/trunk/src/m/enum/EpsRelEnum.m =================================================================== --- /issm/trunk/src/m/enum/EpsRelEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/EpsRelEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=EpsRelEnum() -macro=203; +macro=208; Index: /issm/trunk/src/m/enum/EpsResEnum.m =================================================================== --- /issm/trunk/src/m/enum/EpsResEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/EpsResEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=EpsResEnum() -macro=204; +macro=209; Index: /issm/trunk/src/m/enum/ExtrudeParamEnum.m =================================================================== --- /issm/trunk/src/m/enum/ExtrudeParamEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ExtrudeParamEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ExtrudeParamEnum() -macro=205; +macro=210; Index: /issm/trunk/src/m/enum/HeatCapacityEnum.m =================================================================== --- /issm/trunk/src/m/enum/HeatCapacityEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/HeatCapacityEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=HeatCapacityEnum() -macro=206; +macro=211; Index: /issm/trunk/src/m/enum/IsHutterEnum.m =================================================================== --- /issm/trunk/src/m/enum/IsHutterEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/IsHutterEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=IsHutterEnum() -macro=207; +macro=212; Index: /issm/trunk/src/m/enum/IsMacAyealPattynEnum.m =================================================================== --- /issm/trunk/src/m/enum/IsMacAyealPattynEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/IsMacAyealPattynEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=IsMacAyealPattynEnum() -macro=208; +macro=213; Index: /issm/trunk/src/m/enum/IsStokesEnum.m =================================================================== --- /issm/trunk/src/m/enum/IsStokesEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/IsStokesEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=IsStokesEnum() -macro=209; +macro=214; Index: /issm/trunk/src/m/enum/LatentHeatEnum.m =================================================================== --- /issm/trunk/src/m/enum/LatentHeatEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/LatentHeatEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=LatentHeatEnum() -macro=210; +macro=215; Index: /issm/trunk/src/m/enum/LowmemEnum.m =================================================================== --- /issm/trunk/src/m/enum/LowmemEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/LowmemEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=LowmemEnum() -macro=211; +macro=216; Index: /issm/trunk/src/m/enum/MaxIterEnum.m =================================================================== --- /issm/trunk/src/m/enum/MaxIterEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/MaxIterEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=MaxIterEnum() -macro=212; +macro=217; Index: /issm/trunk/src/m/enum/MaxNonlinearIterationsEnum.m =================================================================== --- /issm/trunk/src/m/enum/MaxNonlinearIterationsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/MaxNonlinearIterationsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=MaxNonlinearIterationsEnum() -macro=213; +macro=218; Index: /issm/trunk/src/m/enum/MeltingPointEnum.m =================================================================== --- /issm/trunk/src/m/enum/MeltingPointEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/MeltingPointEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=MeltingPointEnum() -macro=214; +macro=219; Index: /issm/trunk/src/m/enum/MinMechanicalConstraintsEnum.m =================================================================== --- /issm/trunk/src/m/enum/MinMechanicalConstraintsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/MinMechanicalConstraintsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=MinMechanicalConstraintsEnum() -macro=215; +macro=220; Index: /issm/trunk/src/m/enum/MinThermalConstraintsEnum.m =================================================================== --- /issm/trunk/src/m/enum/MinThermalConstraintsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/MinThermalConstraintsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=MinThermalConstraintsEnum() -macro=216; +macro=221; Index: /issm/trunk/src/m/enum/NStepsEnum.m =================================================================== --- /issm/trunk/src/m/enum/NStepsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/NStepsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=NStepsEnum() -macro=217; +macro=222; Index: /issm/trunk/src/m/enum/NdtEnum.m =================================================================== --- /issm/trunk/src/m/enum/NdtEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/NdtEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=NdtEnum() -macro=218; +macro=223; Index: /issm/trunk/src/m/enum/NumOutputEnum.m =================================================================== --- /issm/trunk/src/m/enum/NumOutputEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/NumOutputEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=NumOutputEnum() -macro=219; +macro=224; Index: /issm/trunk/src/m/enum/NumRiftsEnum.m =================================================================== --- /issm/trunk/src/m/enum/NumRiftsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/NumRiftsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=NumRiftsEnum() -macro=220; +macro=225; Index: /issm/trunk/src/m/enum/NumberOfDofsPerNodeEnum.m =================================================================== --- /issm/trunk/src/m/enum/NumberOfDofsPerNodeEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/NumberOfDofsPerNodeEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=NumberOfDofsPerNodeEnum() -macro=221; +macro=226; Index: /issm/trunk/src/m/enum/NumberOfElementsEnum.m =================================================================== --- /issm/trunk/src/m/enum/NumberOfElementsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/NumberOfElementsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=NumberOfElementsEnum() -macro=222; +macro=227; Index: /issm/trunk/src/m/enum/NumberOfNodesEnum.m =================================================================== --- /issm/trunk/src/m/enum/NumberOfNodesEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/NumberOfNodesEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=NumberOfNodesEnum() -macro=223; +macro=228; Index: /issm/trunk/src/m/enum/NumberOfVerticesEnum.m =================================================================== --- /issm/trunk/src/m/enum/NumberOfVerticesEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/NumberOfVerticesEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=NumberOfVerticesEnum() -macro=224; +macro=229; Index: /issm/trunk/src/m/enum/OptScalEnum.m =================================================================== --- /issm/trunk/src/m/enum/OptScalEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/OptScalEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=OptScalEnum() -macro=225; +macro=230; Index: /issm/trunk/src/m/enum/OutputFileNameEnum.m =================================================================== --- /issm/trunk/src/m/enum/OutputFileNameEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/OutputFileNameEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=OutputFileNameEnum() -macro=226; +macro=231; Index: /issm/trunk/src/m/enum/P0Enum.m =================================================================== --- /issm/trunk/src/m/enum/P0Enum.m (revision 4042) +++ /issm/trunk/src/m/enum/P0Enum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=P0Enum() -macro=184; +macro=189; Index: /issm/trunk/src/m/enum/P1Enum.m =================================================================== --- /issm/trunk/src/m/enum/P1Enum.m (revision 4042) +++ /issm/trunk/src/m/enum/P1Enum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=P1Enum() -macro=185; +macro=190; Index: /issm/trunk/src/m/enum/ParameterOutputEnum.m =================================================================== --- /issm/trunk/src/m/enum/ParameterOutputEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ParameterOutputEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ParameterOutputEnum() -macro=227; +macro=232; Index: /issm/trunk/src/m/enum/PenaltyMeltingEnum.m =================================================================== --- /issm/trunk/src/m/enum/PenaltyMeltingEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/PenaltyMeltingEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=PenaltyMeltingEnum() -macro=228; +macro=233; Index: /issm/trunk/src/m/enum/PentaVertexResultEnum.m =================================================================== --- /issm/trunk/src/m/enum/PentaVertexResultEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/PentaVertexResultEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=PentaVertexResultEnum() -macro=188; +macro=193; Index: /issm/trunk/src/m/enum/QmuAnalysisEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuAnalysisEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/QmuAnalysisEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=QmuAnalysisEnum() -macro=229; +macro=234; Index: /issm/trunk/src/m/enum/QmuErrNameEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuErrNameEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/QmuErrNameEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=QmuErrNameEnum() -macro=230; +macro=235; Index: /issm/trunk/src/m/enum/QmuInNameEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuInNameEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/QmuInNameEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=QmuInNameEnum() -macro=231; +macro=236; Index: /issm/trunk/src/m/enum/QmuMassFluxSegmentsEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuMassFluxSegmentsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/QmuMassFluxSegmentsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=QmuMassFluxSegmentsEnum() -macro=232; +macro=237; Index: /issm/trunk/src/m/enum/QmuNPartEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuNPartEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/QmuNPartEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=QmuNPartEnum() -macro=233; +macro=238; Index: /issm/trunk/src/m/enum/QmuOutNameEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuOutNameEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/QmuOutNameEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=QmuOutNameEnum() -macro=234; +macro=239; Index: /issm/trunk/src/m/enum/QmuPartEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuPartEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/QmuPartEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=QmuPartEnum() -macro=235; +macro=240; Index: /issm/trunk/src/m/enum/QmuPressureEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuPressureEnum.m (revision 4043) +++ /issm/trunk/src/m/enum/QmuPressureEnum.m (revision 4043) @@ -0,0 +1,11 @@ +function macro=QmuPressureEnum() +%QMUPRESSUREENUM - Enum of QmuPressure +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/SynchronizeMatlabEnum +% Please read src/c/README for more information +% +% Usage: +% macro=QmuPressureEnum() + +macro=156; Index: /issm/trunk/src/m/enum/QmuVxEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuVxEnum.m (revision 4043) +++ /issm/trunk/src/m/enum/QmuVxEnum.m (revision 4043) @@ -0,0 +1,11 @@ +function macro=QmuVxEnum() +%QMUVXENUM - Enum of QmuVx +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/SynchronizeMatlabEnum +% Please read src/c/README for more information +% +% Usage: +% macro=QmuVxEnum() + +macro=177; Index: /issm/trunk/src/m/enum/QmuVyEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuVyEnum.m (revision 4043) +++ /issm/trunk/src/m/enum/QmuVyEnum.m (revision 4043) @@ -0,0 +1,11 @@ +function macro=QmuVyEnum() +%QMUVYENUM - Enum of QmuVy +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/SynchronizeMatlabEnum +% Please read src/c/README for more information +% +% Usage: +% macro=QmuVyEnum() + +macro=182; Index: /issm/trunk/src/m/enum/QmuVzEnum.m =================================================================== --- /issm/trunk/src/m/enum/QmuVzEnum.m (revision 4043) +++ /issm/trunk/src/m/enum/QmuVzEnum.m (revision 4043) @@ -0,0 +1,11 @@ +function macro=QmuVzEnum() +%QMUVZENUM - Enum of QmuVz +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/SynchronizeMatlabEnum +% Please read src/c/README for more information +% +% Usage: +% macro=QmuVzEnum() + +macro=187; Index: /issm/trunk/src/m/enum/ResetPenaltiesEnum.m =================================================================== --- /issm/trunk/src/m/enum/ResetPenaltiesEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ResetPenaltiesEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ResetPenaltiesEnum() -macro=156; +macro=158; Index: /issm/trunk/src/m/enum/ResponseDescriptorsEnum.m =================================================================== --- /issm/trunk/src/m/enum/ResponseDescriptorsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ResponseDescriptorsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ResponseDescriptorsEnum() -macro=236; +macro=241; Index: /issm/trunk/src/m/enum/RheologyBEnum.m =================================================================== --- /issm/trunk/src/m/enum/RheologyBEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/RheologyBEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=RheologyBEnum() -macro=157; +macro=159; Index: /issm/trunk/src/m/enum/RheologyNEnum.m =================================================================== --- /issm/trunk/src/m/enum/RheologyNEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/RheologyNEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=RheologyNEnum() -macro=158; +macro=160; Index: /issm/trunk/src/m/enum/SegmentOnIceShelfEnum.m =================================================================== --- /issm/trunk/src/m/enum/SegmentOnIceShelfEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/SegmentOnIceShelfEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=SegmentOnIceShelfEnum() -macro=159; +macro=161; Index: /issm/trunk/src/m/enum/SingVertexResultEnum.m =================================================================== --- /issm/trunk/src/m/enum/SingVertexResultEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/SingVertexResultEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=SingVertexResultEnum() -macro=189; +macro=194; Index: /issm/trunk/src/m/enum/SolverStringEnum.m =================================================================== --- /issm/trunk/src/m/enum/SolverStringEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/SolverStringEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=SolverStringEnum() -macro=237; +macro=242; Index: /issm/trunk/src/m/enum/SparsityEnum.m =================================================================== --- /issm/trunk/src/m/enum/SparsityEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/SparsityEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=SparsityEnum() -macro=238; +macro=243; Index: /issm/trunk/src/m/enum/StabilizeConstraintsEnum.m =================================================================== --- /issm/trunk/src/m/enum/StabilizeConstraintsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/StabilizeConstraintsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=StabilizeConstraintsEnum() -macro=160; +macro=162; Index: /issm/trunk/src/m/enum/StokesPressureEnum.m =================================================================== --- /issm/trunk/src/m/enum/StokesPressureEnum.m (revision 4043) +++ /issm/trunk/src/m/enum/StokesPressureEnum.m (revision 4043) @@ -0,0 +1,11 @@ +function macro=StokesPressureEnum() +%STOKESPRESSUREENUM - Enum of StokesPressure +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/SynchronizeMatlabEnum +% Please read src/c/README for more information +% +% Usage: +% macro=StokesPressureEnum() + +macro=157; Index: /issm/trunk/src/m/enum/StokesReconditioningEnum.m =================================================================== --- /issm/trunk/src/m/enum/StokesReconditioningEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/StokesReconditioningEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=StokesReconditioningEnum() -macro=161; +macro=163; Index: /issm/trunk/src/m/enum/StringAsEnum.m =================================================================== --- /issm/trunk/src/m/enum/StringAsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/StringAsEnum.m (revision 4043) @@ -165,4 +165,6 @@ elseif (strcmpi(name,'Pressure')), enum=PressureEnum(); return elseif (strcmpi(name,'PressureOld')), enum=PressureOldEnum(); return +elseif (strcmpi(name,'QmuPressure')), enum=QmuPressureEnum(); return +elseif (strcmpi(name,'StokesPressure')), enum=StokesPressureEnum(); return elseif (strcmpi(name,'ResetPenalties')), enum=ResetPenaltiesEnum(); return elseif (strcmpi(name,'RheologyB')), enum=RheologyBEnum(); return @@ -184,12 +186,15 @@ elseif (strcmpi(name,'VxObs')), enum=VxObsEnum(); return elseif (strcmpi(name,'VxOld')), enum=VxOldEnum(); return +elseif (strcmpi(name,'QmuVx')), enum=QmuVxEnum(); return elseif (strcmpi(name,'VyAverage')), enum=VyAverageEnum(); return elseif (strcmpi(name,'Vy')), enum=VyEnum(); return elseif (strcmpi(name,'VyObs')), enum=VyObsEnum(); return elseif (strcmpi(name,'VyOld')), enum=VyOldEnum(); return +elseif (strcmpi(name,'QmuVy')), enum=QmuVyEnum(); return elseif (strcmpi(name,'VzAverage')), enum=VzAverageEnum(); return elseif (strcmpi(name,'Vz')), enum=VzEnum(); return elseif (strcmpi(name,'VzObs')), enum=VzObsEnum(); return elseif (strcmpi(name,'VzOld')), enum=VzOldEnum(); return +elseif (strcmpi(name,'QmuVz')), enum=QmuVzEnum(); return elseif (strcmpi(name,'Weights')), enum=WeightsEnum(); return elseif (strcmpi(name,'P0')), enum=P0Enum(); return Index: /issm/trunk/src/m/enum/SurfaceAreaEnum.m =================================================================== --- /issm/trunk/src/m/enum/SurfaceAreaEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/SurfaceAreaEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=SurfaceAreaEnum() -macro=162; +macro=164; Index: /issm/trunk/src/m/enum/SurfaceEnum.m =================================================================== --- /issm/trunk/src/m/enum/SurfaceEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/SurfaceEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=SurfaceEnum() -macro=163; +macro=165; Index: /issm/trunk/src/m/enum/SurfaceSlopeXEnum.m =================================================================== --- /issm/trunk/src/m/enum/SurfaceSlopeXEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/SurfaceSlopeXEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=SurfaceSlopeXEnum() -macro=164; +macro=166; Index: /issm/trunk/src/m/enum/SurfaceSlopeYEnum.m =================================================================== --- /issm/trunk/src/m/enum/SurfaceSlopeYEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/SurfaceSlopeYEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=SurfaceSlopeYEnum() -macro=165; +macro=167; Index: /issm/trunk/src/m/enum/TemperatureAverageEnum.m =================================================================== --- /issm/trunk/src/m/enum/TemperatureAverageEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/TemperatureAverageEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=TemperatureAverageEnum() -macro=167; +macro=169; Index: /issm/trunk/src/m/enum/TemperatureEnum.m =================================================================== --- /issm/trunk/src/m/enum/TemperatureEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/TemperatureEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=TemperatureEnum() -macro=166; +macro=168; Index: /issm/trunk/src/m/enum/ThicknessEnum.m =================================================================== --- /issm/trunk/src/m/enum/ThicknessEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ThicknessEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ThicknessEnum() -macro=168; +macro=170; Index: /issm/trunk/src/m/enum/TolXEnum.m =================================================================== --- /issm/trunk/src/m/enum/TolXEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/TolXEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=TolXEnum() -macro=239; +macro=244; Index: /issm/trunk/src/m/enum/TriaVertexResultEnum.m =================================================================== --- /issm/trunk/src/m/enum/TriaVertexResultEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/TriaVertexResultEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=TriaVertexResultEnum() -macro=187; +macro=192; Index: /issm/trunk/src/m/enum/TypeEnum.m =================================================================== --- /issm/trunk/src/m/enum/TypeEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/TypeEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=TypeEnum() -macro=169; +macro=171; Index: /issm/trunk/src/m/enum/VariableDescriptorsEnum.m =================================================================== --- /issm/trunk/src/m/enum/VariableDescriptorsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VariableDescriptorsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VariableDescriptorsEnum() -macro=240; +macro=245; Index: /issm/trunk/src/m/enum/VerboseEnum.m =================================================================== --- /issm/trunk/src/m/enum/VerboseEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VerboseEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VerboseEnum() -macro=241; +macro=246; Index: /issm/trunk/src/m/enum/ViscosityOvershootEnum.m =================================================================== --- /issm/trunk/src/m/enum/ViscosityOvershootEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/ViscosityOvershootEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=ViscosityOvershootEnum() -macro=170; +macro=172; Index: /issm/trunk/src/m/enum/VxAverageEnum.m =================================================================== --- /issm/trunk/src/m/enum/VxAverageEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VxAverageEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VxAverageEnum() -macro=171; +macro=173; Index: /issm/trunk/src/m/enum/VxEnum.m =================================================================== --- /issm/trunk/src/m/enum/VxEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VxEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VxEnum() -macro=172; +macro=174; Index: /issm/trunk/src/m/enum/VxObsEnum.m =================================================================== --- /issm/trunk/src/m/enum/VxObsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VxObsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VxObsEnum() -macro=173; +macro=175; Index: /issm/trunk/src/m/enum/VxOldEnum.m =================================================================== --- /issm/trunk/src/m/enum/VxOldEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VxOldEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VxOldEnum() -macro=174; +macro=176; Index: /issm/trunk/src/m/enum/VyAverageEnum.m =================================================================== --- /issm/trunk/src/m/enum/VyAverageEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VyAverageEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VyAverageEnum() -macro=175; +macro=178; Index: /issm/trunk/src/m/enum/VyEnum.m =================================================================== --- /issm/trunk/src/m/enum/VyEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VyEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VyEnum() -macro=176; +macro=179; Index: /issm/trunk/src/m/enum/VyObsEnum.m =================================================================== --- /issm/trunk/src/m/enum/VyObsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VyObsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VyObsEnum() -macro=177; +macro=180; Index: /issm/trunk/src/m/enum/VyOldEnum.m =================================================================== --- /issm/trunk/src/m/enum/VyOldEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VyOldEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VyOldEnum() -macro=178; +macro=181; Index: /issm/trunk/src/m/enum/VzAverageEnum.m =================================================================== --- /issm/trunk/src/m/enum/VzAverageEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VzAverageEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VzAverageEnum() -macro=179; +macro=183; Index: /issm/trunk/src/m/enum/VzEnum.m =================================================================== --- /issm/trunk/src/m/enum/VzEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VzEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VzEnum() -macro=180; +macro=184; Index: /issm/trunk/src/m/enum/VzObsEnum.m =================================================================== --- /issm/trunk/src/m/enum/VzObsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VzObsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VzObsEnum() -macro=181; +macro=185; Index: /issm/trunk/src/m/enum/VzOldEnum.m =================================================================== --- /issm/trunk/src/m/enum/VzOldEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/VzOldEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=VzOldEnum() -macro=182; +macro=186; Index: /issm/trunk/src/m/enum/WaitOnLockEnum.m =================================================================== --- /issm/trunk/src/m/enum/WaitOnLockEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/WaitOnLockEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=WaitOnLockEnum() -macro=242; +macro=247; Index: /issm/trunk/src/m/enum/WeightsEnum.m =================================================================== --- /issm/trunk/src/m/enum/WeightsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/WeightsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=WeightsEnum() -macro=183; +macro=188; Index: /issm/trunk/src/m/enum/YtsEnum.m =================================================================== --- /issm/trunk/src/m/enum/YtsEnum.m (revision 4042) +++ /issm/trunk/src/m/enum/YtsEnum.m (revision 4043) @@ -9,3 +9,3 @@ % macro=YtsEnum() -macro=243; +macro=248; Index: /issm/trunk/src/m/solutions/jpl/SpawnCore.m =================================================================== --- /issm/trunk/src/m/solutions/jpl/SpawnCore.m (revision 4042) +++ /issm/trunk/src/m/solutions/jpl/SpawnCore.m (revision 4043) @@ -1,3 +1,3 @@ -function responses=SpawnCore(models,variables,variabledescriptors,analysis_type,sub_analysis_type,counter); +function responses=SpawnCore(models,variables,variabledescriptors,counter); %SPAWNCORE - for Qmu analysis, using Dakota. Spawn the core solution. %