source: issm/oecreview/Archive/17984-18295/ISSM-18002-18003.diff@ 18296

Last change on this file since 18296 was 18296, checked in by Mathieu Morlighem, 11 years ago

Added 17984-18295
File size: 20.4 KB

  • ../trunk-jpl/src/c/analyses/AdjointBalancethickness2Analysis.cpp

     
    3737}/*}}}*/
    3838ElementMatrix* AdjointBalancethickness2Analysis::CreateKMatrix(Element* element){/*{{{*/
    3939
    40         _error_("not implemented");
    4140        Balancethickness2Analysis* analysis = new Balancethickness2Analysis();
    4241        ElementMatrix* Ke = analysis->CreateKMatrix(element);
    4342        delete analysis;
    4443
    45         /*Transpose and return Ke*/
    46         Ke->Transpose();
    4744        return Ke;
    4845}/*}}}*/
    4946ElementVector* AdjointBalancethickness2Analysis::CreatePVector(Element* element){/*{{{*/
    5047
    51         _error_("not implemented");
    52         /*Intermediaries*/
    53         int      domaintype;
    54         Element* basalelement;
    55 
    56         /*Get basal element*/
    57         element->FindParam(&domaintype,DomainTypeEnum);
    58         switch(domaintype){
    59                 case Domain2DhorizontalEnum:
    60                         basalelement = element;
    61                         break;
    62                 case Domain3DEnum:
    63                         if(!element->IsOnBase()) return NULL;
    64                         basalelement = element->SpawnBasalElement();
    65                         break;
    66                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    67         }
    68 
    6948        /*Intermediaries */
    7049        int         num_responses,i;
    71         IssmDouble  dH[2];
    72         IssmDouble  vx,vy,vel,Jdet;
    73         IssmDouble  thickness,thicknessobs,weight;
     50        IssmDouble  hobs,hu2,weight,NUMx,NUMy,DEN,Jdet;
     51        IssmDouble  vx,vy,vbar2,nux,nuy,dphi[2];
    7452        int        *responses = NULL;
    7553        IssmDouble *xyz_list  = NULL;
    7654
    7755        /*Fetch number of nodes and dof for this finite element*/
    78         int numnodes = basalelement->GetNumberOfNodes();
     56        int numnodes = element->GetNumberOfNodes();
    7957
    8058        /*Initialize Element vector and vectors*/
    81         ElementVector* pe     = basalelement->NewElementVector(SSAApproximationEnum);
     59        ElementVector* pe     = element->NewElementVector(SSAApproximationEnum);
    8260        IssmDouble*    basis  = xNew<IssmDouble>(numnodes);
    8361        IssmDouble*    dbasis = xNew<IssmDouble>(2*numnodes);
    8462
    8563        /*Retrieve all inputs and parameters*/
    86         basalelement->GetVerticesCoordinates(&xyz_list);
    87         basalelement->FindParam(&num_responses,InversionNumCostFunctionsEnum);
    88         basalelement->FindParam(&responses,NULL,InversionCostFunctionsEnum);
    89         Input* thickness_input    = basalelement->GetInput(ThicknessEnum);                          _assert_(thickness_input);
    90         Input* thicknessobs_input = basalelement->GetInput(InversionThicknessObsEnum);              _assert_(thicknessobs_input);
    91         Input* weights_input      = basalelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    92         Input* vx_input           = basalelement->GetInput(VxEnum);                                 _assert_(vx_input);
    93         Input* vy_input           = basalelement->GetInput(VyEnum);                                 _assert_(vy_input);
     64        element->GetVerticesCoordinates(&xyz_list);
     65        element->FindParam(&num_responses,InversionNumCostFunctionsEnum);
     66        element->FindParam(&responses,NULL,InversionCostFunctionsEnum);
     67        Input* thicknessobs_input = element->GetInput(InversionThicknessObsEnum);              _assert_(thicknessobs_input);
     68        Input* weights_input      = element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     69        Input* potential_input = element->GetInput(PotentialEnum);             _assert_(potential_input);
     70        Input* vx_input        = element->GetInput(BalancethicknessVxObsEnum); _assert_(vx_input);
     71        Input* vy_input        = element->GetInput(BalancethicknessVyObsEnum); _assert_(vy_input);
     72        Input* nux_input       = element->GetInput(BalancethicknessNuxEnum);   _assert_(nux_input);
     73        Input* nuy_input       = element->GetInput(BalancethicknessNuyEnum);   _assert_(nuy_input);
    9474
    9575        /* Start  looping on the number of gaussian points: */
    96         Gauss* gauss=basalelement->NewGauss(2);
     76        Gauss* gauss=element->NewGauss(2);
    9777        for(int ig=gauss->begin();ig<gauss->end();ig++){
    9878                gauss->GaussPoint(ig);
    9979
    100                 basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
    101                 basalelement->NodalFunctions(basis,gauss);
    102                 basalelement->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     80                element->JacobianDeterminant(&Jdet,xyz_list,gauss);
     81                element->NodalFunctions(basis,gauss);
     82                element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
    10383
    104                 thickness_input->GetInputValue(&thickness, gauss);
    105                 thickness_input->GetInputDerivativeValue(&dH[0],xyz_list,gauss);
    106                 thicknessobs_input->GetInputValue(&thicknessobs, gauss);
     84                vx_input->GetInputValue(&vx,gauss);
     85                vy_input->GetInputValue(&vy,gauss);
     86                nux_input->GetInputValue(&nux,gauss);
     87                nuy_input->GetInputValue(&nuy,gauss);
     88                potential_input->GetInputDerivativeValue(&dphi[0],xyz_list,gauss);
     89                thicknessobs_input->GetInputValue(&hobs,gauss);
    10790
     91                vbar2 = (nux*nux*vx*vx + nuy*nuy*vy*vy);
     92                hu2 = hobs*hobs*vbar2;
     93
     94                NUMx = 2.*dbasis[0]*dphi[0]*(dphi[0]*dphi[0] + dphi[1]*dphi[1] - hu2);
     95                NUMy = 2.*dbasis[1]*dphi[1]*(dphi[0]*dphi[0] + dphi[1]*dphi[1] - hu2);
     96                DEN = vbar2*vbar2;
     97
    10898                /*Loop over all requested responses*/
    10999                for(int resp=0;resp<num_responses;resp++){
    110100                        weights_input->GetInputValue(&weight,gauss,responses[resp]);
    111101
    112102                        switch(responses[resp]){
    113                                 case ThicknessAbsMisfitEnum:
    114                                         for(i=0;i<numnodes;i++) pe->values[i]+=(thicknessobs-thickness)*weight*Jdet*gauss->weight*basis[i];
     103                                case Balancethickness2MisfitEnum:
     104                                        for(i=0;i<numnodes;i++) pe->values[i]+=(NUMx+NUMy)/DEN *weight*Jdet*gauss->weight*basis[i];
    115105                                        break;
    116                                 case ThicknessAbsGradientEnum:
    117                                         for(i=0;i<numnodes;i++) pe->values[i]+= - weight*dH[0]*dbasis[0*numnodes+i]*Jdet*gauss->weight;
    118                                         for(i=0;i<numnodes;i++) pe->values[i]+= - weight*dH[1]*dbasis[1*numnodes+i]*Jdet*gauss->weight;
    119                                         break;
    120                                 case ThicknessAlongGradientEnum:
    121                                         vx_input->GetInputValue(&vx,gauss);
    122                                         vy_input->GetInputValue(&vy,gauss);
    123                                         vel = sqrt(vx*vx+vy*vy);
    124                                         vx  = vx/(vel+1.e-9);
    125                                         vy  = vy/(vel+1.e-9);
    126                                         for(i=0;i<numnodes;i++) pe->values[i]+= - weight*(dH[0]*vx+dH[1]*vy)*(dbasis[0*numnodes+i]*vx+dbasis[1*numnodes+i]*vy)*Jdet*gauss->weight;
    127                                         break;
    128                                 case ThicknessAcrossGradientEnum:
    129                                         vx_input->GetInputValue(&vx,gauss);
    130                                         vy_input->GetInputValue(&vy,gauss);
    131                                         vel = sqrt(vx*vx+vy*vy);
    132                                         vx  = vx/(vel+1.e-9);
    133                                         vy  = vy/(vel+1.e-9);
    134                                         for(i=0;i<numnodes;i++) pe->values[i]+= - weight*(dH[0]*(-vy)+dH[1]*vx)*(dbasis[0*numnodes+i]*(-vy)+dbasis[1*numnodes+i]*vx)*Jdet*gauss->weight;
    135                                         break;
    136106                                default:
    137107                                        _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
    138108                        }
    … …  
    144114        xDelete<IssmDouble>(xyz_list);
    145115        xDelete<IssmDouble>(basis);
    146116        xDelete<IssmDouble>(dbasis);
    147         if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    148117        delete gauss;
    149118        return pe;
    150119}/*}}}*/

  • ../trunk-jpl/src/c/analyses/Balancethickness2Analysis.cpp

     
    182182                element->JacobianDeterminantSurface(&Jdet,xyz_list_front,gauss);
    183183                element->NodalFunctions(basis,gauss);
    184184
    185                 for(int i=0;i<numnodes;i++) pe->values[i] += - Jdet*gauss->weight*thickness*(vx*normal[0] + vy*normal[1])*basis[i];
     185                for(int i=0;i<numnodes;i++) pe->values[i] += Jdet*gauss->weight*thickness*(vx*normal[0] + vy*normal[1])*basis[i];
    186186        }
    187187
    188188        /*Clean up and return*/

  • ../trunk-jpl/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp

     
    1111void    UpdateElementsAndMaterialsControl(Elements* elements,Materials* materials, IoModel* iomodel){
    1212
    1313        /*Intermediary*/
    14         int       i;
    15         int       counter;
     14        int       control;
    1615        Element  *element = NULL;
    1716        Material *material = NULL;
    1817        int       num_control_type;
    … …  
    3231
    3332        iomodel->FetchData(5,InversionControlParametersEnum,InversionCostFunctionsEnum,InversionCostFunctionsCoefficientsEnum,InversionMinParametersEnum,InversionMaxParametersEnum);
    3433
    35         for(i=0;i<num_control_type;i++){
    36                 int control = reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i]);
     34        for(int i=0;i<num_control_type;i++){
     35                control = reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i]);
    3736                switch(control){
    3837                        /*List of supported controls*/
    3938                        case BalancethicknessThickeningRateEnum:
    … …  
    4342                        case FrictionCoefficientEnum:
    4443                        case BalancethicknessNuxEnum:
    4544                        case BalancethicknessNuyEnum:
     45                        case BalancethicknessApparentMassbalanceEnum:
    4646                                iomodel->FetchData(1,control);
    4747                                break;
    4848
    … …  
    5555        }
    5656
    5757        /*Update elements: */
    58         counter=0;
    59         for (i=0;i<iomodel->numberofelements;i++){
     58        int counter=0;
     59        for(int i=0;i<iomodel->numberofelements;i++){
    6060                if(iomodel->my_elements[i]){
    6161                        element=(Element*)elements->GetObjectByOffset(counter);
    6262                        element->InputUpdateFromIoModel(i,iomodel); //we need i to index into elements.
    … …  
    6565        }
    6666
    6767        /*Free data: */
    68         iomodel->DeleteData(5+7,InversionControlParametersEnum,InversionCostFunctionsCoefficientsEnum,InversionCostFunctionsEnum,InversionMinParametersEnum,InversionMaxParametersEnum,BalancethicknessThickeningRateEnum,VxEnum,VyEnum,ThicknessEnum,FrictionCoefficientEnum,MaterialsRheologyBEnum,DamageDEnum);
     68        for(int i=0;i<num_control_type;i++){
     69                control = reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i]);
     70                switch(control){
     71                        case MaterialsRheologyBbarEnum: iomodel->DeleteData(1,MaterialsRheologyBEnum); break;
     72                        case DamageDbarEnum:            iomodel->DeleteData(1,DamageDEnum);            break;
     73                        default:                        iomodel->DeleteData(1,control);
     74                }
     75        }
     76        iomodel->DeleteData(5,InversionControlParametersEnum,InversionCostFunctionsCoefficientsEnum,InversionCostFunctionsEnum,InversionMinParametersEnum,InversionMaxParametersEnum);
     77
     78
    6979}

  • ../trunk-jpl/src/c/cores/control_core.cpp

     
    144144        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    145145
    146146        /*set analysis type to compute velocity: */
    147         if (solution_type==SteadystateSolutionEnum || solution_type==StressbalanceSolutionEnum){
    148                 femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
     147        switch(solution_type){
     148                case SteadystateSolutionEnum:
     149                case StressbalanceSolutionEnum:
     150                        femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
     151                        break;
     152                case BalancethicknessSolutionEnum:
     153                        femmodel->SetCurrentConfiguration(BalancethicknessAnalysisEnum);
     154                        break;
     155                case BalancethicknessSoftSolutionEnum:
     156                        femmodel->SetCurrentConfiguration(BalancethicknessAnalysisEnum);
     157                        break;
     158                case Balancethickness2SolutionEnum:
     159                        femmodel->SetCurrentConfiguration(Balancethickness2AnalysisEnum);
     160                        break;
     161                default:
     162                        _error_("Solution " << EnumToStringx(solution_type) << " not implemented yet");
    149163        }
    150         else if (solution_type==BalancethicknessSolutionEnum){
    151                 femmodel->SetCurrentConfiguration(BalancethicknessAnalysisEnum);
    152         }
    153         else if (solution_type==BalancethicknessSoftSolutionEnum){
    154                 femmodel->SetCurrentConfiguration(BalancethicknessAnalysisEnum);
    155         }
    156         else{
    157                 _error_("Solution " << EnumToStringx(solution_type) << " not implemented yet");
    158         }
    159164
    160165        /*update parameter according to scalar: */ //false means: do not save control
    161166        InputControlUpdatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,search_scalar,false);
    … …  
    170175        else if (solution_type==BalancethicknessSolutionEnum){
    171176                solutionsequence_linear(femmodel);
    172177        }
     178        else if (solution_type==Balancethickness2SolutionEnum){
     179                solutionsequence_linear(femmodel);
     180        }
    173181        else if (solution_type==BalancethicknessSoftSolutionEnum){
    174182                /*Don't do anything*/
    175183        }

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

     
    435435                case IceVolumeEnum:                this->IceVolumex(responses); break;
    436436                case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(responses); break;
    437437                case MinVelEnum:                   this->MinVelx(responses); break;
    438                 case MaxVelEnum:                   this->MaxVelx(                  responses); break;
     438                case MaxVelEnum:                   this->MaxVelx(responses); break;
    439439                case MinVxEnum:                    this->MinVxx(responses); break;
    440                 case MaxVxEnum:                    this->MaxVxx(                   responses); break;
    441                 case MaxAbsVxEnum:                 this->MaxAbsVxx(                responses); break;
     440                case MaxVxEnum:                    this->MaxVxx(responses); break;
     441                case MaxAbsVxEnum:                 this->MaxAbsVxx(responses); break;
    442442                case MinVyEnum:                    this->MinVyx(responses); break;
    443                 case MaxVyEnum:                    this->MaxVyx(                   responses); break;
    444                 case MaxAbsVyEnum:                 this->MaxAbsVyx(                responses); break;
     443                case MaxVyEnum:                    this->MaxVyx(responses); break;
     444                case MaxAbsVyEnum:                 this->MaxAbsVyx(responses); break;
    445445                case MinVzEnum:                    this->MinVzx(responses); break;
    446                 case MaxVzEnum:                    this->MaxVzx(                   responses); break;
    447                 case MaxAbsVzEnum:                 this->MaxAbsVzx(                responses); break;
    448                 case MassFluxEnum:                 this->MassFluxx(         responses); break;
     446                case MaxVzEnum:                    this->MaxVzx(responses); break;
     447                case MaxAbsVzEnum:                 this->MaxAbsVzx(responses); break;
     448                case MassFluxEnum:                 this->MassFluxx(responses); break;
    449449                case SurfaceAbsVelMisfitEnum:      SurfaceAbsVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
    450450                case SurfaceRelVelMisfitEnum:      SurfaceRelVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
    451451                case SurfaceLogVelMisfitEnum:      SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
    … …  
    458458                case RheologyBbarAbsGradientEnum:  RheologyBbarAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
    459459                case DragCoefficientAbsGradientEnum:DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
    460460                case BalancethicknessMisfitEnum:   BalancethicknessMisfitx(responses); break;
     461                case Balancethickness2MisfitEnum:  Balancethickness2Misfitx(responses); break;
    461462                case TotalSmbEnum:                                        this->TotalSmbx(responses); break;
    462463                case MaterialsRheologyBbarEnum:    this->ElementResponsex(responses,MaterialsRheologyBbarEnum); break;
    463464                case VelEnum:                      this->ElementResponsex(responses,VelEnum); break;
    … …  
    11991200        *presponse=J;
    12001201
    12011202}/*}}}*/
     1203void FemModel::Balancethickness2Misfitx(IssmDouble* presponse){/*{{{*/
     1204
     1205        /*output: */
     1206        IssmDouble J=0.;
     1207        IssmDouble J_sum;
     1208
     1209        IssmDouble  weight,thicknessobs,thickness;
     1210        IssmDouble  Jdet;
     1211        IssmDouble* xyz_list = NULL;
     1212
     1213        /*Compute Misfit: */
     1214        for(int i=0;i<elements->Size();i++){
     1215                Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1216
     1217                /*If on water, return 0: */
     1218                if(!element->IsIceInElement()) continue;
     1219
     1220                /* Get node coordinates*/
     1221                element->GetVerticesCoordinates(&xyz_list);
     1222                Input* weights_input     =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     1223                Input* thickness_input   =element->GetInput(ThicknessEnum);                          _assert_(thickness_input);
     1224                Input* thicknessobs_input=element->GetInput(InversionThicknessObsEnum);              _assert_(thicknessobs_input);
     1225
     1226                /* Start  looping on the number of gaussian points: */
     1227                Gauss* gauss=element->NewGauss(2);
     1228                for(int ig=gauss->begin();ig<gauss->end();ig++){
     1229
     1230                        gauss->GaussPoint(ig);
     1231
     1232                        /* Get Jacobian determinant: */
     1233                        element->JacobianDeterminant(&Jdet,xyz_list,gauss);
     1234
     1235                        /*Get all parameters at gaussian point*/
     1236                        weights_input->GetInputValue(&weight,gauss,Balancethickness2MisfitEnum);
     1237                        thickness_input->GetInputValue(&thickness,gauss);
     1238                        thicknessobs_input->GetInputValue(&thicknessobs,gauss);
     1239                        gauss->GaussPoint(ig);
     1240
     1241                        J +=0.5*(thickness*thickness - thicknessobs*thicknessobs)*weight*Jdet*gauss->weight;
     1242                }
     1243
     1244                /*clean up and Return: */
     1245                xDelete<IssmDouble>(xyz_list);
     1246                delete gauss;
     1247        }
     1248
     1249        /*Sum all J from all cpus of the cluster:*/
     1250        ISSM_MPI_Reduce (&J,&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
     1251        ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
     1252        J=J_sum;
     1253
     1254        /*Assign output pointers: */
     1255        *presponse=J;
     1256
     1257}/*}}}*/
    12021258void FemModel::ThicknessAbsGradientx( IssmDouble* pJ){/*{{{*/
    12031259
    12041260        /*output: */

  • ../trunk-jpl/src/c/classes/Elements/Tria.cpp

     
    990990                        switch(control){
    991991                                /*yts conversion*/
    992992                                case BalancethicknessThickeningRateEnum:
     993                                case BalancethicknessApparentMassbalanceEnum:
    993994                                case VxEnum:
    994995                                case VyEnum:
    995996                                        if(iomodel->Data(control)){
    … …  
    28022803                case ThicknessEnum:
    28032804                        GradjThicknessBalancethicknessSoft(gradient,control_index);
    28042805                        break;
     2806                case BalancethicknessApparentMassbalanceEnum:
     2807                        GradjAdotBulancethickness2(gradient,control_index);
     2808                        break;
    28052809                default:
    2806                         _error_("control type not supported yet: " << control_type);
     2810                        _error_("control type not supported yet: " << EnumToStringx(control_type));
    28072811        }
    28082812
    28092813        /*Now deal with ∂J/∂alpha*/
    … …  
    28202824                case ThicknessAlongGradientEnum:
    28212825                case ThicknessAcrossGradientEnum:
    28222826                case BalancethicknessMisfitEnum:
     2827                case Balancethickness2MisfitEnum:
    28232828                case SurfaceAbsVelMisfitEnum:
    28242829                case SurfaceRelVelMisfitEnum:
    28252830                case SurfaceLogVelMisfitEnum:
    … …  
    31673172        gradient->SetValues(NUMVERTICES,vertexpidlist,gradient_g,INS_VAL);
    31683173}
    31693174/*}}}*/
     3175void       Tria::GradjAdotBulancethickness2(Vector<IssmDouble>* gradient,int control_index){/*{{{*/
     3176
     3177        /*Intermediaries*/
     3178        int    vertexpidlist[NUMVERTICES];
     3179        IssmDouble lambda[NUMVERTICES];
     3180        IssmDouble gradient_g[NUMVERTICES];
     3181
     3182        /*Compute Gradient*/
     3183        GradientIndexing(&vertexpidlist[0],control_index);
     3184        GetInputListOnVertices(&lambda[0],AdjointEnum);
     3185        for(int i=0;i<NUMVERTICES;i++) gradient_g[i]=lambda[i];
     3186
     3187        gradient->SetValues(NUMVERTICES,vertexpidlist,gradient_g,INS_VAL);
     3188}
     3189/*}}}*/
    31703190void       Tria::GradjVxBalancedthickness(Vector<IssmDouble>* gradient,int control_index){/*{{{*/
    31713191
    31723192        /*Intermediaries*/

  • ../trunk-jpl/src/c/classes/Elements/Tria.h

     
    148148                void       GradjVxBalancedthickness(Vector<IssmDouble>* gradient,int control_index);
    149149                void       GradjVyBalancedthickness(Vector<IssmDouble>* gradient,int control_index);
    150150                void       GradjThicknessBalancethicknessSoft(Vector<IssmDouble>* gradient,int control_index);
     151                void       GradjAdotBulancethickness2(Vector<IssmDouble>* gradient,int control_index);
    151152                void       GetVectorFromControlInputs(Vector<IssmDouble>* gradient,int control_enum,int control_index,const char* data);
    152153                void       SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index);
    153154                void       ControlInputGetGradient(Vector<IssmDouble>* gradient,int enum_type,int control_index);

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

     
    7676                void IceVolumeAboveFloatationx(IssmDouble* pV);
    7777                void ElementResponsex(IssmDouble* presponse,int response_enum);
    7878                void BalancethicknessMisfitx(IssmDouble* pV);
     79                void Balancethickness2Misfitx(IssmDouble* pV);
    7980                #ifdef  _HAVE_DAKOTA_
    8081                void DakotaResponsesx(double* d_responses,char** responses_descriptors,int numresponsedescriptors,int d_numresponses);
    8182                #endif
Note: See TracBrowser for help on using the repository browser.