Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 17932) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 17933) @@ -421,4 +421,5 @@ ./cores/adjointstressbalance_core.cpp\ ./cores/adjointbalancethickness_core.cpp\ + ./cores/adjointbalancethickness2_core.cpp\ ./cores/AdjointCorePointerFromSolutionEnum.cpp\ ./solutionsequences/solutionsequence_adjoint_linear.cpp\ @@ -514,4 +515,7 @@ if ADJOINTBALANCETHICKNESS issm_sources += ./analyses/AdjointBalancethicknessAnalysis.cpp +endif +if ADJOINTBALANCETHICKNESS2 +issm_sources += ./analyses/AdjointBalancethickness2Analysis.cpp endif if ADJOINTHORIZ Index: /issm/trunk-jpl/src/c/analyses/AdjointBalancethickness2Analysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/AdjointBalancethickness2Analysis.cpp (revision 17933) +++ /issm/trunk-jpl/src/c/analyses/AdjointBalancethickness2Analysis.cpp (revision 17933) @@ -0,0 +1,160 @@ +#include "./AdjointBalancethickness2Analysis.h" +#include "../toolkits/toolkits.h" +#include "../classes/classes.h" +#include "../shared/shared.h" +#include "../modules/modules.h" + +/*Model processor*/ +int AdjointBalancethickness2Analysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ + return 1; +}/*}}}*/ +void AdjointBalancethickness2Analysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +void AdjointBalancethickness2Analysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +void AdjointBalancethickness2Analysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +void AdjointBalancethickness2Analysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +void AdjointBalancethickness2Analysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ + +/*Finite Element Analysis*/ +void AdjointBalancethickness2Analysis::Core(FemModel* femmodel){/*{{{*/ + _error_("not implemented"); +}/*}}}*/ +ElementVector* AdjointBalancethickness2Analysis::CreateDVector(Element* element){/*{{{*/ + /*Default, return NULL*/ + return NULL; +}/*}}}*/ +ElementMatrix* AdjointBalancethickness2Analysis::CreateJacobianMatrix(Element* element){/*{{{*/ +_error_("Not implemented"); +}/*}}}*/ +ElementMatrix* AdjointBalancethickness2Analysis::CreateKMatrix(Element* element){/*{{{*/ + + _error_("not implemented"); + Balancethickness2Analysis* analysis = new Balancethickness2Analysis(); + ElementMatrix* Ke = analysis->CreateKMatrix(element); + delete analysis; + + /*Transpose and return Ke*/ + Ke->Transpose(); + return Ke; +}/*}}}*/ +ElementVector* AdjointBalancethickness2Analysis::CreatePVector(Element* element){/*{{{*/ + + _error_("not implemented"); + /*Intermediaries*/ + int domaintype; + Element* basalelement; + + /*Get basal element*/ + element->FindParam(&domaintype,DomainTypeEnum); + switch(domaintype){ + case Domain2DhorizontalEnum: + basalelement = element; + break; + case Domain3DEnum: + if(!element->IsOnBase()) return NULL; + basalelement = element->SpawnBasalElement(); + break; + default: _error_("mesh "<GetNumberOfNodes(); + + /*Initialize Element vector and vectors*/ + ElementVector* pe = basalelement->NewElementVector(SSAApproximationEnum); + IssmDouble* basis = xNew(numnodes); + IssmDouble* dbasis = xNew(2*numnodes); + + /*Retrieve all inputs and parameters*/ + basalelement->GetVerticesCoordinates(&xyz_list); + basalelement->FindParam(&num_responses,InversionNumCostFunctionsEnum); + basalelement->FindParam(&responses,NULL,InversionCostFunctionsEnum); + Input* thickness_input = basalelement->GetInput(ThicknessEnum); _assert_(thickness_input); + Input* thicknessobs_input = basalelement->GetInput(InversionThicknessObsEnum); _assert_(thicknessobs_input); + Input* weights_input = basalelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input); + Input* vx_input = basalelement->GetInput(VxEnum); _assert_(vx_input); + Input* vy_input = basalelement->GetInput(VyEnum); _assert_(vy_input); + + /* Start looping on the number of gaussian points: */ + Gauss* gauss=basalelement->NewGauss(2); + for(int ig=gauss->begin();igend();ig++){ + gauss->GaussPoint(ig); + + basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss); + basalelement->NodalFunctions(basis,gauss); + basalelement->NodalFunctionsDerivatives(dbasis,xyz_list,gauss); + + thickness_input->GetInputValue(&thickness, gauss); + thickness_input->GetInputDerivativeValue(&dH[0],xyz_list,gauss); + thicknessobs_input->GetInputValue(&thicknessobs, gauss); + + /*Loop over all requested responses*/ + for(int resp=0;respGetInputValue(&weight,gauss,responses[resp]); + + switch(responses[resp]){ + case ThicknessAbsMisfitEnum: + for(i=0;ivalues[i]+=(thicknessobs-thickness)*weight*Jdet*gauss->weight*basis[i]; + break; + case ThicknessAbsGradientEnum: + for(i=0;ivalues[i]+= - weight*dH[0]*dbasis[0*numnodes+i]*Jdet*gauss->weight; + for(i=0;ivalues[i]+= - weight*dH[1]*dbasis[1*numnodes+i]*Jdet*gauss->weight; + break; + case ThicknessAlongGradientEnum: + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vel = sqrt(vx*vx+vy*vy); + vx = vx/(vel+1.e-9); + vy = vy/(vel+1.e-9); + for(i=0;ivalues[i]+= - weight*(dH[0]*vx+dH[1]*vy)*(dbasis[0*numnodes+i]*vx+dbasis[1*numnodes+i]*vy)*Jdet*gauss->weight; + break; + case ThicknessAcrossGradientEnum: + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vel = sqrt(vx*vx+vy*vy); + vx = vx/(vel+1.e-9); + vy = vy/(vel+1.e-9); + for(i=0;ivalues[i]+= - weight*(dH[0]*(-vy)+dH[1]*vx)*(dbasis[0*numnodes+i]*(-vy)+dbasis[1*numnodes+i]*vx)*Jdet*gauss->weight; + break; + default: + _error_("response " << EnumToStringx(responses[resp]) << " not supported yet"); + } + } + } + + /*Clean up and return*/ + xDelete(responses); + xDelete(xyz_list); + xDelete(basis); + xDelete(dbasis); + if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;}; + delete gauss; + return pe; +}/*}}}*/ +void AdjointBalancethickness2Analysis::GetSolutionFromInputs(Vector* solution,Element* element){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +void AdjointBalancethickness2Analysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ + element->InputUpdateFromSolutionOneDof(solution,AdjointEnum); +}/*}}}*/ +void AdjointBalancethickness2Analysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ + /*Default, do nothing*/ + return; +}/*}}}*/ Index: /issm/trunk-jpl/src/c/analyses/AdjointBalancethickness2Analysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/AdjointBalancethickness2Analysis.h (revision 17933) +++ /issm/trunk-jpl/src/c/analyses/AdjointBalancethickness2Analysis.h (revision 17933) @@ -0,0 +1,32 @@ +/*! \file AdjointBalancethickness2Analysis.h + * \brief: header file for generic external result object + */ + +#ifndef _AdjointBalancethickness2Analysis_ +#define _AdjointBalancethickness2Analysis_ + +/*Headers*/ +#include "./Analysis.h" + +class AdjointBalancethickness2Analysis: public Analysis{ + + public: + /*Model processing*/ + int DofsPerNode(int** doflist,int domaintype,int approximation); + void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); + void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); + void CreateNodes(Nodes* nodes,IoModel* iomodel); + void CreateConstraints(Constraints* constraints,IoModel* iomodel); + void CreateLoads(Loads* loads, IoModel* iomodel); + + /*Finite element Analysis*/ + void Core(FemModel* femmodel); + ElementVector* CreateDVector(Element* element); + ElementMatrix* CreateJacobianMatrix(Element* element); + ElementMatrix* CreateKMatrix(Element* element); + ElementVector* CreatePVector(Element* element); + void GetSolutionFromInputs(Vector* solution,Element* element); + void InputUpdateFromSolution(IssmDouble* solution,Element* element); + void UpdateConstraints(FemModel* femmodel); +}; +#endif Index: /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.cpp (revision 17932) +++ /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.cpp (revision 17933) @@ -16,4 +16,7 @@ #ifdef _HAVE_ADJOINTBALANCETHICKNESS_ case AdjointBalancethicknessAnalysisEnum : return new AdjointBalancethicknessAnalysis(); + #endif + #ifdef _HAVE_ADJOINTBALANCETHICKNESS2_ + case AdjointBalancethickness2AnalysisEnum : return new AdjointBalancethickness2Analysis(); #endif #ifdef _HAVE_ADJOINTHORIZ_ Index: /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp (revision 17932) +++ /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp (revision 17933) @@ -38,5 +38,5 @@ if(iomodel->my_elements[i]){ Element* element=(Element*)elements->GetObjectByOffset(counter); - element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum); + element->Update(i,iomodel,analysis_counter,analysis_type,P2Enum); counter++; } @@ -60,4 +60,6 @@ } iomodel->FetchDataToInput(elements,FlowequationElementEquationEnum); + iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); + iomodel->FetchDataToInput(elements,MeshVertexonsurfaceEnum); iomodel->FetchDataToInput(elements,MaterialsRheologyBEnum); iomodel->FetchDataToInput(elements,MaterialsRheologyNEnum); @@ -86,5 +88,5 @@ if(iomodel->domaintype==Domain3DEnum) iomodel->FetchData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); - ::CreateNodes(nodes,iomodel,ThermalAnalysisEnum,P1Enum); + ::CreateNodes(nodes,iomodel,ThermalAnalysisEnum,P2Enum); iomodel->DeleteData(2,MeshVertexonbaseEnum,MeshVertexonsurfaceEnum); }/*}}}*/ @@ -93,5 +95,5 @@ /*Only 3d mesh supported*/ if(iomodel->domaintype==Domain3DEnum){ - IoModelToConstraintsx(constraints,iomodel,ThermalSpctemperatureEnum,ThermalAnalysisEnum,P1Enum); + IoModelToConstraintsx(constraints,iomodel,ThermalSpctemperatureEnum,ThermalAnalysisEnum,P2Enum); } Index: /issm/trunk-jpl/src/c/analyses/analyses.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/analyses.h (revision 17932) +++ /issm/trunk-jpl/src/c/analyses/analyses.h (revision 17933) @@ -9,4 +9,5 @@ #include "./AdjointBalancethicknessAnalysis.h" +#include "./AdjointBalancethickness2Analysis.h" #include "./AdjointHorizAnalysis.h" #include "./BalancethicknessAnalysis.h" Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 17932) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 17933) @@ -1019,45 +1019,32 @@ if (control_analysis && iomodel->Data(InversionControlParametersEnum)){ for(i=0;i(iomodel->Data(InversionControlParametersEnum)[i])){ + int control = reCast(iomodel->Data(InversionControlParametersEnum)[i]); + switch(control){ + /*yts conversion*/ case BalancethicknessThickeningRateEnum: - if (iomodel->Data(BalancethicknessThickeningRateEnum)){ - for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(BalancethicknessThickeningRateEnum)[tria_vertex_ids[j]-1]; + case VxEnum: + case VyEnum: + if(iomodel->Data(control)){ + for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(control)[tria_vertex_ids[j]-1]; for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + this->inputs->AddInput(new ControlInput(control,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; - case VxEnum: - if (iomodel->Data(VxEnum)){ - for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(VxEnum)[tria_vertex_ids[j]-1]; - for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; - for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(VxEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); + + /*No yts conversion*/ + case ThicknessEnum: + case FrictionCoefficientEnum: + case BalancethicknessNuxEnum: + case BalancethicknessNuyEnum: + if(iomodel->Data(control)){ + for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(control)[tria_vertex_ids[j]-1]; + for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]; + for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]; + this->inputs->AddInput(new ControlInput(control,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); } break; - case VyEnum: - if (iomodel->Data(VyEnum)){ - for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(VyEnum)[tria_vertex_ids[j]-1]; - for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; - for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]/yts; - this->inputs->AddInput(new ControlInput(VyEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); - } - break; - case ThicknessEnum: - if (iomodel->Data(ThicknessEnum)){ - for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(ThicknessEnum)[tria_vertex_ids[j]-1]; - for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]; - for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]; - this->inputs->AddInput(new ControlInput(ThicknessEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); - } - break; - case FrictionCoefficientEnum: - if (iomodel->Data(FrictionCoefficientEnum)){ - for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data(FrictionCoefficientEnum)[tria_vertex_ids[j]-1]; - for(j=0;j<3;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]; - for(j=0;j<3;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(tria_vertex_ids[j]-1)*num_control_type+i]; - this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1)); - } - break; + + /*Special cases (depth averaged quantities)*/ case MaterialsRheologyBbarEnum: if(iomodel->Data(MaterialsRheologyBEnum)){ @@ -1077,5 +1064,5 @@ break; default: - _error_("Control " << EnumToStringx(reCast(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet"); + _error_("Control " << EnumToStringx(control) << " not implemented yet"); } } Index: /issm/trunk-jpl/src/c/cores/AdjointCorePointerFromSolutionEnum.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/AdjointCorePointerFromSolutionEnum.cpp (revision 17932) +++ /issm/trunk-jpl/src/c/cores/AdjointCorePointerFromSolutionEnum.cpp (revision 17933) @@ -32,4 +32,7 @@ adjointcore=&adjointbalancethickness_core; break; + case Balancethickness2SolutionEnum: + adjointcore=&adjointbalancethickness2_core; + break; case BalancethicknessSoftSolutionEnum: adjointcore=&dummy_core; Index: /issm/trunk-jpl/src/c/cores/adjointbalancethickness2_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/adjointbalancethickness2_core.cpp (revision 17933) +++ /issm/trunk-jpl/src/c/cores/adjointbalancethickness2_core.cpp (revision 17933) @@ -0,0 +1,39 @@ +/*!\file: adjointbalancethickness2_core.cpp + * \brief compute inverse method adjoint state + */ + +#include "./cores.h" +#include "../toolkits/toolkits.h" +#include "../classes/classes.h" +#include "../shared/shared.h" +#include "../modules/modules.h" +#include "../solutionsequences/solutionsequences.h" + +void adjointbalancethickness2_core(FemModel* femmodel){ + + /*parameters: */ + bool save_results; + + /*retrieve parameters:*/ + femmodel->parameters->FindParam(&save_results,SaveResultsEnum); + + /*compute thickness2 */ + if(VerboseSolution()) _printf0_(" computing thickness2\n"); + femmodel->SetCurrentConfiguration(Balancethickness2AnalysisEnum); + solutionsequence_linear(femmodel); + + /*Call SurfaceAreax, because some it might be needed by PVector*/ + SurfaceAreax(NULL,femmodel); + + /*compute adjoint*/ + if(VerboseSolution()) _printf0_(" computing adjoint\n"); + femmodel->SetCurrentConfiguration(Balancethickness2AnalysisEnum,AdjointBalancethickness2AnalysisEnum); + solutionsequence_adjoint_linear(femmodel); + + /*Save results*/ + if(save_results){ + if(VerboseSolution()) _printf0_(" saving results\n"); + int outputs[1] = {AdjointEnum}; + femmodel->RequestedOutputsx(&femmodel->results,&outputs[0],1); + } +} Index: /issm/trunk-jpl/src/c/cores/cores.h =================================================================== --- /issm/trunk-jpl/src/c/cores/cores.h (revision 17932) +++ /issm/trunk-jpl/src/c/cores/cores.h (revision 17933) @@ -18,4 +18,5 @@ void adjointstressbalance_core(FemModel* femmodel); void adjointbalancethickness_core(FemModel* femmodel); +void adjointbalancethickness2_core(FemModel* femmodel); void gradient_core(FemModel* femmodel,int n=0,bool orthogonalize=false); void stressbalance_core(FemModel* femmodel); Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp (revision 17932) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp (revision 17933) @@ -16,6 +16,6 @@ Element *element = NULL; Material *material = NULL; - int num_control_type; - bool control_analysis; + int num_control_type; + bool control_analysis; /*Fetch parameters: */ @@ -32,14 +32,22 @@ iomodel->FetchData(5,InversionControlParametersEnum,InversionCostFunctionsEnum,InversionCostFunctionsCoefficientsEnum,InversionMinParametersEnum,InversionMaxParametersEnum); + for(i=0;i(iomodel->Data(InversionControlParametersEnum)[i])){ - case BalancethicknessThickeningRateEnum: iomodel->FetchData(1,BalancethicknessThickeningRateEnum); break; - case VxEnum: iomodel->FetchData(1,VxEnum); break; - case VyEnum: iomodel->FetchData(1,VyEnum); break; - case ThicknessEnum: iomodel->FetchData(1,ThicknessEnum); break; - case FrictionCoefficientEnum: iomodel->FetchData(1,FrictionCoefficientEnum); break; - case MaterialsRheologyBbarEnum: iomodel->FetchData(1,MaterialsRheologyBEnum); break; - case DamageDbarEnum: iomodel->FetchData(1,DamageDEnum); break; - default: _error_("Control " << EnumToStringx(reCast(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet"); + int control = reCast(iomodel->Data(InversionControlParametersEnum)[i]); + switch(control){ + /*List of supported controls*/ + case BalancethicknessThickeningRateEnum: + case VxEnum: + case VyEnum: + case ThicknessEnum: + case FrictionCoefficientEnum: + case MaterialsRheologyBbarEnum: + case DamageDbarEnum: + case BalancethicknessNuxEnum: + case BalancethicknessNuyEnum: + iomodel->FetchData(1,control); + break; + default: + _error_("Control " << EnumToStringx(control) << " not implemented yet"); } } Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 17932) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 17933) @@ -329,4 +329,5 @@ ConfigurationTypeEnum, AdjointBalancethicknessAnalysisEnum, + AdjointBalancethickness2AnalysisEnum, AdjointHorizAnalysisEnum, AnalysisCounterEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 17932) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 17933) @@ -332,4 +332,5 @@ case ConfigurationTypeEnum : return "ConfigurationType"; case AdjointBalancethicknessAnalysisEnum : return "AdjointBalancethicknessAnalysis"; + case AdjointBalancethickness2AnalysisEnum : return "AdjointBalancethickness2Analysis"; case AdjointHorizAnalysisEnum : return "AdjointHorizAnalysis"; case AnalysisCounterEnum : return "AnalysisCounter"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 17932) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 17933) @@ -338,4 +338,5 @@ else if (strcmp(name,"ConfigurationType")==0) return ConfigurationTypeEnum; else if (strcmp(name,"AdjointBalancethicknessAnalysis")==0) return AdjointBalancethicknessAnalysisEnum; + else if (strcmp(name,"AdjointBalancethickness2Analysis")==0) return AdjointBalancethickness2AnalysisEnum; else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum; else if (strcmp(name,"AnalysisCounter")==0) return AnalysisCounterEnum; @@ -382,9 +383,9 @@ else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum; else if (strcmp(name,"GiaSolution")==0) return GiaSolutionEnum; - else if (strcmp(name,"GiaAnalysis")==0) return GiaAnalysisEnum; else stage=4; } if(stage==4){ - if (strcmp(name,"MeshdeformationSolution")==0) return MeshdeformationSolutionEnum; + if (strcmp(name,"GiaAnalysis")==0) return GiaAnalysisEnum; + else if (strcmp(name,"MeshdeformationSolution")==0) return MeshdeformationSolutionEnum; else if (strcmp(name,"MeshdeformationAnalysis")==0) return MeshdeformationAnalysisEnum; else if (strcmp(name,"LevelsetAnalysis")==0) return LevelsetAnalysisEnum; @@ -505,9 +506,9 @@ else if (strcmp(name,"QmuVyMesh")==0) return QmuVyMeshEnum; else if (strcmp(name,"QmuVzMesh")==0) return QmuVzMeshEnum; - else if (strcmp(name,"AndroidFrictionCoefficient")==0) return AndroidFrictionCoefficientEnum; else stage=5; } if(stage==5){ - if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum; + if (strcmp(name,"AndroidFrictionCoefficient")==0) return AndroidFrictionCoefficientEnum; + else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum; else if (strcmp(name,"SegmentOnIceShelf")==0) return SegmentOnIceShelfEnum; else if (strcmp(name,"SurfaceAbsVelMisfit")==0) return SurfaceAbsVelMisfitEnum; @@ -628,9 +629,9 @@ else if (strcmp(name,"MinVy")==0) return MinVyEnum; else if (strcmp(name,"MaxVy")==0) return MaxVyEnum; - else if (strcmp(name,"MaxAbsVy")==0) return MaxAbsVyEnum; else stage=6; } if(stage==6){ - if (strcmp(name,"MinVz")==0) return MinVzEnum; + if (strcmp(name,"MaxAbsVy")==0) return MaxAbsVyEnum; + else if (strcmp(name,"MinVz")==0) return MinVzEnum; else if (strcmp(name,"MaxVz")==0) return MaxVzEnum; else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum; Index: /issm/trunk-jpl/src/m/enum/AdjointBalancethickness2AnalysisEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/AdjointBalancethickness2AnalysisEnum.m (revision 17933) +++ /issm/trunk-jpl/src/m/enum/AdjointBalancethickness2AnalysisEnum.m (revision 17933) @@ -0,0 +1,11 @@ +function macro=AdjointBalancethickness2AnalysisEnum() +%ADJOINTBALANCETHICKNESS2ANALYSISENUM - Enum of AdjointBalancethickness2Analysis +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=AdjointBalancethickness2AnalysisEnum() + +macro=StringToEnum('AdjointBalancethickness2Analysis'); Index: /issm/trunk-jpl/src/m/enum/EnumDefinitions.py =================================================================== --- /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 17932) +++ /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 17933) @@ -324,4 +324,5 @@ def ConfigurationTypeEnum(): return StringToEnum("ConfigurationType")[0] def AdjointBalancethicknessAnalysisEnum(): return StringToEnum("AdjointBalancethicknessAnalysis")[0] +def AdjointBalancethickness2AnalysisEnum(): return StringToEnum("AdjointBalancethickness2Analysis")[0] def AdjointHorizAnalysisEnum(): return StringToEnum("AdjointHorizAnalysis")[0] def AnalysisCounterEnum(): return StringToEnum("AnalysisCounter")[0]