Index: /issm/trunk/src/c/Container/Inputs.cpp =================================================================== --- /issm/trunk/src/c/Container/Inputs.cpp (revision 10134) +++ /issm/trunk/src/c/Container/Inputs.cpp (revision 10135) @@ -43,6 +43,6 @@ /*Object management*/ -/*FUNCTION Inputs::GetParameterValue(bool* pvalue,int enum-type){{{1*/ -void Inputs::GetParameterValue(bool* pvalue,int enum_type){ +/*FUNCTION Inputs::GetInputValue(bool* pvalue,int enum-type){{{1*/ +void Inputs::GetInputValue(bool* pvalue,int enum_type){ vector::iterator object; @@ -67,10 +67,10 @@ /*Ok, we have an input if we made it here, request the input to return the value: */ - input->GetParameterValue(pvalue); - -} -/*}}}*/ -/*FUNCTION Inputs::GetParameterValue(int* pvalue,int enum-type){{{1*/ -void Inputs::GetParameterValue(int* pvalue,int enum_type){ + input->GetInputValue(pvalue); + +} +/*}}}*/ +/*FUNCTION Inputs::GetInputValue(int* pvalue,int enum-type){{{1*/ +void Inputs::GetInputValue(int* pvalue,int enum_type){ vector::iterator object; @@ -95,10 +95,10 @@ /*Ok, we have an input if we made it here, request the input to return the value: */ - input->GetParameterValue(pvalue); - -} -/*}}}*/ -/*FUNCTION Inputs::GetParameterValue(double* pvalue,int enum-type){{{1*/ -void Inputs::GetParameterValue(double* pvalue,int enum_type){ + input->GetInputValue(pvalue); + +} +/*}}}*/ +/*FUNCTION Inputs::GetInputValue(double* pvalue,int enum-type){{{1*/ +void Inputs::GetInputValue(double* pvalue,int enum_type){ vector::iterator object; @@ -123,10 +123,10 @@ /*Ok, we have an input if we made it here, request the input to return the value: */ - input->GetParameterValue(pvalue); - -} -/*}}}*/ -/*FUNCTION Inputs::GetParameterAverage{{{1*/ -void Inputs::GetParameterAverage(double* pvalue,int enum_type){ + input->GetInputValue(pvalue); + +} +/*}}}*/ +/*FUNCTION Inputs::GetInputAverage{{{1*/ +void Inputs::GetInputAverage(double* pvalue,int enum_type){ vector::iterator object; @@ -151,5 +151,5 @@ /*Ok, we have an input if we made it here, request the input to return the value: */ - input->GetParameterAverage(pvalue); + input->GetInputAverage(pvalue); } Index: /issm/trunk/src/c/Container/Inputs.h =================================================================== --- /issm/trunk/src/c/Container/Inputs.h (revision 10134) +++ /issm/trunk/src/c/Container/Inputs.h (revision 10135) @@ -44,8 +44,8 @@ double MinAbs(int enumtype); - void GetParameterAverage(double* pvalue, int enum_type); - void GetParameterValue(bool* pvalue,int enum_type); - void GetParameterValue(int* pvalue,int enum_type); - void GetParameterValue(double* pvalue,int enum_type); + void GetInputAverage(double* pvalue, int enum_type); + void GetInputValue(bool* pvalue,int enum_type); + void GetInputValue(int* pvalue,int enum_type); + void GetInputValue(double* pvalue,int enum_type); void Configure(Parameters* parameters); Index: /issm/trunk/src/c/objects/Elements/Element.h =================================================================== --- /issm/trunk/src/c/objects/Elements/Element.h (revision 10134) +++ /issm/trunk/src/c/objects/Elements/Element.h (revision 10135) @@ -37,7 +37,7 @@ virtual bool IsNodeOnShelfFromFlags(double* flags)=0; virtual bool IsOnBed()=0; - virtual void GetParameterListOnVertices(double* pvalue,int enumtype)=0; - virtual void GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue)=0; - virtual void GetParameterValue(double* pvalue,Node* node,int enumtype)=0; + virtual void GetInputListOnVertices(double* pvalue,int enumtype)=0; + virtual void GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue)=0; + virtual void GetInputValue(double* pvalue,Node* node,int enumtype)=0; virtual double SurfaceArea(void)=0; Index: /issm/trunk/src/c/objects/Elements/Penta.cpp =================================================================== --- /issm/trunk/src/c/objects/Elements/Penta.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Elements/Penta.cpp (revision 10135) @@ -383,6 +383,6 @@ friction->GetAlpha2(&alpha2,gauss,VxEnum,VyEnum,VzEnum); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); basalfriction[count]=alpha2*(pow(vx,2.0)+pow(vy,2.0)); count++; @@ -421,5 +421,5 @@ /*retrive parameters: */ parameters->FindParam(&analysis_type,AnalysisTypeEnum); - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*Check analysis_types*/ @@ -459,5 +459,5 @@ this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input); matice->GetViscosity3dStokes(&viscosity,&epsilon[0]); - pressure_input->GetParameterValue(&pressure,gauss); + pressure_input->GetInputValue(&pressure,gauss); /*Compute Stress*/ @@ -869,6 +869,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetParameterListOnVertices(double* pvalue,int enumtype) {{{1*/ -void Penta::GetParameterListOnVertices(double* pvalue,int enumtype){ +/*FUNCTION Penta::GetInputListOnVertices(double* pvalue,int enumtype) {{{1*/ +void Penta::GetInputListOnVertices(double* pvalue,int enumtype){ /*Intermediaries*/ @@ -887,5 +887,5 @@ for (int iv=0;ivGaussVertex(iv); - input->GetParameterValue(&pvalue[iv],gauss); + input->GetInputValue(&pvalue[iv],gauss); } @@ -894,6 +894,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue) {{{1*/ -void Penta::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue){ +/*FUNCTION Penta::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue) {{{1*/ +void Penta::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue){ /*Intermediaries*/ @@ -912,5 +912,5 @@ for (int iv=0;ivGaussVertex(iv); - input->GetParameterValue(&pvalue[iv],gauss); + input->GetInputValue(&pvalue[iv],gauss); } } @@ -923,6 +923,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetParameterValue(double* pvalue,Node* node,int enumtype) {{{1*/ -void Penta::GetParameterValue(double* pvalue,Node* node,int enumtype){ +/*FUNCTION Penta::GetInputValue(double* pvalue,Node* node,int enumtype) {{{1*/ +void Penta::GetInputValue(double* pvalue,Node* node,int enumtype){ Input* input=inputs->GetInput(enumtype); @@ -932,5 +932,5 @@ gauss->GaussVertex(this->GetNodeIndex(node)); - input->GetParameterValue(pvalue,gauss); + input->GetInputValue(pvalue,gauss); delete gauss; } @@ -995,5 +995,5 @@ case DiagnosticHorizAnalysisEnum: int approximation; - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation==StokesApproximationEnum || approximation==NoneApproximationEnum){ GetSolutionFromInputsDiagnosticStokes(solution); @@ -1155,5 +1155,5 @@ GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES); for(i=0;iGetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation==StokesApproximationEnum || approximation==NoneApproximationEnum){ InputUpdateFromSolutionAdjointStokes( solution); @@ -1932,5 +1932,5 @@ bool onbed; - inputs->GetParameterValue(&onbed,MeshElementonbedEnum); + inputs->GetInputValue(&onbed,MeshElementonbedEnum); return onbed; } @@ -1970,5 +1970,5 @@ bool onshelf; - inputs->GetParameterValue(&onshelf,MaskElementonfloatingiceEnum); + inputs->GetInputValue(&onshelf,MaskElementonfloatingiceEnum); return onshelf; } @@ -2008,5 +2008,5 @@ bool onsurface; - inputs->GetParameterValue(&onsurface,MeshElementonsurfaceEnum); + inputs->GetInputValue(&onsurface,MeshElementonsurfaceEnum); return onsurface; } @@ -2016,5 +2016,5 @@ bool onwater; - inputs->GetParameterValue(&onwater,MaskElementonwaterEnum); + inputs->GetInputValue(&onwater,MaskElementonwaterEnum); return onwater; } @@ -2345,5 +2345,5 @@ /*retrieve inputs :*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*If on water, return 0: */ @@ -2648,5 +2648,5 @@ gauss->GaussVertex(iv); - thickness_input->GetParameterValue(&thickness,gauss); + thickness_input->GetInputValue(&thickness,gauss); this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input); @@ -2738,5 +2738,5 @@ /*ok, we are good. retrieve value of input at vertex :*/ gauss=new GaussPenta(); gauss->GaussVertex(i); - data->GetParameterValue(&value,gauss); + data->GetInputValue(&value,gauss); found=1; break; @@ -2983,6 +2983,6 @@ GetBConduct(&B_conduct[0][0],&xyz_list[0][0],gauss); - enthalpy_input->GetParameterValue(&enthalpy, gauss); - pressure_input->GetParameterValue(&pressure, gauss); + enthalpy_input->GetInputValue(&enthalpy, gauss); + pressure_input->GetInputValue(&pressure, gauss); kappa=matpar->GetEnthalpyDiffusionParameter(enthalpy,pressure); D_scalar_conduct=gauss->weight*Jdet*kappa; @@ -3003,10 +3003,10 @@ GetBprimeAdvec(&Bprime_advec[0][0],&xyz_list[0][0],gauss); - vx_input->GetParameterValue(&u, gauss); - vy_input->GetParameterValue(&v, gauss); - vz_input->GetParameterValue(&w, gauss); - vxm_input->GetParameterValue(&um,gauss); - vym_input->GetParameterValue(&vm,gauss); - vzm_input->GetParameterValue(&wm,gauss); + vx_input->GetInputValue(&u, gauss); + vy_input->GetInputValue(&v, gauss); + vz_input->GetInputValue(&w, gauss); + vxm_input->GetInputValue(&um,gauss); + vym_input->GetInputValue(&vm,gauss); + vzm_input->GetInputValue(&wm,gauss); D_scalar_advec=gauss->weight*Jdet; @@ -3237,10 +3237,10 @@ GetBprimeAdvec(&Bprime_advec[0][0],&xyz_list[0][0],gauss); - vx_input->GetParameterValue(&u, gauss); - vy_input->GetParameterValue(&v, gauss); - vz_input->GetParameterValue(&w, gauss); - vxm_input->GetParameterValue(&um,gauss); - vym_input->GetParameterValue(&vm,gauss); - vzm_input->GetParameterValue(&wm,gauss); + vx_input->GetInputValue(&u, gauss); + vy_input->GetInputValue(&v, gauss); + vz_input->GetInputValue(&w, gauss); + vxm_input->GetInputValue(&um,gauss); + vym_input->GetInputValue(&vm,gauss); + vzm_input->GetInputValue(&wm,gauss); D_scalar_advec=gauss->weight*Jdet; @@ -3443,5 +3443,5 @@ /* Build transient now */ if(dt){ - temperature_input->GetParameterValue(&temperature, gauss); + temperature_input->GetInputValue(&temperature, gauss); scalar_transient=temperature*Jdet*gauss->weight; for(i=0;ivalues[i]+=scalar_transient*L[i]; @@ -3451,7 +3451,7 @@ GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss); - vx_input->GetParameterValue(&u, gauss); - vy_input->GetParameterValue(&v, gauss); - vz_input->GetParameterValue(&w, gauss); + vx_input->GetInputValue(&u, gauss); + vy_input->GetInputValue(&v, gauss); + vz_input->GetInputValue(&w, gauss); tau_parameter=GetStabilizationParameter(u,v,w,diameter,rho_ice,heatcapacity,thermalconductivity); @@ -3512,5 +3512,5 @@ GetNodalFunctionsP1(&basis[0], gauss); - pressure_input->GetParameterValue(&pressure,gauss); + pressure_input->GetInputValue(&pressure,gauss); h_pmp=matpar->PureIceEnthalpy(pressure); @@ -3575,8 +3575,8 @@ GetNodalFunctionsP1(&basis[0], gauss); - geothermalflux_input->GetParameterValue(&geothermalflux_value,gauss); + geothermalflux_input->GetInputValue(&geothermalflux_value,gauss); friction->GetAlpha2(&alpha2,gauss,VxEnum,VyEnum,VzEnum); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); basalfriction=alpha2*(pow(vx,2.0)+pow(vy,2.0)); @@ -3674,5 +3674,5 @@ /* Build transient now */ if(dt){ - temperature_input->GetParameterValue(&temperature, gauss); + temperature_input->GetInputValue(&temperature, gauss); scalar_transient=temperature*Jdet*gauss->weight; for(i=0;ivalues[i]+=scalar_transient*L[i]; @@ -3682,7 +3682,7 @@ GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss); - vx_input->GetParameterValue(&u, gauss); - vy_input->GetParameterValue(&v, gauss); - vz_input->GetParameterValue(&w, gauss); + vx_input->GetInputValue(&u, gauss); + vy_input->GetInputValue(&v, gauss); + vz_input->GetInputValue(&w, gauss); tau_parameter=GetStabilizationParameter(u,v,w,diameter,rho_ice,heatcapacity,thermalconductivity); @@ -3743,5 +3743,5 @@ GetNodalFunctionsP1(&basis[0], gauss); - pressure_input->GetParameterValue(&pressure,gauss); + pressure_input->GetInputValue(&pressure,gauss); t_pmp=matpar->TMeltingPoint(pressure); @@ -3806,8 +3806,8 @@ GetNodalFunctionsP1(&basis[0], gauss); - geothermalflux_input->GetParameterValue(&geothermalflux_value,gauss); + geothermalflux_input->GetInputValue(&geothermalflux_value,gauss); friction->GetAlpha2(&alpha2,gauss,VxEnum,VyEnum,VzEnum); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); basalfriction=alpha2*(pow(vx,2.0)+pow(vy,2.0)); @@ -3843,5 +3843,5 @@ /*Recover temperature*/ gauss->GaussVertex(i); - t_input->GetParameterValue(&temp,gauss); + t_input->GetInputValue(&temp,gauss); values[i]=temp; } @@ -3874,5 +3874,5 @@ /*Recover temperature*/ gauss->GaussVertex(i); - h_input->GetParameterValue(&enthalpy,gauss); + h_input->GetInputValue(&enthalpy,gauss); values[i]=enthalpy; } @@ -3916,5 +3916,5 @@ Input* surface_input=inputs->GetInput(SurfaceEnum); _assert_(surface_input); - this->inputs->GetParameterValue(&converged,ConvergedEnum); + this->inputs->GetInputValue(&converged,ConvergedEnum); if(converged){ this->inputs->AddInput(new PentaVertexInput(TemperatureEnum,values)); @@ -3933,5 +3933,5 @@ break; case ArrheniusEnum: - surface_input->GetParameterAverage(&s_average); + surface_input->GetInputAverage(&s_average); B_average=Arrhenius((values[0]+values[1]+values[2]+values[3]+values[4]+values[5])/6.0, s_average-((xyz_list[0][2]+xyz_list[1][2]+xyz_list[2][2]+xyz_list[3][2]+xyz_list[4][2]+xyz_list[5][2])/6.0), @@ -3982,9 +3982,9 @@ /*Get all inputs and parameters*/ GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES); - GetParameterListOnVertices(&pressure[0],PressureEnum); + GetInputListOnVertices(&pressure[0],PressureEnum); Input* surface_input=inputs->GetInput(SurfaceEnum); _assert_(surface_input); -// this->inputs->GetParameterValue(&converged,ConvergedEnum); +// this->inputs->GetInputValue(&converged,ConvergedEnum); // if(converged){ /*Convert enthalpy into temperature and water fraction*/ @@ -4008,5 +4008,5 @@ break; case ArrheniusEnum: - surface_input->GetParameterAverage(&s_average); + surface_input->GetInputAverage(&s_average); B_average=Arrhenius((temperatures[0]+temperatures[1]+temperatures[2]+temperatures[3]+temperatures[4]+temperatures[5])/6.0, s_average-((xyz_list[0][2]+xyz_list[1][2]+xyz_list[2][2]+xyz_list[3][2]+xyz_list[4][2]+xyz_list[5][2])/6.0), @@ -4094,5 +4094,5 @@ int approximation; - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); switch(approximation){ @@ -4166,5 +4166,5 @@ case FrictionCoefficientEnum: - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); switch(approximation){ case MacAyealApproximationEnum: @@ -4186,5 +4186,5 @@ case MaterialsRheologyBbarEnum: - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); switch(approximation){ case MacAyealApproximationEnum: @@ -4301,10 +4301,10 @@ friction->GetAlphaComplement(&alpha_complement, gauss,VxEnum,VyEnum,VzEnum); - dragcoefficient_input->GetParameterValue(&drag, gauss); - adjointx_input->GetParameterValue(&lambda, gauss); - adjointy_input->GetParameterValue(&mu, gauss); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - dragcoefficient_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss); + dragcoefficient_input->GetInputValue(&drag, gauss); + adjointx_input->GetInputValue(&lambda, gauss); + adjointy_input->GetInputValue(&mu, gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + dragcoefficient_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss); /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */ @@ -4372,15 +4372,15 @@ /*Recover alpha_complement and drag: */ friction->GetAlphaComplement(&alpha_complement, gauss,VxEnum,VyEnum,VzEnum); - drag_input->GetParameterValue(&drag,gauss); + drag_input->GetInputValue(&drag,gauss); /*recover lambda mu and xi: */ - adjointx_input->GetParameterValue(&lambda,gauss); - adjointy_input->GetParameterValue(&mu ,gauss); - adjointz_input->GetParameterValue(&xi ,gauss); + adjointx_input->GetInputValue(&lambda,gauss); + adjointy_input->GetInputValue(&mu ,gauss); + adjointz_input->GetInputValue(&xi ,gauss); /*recover vx vy and vz: */ - vx_input->GetParameterValue(&vx, gauss); - vy_input->GetParameterValue(&vy, gauss); - vz_input->GetParameterValue(&vz, gauss); + vx_input->GetInputValue(&vx, gauss); + vy_input->GetInputValue(&vy, gauss); + vz_input->GetInputValue(&vz, gauss); /*Get normal vector to the bed */ @@ -4396,5 +4396,5 @@ /*Get k derivative: dk/dx */ - drag_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss); + drag_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss); /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */ @@ -4594,5 +4594,5 @@ /*retrieve inputs :*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*If on water, return 0: */ @@ -4631,5 +4631,5 @@ /*retrieve inputs :*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*If on water, return 0: */ @@ -4668,5 +4668,5 @@ /*retrieve inputs :*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*If on water, return 0: */ @@ -4707,5 +4707,5 @@ /*retrieve inputs :*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*If on water, return 0: */ @@ -4744,5 +4744,5 @@ /*retrieve inputs :*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*If on water, return 0: */ @@ -4787,5 +4787,5 @@ /*retrieve inputs :*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*If on water, return 0: */ @@ -4864,8 +4864,8 @@ /*retrieve inputs: */ - GetParameterListOnVertices(&thickness_init[0],ThicknessEnum); - GetParameterListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum); - GetParameterListOnVertices(&bed[0],BedEnum); - GetParameterListOnVertices(&surface[0],SurfaceEnum); + GetInputListOnVertices(&thickness_init[0],ThicknessEnum); + GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum); + GetInputListOnVertices(&bed[0],BedEnum); + GetInputListOnVertices(&surface[0],SurfaceEnum); /*build new thickness: */ @@ -4952,5 +4952,5 @@ int approximation; - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); switch(approximation){ @@ -4972,5 +4972,5 @@ /*Initialize Element vector and return if necessary*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation!=StokesApproximationEnum) return NULL; @@ -5133,5 +5133,5 @@ // If we have a slope > 6% for this element, it means we are on a mountain. In this particular case, //velocity should be = 0. To achieve this result, we set alpha2_list to a very high value: */ - surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss); + surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss); slope_magnitude=sqrt(pow(slope[0],2)+pow(slope[1],2)); @@ -5299,5 +5299,5 @@ /*If on water or not Stokes, skip stiffness: */ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(IsOnShelf() || !IsOnBed()) return NULL; ElementMatrix* Ke1=new ElementMatrix(this->nodes,NUMVERTICES,this->parameters,MacAyealApproximationEnum); @@ -5407,5 +5407,5 @@ int approximation; - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); switch(approximation){ @@ -5560,5 +5560,5 @@ /*Initialize Element matrix*/ ElementMatrix* Ke=new ElementMatrix(tria->nodes,NUMVERTICES2D,this->parameters,MacAyealApproximationEnum); - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*Retrieve all inputs and parameters*/ @@ -5704,5 +5704,5 @@ /*Retrieve all inputs and parameters*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES); this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum); @@ -5789,5 +5789,5 @@ GetL(&L[0][0], gauss,NDOF2); - surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss); + surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss); friction->GetAlpha2(&alpha2, gauss,VxEnum,VyEnum,VzEnum); slope_magnitude=sqrt(pow(slope[0],2)+pow(slope[1],2)); @@ -5861,5 +5861,5 @@ /*If on water or not Stokes, skip stiffness: */ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation!=StokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum && approximation!=PattynStokesApproximationEnum) return NULL; ElementMatrix* Ke=new ElementMatrix(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum); @@ -5929,5 +5929,5 @@ /*If on water or not Stokes, skip stiffness: */ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(IsOnShelf() || !IsOnBed() || (approximation!=StokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum && approximation!=PattynStokesApproximationEnum)) return NULL; ElementMatrix* Ke=new ElementMatrix(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum); @@ -6129,5 +6129,5 @@ /*Initialize Element vector and return if necessary*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation!=MacAyealStokesApproximationEnum) return NULL; ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum); @@ -6151,5 +6151,5 @@ GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss); - vzmacayeal_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss); + vzmacayeal_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss); this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input); @@ -6193,5 +6193,5 @@ /*Initialize Element vector and return if necessary*/ if(!IsOnBed() || IsOnShelf()) return NULL; - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation!=MacAyealStokesApproximationEnum) return NULL; ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum); @@ -6220,6 +6220,6 @@ GetNodalFunctionsP1(basis, gauss); - vzmacayeal_input->GetParameterValue(&w, gauss); - vzmacayeal_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss); + vzmacayeal_input->GetInputValue(&w, gauss); + vzmacayeal_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss); BedNormal(&bed_normal[0],xyz_list_tria); @@ -6274,5 +6274,5 @@ /*Initialize Element vector and return if necessary*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation!=PattynStokesApproximationEnum) return NULL; ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum); @@ -6296,5 +6296,5 @@ GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss); - vzpattyn_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss); + vzpattyn_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss); this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input); @@ -6338,5 +6338,5 @@ /*Initialize Element vector and return if necessary*/ if(!IsOnBed() || IsOnShelf()) return NULL; - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation!=PattynStokesApproximationEnum) return NULL; ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum); @@ -6365,6 +6365,6 @@ GetNodalFunctionsP1(basis, gauss); - vzpattyn_input->GetParameterValue(&w, gauss); - vzpattyn_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss); + vzpattyn_input->GetInputValue(&w, gauss); + vzpattyn_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss); BedNormal(&bed_normal[0],xyz_list_tria); @@ -6390,5 +6390,5 @@ int approximation; - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); switch(approximation){ @@ -6513,13 +6513,13 @@ gauss->GaussPoint(ig); - slopex_input->GetParameterValue(&slope[0],gauss); - slopey_input->GetParameterValue(&slope[1],gauss); - surface_input->GetParameterValue(&surface,gauss); - thickness_input->GetParameterValue(&thickness,gauss); + slopex_input->GetInputValue(&slope[0],gauss); + slopey_input->GetInputValue(&slope[1],gauss); + surface_input->GetInputValue(&surface,gauss); + thickness_input->GetInputValue(&thickness,gauss); slope2=pow(slope[0],2)+pow(slope[1],2); constant_part=-2*pow(rho_ice*gravity,n)*pow(slope2,((n-1)/2)); - PentaRef::GetParameterValue(&z_g,&z_list[0],gauss); + PentaRef::GetInputValue(&z_g,&z_list[0],gauss); GetSegmentJacobianDeterminant(&Jdet,&xyz_list_segment[0][0],gauss); @@ -6571,5 +6571,5 @@ int i,j,ig; double Jdet; - double slope[3]; //do not put 2! this goes into GetParameterDerivativeValue, which addresses slope[3] also! + double slope[3]; //do not put 2! this goes into GetInputDerivativeValue, which addresses slope[3] also! double driving_stress_baseline,thickness; double xyz_list[NUMVERTICES][3]; @@ -6594,6 +6594,6 @@ GetNodalFunctionsP1(basis, gauss); - thickness_input->GetParameterValue(&thickness, gauss); - surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss); + thickness_input->GetInputValue(&thickness, gauss); + surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss); driving_stress_baseline=matpar->GetRhoIce()*matpar->GetG(); @@ -6646,5 +6646,5 @@ /*Initialize Element vector and return if necessary*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation!=StokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum && approximation!=PattynStokesApproximationEnum) return NULL; ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum); @@ -6718,5 +6718,5 @@ /*Initialize Element vector and return if necessary*/ if(!IsOnBed() || !IsOnShelf()) return NULL; - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); this->parameters->FindParam(&shelf_dampening,DiagnosticShelfDampeningEnum); if(approximation!=StokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum && approximation!=PattynStokesApproximationEnum) return NULL; @@ -6744,10 +6744,10 @@ BedNormal(&bed_normal[0],xyz_list_tria); - bed_input->GetParameterValue(&bed, gauss); + bed_input->GetInputValue(&bed, gauss); if(shelf_dampening){ //add dampening to avoid too high vertical velocities when not in hydrostatic equilibrium - bed_input->GetParameterDerivativeValue(&dz[0],&xyz_list[0][0],gauss); - vx_input->GetParameterValue(&vx, gauss); - vy_input->GetParameterValue(&vy, gauss); - vz_input->GetParameterValue(&vz, gauss); + bed_input->GetInputDerivativeValue(&dz[0],&xyz_list[0][0],gauss); + vx_input->GetInputValue(&vx, gauss); + vy_input->GetInputValue(&vy, gauss); + vz_input->GetInputValue(&vz, gauss); dt=0; normal_vel=bed_normal[0]*vx+bed_normal[1]*vy+bed_normal[2]*vz; @@ -6800,5 +6800,5 @@ /*Retrieve all inputs and parameters*/ GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES); - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -6817,8 +6817,8 @@ GetNodalFunctionsP1(basis, gauss); - vx_input->GetParameterDerivativeValue(&du[0],&xyz_list[0][0],gauss); - vy_input->GetParameterDerivativeValue(&dv[0],&xyz_list[0][0],gauss); + vx_input->GetInputDerivativeValue(&du[0],&xyz_list[0][0],gauss); + vy_input->GetInputDerivativeValue(&dv[0],&xyz_list[0][0],gauss); if(approximation==PattynStokesApproximationEnum || approximation==MacAyealStokesApproximationEnum){ - vzstokes_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss); + vzstokes_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss); dwdz=dw[2]; } @@ -6861,5 +6861,5 @@ GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES); for(i=0;iGetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); Input* bed_input=inputs->GetInput(BedEnum); _assert_(bed_input); Input* basal_melting_input=inputs->GetInput(BasalforcingsMeltingRateEnum); _assert_(basal_melting_input); @@ -6877,10 +6877,10 @@ gauss->GaussPoint(ig); - basal_melting_input->GetParameterValue(&basalmeltingvalue, gauss); - bed_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss); - vx_input->GetParameterValue(&vx, gauss); - vy_input->GetParameterValue(&vy, gauss); + basal_melting_input->GetInputValue(&basalmeltingvalue, gauss); + bed_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss); + vx_input->GetInputValue(&vx, gauss); + vy_input->GetInputValue(&vy, gauss); if(approximation==PattynStokesApproximationEnum || approximation==MacAyealStokesApproximationEnum){ - vzstokes_input->GetParameterValue(&vz, gauss); + vzstokes_input->GetInputValue(&vz, gauss); } else vz=0; @@ -6913,5 +6913,5 @@ /*Get approximation enum and dof list: */ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -6928,6 +6928,6 @@ /*Recover vx and vy*/ gauss->GaussVertex(i); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); values[i*NDOF2+0]=vx; values[i*NDOF2+1]=vy; @@ -6964,6 +6964,6 @@ /*Recover vx and vy*/ gauss->GaussVertex(i); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); values[i*NDOF2+0]=vx; values[i*NDOF2+1]=vy; @@ -6999,5 +6999,5 @@ /*Recover vz */ gauss->GaussVertex(i); - vz_input->GetParameterValue(&vz,gauss); + vz_input->GetInputValue(&vz,gauss); values[i]=vz; } @@ -7038,8 +7038,8 @@ for(i=0;iGaussVertex(i); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vz_input->GetParameterValue(&vz,gauss); - p_input ->GetParameterValue(&p ,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vz_input->GetInputValue(&vz,gauss); + p_input ->GetInputValue(&p ,gauss); values[i*NDOF4+0]=vx; values[i*NDOF4+1]=vy; @@ -7062,5 +7062,5 @@ /*Recover inputs*/ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); /*MacAyeal, everything is done by the element on bed*/ @@ -7151,5 +7151,5 @@ /*Now compute pressure*/ - GetParameterListOnVertices(&surface[0],SurfaceEnum); + GetInputListOnVertices(&surface[0],SurfaceEnum); for(i=0;iGetRhoIce(); g=matpar->GetG(); - GetParameterListOnVertices(&surface[0],SurfaceEnum); + GetInputListOnVertices(&surface[0],SurfaceEnum); for(i=0;iGetInput(VzEnum); if (vz_input){ - GetParameterListOnVertices(&vz[0],VzEnum); + GetInputListOnVertices(&vz[0],VzEnum); } else{ @@ -7420,5 +7420,5 @@ rho_ice=matpar->GetRhoIce(); g=matpar->GetG(); - GetParameterListOnVertices(&surface[0],SurfaceEnum); + GetInputListOnVertices(&surface[0],SurfaceEnum); for(i=0;iGetRhoIce(); g=matpar->GetG(); - GetParameterListOnVertices(&surface[0],SurfaceEnum); + GetInputListOnVertices(&surface[0],SurfaceEnum); for(i=0;iGetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation==StokesApproximationEnum || approximation==NoneApproximationEnum){ return; @@ -7704,5 +7704,5 @@ rho_ice=matpar->GetRhoIce(); g=matpar->GetG(); - GetParameterListOnVertices(&surface[0],SurfaceEnum); + GetInputListOnVertices(&surface[0],SurfaceEnum); for(i=0;iObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!"); - GetParameterListOnVertices(&h[0],ThicknessEnum); - GetParameterListOnVertices(&s[0],SurfaceEnum); - GetParameterListOnVertices(&b[0],BedEnum); - GetParameterListOnVertices(&ba[0],BathymetryEnum); + GetInputListOnVertices(&h[0],ThicknessEnum); + GetInputListOnVertices(&s[0],SurfaceEnum); + GetInputListOnVertices(&b[0],BedEnum); + GetInputListOnVertices(&ba[0],BathymetryEnum); /*material parameters: */ @@ -542,6 +542,6 @@ delete gauss; - vxaverage_input->GetParameterAverage(&v_gauss[0]); - vyaverage_input->GetParameterAverage(&v_gauss[1]); + vxaverage_input->GetInputAverage(&v_gauss[0]); + vyaverage_input->GetInputAverage(&v_gauss[1]); K[0][0]=pow(Jdettria,(double).5)/2.0*fabs(v_gauss[0]); @@ -558,8 +558,8 @@ GetL(&L[0], &xyz_list[0][0], gauss,NDOF1); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); - vxaverage_input->GetParameterDerivativeValue(&dvx[0],&xyz_list[0][0],gauss); - vyaverage_input->GetParameterDerivativeValue(&dvy[0],&xyz_list[0][0],gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); + vxaverage_input->GetInputDerivativeValue(&dvx[0],&xyz_list[0][0],gauss); + vyaverage_input->GetInputDerivativeValue(&dvy[0],&xyz_list[0][0],gauss); DL_scalar=gauss->weight*Jdettria; @@ -650,6 +650,6 @@ gauss->GaussPoint(ig); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); GetJacobianDeterminant2d(&Jdettria, &xyz_list[0][0],gauss); @@ -832,8 +832,8 @@ GetL(&L[0], &xyz_list[0][0], gauss,NDOF1); - surface_mass_balance_input->GetParameterValue(&surface_mass_balance_g,gauss); - basal_melting_input->GetParameterValue(&basal_melting_g,gauss); - thickness_input->GetParameterValue(&thickness_g,gauss); - if(basal_melting_correction_input) basal_melting_correction_input->GetParameterValue(&basal_melting_correction_g,gauss); + surface_mass_balance_input->GetInputValue(&surface_mass_balance_g,gauss); + basal_melting_input->GetInputValue(&basal_melting_g,gauss); + thickness_input->GetInputValue(&thickness_g,gauss); + if(basal_melting_correction_input) basal_melting_correction_input->GetInputValue(&basal_melting_correction_g,gauss); for(i=0;ivalues[i]+=Jdettria*gauss->weight*(thickness_g+dt*(surface_mass_balance_g-basal_melting_g-basal_melting_correction_g))*L[i]; @@ -878,7 +878,7 @@ GetL(&L[0], &xyz_list[0][0], gauss,NDOF1); - surface_mass_balance_input->GetParameterValue(&surface_mass_balance_g,gauss); - basal_melting_input->GetParameterValue(&basal_melting_g,gauss); - thickness_input->GetParameterValue(&thickness_g,gauss); + surface_mass_balance_input->GetInputValue(&surface_mass_balance_g,gauss); + basal_melting_input->GetInputValue(&basal_melting_g,gauss); + thickness_input->GetInputValue(&thickness_g,gauss); for(i=0;ivalues[i]+=Jdettria*gauss->weight*(thickness_g+dt*(surface_mass_balance_g-basal_melting_g))*L[i]; @@ -928,5 +928,5 @@ GetNodalFunctions(basis, gauss); - slope_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss); + slope_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss); if ( (analysis_type==SurfaceSlopeXAnalysisEnum) || (analysis_type==BedSlopeXAnalysisEnum)){ @@ -1140,6 +1140,6 @@ } /*}}}*/ -/*FUNCTION Tria::GetParameterListOnVertices(double* pvalue,int enumtype) {{{1*/ -void Tria::GetParameterListOnVertices(double* pvalue,int enumtype){ +/*FUNCTION Tria::GetInputListOnVertices(double* pvalue,int enumtype) {{{1*/ +void Tria::GetInputListOnVertices(double* pvalue,int enumtype){ /*Intermediaries*/ @@ -1158,5 +1158,5 @@ for (int iv=0;ivGaussVertex(iv); - input->GetParameterValue(&pvalue[iv],gauss); + input->GetInputValue(&pvalue[iv],gauss); } @@ -1165,6 +1165,6 @@ } /*}}}*/ -/*FUNCTION Tria::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue) {{{1*/ -void Tria::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue){ +/*FUNCTION Tria::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue) {{{1*/ +void Tria::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue){ double value[NUMVERTICES]; @@ -1180,5 +1180,5 @@ for (int iv=0;ivGaussVertex(iv); - input->GetParameterValue(&pvalue[iv],gauss); + input->GetInputValue(&pvalue[iv],gauss); } } @@ -1191,6 +1191,6 @@ } /*}}}*/ -/*FUNCTION Tria::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index) TO BE REMOVED{{{1*/ -void Tria::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index){ +/*FUNCTION Tria::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index) TO BE REMOVED{{{1*/ +void Tria::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index){ double value[NUMVERTICES]; @@ -1206,5 +1206,5 @@ for (int iv=0;ivGaussVertex(iv); - input->GetParameterValue(&pvalue[iv],gauss,index); + input->GetInputValue(&pvalue[iv],gauss,index); } } @@ -1217,6 +1217,6 @@ } /*}}}*/ -/*FUNCTION Tria::GetParameterValue(double* pvalue,Node* node,int enumtype) {{{1*/ -void Tria::GetParameterValue(double* pvalue,Node* node,int enumtype){ +/*FUNCTION Tria::GetInputValue(double* pvalue,Node* node,int enumtype) {{{1*/ +void Tria::GetInputValue(double* pvalue,Node* node,int enumtype){ Input* input=inputs->GetInput(enumtype); @@ -1226,5 +1226,5 @@ gauss->GaussVertex(this->GetNodeIndex(node)); - input->GetParameterValue(pvalue,gauss); + input->GetInputValue(pvalue,gauss); delete gauss; } @@ -1896,5 +1896,5 @@ bool onbed; - inputs->GetParameterValue(&onbed,MeshElementonbedEnum); + inputs->GetInputValue(&onbed,MeshElementonbedEnum); return onbed; } @@ -1904,5 +1904,5 @@ bool shelf; - inputs->GetParameterValue(&shelf,MaskElementonfloatingiceEnum); + inputs->GetInputValue(&shelf,MaskElementonfloatingiceEnum); return shelf; } @@ -1942,5 +1942,5 @@ bool water; - inputs->GetParameterValue(&water,MaskElementonwaterEnum); + inputs->GetInputValue(&water,MaskElementonwaterEnum); return water; } @@ -1998,8 +1998,8 @@ if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!"); - GetParameterListOnVertices(&h[0],ThicknessEnum); - GetParameterListOnVertices(&s[0],SurfaceEnum); - GetParameterListOnVertices(&b[0],BedEnum); - GetParameterListOnVertices(&ba[0],BathymetryEnum); + GetInputListOnVertices(&h[0],ThicknessEnum); + GetInputListOnVertices(&s[0],SurfaceEnum); + GetInputListOnVertices(&b[0],BedEnum); + GetInputListOnVertices(&ba[0],BathymetryEnum); for(i=0;i<3;i++){ isonshelf[i]=nodes[i]->IsOnShelf(); @@ -2128,8 +2128,8 @@ if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!"); - GetParameterListOnVertices(&h[0],ThicknessEnum); - GetParameterListOnVertices(&s[0],SurfaceEnum); - GetParameterListOnVertices(&b[0],BedEnum); - GetParameterListOnVertices(&ba[0],BathymetryEnum); + GetInputListOnVertices(&h[0],ThicknessEnum); + GetInputListOnVertices(&s[0],SurfaceEnum); + GetInputListOnVertices(&b[0],BedEnum); + GetInputListOnVertices(&ba[0],BathymetryEnum); /*material parameters: */ @@ -2229,8 +2229,8 @@ if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!"); - GetParameterListOnVertices(&h[0],ThicknessEnum); - GetParameterListOnVertices(&s[0],SurfaceEnum); - GetParameterListOnVertices(&b[0],BedEnum); - GetParameterListOnVertices(&ba[0],BathymetryEnum); + GetInputListOnVertices(&h[0],ThicknessEnum); + GetInputListOnVertices(&s[0],SurfaceEnum); + GetInputListOnVertices(&b[0],BedEnum); + GetInputListOnVertices(&ba[0],BathymetryEnum); /*material parameters: */ @@ -2290,8 +2290,8 @@ if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!"); - GetParameterListOnVertices(&h[0],ThicknessEnum); - GetParameterListOnVertices(&s[0],SurfaceEnum); - GetParameterListOnVertices(&b[0],BedEnum); - GetParameterListOnVertices(&ba[0],BathymetryEnum); + GetInputListOnVertices(&h[0],ThicknessEnum); + GetInputListOnVertices(&s[0],SurfaceEnum); + GetInputListOnVertices(&b[0],BedEnum); + GetInputListOnVertices(&ba[0],BathymetryEnum); /*material parameters: */ @@ -2567,8 +2567,8 @@ if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!"); - GetParameterListOnVertices(&h[0],ThicknessEnum); - GetParameterListOnVertices(&s[0],SurfaceEnum); - GetParameterListOnVertices(&b[0],BedEnum); - GetParameterListOnVertices(&ba[0],BathymetryEnum); + GetInputListOnVertices(&h[0],ThicknessEnum); + GetInputListOnVertices(&s[0],SurfaceEnum); + GetInputListOnVertices(&b[0],BedEnum); + GetInputListOnVertices(&ba[0],BathymetryEnum); /*material parameters: */ @@ -2630,8 +2630,8 @@ double ba[3]; - GetParameterListOnVertices(&h[0],ThicknessEnum); - GetParameterListOnVertices(&s[0],SurfaceEnum); - GetParameterListOnVertices(&b[0],BedEnum); - GetParameterListOnVertices(&ba[0],BathymetryEnum); + GetInputListOnVertices(&h[0],ThicknessEnum); + GetInputListOnVertices(&s[0],SurfaceEnum); + GetInputListOnVertices(&b[0],BedEnum); + GetInputListOnVertices(&ba[0],BathymetryEnum); for(i=0;i<3;i++){ @@ -2682,6 +2682,6 @@ Input* surface_input = inputs->GetInput(SurfaceEnum); _assert_(surface_input); Input* bed_input = inputs->GetInput(BedEnum); _assert_(bed_input); - surface_input->GetParameterAverage(&surface); - bed_input->GetParameterAverage(&bed); + surface_input->GetInputAverage(&surface); + bed_input->GetInputAverage(&bed); /*Return: */ @@ -2731,10 +2731,10 @@ Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); - thickness_input->GetParameterValue(&h1, gauss_1); - thickness_input->GetParameterValue(&h2, gauss_2); - vx_input->GetParameterValue(&vx1,gauss_1); - vx_input->GetParameterValue(&vx2,gauss_2); - vy_input->GetParameterValue(&vy1,gauss_1); - vy_input->GetParameterValue(&vy2,gauss_2); + thickness_input->GetInputValue(&h1, gauss_1); + thickness_input->GetInputValue(&h2, gauss_2); + vx_input->GetInputValue(&vx1,gauss_1); + vx_input->GetInputValue(&vx2,gauss_2); + vy_input->GetInputValue(&vy1,gauss_1); + vy_input->GetInputValue(&vy2,gauss_2); mass_flux= rho_ice*length*( @@ -2916,5 +2916,5 @@ /*ok, we are good. retrieve value of input at vertex :*/ gauss=new GaussTria(); gauss->GaussVertex(i); - data->GetParameterValue(&value,gauss); + data->GetInputValue(&value,gauss); found=1; break; @@ -2995,5 +2995,5 @@ matice->GetViscosity2d(&viscosity, &epsilon[0]); matice->GetViscosity2d(&oldviscosity, &oldepsilon[0]); - thickness_input->GetParameterValue(&thickness, gauss); + thickness_input->GetInputValue(&thickness, gauss); newviscosity=viscosity+viscosity_overshoot*(viscosity-oldviscosity); @@ -3056,5 +3056,5 @@ // If we have a slope > 6% for this element, it means we are on a mountain. In this particular case, //velocity should be = 0. To achieve this result, we set alpha2_list to a very high value: */ - surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss); + surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss); slope_magnitude=sqrt(pow(slope[0],2)+pow(slope[1],2)); if(slope_magnitude>MAXSLOPE) alpha2=pow((double)10,MOUNTAINKEXPONENT); @@ -3133,6 +3133,6 @@ GetNodalFunctions(basis, gauss); - thickness_input->GetParameterValue(&thickness,gauss); - surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss); + thickness_input->GetInputValue(&thickness,gauss); + surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss); driving_stress_baseline=matpar->GetRhoIce()*matpar->GetG()*thickness; @@ -3181,7 +3181,7 @@ connectivity=nodes[i]->GetConnectivity(); - thickness_input->GetParameterValue(&thickness,gauss); - slopex_input->GetParameterValue(&slope[0],gauss); - slopey_input->GetParameterValue(&slope[1],gauss); + thickness_input->GetInputValue(&thickness,gauss); + slopex_input->GetInputValue(&slope[0],gauss); + slopey_input->GetInputValue(&slope[1],gauss); slope2=pow(slope[0],2)+pow(slope[1],2); @@ -3226,6 +3226,6 @@ /*Recover vx and vy*/ - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); values[i*NDOF2+0]=vx; values[i*NDOF2+1]=vy; @@ -3265,6 +3265,6 @@ /*Recover vx and vy*/ - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); values[i*NDOF2+0]=vx; values[i*NDOF2+1]=vy; @@ -3312,5 +3312,5 @@ /*Get Vz and compute vel*/ - GetParameterListOnVertices(&vz[0],VzEnum,0); + GetInputListOnVertices(&vz[0],VzEnum,0); for(i=0;iGetRhoIce(); g=matpar->GetG(); - GetParameterListOnVertices(&thickness[0],ThicknessEnum); + GetInputListOnVertices(&thickness[0],ThicknessEnum); for(i=0;iGetRhoIce(); g=matpar->GetG(); - GetParameterListOnVertices(&thickness[0],ThicknessEnum); + GetInputListOnVertices(&thickness[0],ThicknessEnum); for(i=0;iGetParameterValue(&weight,gauss,weight_index); + weights_input->GetInputValue(&weight,gauss,weight_index); /*Build alpha_complement_list: */ - rheologyb_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss); + rheologyb_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss); /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */ @@ -3642,10 +3642,10 @@ gauss->GaussPoint(ig); - thickness_input->GetParameterValue(&thickness,gauss); - rheologyb_input->GetParameterDerivativeValue(&dB[0],&xyz_list[0][0],gauss); - vx_input->GetParameterDerivativeValue(&dvx[0],&xyz_list[0][0],gauss); - vy_input->GetParameterDerivativeValue(&dvy[0],&xyz_list[0][0],gauss); - adjointx_input->GetParameterDerivativeValue(&dadjx[0],&xyz_list[0][0],gauss); - adjointy_input->GetParameterDerivativeValue(&dadjy[0],&xyz_list[0][0],gauss); + thickness_input->GetInputValue(&thickness,gauss); + rheologyb_input->GetInputDerivativeValue(&dB[0],&xyz_list[0][0],gauss); + vx_input->GetInputDerivativeValue(&dvx[0],&xyz_list[0][0],gauss); + vy_input->GetInputDerivativeValue(&dvy[0],&xyz_list[0][0],gauss); + adjointx_input->GetInputDerivativeValue(&dadjx[0],&xyz_list[0][0],gauss); + adjointy_input->GetInputDerivativeValue(&dadjy[0],&xyz_list[0][0],gauss); this->GetStrainRate2d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input); @@ -3713,10 +3713,10 @@ friction->GetAlphaComplement(&alpha_complement, gauss,VxEnum,VyEnum,VzEnum); - dragcoefficient_input->GetParameterValue(&drag, gauss); - adjointx_input->GetParameterValue(&lambda, gauss); - adjointy_input->GetParameterValue(&mu, gauss); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - dragcoefficient_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss); + dragcoefficient_input->GetInputValue(&drag, gauss); + adjointx_input->GetInputValue(&lambda, gauss); + adjointy_input->GetInputValue(&mu, gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + dragcoefficient_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss); /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */ @@ -3737,9 +3737,9 @@ // gauss->GaussVertex(iv); // friction->GetAlphaComplement(&alpha_complement, gauss,VxEnum,VyEnum,VzEnum); - // dragcoefficient_input->GetParameterValue(&drag, gauss); - // adjointx_input->GetParameterValue(&lambda, gauss); - // adjointy_input->GetParameterValue(&mu, gauss); - // vx_input->GetParameterValue(&vx,gauss); - // vy_input->GetParameterValue(&vy,gauss); + // dragcoefficient_input->GetInputValue(&drag, gauss); + // adjointx_input->GetInputValue(&lambda, gauss); + // adjointy_input->GetInputValue(&mu, gauss); + // vx_input->GetInputValue(&vx,gauss); + // vy_input->GetInputValue(&vy,gauss); // grade_g[iv]=-2*drag*alpha_complement*((lambda*vx+mu*vy)); // VecSetValues(gradient,NUMVERTICES,doflist1,(const double*)grade_g,INSERT_VALUES); @@ -3781,8 +3781,8 @@ GetJacobianDeterminant2d(&Jdet, &xyz_list[0][0],gauss); GetNodalFunctionsDerivatives(&dbasis[0][0],&xyz_list[0][0],gauss); - weights_input->GetParameterValue(&weight,gauss,weight_index); + weights_input->GetInputValue(&weight,gauss,weight_index); /*Build alpha_complement_list: */ - dragcoefficient_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss); + dragcoefficient_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss); /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */ @@ -3809,5 +3809,5 @@ /*Compute Gradient*/ - GetParameterListOnVertices(&lambda[0],AdjointEnum); + GetInputListOnVertices(&lambda[0],AdjointEnum); for(int i=0;iGetParameterDerivativeValue(&Dlambda[0],&xyz_list[0][0],gauss); - thickness_input->GetParameterValue(&thickness, gauss); - thickness_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss); + adjoint_input->GetInputDerivativeValue(&Dlambda[0],&xyz_list[0][0],gauss); + thickness_input->GetInputValue(&thickness, gauss); + thickness_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss); for(i=0;iweight*basis[i]; @@ -3888,7 +3888,7 @@ GetNodalFunctions(basis, gauss); - adjoint_input->GetParameterDerivativeValue(&Dlambda[0],&xyz_list[0][0],gauss); - thickness_input->GetParameterValue(&thickness, gauss); - thickness_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss); + adjoint_input->GetInputDerivativeValue(&Dlambda[0],&xyz_list[0][0],gauss); + thickness_input->GetInputValue(&thickness, gauss); + thickness_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss); for(i=0;iweight*basis[i]; @@ -3932,6 +3932,6 @@ /*Get all parameters at gaussian point*/ - weights_input->GetParameterValue(&weight,gauss,weight_index); - rheologyb_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); + rheologyb_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss); /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */ @@ -3963,5 +3963,5 @@ /*Retrieve all inputs we will be needing: */ - inputs->GetParameterValue(&S,SurfaceAreaEnum); + inputs->GetInputValue(&S,SurfaceAreaEnum); Input* weights_input=inputs->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input); Input* vx_input =inputs->GetInput(VxEnum); _assert_(vx_input); @@ -3980,9 +3980,9 @@ /*Get all parameters at gaussian point*/ - weights_input->GetParameterValue(&weight,gauss,weight_index); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vxobs_input->GetParameterValue(&vxobs,gauss); - vyobs_input->GetParameterValue(&vyobs,gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vxobs_input->GetInputValue(&vxobs,gauss); + vyobs_input->GetInputValue(&vyobs,gauss); /*Compute SurfaceAverageVelMisfitEnum: @@ -4043,9 +4043,9 @@ /*Get all parameters at gaussian point*/ - weights_input->GetParameterValue(&weight,gauss,weight_index); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vxobs_input->GetParameterValue(&vxobs,gauss); - vyobs_input->GetParameterValue(&vyobs,gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vxobs_input->GetInputValue(&vxobs,gauss); + vyobs_input->GetInputValue(&vyobs,gauss); /*Compute SurfaceLogVelMisfit: @@ -4108,9 +4108,9 @@ /*Get all parameters at gaussian point*/ - weights_input->GetParameterValue(&weight,gauss,weight_index); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vxobs_input->GetParameterValue(&vxobs,gauss); - vyobs_input->GetParameterValue(&vyobs,gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vxobs_input->GetInputValue(&vxobs,gauss); + vyobs_input->GetInputValue(&vyobs,gauss); /*Compute SurfaceRelVelMisfit: @@ -4171,9 +4171,9 @@ /*Get all parameters at gaussian point*/ - weights_input->GetParameterValue(&weight,gauss,weight_index); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vxobs_input->GetParameterValue(&vxobs,gauss); - vyobs_input->GetParameterValue(&vyobs,gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vxobs_input->GetInputValue(&vxobs,gauss); + vyobs_input->GetInputValue(&vyobs,gauss); /*Compute SurfaceAbsVelMisfitEnum: @@ -4234,9 +4234,9 @@ /*Get all parameters at gaussian point*/ - weights_input->GetParameterValue(&weight,gauss,weight_index); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vxobs_input->GetParameterValue(&vxobs,gauss); - vyobs_input->GetParameterValue(&vyobs,gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vxobs_input->GetInputValue(&vxobs,gauss); + vyobs_input->GetInputValue(&vyobs,gauss); /*Compute SurfaceRelVelMisfit: @@ -4293,6 +4293,6 @@ /*Get all parameters at gaussian point*/ - weights_input->GetParameterValue(&weight,gauss,weight_index); - thickness_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); + thickness_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss); /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */ @@ -4336,8 +4336,8 @@ /*Get parameters at gauss point*/ - thickness_input->GetParameterValue(&thickness,gauss); - thickness_input->GetParameterDerivativeValue(&dH[0],&xyz_list[0][0],gauss); - thicknessobs_input->GetParameterValue(&thicknessobs,gauss); - weights_input->GetParameterValue(&weight,gauss,weight_index); + thickness_input->GetInputValue(&thickness,gauss); + thickness_input->GetInputDerivativeValue(&dH[0],&xyz_list[0][0],gauss); + thicknessobs_input->GetInputValue(&thicknessobs,gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); /*compute ThicknessAbsMisfit*/ @@ -4389,7 +4389,7 @@ GetNodalFunctionsDerivatives(&dbasis[0][0],&xyz_list[0][0],gauss); - thickness_input->GetParameterValue(&thickness, gauss); - thickness_input->GetParameterDerivativeValue(&dH[0],&xyz_list[0][0],gauss); - thicknessobs_input->GetParameterValue(&thicknessobs, gauss); + thickness_input->GetInputValue(&thickness, gauss); + thickness_input->GetInputDerivativeValue(&dH[0],&xyz_list[0][0],gauss); + thicknessobs_input->GetInputValue(&thicknessobs, gauss); /*Loop over all requested responses*/ @@ -4397,9 +4397,9 @@ case ThicknessAbsMisfitEnum: - weights_input->GetParameterValue(&weight, gauss,resp); + weights_input->GetInputValue(&weight, gauss,resp); for(i=0;ivalues[i]+=(thicknessobs-thickness)*weight*Jdet*gauss->weight*basis[i]; break; case ThicknessAbsGradientEnum: - weights_input->GetParameterValue(&weight, gauss,resp); + weights_input->GetInputValue(&weight, gauss,resp); for(i=0;ivalues[i]+= - weight*dH[0]*dbasis[0][i]*Jdet*gauss->weight; for(i=0;ivalues[i]+= - weight*dH[1]*dbasis[1][i]*Jdet*gauss->weight; @@ -4452,5 +4452,5 @@ for(resp=0;respGetParameterValue(&S,SurfaceAreaEnum); break; + inputs->GetInputValue(&S,SurfaceAreaEnum); break; } } @@ -4466,8 +4466,8 @@ /*Get all parameters at gaussian point*/ - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vxobs_input->GetParameterValue(&vxobs,gauss); - vyobs_input->GetParameterValue(&vyobs,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vxobs_input->GetInputValue(&vxobs,gauss); + vyobs_input->GetInputValue(&vyobs,gauss); GetNodalFunctions(basis, gauss); @@ -4475,5 +4475,5 @@ for(resp=0;respGetParameterValue(&weight,gauss,resp); + weights_input->GetInputValue(&weight,gauss,resp); switch(responses[resp]){ @@ -4628,5 +4628,5 @@ for(resp=0;respGetParameterValue(&S,SurfaceAreaEnum); break; + inputs->GetInputValue(&S,SurfaceAreaEnum); break; } } @@ -4642,8 +4642,8 @@ /*Get all parameters at gaussian point*/ - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vxobs_input->GetParameterValue(&vxobs,gauss); - vyobs_input->GetParameterValue(&vyobs,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vxobs_input->GetInputValue(&vxobs,gauss); + vyobs_input->GetInputValue(&vyobs,gauss); GetNodalFunctions(basis, gauss); @@ -4651,5 +4651,5 @@ for(resp=0;respGetParameterValue(&weight,gauss,resp); + weights_input->GetInputValue(&weight,gauss,resp); switch(responses[resp]){ @@ -4803,6 +4803,6 @@ /*Get all parameters at gaussian point*/ - weights_input->GetParameterValue(&weight,gauss,weight_index); - drag_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss); + weights_input->GetInputValue(&weight,gauss,weight_index); + drag_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss); /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */ @@ -4929,9 +4929,9 @@ for (int iv=0;ivGaussVertex(iv); - surfaceslopex_input->GetParameterValue(&dsdx,gauss); - surfaceslopey_input->GetParameterValue(&dsdy,gauss); - bedslopex_input->GetParameterValue(&dbdx,gauss); - bedslopey_input->GetParameterValue(&dbdy,gauss); - watercolumn_input->GetParameterValue(&w,gauss); + surfaceslopex_input->GetInputValue(&dsdx,gauss); + surfaceslopey_input->GetInputValue(&dsdy,gauss); + bedslopex_input->GetInputValue(&dbdx,gauss); + bedslopey_input->GetInputValue(&dbdy,gauss); + watercolumn_input->GetInputValue(&w,gauss); /* Water velocity x and y components */ @@ -4996,8 +4996,8 @@ GetL(&L[0], &xyz_list[0][0], gauss,NDOF1); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); - vx_input->GetParameterDerivativeValue(&dvx[0],&xyz_list[0][0],gauss); - vy_input->GetParameterDerivativeValue(&dvy[0],&xyz_list[0][0],gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vx_input->GetInputDerivativeValue(&dvx[0],&xyz_list[0][0],gauss); + vy_input->GetInputDerivativeValue(&dvy[0],&xyz_list[0][0],gauss); DL_scalar=gauss->weight*Jdettria; @@ -5086,6 +5086,6 @@ GetNodalFunctions(basis, gauss); - basal_melting_input->GetParameterValue(&basal_melting_g,gauss); - old_watercolumn_input->GetParameterValue(&old_watercolumn_g,gauss); + basal_melting_input->GetInputValue(&basal_melting_g,gauss); + old_watercolumn_input->GetInputValue(&old_watercolumn_g,gauss); if(dt)for(i=0;ivalues[i]+=Jdettria*gauss->weight*(old_watercolumn_g+dt*basal_melting_g)*basis[i]; @@ -5123,5 +5123,5 @@ /*Recover watercolumn*/ - watercolumn_input->GetParameterValue(&watercolumn,gauss); + watercolumn_input->GetInputValue(&watercolumn,gauss); values[i]=watercolumn; } @@ -5196,8 +5196,8 @@ /*retrieve inputs: */ - GetParameterListOnVertices(&thickness_init[0],ThicknessEnum); - GetParameterListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum); - GetParameterListOnVertices(&bed[0],BedEnum); - GetParameterListOnVertices(&surface[0],SurfaceEnum); + GetInputListOnVertices(&thickness_init[0],ThicknessEnum); + GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum); + GetInputListOnVertices(&bed[0],BedEnum); + GetInputListOnVertices(&surface[0],SurfaceEnum); /*build new thickness: */ @@ -5342,6 +5342,6 @@ // delete gauss; - // vxaverage_input->GetParameterAverage(&vx); - // vyaverage_input->GetParameterAverage(&vy); + // vxaverage_input->GetInputAverage(&vx); + // vyaverage_input->GetInputAverage(&vy); // K[0][0]=pow(Jdettria,(double).5)/2.0*fabs(vx); // K[1][1]=pow(Jdettria,(double).5)/2.0*fabs(vy); @@ -5358,8 +5358,8 @@ GetBprimePrognostic(&Bprime[0][0], &xyz_list[0][0], gauss); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); - vxaverage_input->GetParameterDerivativeValue(&dvx[0],&xyz_list[0][0],gauss); - vyaverage_input->GetParameterDerivativeValue(&dvy[0],&xyz_list[0][0],gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); + vxaverage_input->GetInputDerivativeValue(&dvx[0],&xyz_list[0][0],gauss); + vyaverage_input->GetInputDerivativeValue(&dvy[0],&xyz_list[0][0],gauss); dvxdx=dvx[0]; @@ -5445,6 +5445,6 @@ GetBprimePrognostic(&B[0][0], &xyz_list[0][0], gauss); - vx_input->GetParameterValue(&vx,gauss); - vy_input->GetParameterValue(&vy,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); DL_scalar=-gauss->weight*Jdettria; @@ -5505,7 +5505,7 @@ gauss->GaussPoint(ig); - surface_mass_balance_input->GetParameterValue(&surface_mass_balance_g,gauss); - basal_melting_input->GetParameterValue(&basal_melting_g,gauss); - dhdt_input->GetParameterValue(&dhdt_g,gauss); + surface_mass_balance_input->GetInputValue(&surface_mass_balance_g,gauss); + basal_melting_input->GetInputValue(&basal_melting_g,gauss); + dhdt_input->GetInputValue(&dhdt_g,gauss); GetJacobianDeterminant2d(&Jdettria, &xyz_list[0][0],gauss); @@ -5548,7 +5548,7 @@ gauss->GaussPoint(ig); - surface_mass_balance_input->GetParameterValue(&surface_mass_balance_g,gauss); - basal_melting_input->GetParameterValue(&basal_melting_g,gauss); - dhdt_input->GetParameterValue(&dhdt_g,gauss); + surface_mass_balance_input->GetInputValue(&surface_mass_balance_g,gauss); + basal_melting_input->GetInputValue(&basal_melting_g,gauss); + dhdt_input->GetInputValue(&dhdt_g,gauss); GetJacobianDeterminant2d(&Jdettria, &xyz_list[0][0],gauss); Index: /issm/trunk/src/c/objects/Elements/Tria.h =================================================================== --- /issm/trunk/src/c/objects/Elements/Tria.h (revision 10134) +++ /issm/trunk/src/c/objects/Elements/Tria.h (revision 10135) @@ -186,11 +186,11 @@ double GetArea(void); int GetElementType(void); - void GetDofList(int** pdoflist,int approximation_enum,int setenum); - void GetDofList1(int* doflist); + void GetDofList(int** pdoflist,int approximation_enum,int setenum); + void GetDofList1(int* doflist); void GetSidList(int* sidlist); - void GetParameterListOnVertices(double* pvalue,int enumtype); - void GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue); - void GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index); //TO BE REMOVED - void GetParameterValue(double* pvalue,Node* node,int enumtype); + void GetInputListOnVertices(double* pvalue,int enumtype); + void GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue); + void GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index); //TO BE REMOVED + void GetInputValue(double* pvalue,Node* node,int enumtype); void GetStrainRate2d(double* epsilon,double* xyz_list, GaussTria* gauss, Input* vx_input, Input* vy_input); void InputUpdateFromSolutionOneDof(double* solution,int enum_type); Index: /issm/trunk/src/c/objects/Elements/TriaRef.cpp =================================================================== --- /issm/trunk/src/c/objects/Elements/TriaRef.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Elements/TriaRef.cpp (revision 10135) @@ -463,6 +463,6 @@ } /*}}}*/ -/*FUNCTION TriaRef::GetParameterDerivativeValue{{{1*/ -void TriaRef::GetParameterDerivativeValue(double* p, double* plist,double* xyz_list, GaussTria* gauss){ +/*FUNCTION TriaRef::GetInputDerivativeValue{{{1*/ +void TriaRef::GetInputDerivativeValue(double* p, double* plist,double* xyz_list, GaussTria* gauss){ /*From node values of parameter p (plist[0],plist[1],plist[2]), return parameter derivative value at gaussian @@ -486,6 +486,6 @@ } /*}}}*/ -/*FUNCTION TriaRef::GetParameterValue{{{1*/ -void TriaRef::GetParameterValue(double* p, double* plist, GaussTria* gauss){ +/*FUNCTION TriaRef::GetInputValue{{{1*/ +void TriaRef::GetInputValue(double* p, double* plist, GaussTria* gauss){ /*From node values of parameter p (plist[0],plist[1],plist[2]), return parameter value at gaussian Index: /issm/trunk/src/c/objects/Elements/TriaRef.h =================================================================== --- /issm/trunk/src/c/objects/Elements/TriaRef.h (revision 10134) +++ /issm/trunk/src/c/objects/Elements/TriaRef.h (revision 10135) @@ -43,6 +43,6 @@ void GetNodalFunctionsDerivatives(double* l1l2l3,double* xyz_list, GaussTria* gauss); void GetNodalFunctionsDerivativesReference(double* dl1dl3,GaussTria* gauss); - void GetParameterValue(double* pp, double* plist, GaussTria* gauss); - void GetParameterDerivativeValue(double* pp, double* plist,double* xyz_list, GaussTria* gauss); + void GetInputValue(double* pp, double* plist, GaussTria* gauss); + void GetInputDerivativeValue(double* pp, double* plist,double* xyz_list, GaussTria* gauss); }; Index: /issm/trunk/src/c/objects/Inputs/BoolInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/BoolInput.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/BoolInput.cpp (revision 10135) @@ -157,26 +157,26 @@ /*Object functions*/ -/*FUNCTION BoolInput::GetParameterValue(bool* pvalue) {{{1*/ -void BoolInput::GetParameterValue(bool* pvalue){ +/*FUNCTION BoolInput::GetInputValue(bool* pvalue) {{{1*/ +void BoolInput::GetInputValue(bool* pvalue){ *pvalue=value; } /*}}}*/ -/*FUNCTION BoolInput::GetParameterValue(int* pvalue){{{1*/ -void BoolInput::GetParameterValue(int* pvalue){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION BoolInput::GetParameterValue(double* pvalue){{{1*/ -void BoolInput::GetParameterValue(double* pvalue){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION BoolInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/ -void BoolInput::GetParameterValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION BoolInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/ -void BoolInput::GetParameterValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/ -void BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/ -void BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");} +/*FUNCTION BoolInput::GetInputValue(int* pvalue){{{1*/ +void BoolInput::GetInputValue(int* pvalue){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION BoolInput::GetInputValue(double* pvalue){{{1*/ +void BoolInput::GetInputValue(double* pvalue){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION BoolInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/ +void BoolInput::GetInputValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION BoolInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/ +void BoolInput::GetInputValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION BoolInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/ +void BoolInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION BoolInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/ +void BoolInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");} /*}}}*/ /*FUNCTION BoolInput::ChangeEnum{{{1*/ Index: /issm/trunk/src/c/objects/Inputs/BoolInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/BoolInput.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/BoolInput.h (revision 10135) @@ -50,14 +50,14 @@ /*}}}*/ /*numerics: {{{1*/ - void GetParameterValue(bool* pvalue); - void GetParameterValue(int* pvalue); - void GetParameterValue(double* pvalue); - void GetParameterValue(double* pvalue,GaussTria* gauss); - void GetParameterValue(double* pvalue,GaussPenta* gauss); - void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); - void GetParameterAverage(double* pvalue){_error_("not implemented yet");}; + void GetInputValue(bool* pvalue); + void GetInputValue(int* pvalue); + void GetInputValue(double* pvalue); + void GetInputValue(double* pvalue,GaussTria* gauss); + void GetInputValue(double* pvalue,GaussPenta* gauss); + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); + void GetInputAverage(double* pvalue){_error_("not implemented yet");}; void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; Index: /issm/trunk/src/c/objects/Inputs/ControlInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/ControlInput.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/ControlInput.cpp (revision 10135) @@ -398,39 +398,39 @@ return gradient->SpawnResult(step,time); }/*}}}*/ -/*FUNCTION ControlInput::GetParameterValue(bool* pvalue){{{1*/ +/*FUNCTION ControlInput::GetInputValue(bool* pvalue){{{1*/ void ControlInput::GetVectorFromInputs(Vec vector,int* doflist){ values->GetVectorFromInputs(vector,doflist); }/*}}}*/ -/*FUNCTION ControlInput::GetParameterAverage(double* pvalue){{{1*/ -void ControlInput::GetParameterAverage(double* pvalue){ - values->GetParameterAverage(pvalue); -}/*}}}*/ -/*FUNCTION ControlInput::GetParameterValue(bool* pvalue){{{1*/ -void ControlInput::GetParameterValue(bool* pvalue){ - values->GetParameterValue(pvalue); -}/*}}}*/ -/*FUNCTION ControlInput::GetParameterValue(int* pvalue){{{1*/ -void ControlInput::GetParameterValue(int* pvalue){ - values->GetParameterValue(pvalue); -}/*}}}*/ -/*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/ -void ControlInput::GetParameterValue(double* pvalue){ - values->GetParameterValue(pvalue); -}/*}}}*/ -/*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/ -void ControlInput::GetParameterValue(double* pvalue,GaussTria* gauss){ - values->GetParameterValue(pvalue,gauss); -}/*}}}*/ -/*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/ -void ControlInput::GetParameterValue(double* pvalue,GaussPenta* gauss){ - values->GetParameterValue(pvalue,gauss); -}/*}}}*/ -/*FUNCTION ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/ -void ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){ - values->GetParameterDerivativeValue(derivativevalues,xyz_list,gauss); -}/*}}}*/ -/*FUNCTION ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/ -void ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){ - values->GetParameterDerivativeValue(derivativevalues,xyz_list,gauss); +/*FUNCTION ControlInput::GetInputAverage(double* pvalue){{{1*/ +void ControlInput::GetInputAverage(double* pvalue){ + values->GetInputAverage(pvalue); +}/*}}}*/ +/*FUNCTION ControlInput::GetInputValue(bool* pvalue){{{1*/ +void ControlInput::GetInputValue(bool* pvalue){ + values->GetInputValue(pvalue); +}/*}}}*/ +/*FUNCTION ControlInput::GetInputValue(int* pvalue){{{1*/ +void ControlInput::GetInputValue(int* pvalue){ + values->GetInputValue(pvalue); +}/*}}}*/ +/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/ +void ControlInput::GetInputValue(double* pvalue){ + values->GetInputValue(pvalue); +}/*}}}*/ +/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/ +void ControlInput::GetInputValue(double* pvalue,GaussTria* gauss){ + values->GetInputValue(pvalue,gauss); +}/*}}}*/ +/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/ +void ControlInput::GetInputValue(double* pvalue,GaussPenta* gauss){ + values->GetInputValue(pvalue,gauss); +}/*}}}*/ +/*FUNCTION ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/ +void ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){ + values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss); +}/*}}}*/ +/*FUNCTION ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/ +void ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){ + values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss); }/*}}}*/ /*FUNCTION ControlInput::SaveValue{{{1*/ Index: /issm/trunk/src/c/objects/Inputs/ControlInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/ControlInput.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/ControlInput.h (revision 10135) @@ -54,14 +54,14 @@ /*}}}*/ /*numerics: {{{1*/ - void GetParameterValue(bool* pvalue); - void GetParameterValue(int* pvalue); - void GetParameterValue(double* pvalue); - void GetParameterValue(double* pvalue,GaussTria* gauss); - void GetParameterValue(double* pvalue,GaussPenta* gauss); - void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); - void GetParameterAverage(double* pvalue); + void GetInputValue(bool* pvalue); + void GetInputValue(int* pvalue); + void GetInputValue(double* pvalue); + void GetInputValue(double* pvalue,GaussTria* gauss); + void GetInputValue(double* pvalue,GaussPenta* gauss); + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); + void GetInputAverage(double* pvalue); void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; Index: /issm/trunk/src/c/objects/Inputs/DatasetInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/DatasetInput.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/DatasetInput.cpp (revision 10135) @@ -175,6 +175,6 @@ } /*}}}*/ -/*FUNCTION DatasetInput::GetParameterValue(double* pvalue,GaussTria* gauss,int index){{{1*/ -void DatasetInput::GetParameterValue(double* pvalue,GaussTria* gauss,int index){ +/*FUNCTION DatasetInput::GetInputValue(double* pvalue,GaussTria* gauss,int index){{{1*/ +void DatasetInput::GetInputValue(double* pvalue,GaussTria* gauss,int index){ /*Get requested input within dataset*/ @@ -182,5 +182,5 @@ Input* input=(Input*)this->inputs->GetObjectByOffset(index); - input->GetParameterValue(pvalue,gauss); + input->GetInputValue(pvalue,gauss); } /*}}}*/ Index: /issm/trunk/src/c/objects/Inputs/DatasetInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/DatasetInput.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/DatasetInput.h (revision 10135) @@ -50,14 +50,14 @@ /*}}}*/ /*numeriics: {{{1*/ - void GetParameterValue(bool* pvalue){_error_("not implemented yet");}; - void GetParameterValue(int* pvalue){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussTria* gauss ,int index); - void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void GetParameterAverage(double* pvalue){_error_("not implemented yet");}; + void GetInputValue(bool* pvalue){_error_("not implemented yet");}; + void GetInputValue(int* pvalue){_error_("not implemented yet");}; + void GetInputValue(double* pvalue){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussTria* gauss ,int index); + void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void GetInputAverage(double* pvalue){_error_("not implemented yet");}; void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; Index: /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp (revision 10135) @@ -157,6 +157,6 @@ /*Object functions*/ -/*FUNCTION DoubleInput::GetParameterValue(bool* pvalue) {{{1*/ -void DoubleInput::GetParameterValue(bool* pvalue){ +/*FUNCTION DoubleInput::GetInputValue(bool* pvalue) {{{1*/ +void DoubleInput::GetInputValue(bool* pvalue){ #ifdef _SERIAL_ *pvalue=(bool)value; @@ -167,6 +167,6 @@ } /*}}}*/ -/*FUNCTION DoubleInput::GetParameterValue(int* pvalue){{{1*/ -void DoubleInput::GetParameterValue(int* pvalue){ +/*FUNCTION DoubleInput::GetInputValue(int* pvalue){{{1*/ +void DoubleInput::GetInputValue(int* pvalue){ #ifdef _SERIAL_ *pvalue=(int)value; @@ -177,6 +177,6 @@ } /*}}}*/ -/*FUNCTION DoubleInput::GetParameterValue(double* pvalue){{{1*/ -void DoubleInput::GetParameterValue(double* pvalue){ +/*FUNCTION DoubleInput::GetInputValue(double* pvalue){{{1*/ +void DoubleInput::GetInputValue(double* pvalue){ /*return value*/ @@ -184,15 +184,15 @@ } /*}}}*/ -/*FUNCTION DoubleInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/ -void DoubleInput::GetParameterValue(double* pvalue,GaussTria* gauss){*pvalue=this->value;} -/*}}}*/ -/*FUNCTION DoubleInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/ -void DoubleInput::GetParameterValue(double* pvalue,GaussPenta* gauss){*pvalue=this->value;} -/*}}}*/ -/*FUNCTION DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/ -void DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/ -void DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");} +/*FUNCTION DoubleInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/ +void DoubleInput::GetInputValue(double* pvalue,GaussTria* gauss){*pvalue=this->value;} +/*}}}*/ +/*FUNCTION DoubleInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/ +void DoubleInput::GetInputValue(double* pvalue,GaussPenta* gauss){*pvalue=this->value;} +/*}}}*/ +/*FUNCTION DoubleInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/ +void DoubleInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION DoubleInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/ +void DoubleInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");} /*}}}*/ /*FUNCTION DoubleInput::GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){{{1*/ @@ -323,6 +323,6 @@ } /*}}}*/ -/*FUNCTION DoubleInput::GetParameterAverage{{{1*/ -void DoubleInput::GetParameterAverage(double* pvalue){ +/*FUNCTION DoubleInput::GetInputAverage{{{1*/ +void DoubleInput::GetInputAverage(double* pvalue){ *pvalue=value; } @@ -341,5 +341,5 @@ case PentaVertexInputEnum: - thickness_input->GetParameterAverage(&thickness_value); + thickness_input->GetInputAverage(&thickness_value); this->value=this->value*thickness_value; return; @@ -360,5 +360,5 @@ /*Check that inputB is of the same type*/ - inputB->GetParameterAverage(&Bvalue); + inputB->GetInputAverage(&Bvalue); /*Create new DoubleInput*/ Index: /issm/trunk/src/c/objects/Inputs/DoubleInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/DoubleInput.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/DoubleInput.h (revision 10135) @@ -49,14 +49,14 @@ /*}}}*/ /*numerics: {{{1*/ - void GetParameterValue(bool* pvalue); - void GetParameterValue(int* pvalue); - void GetParameterValue(double* pvalue); - void GetParameterValue(double* pvalue,GaussTria* gauss); - void GetParameterValue(double* pvalue,GaussPenta* gauss); - void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); - void GetParameterAverage(double* pvalue); + void GetInputValue(bool* pvalue); + void GetInputValue(int* pvalue); + void GetInputValue(double* pvalue); + void GetInputValue(double* pvalue,GaussTria* gauss); + void GetInputValue(double* pvalue,GaussPenta* gauss); + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); + void GetInputAverage(double* pvalue); void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss); void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss); Index: /issm/trunk/src/c/objects/Inputs/Input.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/Input.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/Input.h (revision 10135) @@ -23,14 +23,14 @@ /*Virtual functions:{{{1*/ virtual int InstanceEnum()=0; - virtual void GetParameterValue(bool* pvalue)=0; - virtual void GetParameterValue(int* pvalue)=0; - virtual void GetParameterValue(double* pvalue)=0; - virtual void GetParameterValue(double* pvalue,GaussTria* gauss)=0; - virtual void GetParameterValue(double* pvalue,GaussPenta* gauss)=0; - virtual void GetParameterValue(double* pvalue,GaussTria* gauss ,int index)=0; - virtual void GetParameterValue(double* pvalue,GaussPenta* gauss,int index)=0; - virtual void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss)=0; - virtual void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss)=0; - virtual void GetParameterAverage(double* pvalue)=0; + virtual void GetInputValue(bool* pvalue)=0; + virtual void GetInputValue(int* pvalue)=0; + virtual void GetInputValue(double* pvalue)=0; + virtual void GetInputValue(double* pvalue,GaussTria* gauss)=0; + virtual void GetInputValue(double* pvalue,GaussPenta* gauss)=0; + virtual void GetInputValue(double* pvalue,GaussTria* gauss ,int index)=0; + virtual void GetInputValue(double* pvalue,GaussPenta* gauss,int index)=0; + virtual void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss)=0; + virtual void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss)=0; + virtual void GetInputAverage(double* pvalue)=0; virtual void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss)=0; virtual void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss)=0; Index: /issm/trunk/src/c/objects/Inputs/IntInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/IntInput.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/IntInput.cpp (revision 10135) @@ -156,28 +156,28 @@ /*Object functions*/ -/*FUNCTION IntInput::GetParameterValue(bool* pvalue) {{{1*/ -void IntInput::GetParameterValue(bool* pvalue){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION IntInput::GetParameterValue(int* pvalue){{{1*/ -void IntInput::GetParameterValue(int* pvalue){ +/*FUNCTION IntInput::GetInputValue(bool* pvalue) {{{1*/ +void IntInput::GetInputValue(bool* pvalue){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION IntInput::GetInputValue(int* pvalue){{{1*/ +void IntInput::GetInputValue(int* pvalue){ *pvalue=value; } /*}}}*/ -/*FUNCTION IntInput::GetParameterValue(double* pvalue){{{1*/ -void IntInput::GetParameterValue(double* pvalue){ +/*FUNCTION IntInput::GetInputValue(double* pvalue){{{1*/ +void IntInput::GetInputValue(double* pvalue){ _error_("IntInput cannot return a double in parallel"); } /*}}}*/ -/*FUNCTION IntInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/ -void IntInput::GetParameterValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION IntInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/ -void IntInput::GetParameterValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/ -void IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");} -/*}}}*/ -/*FUNCTION IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/ -void IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");} +/*FUNCTION IntInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/ +void IntInput::GetInputValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION IntInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/ +void IntInput::GetInputValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION IntInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/ +void IntInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");} +/*}}}*/ +/*FUNCTION IntInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/ +void IntInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");} /*}}}*/ /*FUNCTION IntInput::ChangeEnum{{{1*/ Index: /issm/trunk/src/c/objects/Inputs/IntInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/IntInput.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/IntInput.h (revision 10135) @@ -50,14 +50,14 @@ /*}}}*/ /*numerics: {{{1*/ - void GetParameterValue(bool* pvalue); - void GetParameterValue(int* pvalue); - void GetParameterValue(double* pvalue); - void GetParameterValue(double* pvalue,GaussTria* gauss); - void GetParameterValue(double* pvalue,GaussPenta* gauss); - void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); - void GetParameterAverage(double* pvalue){_error_("not implemented yet");}; + void GetInputValue(bool* pvalue); + void GetInputValue(int* pvalue); + void GetInputValue(double* pvalue); + void GetInputValue(double* pvalue,GaussTria* gauss); + void GetInputValue(double* pvalue,GaussPenta* gauss); + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); + void GetInputAverage(double* pvalue){_error_("not implemented yet");}; void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; Index: /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp (revision 10135) @@ -178,17 +178,17 @@ /*Object functions*/ -/*FUNCTION PentaVertexInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/ -void PentaVertexInput::GetParameterValue(double* pvalue,GaussPenta* gauss){ +/*FUNCTION PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/ +void PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){ /*Call PentaRef function*/ - PentaRef::GetParameterValue(pvalue,&values[0],gauss); - -} -/*}}}*/ -/*FUNCTION PentaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/ -void PentaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){ + PentaRef::GetInputValue(pvalue,&values[0],gauss); + +} +/*}}}*/ +/*FUNCTION PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/ +void PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){ /*Call PentaRef function*/ - PentaRef::GetParameterDerivativeValue(p,&values[0],xyz_list,gauss); + PentaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss); } /*}}}*/ @@ -382,6 +382,6 @@ } /*}}}*/ -/*FUNCTION PentaVertexInput::GetParameterAverage{{{1*/ -void PentaVertexInput::GetParameterAverage(double* pvalue){ +/*FUNCTION PentaVertexInput::GetInputAverage{{{1*/ +void PentaVertexInput::GetInputAverage(double* pvalue){ *pvalue=1./6.*(values[0]+values[1]+values[2]+values[3]+values[4]+values[5]); } Index: /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h (revision 10135) @@ -50,14 +50,14 @@ /*}}}*/ /*numerics: {{{1*/ - void GetParameterValue(bool* pvalue){_error_("not implemented yet");}; - void GetParameterValue(int* pvalue){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss); - void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); - void GetParameterAverage(double* pvalue); + void GetInputValue(bool* pvalue){_error_("not implemented yet");}; + void GetInputValue(int* pvalue){_error_("not implemented yet");}; + void GetInputValue(double* pvalue){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss); + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss); + void GetInputAverage(double* pvalue); void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; Index: /issm/trunk/src/c/objects/Inputs/TransientInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/TransientInput.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/TransientInput.cpp (revision 10135) @@ -258,6 +258,6 @@ /*Object functions*/ -/*FUNCTION TransientInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/ -void TransientInput::GetParameterValue(double* pvalue,GaussTria* gauss){ +/*FUNCTION TransientInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/ +void TransientInput::GetInputValue(double* pvalue,GaussTria* gauss){ double time; @@ -270,12 +270,12 @@ /*Call input function*/ - input->GetParameterValue(pvalue,gauss); - - delete input; - -} -/*}}}*/ -/*FUNCTION TransientInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/ -void TransientInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){ + input->GetInputValue(pvalue,gauss); + + delete input; + +} +/*}}}*/ +/*FUNCTION TransientInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/ +void TransientInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){ double time; @@ -288,5 +288,5 @@ /*Call input function*/ - input->GetParameterDerivativeValue(p,xyz_list,gauss); + input->GetInputDerivativeValue(p,xyz_list,gauss); delete input; @@ -299,6 +299,6 @@ } /*}}}*/ -/*FUNCTION TransientInput::GetParameterAverage{{{1*/ -void TransientInput::GetParameterAverage(double* pvalue){ +/*FUNCTION TransientInput::GetInputAverage{{{1*/ +void TransientInput::GetInputAverage(double* pvalue){ double time; @@ -311,5 +311,5 @@ /*Call input function*/ - input->GetParameterAverage(pvalue); + input->GetInputAverage(pvalue); delete input; Index: /issm/trunk/src/c/objects/Inputs/TransientInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/TransientInput.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/TransientInput.h (revision 10135) @@ -52,14 +52,14 @@ /*}}}*/ /*numerics: {{{1*/ - void GetParameterValue(bool* pvalue){_error_("not implemented yet");}; - void GetParameterValue(int* pvalue){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussTria* gauss); - void GetParameterValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void GetParameterAverage(double* pvalue); + void GetInputValue(bool* pvalue){_error_("not implemented yet");}; + void GetInputValue(int* pvalue){_error_("not implemented yet");}; + void GetInputValue(double* pvalue){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussTria* gauss); + void GetInputValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void GetInputAverage(double* pvalue); void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");}; Index: /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp (revision 10135) @@ -167,17 +167,17 @@ /*Object functions*/ -/*FUNCTION TriaVertexInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/ -void TriaVertexInput::GetParameterValue(double* pvalue,GaussTria* gauss){ +/*FUNCTION TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/ +void TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){ /*Call TriaRef function*/ - TriaRef::GetParameterValue(pvalue,&values[0],gauss); - -} -/*}}}*/ -/*FUNCTION TriaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/ -void TriaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){ + TriaRef::GetInputValue(pvalue,&values[0],gauss); + +} +/*}}}*/ +/*FUNCTION TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/ +void TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){ /*Call TriaRef function*/ - TriaRef::GetParameterDerivativeValue(p,&values[0],xyz_list,gauss); + TriaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss); } /*}}}*/ @@ -233,6 +233,6 @@ } /*}}}*/ -/*FUNCTION TriaVertexInput::GetParameterAverage{{{1*/ -void TriaVertexInput::GetParameterAverage(double* pvalue){ +/*FUNCTION TriaVertexInput::GetInputAverage{{{1*/ +void TriaVertexInput::GetInputAverage(double* pvalue){ *pvalue=1./3.*(values[0]+values[1]+values[2]); } Index: /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h =================================================================== --- /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h (revision 10134) +++ /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h (revision 10135) @@ -50,14 +50,14 @@ /*}}}*/ /*numerics: {{{1*/ - void GetParameterValue(bool* pvalue){_error_("not implemented yet");} - void GetParameterValue(int* pvalue){_error_("not implemented yet");} - void GetParameterValue(double* pvalue){_error_("not implemented yet");} - void GetParameterValue(double* pvalue,GaussTria* gauss); - void GetParameterValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; - void GetParameterValue(double* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");}; - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); - void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; - void GetParameterAverage(double* pvalue); + void GetInputValue(bool* pvalue){_error_("not implemented yet");} + void GetInputValue(int* pvalue){_error_("not implemented yet");} + void GetInputValue(double* pvalue){_error_("not implemented yet");} + void GetInputValue(double* pvalue,GaussTria* gauss); + void GetInputValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");}; + void GetInputValue(double* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");}; + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss); + void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");}; + void GetInputAverage(double* pvalue); void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss); void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss); Index: /issm/trunk/src/c/objects/Loads/Friction.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Friction.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Loads/Friction.cpp (revision 10135) @@ -73,9 +73,9 @@ /*Recover parameters: */ - inputs->GetParameterValue(&drag_p,FrictionPEnum); - inputs->GetParameterValue(&drag_q,FrictionQEnum); - this->GetParameterValue(&thickness, gauss,ThicknessEnum); - this->GetParameterValue(&bed, gauss,BedEnum); - this->GetParameterValue(&drag_coefficient, gauss,FrictionCoefficientEnum); + inputs->GetInputValue(&drag_p,FrictionPEnum); + inputs->GetInputValue(&drag_q,FrictionQEnum); + this->GetInputValue(&thickness, gauss,ThicknessEnum); + this->GetInputValue(&bed, gauss,BedEnum); + this->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum); /*Get material parameters: */ @@ -98,12 +98,12 @@ if(strcmp(element_type,"2d")==0){ - this->GetParameterValue(&vx, gauss,vxenum); - this->GetParameterValue(&vy, gauss,vyenum); + this->GetInputValue(&vx, gauss,vxenum); + this->GetInputValue(&vy, gauss,vyenum); vmag=sqrt(pow(vx,2)+pow(vy,2)); } else if (strcmp(element_type,"3d")==0){ - this->GetParameterValue(&vx, gauss,vxenum); - this->GetParameterValue(&vy, gauss,vyenum); - this->GetParameterValue(&vz, gauss,vzenum); + this->GetInputValue(&vx, gauss,vxenum); + this->GetInputValue(&vy, gauss,vyenum); + this->GetInputValue(&vz, gauss,vzenum); vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2)); } @@ -137,9 +137,9 @@ /*Recover parameters: */ - inputs->GetParameterValue(&drag_p,FrictionPEnum); - inputs->GetParameterValue(&drag_q,FrictionQEnum); - this->GetParameterValue(&thickness, gauss,ThicknessEnum); - this->GetParameterValue(&bed, gauss,BedEnum); - this->GetParameterValue(&drag_coefficient, gauss,FrictionCoefficientEnum); + inputs->GetInputValue(&drag_p,FrictionPEnum); + inputs->GetInputValue(&drag_q,FrictionQEnum); + this->GetInputValue(&thickness, gauss,ThicknessEnum); + this->GetInputValue(&bed, gauss,BedEnum); + this->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum); /*Get material parameters: */ @@ -162,12 +162,12 @@ if(strcmp(element_type,"2d")==0){ - this->GetParameterValue(&vx, gauss,vxenum); - this->GetParameterValue(&vy, gauss,vyenum); + this->GetInputValue(&vx, gauss,vxenum); + this->GetInputValue(&vy, gauss,vyenum); vmag=sqrt(pow(vx,2)+pow(vy,2)); } else if (strcmp(element_type,"3d")==0){ - this->GetParameterValue(&vx, gauss,vxenum); - this->GetParameterValue(&vy, gauss,vyenum); - this->GetParameterValue(&vz, gauss,vzenum); + this->GetInputValue(&vx, gauss,vxenum); + this->GetInputValue(&vy, gauss,vyenum); + this->GetInputValue(&vz, gauss,vzenum); vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2)); } @@ -203,9 +203,9 @@ /*Recover parameters: */ - inputs->GetParameterValue(&drag_p,FrictionPEnum); - inputs->GetParameterValue(&drag_q,FrictionQEnum); - this->GetParameterValue(&thickness, gauss,ThicknessEnum); - this->GetParameterValue(&bed, gauss,BedEnum); - this->GetParameterValue(&drag_coefficient, gauss,FrictionCoefficientEnum); + inputs->GetInputValue(&drag_p,FrictionPEnum); + inputs->GetInputValue(&drag_q,FrictionQEnum); + this->GetInputValue(&thickness, gauss,ThicknessEnum); + this->GetInputValue(&bed, gauss,BedEnum); + this->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum); /*Get material parameters: */ @@ -229,12 +229,12 @@ //We need the velocity magnitude to evaluate the basal stress: if(strcmp(element_type,"2d")==0){ - this->GetParameterValue(&vx, gauss,vxenum); - this->GetParameterValue(&vy, gauss,vyenum); + this->GetInputValue(&vx, gauss,vxenum); + this->GetInputValue(&vy, gauss,vyenum); vmag=sqrt(pow(vx,2)+pow(vy,2)); } else if (strcmp(element_type,"3d")==0){ - this->GetParameterValue(&vx, gauss,vxenum); - this->GetParameterValue(&vy, gauss,vyenum); - this->GetParameterValue(&vz, gauss,vzenum); + this->GetInputValue(&vx, gauss,vxenum); + this->GetInputValue(&vy, gauss,vyenum); + this->GetInputValue(&vz, gauss,vzenum); vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2)); } @@ -269,9 +269,9 @@ /*Recover parameters: */ - inputs->GetParameterValue(&drag_p,FrictionPEnum); - inputs->GetParameterValue(&drag_q,FrictionQEnum); - this->GetParameterValue(&thickness, gauss,ThicknessEnum); - this->GetParameterValue(&bed, gauss,BedEnum); - this->GetParameterValue(&drag_coefficient, gauss,FrictionCoefficientEnum); + inputs->GetInputValue(&drag_p,FrictionPEnum); + inputs->GetInputValue(&drag_q,FrictionQEnum); + this->GetInputValue(&thickness, gauss,ThicknessEnum); + this->GetInputValue(&bed, gauss,BedEnum); + this->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum); /*Get material parameters: */ @@ -295,12 +295,12 @@ //We need the velocity magnitude to evaluate the basal stress: if(strcmp(element_type,"2d")==0){ - this->GetParameterValue(&vx, gauss,vxenum); - this->GetParameterValue(&vy, gauss,vyenum); + this->GetInputValue(&vx, gauss,vxenum); + this->GetInputValue(&vy, gauss,vyenum); vmag=sqrt(pow(vx,2)+pow(vy,2)); } else if (strcmp(element_type,"3d")==0){ - this->GetParameterValue(&vx, gauss,vxenum); - this->GetParameterValue(&vy, gauss,vyenum); - this->GetParameterValue(&vz, gauss,vzenum); + this->GetInputValue(&vx, gauss,vxenum); + this->GetInputValue(&vy, gauss,vyenum); + this->GetInputValue(&vz, gauss,vzenum); vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2)); } @@ -316,20 +316,20 @@ } /*}}}*/ -/*FUNCTION Friction::GetParameterValue{{{1*/ -void Friction::GetParameterValue(double* pvalue,GaussTria* gauss,int enum_type){ +/*FUNCTION Friction::GetInputValue{{{1*/ +void Friction::GetInputValue(double* pvalue,GaussTria* gauss,int enum_type){ Input* input=inputs->GetInput(enum_type); if(!input) _error_("input %s not found",EnumToStringx(enum_type)); - input->GetParameterValue(pvalue,gauss); - -} -/*}}}*/ -/*FUNCTION Friction::GetParameterValue{{{1*/ -void Friction::GetParameterValue(double* pvalue,GaussPenta* gauss,int enum_type){ + input->GetInputValue(pvalue,gauss); + +} +/*}}}*/ +/*FUNCTION Friction::GetInputValue{{{1*/ +void Friction::GetInputValue(double* pvalue,GaussPenta* gauss,int enum_type){ Input* input=inputs->GetInput(enum_type); if(!input) _error_("input %s not found",EnumToStringx(enum_type)); - input->GetParameterValue(pvalue,gauss); - -} -/*}}}*/ + input->GetInputValue(pvalue,gauss); + +} +/*}}}*/ Index: /issm/trunk/src/c/objects/Loads/Friction.h =================================================================== --- /issm/trunk/src/c/objects/Loads/Friction.h (revision 10134) +++ /issm/trunk/src/c/objects/Loads/Friction.h (revision 10135) @@ -31,6 +31,6 @@ void GetAlphaComplement(double* alpha_complement, GaussTria* gauss,int vxenum,int vyenum,int vzenum); void GetAlphaComplement(double* alpha_complement, GaussPenta* gauss,int vxenum,int vyenum,int vzenum); - void GetParameterValue(double* pvalue,GaussTria* gauss,int enum_type); - void GetParameterValue(double* pvalue,GaussPenta* gauss,int enum_type); + void GetInputValue(double* pvalue,GaussTria* gauss,int enum_type); + void GetInputValue(double* pvalue,GaussPenta* gauss,int enum_type); }; Index: /issm/trunk/src/c/objects/Loads/Icefront.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Icefront.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Loads/Icefront.cpp (revision 10135) @@ -438,5 +438,5 @@ int type; - inputs->GetParameterValue(&type,TypeEnum); + inputs->GetInputValue(&type,TypeEnum); switch(type){ @@ -483,5 +483,5 @@ Input* thickness_input=tria->inputs->GetInput(ThicknessEnum); _assert_(thickness_input); Input* bed_input =tria->inputs->GetInput(BedEnum); _assert_(bed_input); - inputs->GetParameterValue(&fill,FillEnum); + inputs->GetInputValue(&fill,FillEnum); rho_water=matpar->GetRhoWater(); rho_ice =matpar->GetRhoIce(); @@ -498,6 +498,6 @@ gauss->GaussPoint(ig); - thickness_input->GetParameterValue(&thickness,gauss); - bed_input->GetParameterValue(&bed,gauss); + thickness_input->GetInputValue(&thickness,gauss); + bed_input->GetInputValue(&bed,gauss); switch(fill){ @@ -599,5 +599,5 @@ GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICESQUA); Input* surface_input =penta->inputs->GetInput(SurfaceEnum); _assert_(surface_input); - inputs->GetParameterValue(&fill,FillEnum); + inputs->GetInputValue(&fill,FillEnum); rho_water=matpar->GetRhoWater(); rho_ice =matpar->GetRhoIce(); @@ -623,5 +623,5 @@ penta->GetQuadJacobianDeterminant(&Jdet,xyz_list,gauss); z_g=penta->GetZcoord(gauss); - surface_input->GetParameterValue(&surface,gauss); + surface_input->GetInputValue(&surface,gauss); switch(fill){ @@ -672,5 +672,5 @@ /*Retrieve all inputs and parameters*/ GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICESQUA); - inputs->GetParameterValue(&fill,FillEnum); + inputs->GetInputValue(&fill,FillEnum); rho_water=matpar->GetRhoWater(); gravity =matpar->GetG(); @@ -737,5 +737,5 @@ /*recover type: */ - inputs->GetParameterValue(&type,TypeEnum); + inputs->GetInputValue(&type,TypeEnum); /*Some checks for debugging*/ Index: /issm/trunk/src/c/objects/Loads/Numericalflux.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Numericalflux.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Loads/Numericalflux.cpp (revision 10135) @@ -422,5 +422,5 @@ int type; - inputs->GetParameterValue(&type,TypeEnum); + inputs->GetInputValue(&type,TypeEnum); switch(type){ @@ -474,6 +474,6 @@ tria->GetSegmentBprimeFlux(&Bprime[0],gauss,index1,index2); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); UdotN=vx*normal[0]+vy*normal[1]; tria->GetSegmentJacobianDeterminant(&Jdet,&xyz_list[0][0],gauss); @@ -532,6 +532,6 @@ gauss=new GaussTria(); gauss->GaussEdgeCenter(index1,index2); - vxaverage_input->GetParameterValue(&mean_vx,gauss); - vyaverage_input->GetParameterValue(&mean_vy,gauss); + vxaverage_input->GetInputValue(&mean_vx,gauss); + vyaverage_input->GetInputValue(&mean_vy,gauss); delete gauss; @@ -552,6 +552,6 @@ tria->GetSegmentNodalFunctions(&L[0],gauss,index1,index2); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); UdotN=vx*normal[0]+vy*normal[1]; tria->GetSegmentJacobianDeterminant(&Jdet,&xyz_list[0][0],gauss); @@ -575,5 +575,5 @@ int type; - inputs->GetParameterValue(&type,TypeEnum); + inputs->GetInputValue(&type,TypeEnum); switch(type){ @@ -626,6 +626,6 @@ tria->GetSegmentBprimeFlux(&Bprime[0],gauss,index1,index2); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); UdotN=vx*normal[0]+vy*normal[1]; tria->GetSegmentJacobianDeterminant(&Jdet,&xyz_list[0][0],gauss); @@ -683,6 +683,6 @@ gauss=new GaussTria(); gauss->GaussEdgeCenter(index1,index2); - vxaverage_input->GetParameterValue(&mean_vx,gauss); - vyaverage_input->GetParameterValue(&mean_vy,gauss); + vxaverage_input->GetInputValue(&mean_vx,gauss); + vyaverage_input->GetInputValue(&mean_vy,gauss); delete gauss; @@ -703,6 +703,6 @@ tria->GetSegmentNodalFunctions(&L[0],gauss,index1,index2); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); UdotN=vx*normal[0]+vy*normal[1]; tria->GetSegmentJacobianDeterminant(&Jdet,&xyz_list[0][0],gauss); @@ -726,5 +726,5 @@ int type; - inputs->GetParameterValue(&type,TypeEnum); + inputs->GetInputValue(&type,TypeEnum); switch(type){ @@ -758,5 +758,5 @@ int type; - inputs->GetParameterValue(&type,TypeEnum); + inputs->GetInputValue(&type,TypeEnum); switch(type){ @@ -811,6 +811,6 @@ gauss=new GaussTria(); gauss->GaussEdgeCenter(index1,index2); - vxaverage_input->GetParameterValue(&mean_vx,gauss); - vyaverage_input->GetParameterValue(&mean_vy,gauss); + vxaverage_input->GetInputValue(&mean_vx,gauss); + vyaverage_input->GetInputValue(&mean_vy,gauss); delete gauss; @@ -831,7 +831,7 @@ tria->GetSegmentNodalFunctions(&L[0],gauss,index1,index2); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); - spcthickness_input->GetParameterValue(&thickness,gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); + spcthickness_input->GetInputValue(&thickness,gauss); if(isnan(thickness)) _error_("Cannot weakly apply constraint because NaN was provided"); @@ -852,5 +852,5 @@ int type; - inputs->GetParameterValue(&type,TypeEnum); + inputs->GetInputValue(&type,TypeEnum); switch(type){ @@ -904,6 +904,6 @@ gauss=new GaussTria(); gauss->GaussEdgeCenter(index1,index2); - vxaverage_input->GetParameterValue(&mean_vx,gauss); - vyaverage_input->GetParameterValue(&mean_vy,gauss); + vxaverage_input->GetInputValue(&mean_vx,gauss); + vyaverage_input->GetInputValue(&mean_vy,gauss); delete gauss; UdotN=mean_vx*normal[0]+mean_vy*normal[1]; @@ -923,7 +923,7 @@ tria->GetSegmentNodalFunctions(&L[0],gauss,index1,index2); - vxaverage_input->GetParameterValue(&vx,gauss); - vyaverage_input->GetParameterValue(&vy,gauss); - thickness_input->GetParameterValue(&thickness,gauss); + vxaverage_input->GetInputValue(&vx,gauss); + vyaverage_input->GetInputValue(&vy,gauss); + thickness_input->GetInputValue(&thickness,gauss); UdotN=vx*normal[0]+vy*normal[1]; Index: /issm/trunk/src/c/objects/Loads/Pengrid.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Pengrid.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Loads/Pengrid.cpp (revision 10135) @@ -491,6 +491,6 @@ //First recover pressure and temperature values, using the element: */ - penta->GetParameterValue(&pressure,node,PressureEnum); - penta->GetParameterValue(&temperature,node,TemperaturePicardEnum); + penta->GetInputValue(&pressure,node,PressureEnum); + penta->GetInputValue(&temperature,node,TemperaturePicardEnum); //Recover our data: @@ -545,5 +545,5 @@ /*Initialize Element vector and return if necessary*/ - penta->inputs->GetParameterValue(&approximation,ApproximationEnum); + penta->inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation!=StokesApproximationEnum && approximation!=PattynStokesApproximationEnum) return NULL; ElementMatrix* Ke=new ElementMatrix(&node,1,this->parameters,StokesApproximationEnum); @@ -551,6 +551,6 @@ /*Retrieve all inputs and parameters*/ parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum); - penta->GetParameterValue(&slope[0],node,BedSlopeXEnum); - penta->GetParameterValue(&slope[1],node,BedSlopeYEnum); + penta->GetInputValue(&slope[0],node,BedSlopeXEnum); + penta->GetInputValue(&slope[1],node,BedSlopeYEnum); /*Create elementary matrix: add penalty to constrain wb (wb=ub*db/dx+vb*db/dy)*/ @@ -577,6 +577,6 @@ /*Retrieve all inputs and parameters*/ - penta->GetParameterValue(&pressure,node,PressureEnum); - penta->GetParameterValue(&temperature,node,TemperatureEnum); + penta->GetInputValue(&pressure,node,PressureEnum); + penta->GetInputValue(&temperature,node,TemperatureEnum); parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum); @@ -630,7 +630,7 @@ /*Retrieve all inputs and parameters*/ - penta->GetParameterValue(&pressure,node,PressureEnum); - penta->GetParameterValue(&temperature,node,TemperatureEnum); - inputs->GetParameterValue(&melting_offset,MeltingOffsetEnum); + penta->GetInputValue(&pressure,node,PressureEnum); + penta->GetInputValue(&temperature,node,TemperatureEnum); + inputs->GetInputValue(&melting_offset,MeltingOffsetEnum); parameters->FindParam(&dt,TimesteppingTimeStepEnum); parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum); @@ -670,5 +670,5 @@ /*Retrieve all inputs and parameters*/ - penta->GetParameterValue(&pressure,node,PressureEnum); + penta->GetInputValue(&pressure,node,PressureEnum); parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum); Index: /issm/trunk/src/c/objects/Loads/Riftfront.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Riftfront.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Loads/Riftfront.cpp (revision 10135) @@ -139,7 +139,7 @@ /*recover some inputs first: */ - input=(Input*)this->inputs->GetInput(FillEnum); input->GetParameterValue(&fill); - input=(Input*)this->inputs->GetInput(FrictionEnum); input->GetParameterValue(&friction); - input=(Input*)this->inputs->GetInput(FractionIncrementEnum); input->GetParameterValue(&fractionincrement); + input=(Input*)this->inputs->GetInput(FillEnum); input->GetInputValue(&fill); + input=(Input*)this->inputs->GetInput(FrictionEnum); input->GetInputValue(&friction); + input=(Input*)this->inputs->GetInput(FractionIncrementEnum); input->GetInputValue(&fractionincrement); printf("Riftfront:\n"); @@ -526,7 +526,7 @@ /*Get some parameters: */ this->parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum); - this->inputs->GetParameterValue(&friction,FrictionEnum); - tria1->GetParameterValue(&h[0],nodes[0],ThicknessEnum); - tria2->GetParameterValue(&h[1],nodes[1],ThicknessEnum); + this->inputs->GetInputValue(&friction,FrictionEnum); + tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum); + tria2->GetInputValue(&h[1],nodes[1],ThicknessEnum); if (h[0]!=h[1])_error_(" different thicknesses not supported for rift fronts"); thickness=h[0]; @@ -616,15 +616,15 @@ /*Get some inputs: */ - this->inputs->GetParameterValue(&fill,FillEnum); - this->inputs->GetParameterValue(&shelf,SegmentOnIceShelfEnum); + this->inputs->GetInputValue(&fill,FillEnum); + this->inputs->GetInputValue(&shelf,SegmentOnIceShelfEnum); rho_ice=matpar->GetRhoIce(); rho_water=matpar->GetRhoWater(); gravity=matpar->GetG(); - tria1->GetParameterValue(&h[0],nodes[0],ThicknessEnum); - tria2->GetParameterValue(&h[1],nodes[1],ThicknessEnum); + tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum); + tria2->GetInputValue(&h[1],nodes[1],ThicknessEnum); if (h[0]!=h[1])_error_(" different thicknesses not supported for rift fronts"); thickness=h[0]; - tria1->GetParameterValue(&b[0],nodes[0],BedEnum); - tria2->GetParameterValue(&b[1],nodes[1],BedEnum); + tria1->GetInputValue(&b[0],nodes[0],BedEnum); + tria2->GetInputValue(&b[1],nodes[1],BedEnum); if (b[0]!=b[1])_error_(" different beds not supported for rift fronts"); bed=b[0]; @@ -729,11 +729,11 @@ /*recover parameters: */ - this->inputs->GetParameterValue(&fractionincrement,FractionIncrementEnum); + this->inputs->GetInputValue(&fractionincrement,FractionIncrementEnum); /*First recover velocity: */ - tria1->GetParameterValue(&vx1,nodes[0],VxEnum); - tria2->GetParameterValue(&vx2,nodes[1],VxEnum); - tria1->GetParameterValue(&vy1,nodes[0],VyEnum); - tria2->GetParameterValue(&vy2,nodes[1],VyEnum); + tria1->GetInputValue(&vx1,nodes[0],VxEnum); + tria2->GetInputValue(&vx2,nodes[1],VxEnum); + tria1->GetInputValue(&vy1,nodes[0],VyEnum); + tria2->GetInputValue(&vy2,nodes[1],VyEnum); /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */ @@ -795,5 +795,5 @@ double converged=0; - this->inputs->GetParameterValue(&converged,ConvergedEnum); + this->inputs->GetInputValue(&converged,ConvergedEnum); if(converged){ @@ -834,8 +834,8 @@ /*recover velocity: */ - tria1->GetParameterValue(&vx1,nodes[0],VxEnum); - tria2->GetParameterValue(&vx2,nodes[1],VxEnum); - tria1->GetParameterValue(&vy1,nodes[0],VyEnum); - tria2->GetParameterValue(&vy2,nodes[1],VyEnum); + tria1->GetInputValue(&vx1,nodes[0],VxEnum); + tria2->GetInputValue(&vx2,nodes[1],VxEnum); + tria1->GetInputValue(&vy1,nodes[0],VyEnum); + tria2->GetInputValue(&vy2,nodes[1],VyEnum); /*Node1 faces node2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */ @@ -876,8 +876,8 @@ /*First recover velocity: */ - tria1->GetParameterValue(&vx1,nodes[0],VxEnum); - tria2->GetParameterValue(&vx2,nodes[1],VxEnum); - tria1->GetParameterValue(&vy1,nodes[0],VyEnum); - tria2->GetParameterValue(&vy2,nodes[1],VyEnum); + tria1->GetInputValue(&vx1,nodes[0],VxEnum); + tria2->GetInputValue(&vx2,nodes[1],VxEnum); + tria1->GetInputValue(&vy1,nodes[0],VyEnum); + tria2->GetInputValue(&vy2,nodes[1],VyEnum); /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */ @@ -919,8 +919,8 @@ /*First recover velocity: */ - tria1->GetParameterValue(&vx1,nodes[0],VxEnum); - tria2->GetParameterValue(&vx2,nodes[1],VxEnum); - tria1->GetParameterValue(&vy1,nodes[0],VyEnum); - tria2->GetParameterValue(&vy2,nodes[1],VyEnum); + tria1->GetInputValue(&vx1,nodes[0],VxEnum); + tria2->GetInputValue(&vx2,nodes[1],VxEnum); + tria1->GetInputValue(&vy1,nodes[0],VyEnum); + tria2->GetInputValue(&vy2,nodes[1],VyEnum); /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */ @@ -968,8 +968,8 @@ /*First recover velocity: */ - tria1->GetParameterValue(&vx1,nodes[0],VxEnum); - tria2->GetParameterValue(&vx2,nodes[1],VxEnum); - tria1->GetParameterValue(&vy1,nodes[0],VyEnum); - tria2->GetParameterValue(&vy2,nodes[1],VyEnum); + tria1->GetInputValue(&vx1,nodes[0],VxEnum); + tria2->GetInputValue(&vx2,nodes[1],VxEnum); + tria1->GetInputValue(&vy1,nodes[0],VyEnum); + tria2->GetInputValue(&vy2,nodes[1],VyEnum); /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */ Index: /issm/trunk/src/c/objects/Materials/Matice.cpp =================================================================== --- /issm/trunk/src/c/objects/Materials/Matice.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Materials/Matice.cpp (revision 10135) @@ -204,5 +204,5 @@ double B; - inputs->GetParameterAverage(&B,MaterialsRheologyBEnum); + inputs->GetInputAverage(&B,MaterialsRheologyBEnum); return B; } @@ -214,5 +214,5 @@ double Bbar; - inputs->GetParameterAverage(&Bbar,MaterialsRheologyBbarEnum); + inputs->GetInputAverage(&Bbar,MaterialsRheologyBbarEnum); return Bbar; } @@ -224,5 +224,5 @@ double n; - inputs->GetParameterAverage(&n,MaterialsRheologyNEnum); + inputs->GetInputAverage(&n,MaterialsRheologyNEnum); return n; } Index: /issm/trunk/src/c/objects/Node.cpp =================================================================== --- /issm/trunk/src/c/objects/Node.cpp (revision 10134) +++ /issm/trunk/src/c/objects/Node.cpp (revision 10135) @@ -632,5 +632,5 @@ /*recover parameters: */ - inputs->GetParameterValue(&approximation,ApproximationEnum); + inputs->GetInputValue(&approximation,ApproximationEnum); return approximation; @@ -642,5 +642,5 @@ /*recover parameters: */ - inputs->GetParameterValue(&connectivity,NumberNodeToElementConnectivityEnum); + inputs->GetInputValue(&connectivity,NumberNodeToElementConnectivityEnum); return connectivity; @@ -740,5 +740,5 @@ /*recover parameters: */ - inputs->GetParameterValue(&onbed,MeshVertexonbedEnum); + inputs->GetInputValue(&onbed,MeshVertexonbedEnum); return onbed; @@ -751,5 +751,5 @@ /*recover parameters: */ - inputs->GetParameterValue(&onsheet,MaskVertexongroundediceEnum); + inputs->GetInputValue(&onsheet,MaskVertexongroundediceEnum); return onsheet; @@ -762,5 +762,5 @@ /*recover parameters: */ - inputs->GetParameterValue(&onshelf,MaskVertexonfloatingiceEnum); + inputs->GetInputValue(&onshelf,MaskVertexonfloatingiceEnum); return onshelf; @@ -773,5 +773,5 @@ /*recover parameters: */ - inputs->GetParameterValue(&onsurface,MeshVertexonsurfaceEnum); + inputs->GetInputValue(&onsurface,MeshVertexonsurfaceEnum); return onsurface;