Changeset 15731


Ignore:
Timestamp:
08/06/13 16:02:26 (12 years ago)
Author:
Mathieu Morlighem
Message:

CHG: extended multiple number of nodes to other solutions

Location:
issm/trunk-jpl/src/c/classes/Elements
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r15728 r15731  
    270270        /*Fetch number of nodes and dof for this finite element*/
    271271        int numnodes = this->NumberofNodes();
    272         int numdof   = numnodes*NDOF1;
    273272
    274273        /*Initialize Element matrix and vectors*/
    … …  
    289288                D=gauss->weight*Jdet;
    290289
    291                 TripleMultiply(basis,1,numdof,1,
     290                TripleMultiply(basis,1,numnodes,1,
    292291                                        &D,1,1,0,
    293                                         basis,1,numdof,0,
     292                                        basis,1,numnodes,0,
    294293                                        &Ke->values[0],1);
    295294        }
    … …  
    15831582                        break;
    15841583                case AdjointBalancethicknessAnalysisEnum:
    1585                         InputUpdateFromSolutionAdjointBalancethickness(solution);
     1584                        InputUpdateFromSolutionOneDof(solution,AdjointEnum);
    15861585                        break;
    15871586                #endif
    … …  
    16251624void  Tria::InputUpdateFromSolutionOneDof(IssmDouble* solution,int enum_type){
    16261625
    1627         const int  numdof         = NDOF1*NUMVERTICES;
    1628         int*       doflist        = NULL;
    1629         IssmDouble values[numdof];
    1630 
    1631         /*Get dof list: */
     1626        /*Intermediary*/
     1627        int* doflist = NULL;
     1628
     1629        /*Fetch number of nodes for this finite element*/
     1630        int numnodes = this->NumberofNodes();
     1631
     1632        /*Fetch dof list and allocate solution vector*/
    16321633        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     1634        IssmDouble* values    = xNew<IssmDouble>(numnodes);
    16331635
    16341636        /*Use the dof list to index into the solution vector: */
    1635         for(int i=0;i<numdof;i++){
     1637        for(int i=0;i<numnodes;i++){
    16361638                values[i]=solution[doflist[i]];
    16371639                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
    … …  
    16421644
    16431645        /*Free ressources:*/
     1646        xDelete<IssmDouble>(values);
    16441647        xDelete<int>(doflist);
    16451648}
    … …  
    16491652
    16501653        /*Intermediaries*/
    1651         const int numdof = NDOF1*NUMVERTICES;
    1652 
    1653         int       i,hydroadjustment;
    1654         int*      doflist=NULL;
    1655         IssmDouble    rho_ice,rho_water,minthickness;
    1656         IssmDouble    newthickness[numdof];
    1657         IssmDouble    newbed[numdof];
    1658         IssmDouble    newsurface[numdof];
    1659         IssmDouble    oldbed[NUMVERTICES];
    1660         IssmDouble    oldsurface[NUMVERTICES];
    1661         IssmDouble    oldthickness[NUMVERTICES];
    1662 
    1663         /*Get dof list: */
     1654        int        i,hydroadjustment;
     1655        int*       doflist=NULL;
     1656        IssmDouble rho_ice,rho_water,minthickness;
     1657
     1658        /*Fetch number of nodes for this finite element*/
     1659        int numnodes = this->NumberofNodes();
     1660
     1661        /*Fetch dof list and allocate solution vector*/
    16641662        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     1663        IssmDouble* newthickness = xNew<IssmDouble>(numnodes);
     1664        IssmDouble* newbed       = xNew<IssmDouble>(numnodes);
     1665        IssmDouble* newsurface   = xNew<IssmDouble>(numnodes);
     1666        IssmDouble* oldthickness = xNew<IssmDouble>(numnodes);
     1667        IssmDouble* oldbed       = xNew<IssmDouble>(numnodes);
     1668        IssmDouble* oldsurface   = xNew<IssmDouble>(numnodes);
    16651669
    16661670        /*Use the dof list to index into the solution vector: */
    16671671        this->parameters->FindParam(&minthickness,PrognosticMinThicknessEnum);
    1668         for(i=0;i<numdof;i++){
     1672        for(i=0;i<numnodes;i++){
    16691673                newthickness[i]=solution[doflist[i]];
    16701674                if(xIsNan<IssmDouble>(newthickness[i])) _error_("NaN found in solution vector");
    … …  
    16741678
    16751679        /*Get previous bed, thickness and surface*/
    1676         GetInputListOnVertices(&oldbed[0],BedEnum);
    1677         GetInputListOnVertices(&oldsurface[0],SurfaceEnum);
    1678         GetInputListOnVertices(&oldthickness[0],ThicknessEnum);
     1680        GetInputListOnNodes(&oldbed[0],BedEnum);
     1681        GetInputListOnNodes(&oldsurface[0],SurfaceEnum);
     1682        GetInputListOnNodes(&oldthickness[0],ThicknessEnum);
    16791683
    16801684        /*Fing PrognosticHydrostaticAdjustment to figure out how to update the geometry:*/
    … …  
    16831687        rho_water=matpar->GetRhoWater();
    16841688
    1685         for(i=0;i<numdof;i++) {
     1689        for(i=0;i<numnodes;i++) {
    16861690                /*If shelf: hydrostatic equilibrium*/
    16871691                if (this->nodes[i]->IsGrounded()){
    1688                         newsurface[i]=oldbed[i]+newthickness[i]; //surface = oldbed + newthickness
    1689                         newbed[i]=oldbed[i];               //same bed: do nothing
     1692                        newsurface[i] = oldbed[i]+newthickness[i]; //surface = oldbed + newthickness
     1693                        newbed[i]     = oldbed[i];                 //same bed: do nothing
    16901694                }
    16911695                else{ //this is an ice shelf
    1692 
    16931696                        if(hydroadjustment==AbsoluteEnum){
    1694                                 newsurface[i]=newthickness[i]*(1-rho_ice/rho_water);
    1695                                 newbed[i]=newthickness[i]*(-rho_ice/rho_water);
     1697                                newsurface[i] = newthickness[i]*(1-rho_ice/rho_water);
     1698                                newbed[i]     = newthickness[i]*(-rho_ice/rho_water);
    16961699                        }
    16971700                        else if(hydroadjustment==IncrementalEnum){
    1698                                 newsurface[i]=oldsurface[i]+(1.0-rho_ice/rho_water)*(newthickness[i]-oldthickness[i]); //surface = oldsurface + (1-di) * dH
    1699                                 newbed[i]=oldbed[i]-rho_ice/rho_water*(newthickness[i]-oldthickness[i]); //bed = oldbed + di * dH
     1701                                newsurface[i] = oldsurface[i]+(1.0-rho_ice/rho_water)*(newthickness[i]-oldthickness[i]); //surface = oldsurface + (1-di) * dH
     1702                                newbed[i]     = oldbed[i]-rho_ice/rho_water*(newthickness[i]-oldthickness[i]); //bed              = oldbed + di * dH
    17001703                        }
    17011704                        else _error_("Hydrostatic adjustment " << hydroadjustment << " (" << EnumToStringx(hydroadjustment) << ") not supported yet");
    … …  
    17091712
    17101713        /*Free ressources:*/
     1714        xDelete<IssmDouble>(newthickness);
     1715        xDelete<IssmDouble>(newbed);
     1716        xDelete<IssmDouble>(newsurface);
     1717        xDelete<IssmDouble>(oldthickness);
     1718        xDelete<IssmDouble>(oldbed);
     1719        xDelete<IssmDouble>(oldsurface);
    17111720        xDelete<int>(doflist);
    17121721}
    … …  
    17151724void  Tria::InputUpdateFromVector(IssmDouble* vector, int name, int type){
    17161725
    1717         const int   numdof         = NDOF1 *NUMVERTICES;
    1718         int        *doflist        = NULL;
    1719         IssmDouble  values[numdof];
     1726        const int   numnodes = NUMVERTICES;
     1727        int        *doflist  = NULL;
     1728        IssmDouble  values[numnodes];
    17201729
    17211730        /*Check that name is an element input*/
    … …  
    17501759
    17511760        case NodesEnum:
     1761                _assert_(this->element_type==P1Enum);
    17521762                /*Get dof list: */
    17531763                GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    17541764
    17551765                /*Use the dof list to index into the vector: */
    1756                 for(int i=0;i<numdof;i++){
     1766                for(int i=0;i<numnodes;i++){
    17571767                        values[i]=vector[doflist[i]];
    17581768                        if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
    … …  
    17661776
    17671777        case NodeSIdEnum:
     1778                _assert_(this->element_type==P1Enum);
    17681779                for(int i=0;i<NUMVERTICES;i++){
    17691780                        values[i]=vector[nodes[i]->Sid()];
    … …  
    17721783                /*Add input to the element: */
    17731784                this->inputs->AddInput(new TriaInput(name,values,P1Enum));
    1774 
    1775                 /*Free ressources:*/
    1776                 xDelete<int>(doflist);
    17771785                return;
    17781786
    … …  
    25672575IssmDouble Tria::MassFlux( IssmDouble* segment){
    25682576
    2569         const int  numdofs=2;
    25702577        int        dim;
    2571         IssmDouble mass_flux=0;
     2578        IssmDouble mass_flux=0.;
    25722579        IssmDouble xyz_list[NUMVERTICES][3];
    25732580        IssmDouble normal[2];
    … …  
    50195026        /*Fetch number of nodes and dof for this finite element*/
    50205027        int numnodes = this->NumberofNodes();
    5021         int numdof   = numnodes*NDOF2;
    50225028
    50235029        /*Initialize Element vector*/
    … …  
    52555261ElementMatrix* Tria::CreateKMatrixAdjointSSA(void){
    52565262
    5257         /*Constants*/
    5258         const int numnodes = this->NumberofNodes();
    5259         const int numdof   = NDOF2*numnodes;
    5260 
    52615263        /*Intermediaries */
    52625264        int         i,j;
    … …  
    52715273        GaussTria  *gauss=NULL;
    52725274
     5275        /*Fetch number of nodes and dof for this finite element*/
     5276        int numnodes = this->NumberofNodes();
     5277
    52735278        /*Initialize Jacobian with regular SSA (first part of the Gateau derivative)*/
    52745279        parameters->FindParam(&incomplete_adjoint,InversionIncompleteAdjointEnum);
    … …  
    53285333void  Tria::InputUpdateFromSolutionAdjointHoriz(IssmDouble* solution){
    53295334
    5330         const int numdof=NDOF2*NUMVERTICES;
    5331 
    5332         int       i;
    5333         int*      doflist=NULL;
    5334         IssmDouble    values[numdof];
    5335         IssmDouble    lambdax[NUMVERTICES];
    5336         IssmDouble    lambday[NUMVERTICES];
    5337 
    5338         /*Get dof list: */
     5335        int  i;
     5336        int* doflist=NULL;
     5337
     5338        /*Fetch number of nodes and dof for this finite element*/
     5339        int numnodes = this->NumberofNodes();
     5340        int numdof   = numnodes*NDOF2;
     5341
     5342        /*Fetch dof list and allocate solution vectors*/
    53395343        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     5344        IssmDouble* values  = xNew<IssmDouble>(numdof);
     5345        IssmDouble* lambdax = xNew<IssmDouble>(numnodes);
     5346        IssmDouble* lambday = xNew<IssmDouble>(numnodes);
    53405347
    53415348        /*Use the dof list to index into the solution vector: */
    53425349        for(i=0;i<numdof;i++) values[i]=solution[doflist[i]];
    53435350
     5351        /*Transform solution in Cartesian Space*/
     5352        TransformSolutionCoord(&values[0],nodes,numnodes,XYEnum);
     5353
    53445354        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    5345         for(i=0;i<NUMVERTICES;i++){
     5355        for(i=0;i<numdof;i++){
    53465356                lambdax[i]=values[i*NDOF2+0];
    53475357                lambday[i]=values[i*NDOF2+1];
    … …  
    53575367
    53585368        /*Free ressources:*/
    5359         xDelete<int>(doflist);
    5360 }
    5361 /*}}}*/
    5362 /*FUNCTION Tria::InputUpdateFromSolutionAdjointBalancethickness {{{*/
    5363 void  Tria::InputUpdateFromSolutionAdjointBalancethickness(IssmDouble* solution){
    5364 
    5365         const int numdof=NDOF1*NUMVERTICES;
    5366 
    5367         int       i;
    5368         int*      doflist=NULL;
    5369         IssmDouble    values[numdof];
    5370         IssmDouble    lambda[NUMVERTICES];
    5371 
    5372         /*Get dof list: */
    5373         GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    5374 
    5375         /*Use the dof list to index into the solution vector: */
    5376         for(i=0;i<numdof;i++) values[i]=solution[doflist[i]];
    5377 
    5378         /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    5379         for(i=0;i<numdof;i++){
    5380                 lambda[i]=values[i];
    5381                 if(xIsNan<IssmDouble>(lambda[i])) _error_("NaN found in solution vector");
    5382         }
    5383 
    5384         /*Add vx and vy as inputs to the tria element: */
    5385         this->inputs->AddInput(new TriaInput(AdjointEnum,lambda,P1Enum));
    5386 
    5387         /*Free ressources:*/
     5369        xDelete<IssmDouble>(values);
     5370        xDelete<IssmDouble>(lambdax);
     5371        xDelete<IssmDouble>(lambday);
    53885372        xDelete<int>(doflist);
    53895373}
    … …  
    54645448        /*Fetch number of nodes and dof for this finite element*/
    54655449        int numnodes = this->NumberofNodes();
    5466         int numdof   = numnodes*NDOF1;
    54675450
    54685451        /*Initialize Element vector and vectors*/
    54695452        ElementMatrix* Ke=new ElementMatrix(nodes,numnodes,this->parameters,NoneApproximationEnum);
    54705453        IssmDouble*    basis = xNew<IssmDouble>(numnodes);
    5471 
    5472         /*Initialize Element matrix*/
    54735454
    54745455        /*Retrieve all inputs and parameters*/
    … …  
    54885469                D_scalar=latentheat/heatcapacity*gauss->weight*Jdet;
    54895470
    5490                 TripleMultiply(basis,numdof,1,0,
     5471                TripleMultiply(basis,numnodes,1,0,
    54915472                                        &D_scalar,1,1,0,
    5492                                         basis,1,numdof,0,
     5473                                        basis,1,numnodes,0,
    54935474                                        &Ke->values[0],1);
    54945475        }
    … …  
    56915672        /*Fetch number of nodes and dof for this finite element*/
    56925673        int numnodes = this->NumberofNodes();
    5693         int numdof   = numnodes*NDOF1;
    56945674
    56955675        /*Initialize Element matrix and vectors*/
    56965676        ElementMatrix* Ke     = new ElementMatrix(nodes,numnodes,this->parameters);
    5697         IssmDouble*    B      = xNew<IssmDouble>(5*numdof);
     5677        IssmDouble*    B      = xNew<IssmDouble>(5*numnodes);
    56985678        IssmDouble*    basis  = xNew<IssmDouble>(numnodes);
    56995679        IssmDouble     D[2][2];
    … …  
    57195699                D[1][0]=0.;       D[1][1]=D_scalar;
    57205700                GetBHydro(B,&xyz_list[0][0],gauss);
    5721                 TripleMultiply(B,2,numdof,1,
     5701                TripleMultiply(B,2,numnodes,1,
    57225702                                        &D[0][0],2,2,0,
    5723                                         B,2,numdof,0,
     5703                                        B,2,numnodes,0,
    57245704                                        &Ke->values[0],1);
    57255705
    … …  
    57295709                        D_scalar=sediment_storing*gauss->weight*Jdet;
    57305710
    5731                         TripleMultiply(basis,numdof,1,0,
     5711                        TripleMultiply(basis,numnodes,1,0,
    57325712                                                &D_scalar,1,1,0,
    5733                                                 basis,1,numdof,0,
     5713                                                basis,1,numnodes,0,
    57345714                                                &Ke->values[0],1);
    57355715                }
    … …  
    57585738        /*Fetch number of nodes and dof for this finite element*/
    57595739        int numnodes = this->NumberofNodes();
    5760         int numdof   = numnodes*NDOF1;
    57615740
    57625741        /*Initialize Element matrix and vectors*/
    57635742        ElementMatrix* Ke     = new ElementMatrix(nodes,numnodes,this->parameters);
    5764         IssmDouble*    B      = xNew<IssmDouble>(5*numdof);
     5743        IssmDouble*    B      = xNew<IssmDouble>(5*numnodes);
    57655744        IssmDouble*    basis  = xNew<IssmDouble>(numnodes);
    57665745        IssmDouble     D[2][2];
    … …  
    57855764                D[1][0]=0.;       D[1][1]=D_scalar;
    57865765                GetBHydro(B,&xyz_list[0][0],gauss);
    5787                 TripleMultiply(B,2,numdof,1,
     5766                TripleMultiply(B,2,numnodes,1,
    57885767                                        &D[0][0],2,2,0,
    5789                                         B,2,numdof,0,
     5768                                        B,2,numnodes,0,
    57905769                                        &Ke->values[0],1);
    57915770
    … …  
    57955774                        D_scalar=epl_storing*gauss->weight*Jdet;
    57965775
    5797                         TripleMultiply(basis,numdof,1,0,
     5776                        TripleMultiply(basis,numnodes,1,0,
    57985777                                                &D_scalar,1,1,0,
    5799                                                 basis,1,numdof,0,
     5778                                                basis,1,numnodes,0,
    58005779                                                &Ke->values[0],1);
    58015780                }
    … …  
    58245803        /*Fetch number of nodes and dof for this finite element*/
    58255804        int numnodes = this->NumberofNodes();
    5826         int numdof   = numnodes*NDOF1;
    58275805
    58285806        /*Initialize Element vector*/
    … …  
    58505828
    58515829                if(reCast<int,IssmDouble>(dt)){
    5852                         for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*(old_watercolumn_g+dt*basal_melting_g)*basis[i];
     5830                        for(i=0;i<numnodes;i++) pe->values[i]+=Jdettria*gauss->weight*(old_watercolumn_g+dt*basal_melting_g)*basis[i];
    58535831                }
    58545832                else{
    5855                         for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*basal_melting_g*basis[i];
     5833                        for(i=0;i<numnodes;i++) pe->values[i]+=Jdettria*gauss->weight*basal_melting_g*basis[i];
    58565834                }
    58575835        }
    … …  
    59995977void  Tria::GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution, int enum_type){
    60005978
    6001         const int    numdof=NDOF1*NUMVERTICES;
    6002 
    6003         int         i;
    60045979        int        *doflist = NULL;
    6005         IssmDouble  enum_value;
    6006         IssmDouble  values[numdof];
    6007         GaussTria  *gauss   = NULL;
    6008 
    6009         /*Get dof list: */
     5980        IssmDouble  value;
     5981
     5982        /*Fetch number of nodes for this finite element*/
     5983        int numnodes = this->NumberofNodes();
     5984
     5985        /*Fetch dof list and allocate solution vector*/
    60105986        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     5987        IssmDouble* values = xNew<IssmDouble>(numnodes);
    60115988
    60125989        /*Get inputs*/
    … …  
    60145991
    60155992        /*Ok, we have the values, fill in the array: */
    6016         /*P1 element only for now*/
    6017         gauss=new GaussTria();
    6018         for(i=0;i<NUMVERTICES;i++){
    6019 
    6020                 gauss->GaussVertex(i);
    6021 
    6022                 /*Recover dof values*/
    6023                 enum_input->GetInputValue(&enum_value,gauss);
    6024                 values[i]=enum_value;
    6025         }
    6026 
    6027         solution->SetValues(numdof,doflist,values,INS_VAL);
     5993        GaussTria* gauss=new GaussTria();
     5994        for(int i=0;i<numnodes;i++){
     5995                gauss->GaussNode(this->element_type,i);
     5996
     5997                enum_input->GetInputValue(&value,gauss);
     5998                values[i]=value;
     5999        }
     6000
     6001        solution->SetValues(numnodes,doflist,values,INS_VAL);
    60286002
    60296003        /*Free ressources:*/
     6004        xDelete<int>(doflist);
     6005        xDelete<IssmDouble>(values);
    60306006        delete gauss;
    6031         xDelete<int>(doflist);
    60326007}
    60336008/*}}}*/
    … …  
    60356010void  Tria::InputUpdateFromSolutionHydrologyShreve(IssmDouble* solution){
    60366011
    6037         /*Intermediaries*/
    6038         const int   numdof         = NDOF1 *NUMVERTICES;
    6039         int        *doflist        = NULL;
    6040         IssmDouble  values[numdof];
    6041 
    6042         /*Get dof list: */
     6012        /*Intermediary*/
     6013        int* doflist = NULL;
     6014
     6015        /*Fetch number of nodes for this finite element*/
     6016        int numnodes = this->NumberofNodes();
     6017
     6018        /*Fetch dof list and allocate solution vector*/
    60436019        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     6020        IssmDouble* values    = xNew<IssmDouble>(numnodes);
    60446021
    60456022        /*Use the dof list to index into the solution vector: */
    6046         for(int i=0;i<numdof;i++){
     6023        for(int i=0;i<numnodes;i++){
    60476024                values[i]=solution[doflist[i]];
    60486025                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
    … …  
    60546031
    60556032        /*Free ressources:*/
     6033        xDelete<IssmDouble>(values);
    60566034        xDelete<int>(doflist);
    60576035}
    … …  
    60616039
    60626040        /*Intermediaries*/
    6063         const int   numdof   = NDOF1 *NUMVERTICES;
    60646041        int        *doflist  = NULL;
    60656042        bool        converged;
    6066         IssmDouble  values[numdof];
    6067         IssmDouble  residual[numdof];
    60686043        IssmDouble  penalty_factor, dt;
    60696044        IssmDouble  kmax, kappa, h_max;
    60706045
    6071         /*Get dof list: */
     6046        /*Fetch number of nodes for this finite element*/
     6047        int numnodes = this->NumberofNodes();
     6048
     6049        /*Fetch dof list and allocate solution vector*/
    60726050        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     6051        IssmDouble* values   = xNew<IssmDouble>(numnodes);
     6052        IssmDouble* residual = xNew<IssmDouble>(numnodes);
    60736053
    60746054        /*Use the dof list to index into the solution vector: */
    6075         for(int i=0;i<numdof;i++){
     6055        for(int i=0;i<numnodes;i++){
    60766056                values[i]=solution[doflist[i]];
    60776057                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
    … …  
    60886068                kappa=kmax*pow(10.,penalty_factor);
    60896069
    6090                 for(int i=0;i<NUMVERTICES;i++){
     6070                for(int i=0;i<numnodes;i++){
    60916071                        this->GetHydrologyDCInefficientHmax(&h_max,nodes[i]);
    60926072                        if(values[i]>h_max){
    … …  
    61046084
    61056085        /*Free ressources:*/
     6086        xDelete<IssmDouble>(values);
     6087        xDelete<IssmDouble>(residual);
    61066088        xDelete<int>(doflist);
    61076089}
    … …  
    61456127void  Tria::GetHydrologyTransfer(Vector<IssmDouble>* transfer){
    61466128
    6147         const int  numdof         = NDOF1 *NUMVERTICES;
    6148         int        *doflist       = NULL;
     6129        const int  numdof   = NDOF1 *NUMVERTICES;
     6130        int        *doflist = NULL;
    61496131        bool       isefficientlayer;
    61506132        int        transfermethod;

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

    r15718 r15731  
    242242                ElementVector* CreatePVectorAdjointHoriz(void);
    243243                ElementVector* CreatePVectorAdjointBalancethickness(void);
    244                 void      InputUpdateFromSolutionAdjointBalancethickness( IssmDouble* solution);
    245                 void      InputUpdateFromSolutionAdjointHoriz( IssmDouble* solution);
     244                void             InputUpdateFromSolutionAdjointHoriz( IssmDouble* solution);
    246245                #endif
    247246
Note: See TracChangeset for help on using the changeset viewer.