source: issm/oecreview/Archive/11821-11840/ISSM-11826-11827.diff@ 11991

Last change on this file since 11991 was 11991, checked in by Eric.Larour, 13 years ago

oecreview from 11518 to present
File size: 61.3 KB

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/prognostic_core.cpp

     
    1515
    1616        /*parameters: */
    1717        int solution_type;
    18         bool control_analysis;
     18        bool save_results;
    1919
    2020        /*activate formulation: */
    2121        femmodel->SetCurrentConfiguration(PrognosticAnalysisEnum);
    2222       
    2323        /*recover parameters: */
    24         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     24        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    2525        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2626
    2727        _printf_(VerboseSolution(),"   call computational core\n");
    2828        solver_linear(femmodel);
    2929               
    30         if(solution_type==PrognosticSolutionEnum && !control_analysis){
     30        if(save_results){
    3131                _printf_(VerboseSolution(),"   saving results\n");
    3232                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
    3333        }
    34        
    3534}
    36 

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/steadystate_core.cpp

     
    2424        int step;
    2525
    2626        /*parameters: */
    27         bool control_analysis,isenthalpy;
     27        bool save_results,isenthalpy;
    2828        int  dim;
    2929        int  solution_type;
    3030        int  maxiter;
    … …  
    3333       
    3434        /* recover parameters:*/
    3535        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    36         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     36        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    3737        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    3838        femmodel->parameters->FindParam(&maxiter,SteadystateMaxiterEnum);
    3939        femmodel->parameters->FindParam(&numoutputs,SteadystateNumRequestedOutputsEnum);
    … …  
    8080                step++;
    8181        }
    8282       
    83         if(solution_type==SteadystateSolutionEnum && !control_analysis){
     83        if(save_results){
    8484                _printf_(VerboseSolution(),"   saving results\n");
    8585                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum);
    8686                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/surfaceslope_core.cpp

     
    1616        int dim;
    1717        bool isstokes;
    1818        bool ishutter;
    19         bool control_analysis;
     19        bool save_results;
    2020        int solution_type;
    2121
    2222        /*Recover some parameters: */
    2323        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    24         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     24        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    2525        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2626
    2727        _printf_(VerboseSolution(),"%s\n","computing slope...");
    … …  
    3232        femmodel->SetCurrentConfiguration(SurfaceSlopeAnalysisEnum,SurfaceSlopeYAnalysisEnum);
    3333        solver_linear(femmodel);
    3434       
    35         if(solution_type==SurfaceSlopeSolutionEnum && !control_analysis){
     35        if(save_results){
    3636                _printf_(VerboseSolution(),"saving results:\n");
    3737                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceSlopeXEnum);
    3838                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceSlopeYEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/thermal_core.cpp

     
    1818
    1919        /*intermediary*/
    2020        double melting_offset;
    21         bool   control_analysis;
     21        bool   save_results;
    2222        int    solution_type;
    2323        bool   dakota_analysis  = false;
    2424
    2525        //first recover parameters common to all solutions
    26         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     26        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    2727        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2828        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    2929
    … …  
    3535        /*call thermal_core_step: */
    3636        thermal_core_step(femmodel);
    3737
    38         if(solution_type==ThermalSolutionEnum && !control_analysis){
     38        if(save_results){
    3939                _printf_(VerboseSolution(),"   saving results\n");
    4040                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,TemperatureEnum);
    4141                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BasalforcingsMeltingRateEnum);
    4242        }
    43 
    4443}

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/adjointdiagnostic_core.cpp

     
    1616       
    1717        /*parameters: */
    1818        bool isstokes;
    19         bool control_analysis;
     19        bool save_results;
    2020        bool conserve_loads   = true;
    2121        int  solution_type;
    2222
    2323        /*retrieve parameters:*/
    2424        femmodel->parameters->FindParam(&isstokes,FlowequationIsstokesEnum);
    25         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     25        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    2626        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2727
    2828        /*Compute velocities*/
    … …  
    3939        solver_adjoint_linear(femmodel);
    4040       
    4141        /*Save results*/
    42         if(solution_type==AdjointSolutionEnum && !control_analysis){
     42        if(save_results){
    4343                _printf_(VerboseSolution(),"   saving results\n");
    4444                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointxEnum);
    4545                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointyEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/bedslope_core.cpp

     
    1616        int  dim;
    1717        bool isstokes;
    1818        bool ishutter;
    19         bool control_analysis;
     19        bool save_results;
    2020        int  solution_type;
    2121
    2222        /*Recover some parameters: */
    2323        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    24         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     24        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    2525        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2626
    2727        _printf_(VerboseSolution(),"%s\n","   computing slope");
    … …  
    3232        femmodel->SetCurrentConfiguration(BedSlopeAnalysisEnum,BedSlopeYAnalysisEnum);
    3333        solver_linear(femmodel);
    3434       
    35         if(solution_type==BedSlopeSolutionEnum && !control_analysis){
     35        if(save_results){
    3636                _printf_(VerboseSolution(),"   saving results\n");
    3737                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedSlopeXEnum);
    3838                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedSlopeYEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/balancethickness_core.cpp

     
    1717        /*parameters: */
    1818        int  dim;
    1919        int  solution_type;
    20         bool control_analysis;
     20        bool save_results;
    2121
    2222        /*activate formulation: */
    2323        femmodel->SetCurrentConfiguration(BalancethicknessAnalysisEnum);
    2424       
    2525        /*recover parameters: */
    2626        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    27         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     27        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    2828        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2929
    3030        _printf_(VerboseSolution(),"call computational core:\n");
    3131        solver_linear(femmodel);
    3232
    33         if(solution_type==BalancethicknessSolutionEnum && !control_analysis){
     33        if(save_results){
    3434                _printf_(VerboseSolution(),"   saving results\n");
    3535                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
    3636        }

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/issm.cpp

     
    113113        MPI_Barrier(MPI_COMM_WORLD); finish_core=MPI_Wtime( );
    114114
    115115        _printf_(true,"write results to disk:\n");
    116         OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results);
     116        OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,femmodel->results);
    117117
    118118        /*Close output and petsc options file and write lock file if requested*/
    119119        pfclose(output_fid,lockfilename);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/transient_core.cpp

     
    2323
    2424        /*parameters: */
    2525        double starttime,finaltime,dt,yts;
    26         bool   control_analysis,isdiagnostic,isprognostic,isthermal,isgroundingline,isenthalpy;
    27         bool   dakota_analysis=false;
     26        bool   isdiagnostic,isprognostic,isthermal,isgroundingline,isenthalpy;
     27        bool   save_results,dakota_analysis;
    2828        bool   time_adapt=false;
    2929        int    solution_type;
    3030        int    output_frequency;
    … …  
    4242        femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    4343        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    4444        femmodel->parameters->FindParam(&yts,ConstantsYtsEnum);
    45         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
    4645        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    4746        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    4847        femmodel->parameters->FindParam(&output_frequency,SettingsOutputFrequencyEnum);
    … …  
    8685                step+=1;
    8786                time+=dt;
    8887                femmodel->parameters->SetParam(time,TimeEnum);
     88                femmodel->parameters->SetParam(step,StepEnum);
    8989
    9090                _printf_(VerboseSolution(),"iteration %i/%g  time [yr]: %-7.3g (time step: %.2g)\n",step,floor((finaltime-time)/dt)+step,time/yts,dt/yts);
     91                if(step%output_frequency==0 || time==finaltime)
     92                 save_results=true;
     93                else
     94                 save_results=false;
     95                femmodel->parameters->SetParam(save_results,SaveResultsEnum);
    9196
    9297                if(isthermal && dim==3){
    9398                        _printf_(VerboseSolution(),"   computing temperatures:\n");
    … …  
    128133                        #endif
    129134                }
    130135
    131                 //save should be done by the analysis... see control_core
    132                 if(solution_type==TransientSolutionEnum && !control_analysis && (step%output_frequency==0 || time==finaltime)){
    133                         _printf_(VerboseSolution(),"   saving results\n");
    134                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzMeshEnum,step,time);
    135                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,step,time);
    136                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,step,time);
    137                         if(dim==3) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzEnum,step,time);
    138                         if(isdiagnostic)InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VelEnum,step,time);
    139                         if(isdiagnostic)InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,PressureEnum,step,time);
    140                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum,step,time);
    141                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceEnum,step,time);
    142                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedEnum,step,time);
    143                         if(dim==3 && isthermal) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,TemperatureEnum,step,time);
    144                         if(isenthalpy) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,WaterfractionEnum,step,time);
    145                         if(isenthalpy) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,EnthalpyEnum,step,time);
    146                         if(!isenthalpy) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BasalforcingsMeltingRateEnum,step,time);
    147                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceforcingsMassBalanceEnum,step,time);
    148                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,MaskElementonfloatingiceEnum,step,time);
    149                         RequestedOutputsx(femmodel->results,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,requested_outputs,numoutputs,step,time);
     136                /*unload results*/
     137                if(save_results){
     138                        _printf_(VerboseSolution(),"   saving transient results\n");
     139                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceEnum);
     140                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedEnum);
     141                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceforcingsMassBalanceEnum);
     142                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,MaskElementonfloatingiceEnum);
     143                        RequestedOutputsx(femmodel->results,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,requested_outputs,numoutputs);
    150144
    151                         /*unload results*/
    152145                        _printf_(VerboseSolution(),"   saving temporary results\n");
    153                         OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results);
     146                        OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,femmodel->results);
    154147                }
    155148        }
    156149

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/adjointbalancethickness_core.cpp

     
    1515void adjointbalancethickness_core(FemModel* femmodel){
    1616       
    1717        /*parameters: */
    18         bool control_analysis;
     18        bool save_results;
    1919        int  solution_type;
    2020
    2121        /*retrieve parameters:*/
    22         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     22        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    2323        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2424
    2525        /*compute thickness */
    … …  
    3636        solver_adjoint_linear(femmodel);
    3737       
    3838        /*Save results*/
    39         if(solution_type==AdjointSolutionEnum && !control_analysis){
     39        if(save_results){
    4040                _printf_(VerboseSolution(),"   saving results\n");
    4141                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointEnum);
    4242        }

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/controlrestart.cpp

     
    2828                //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,InversionControlParametersEnum,EnumToStringx(control_type),1,0));
    2929
    3030                /*write to disk: */
    31                 OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results);
     31                OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,femmodel->results);
    3232        }
    3333
    3434        /*Clean up and return*/

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/control_core.cpp

     
    5858        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    5959        femmodel->parameters->FindParam(&isstokes,FlowequationIsstokesEnum);
    6060        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
     61        femmodel->parameters->SetParam(false,SaveResultsEnum);
    6162
    6263        /*out of solution_type, figure out solution core and adjoint function pointer*/
    6364        CorePointerFromSolutionEnum(&solutioncore,femmodel->parameters,solution_type);
    … …  
    6566
    6667        /*Launch once a complete solution to set up all inputs*/
    6768        _printf_(VerboseControl(),"%s\n","   preparing initial solution");
    68         if (isstokes) solutioncore(femmodel);
     69        if(isstokes) solutioncore(femmodel);
    6970
    7071        /*Initialize responses: */
    7172        J=(double*)xmalloc(nsteps*sizeof(double));
    … …  
    107108        }
    108109
    109110        _printf_(VerboseControl(),"%s\n","   preparing final solution");
    110         femmodel->parameters->SetParam(false,InversionIscontrolEnum); //needed to turn control result output in solutioncore
     111        femmodel->parameters->SetParam(true,SaveResultsEnum);
    111112        solutioncore(femmodel);
    112113
    113114        /*some results not computed by steadystate_core or diagnostic_core: */
    … …  
    124125        xfree((void**)&maxiter);
    125126        xfree((void**)&cm_jump);
    126127        xfree((void**)&J);
    127        
    128         /*control_core might be used in Qmu, so leave everything similar to where it started: */
    129         femmodel->parameters->SetParam(true,InversionIscontrolEnum);
    130128}

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/hydrology_core.cpp

     
    2020        int    nsteps;
    2121        double starttime,final_time;
    2222        double dt;
    23         bool   control_analysis;
     23        bool   save_results;
    2424        int    solution_type;
    2525        int    output_frequency;
    2626
    … …  
    2828        femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    2929        femmodel->parameters->FindParam(&final_time,TimesteppingFinalTimeEnum);
    3030        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    31         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     31        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    3232        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    3333        femmodel->parameters->FindParam(&output_frequency,SettingsOutputFrequencyEnum);
    3434        /*first compute slopes: */
    … …  
    5353                /*call hydrology_core step: */
    5454                hydrology_core_step(femmodel,i,time);
    5555
    56                 if(solution_type==HydrologySolutionEnum && !control_analysis && ((i+1)%output_frequency==0 || (i+1)==nsteps)){
    57                        
     56                if(save_results && ((i+1)%output_frequency==0 || (i+1)==nsteps)){
    5857                        _printf_(VerboseSolution(),"   saving results \n");
    59                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,WatercolumnEnum,i+1,time);
    60                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,HydrologyWaterVxEnum,i+1,time);
    61                         InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,HydrologyWaterVyEnum,i+1,time);
     58                        //InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,WatercolumnEnum,i+1,time);
     59                        //InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,HydrologyWaterVxEnum,i+1,time);
     60                        //InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,HydrologyWaterVyEnum,i+1,time);
    6261                       
    6362                        /*unload results*/
    6463                        _printf_(VerboseSolution(),"   saving temporary results\n");
    65                         OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results);
    66 
     64                        OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,femmodel->results);
    6765                }
    68 
    6966        }
    7067}
    7168

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/diagnostic_core.cpp

     
    2323        bool  isnewton          = false;
    2424        bool  conserve_loads    = true;
    2525        bool  modify_loads      = true;
    26         bool  control_analysis;
     26        bool  save_results;
    2727        int   solution_type;
    2828        int   numoutputs        = 0;
    2929        int  *requested_outputs = NULL;
    … …  
    3535        femmodel->parameters->FindParam(&isstokes,FlowequationIsstokesEnum);
    3636        femmodel->parameters->FindParam(&isnewton,DiagnosticIsnewtonEnum);
    3737        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    38         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     38        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    3939        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    4040        femmodel->parameters->FindParam(&numoutputs,DiagnosticNumRequestedOutputsEnum);
    4141        if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,DiagnosticRequestedOutputsEnum);
    … …  
    9393        }
    9494
    9595
    96         if(solution_type==DiagnosticSolutionEnum && !control_analysis){
     96        if(save_results){
    9797                _printf_(VerboseSolution(),"   saving results\n");
    9898                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum);
    9999                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/controltao_core.cpp

     
    4848        femmodel->parameters->FindParam(&control_list,NULL,InversionControlParametersEnum);
    4949        femmodel->parameters->FindParam(&nsteps,InversionNstepsEnum);
    5050        femmodel->parameters->FindParam(&dummy,NULL,NULL,InversionMaxiterPerStepEnum);
     51        femmodel->parameters->SetParam(false,SaveResultsEnum);
    5152        maxiter=nsteps*(int)dummy[0]; xfree((void**)&dummy);
    5253
    5354        /*Initialize TAO*/
    … …  
    8788
    8889        /*Finalize*/
    8990        _printf_(VerboseControl(),"%s\n","   preparing final solution");
    90         femmodel->parameters->SetParam(false,InversionIscontrolEnum); //needed to turn control result output in solutioncore
     91        femmodel->parameters->SetParam(true,SaveResultsEnum);
    9192        void (*solutioncore)(FemModel*)=NULL;
    9293        CorePointerFromSolutionEnum(&solutioncore,femmodel->parameters,solution_type);
    9394        solutioncore(femmodel);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/solutions/enthalpy_core.cpp

     
    1414
    1515void enthalpy_core(FemModel* femmodel){
    1616
    17         int i;
    18 
    1917        /*intermediary*/
    20         bool   control_analysis;
     18        bool   save_results;
    2119        int    solution_type;
    2220
    2321        //first recover parameters common to all solutions
    24         femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
     22        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    2523        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2624
    2725        /*call enthalpy_core_step: */
    2826        enthalpy_core_step(femmodel);
    2927
    30         if(solution_type==EnthalpySolutionEnum && !control_analysis){
     28        if(save_results){
    3129                _printf_(VerboseSolution(),"   saving results\n");
    3230                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,TemperatureEnum);
    3331                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,EnthalpyEnum);
    3432                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,WaterfractionEnum);
    3533        }
    36 
    3734}

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h

     
    384384        P1DGEnum,
    385385        /*}}}*/
    386386        /*Results{{{1*/
     387        SaveResultsEnum,
    387388        BoolElementResultEnum,
    388389        BoolExternalResultEnum,
    389390        DoubleElementResultEnum,
    … …  
    398399        PentaP1ElementResultEnum,
    399400        PetscVecExternalResultEnum,
    400401        StringExternalResultEnum,
     402        StepEnum,
    401403        TimeEnum,
    402404        TriaP1ElementResultEnum,
    403405        WaterColumnOldEnum,

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/io/Matlab/FetchMatlabData.cpp

     
    602602                /*Check type of field: */
    603603                if (mxIsClass(pfield,"double")){
    604604                       
    605                         /*could be  DOUBLE, DOUBLEVEC or DOUBLEMAT, depends on dimensions: */
    606605                        M=mxGetM(pfield);
    607606                        N=mxGetN(pfield);
    608607
    609608                        if (M==0 | N==0){
    610                                 _error_("%s%i (%s) %s%i%s%i%s","array in parameters structure field ",count,name," is of size (",M,",",N,")");
     609                                _error_("array in parameters structure field %s is of size 0",name);
    611610                        }
    612611                        if (M==1 && N==1){
    613612                                /*we have a simple scalar: */
    … …  
    642641                        }
    643642
    644643                }
     644                else if (mxIsClass(pfield,"logical")){
     645
     646                        M=mxGetM(pfield);
     647                        N=mxGetN(pfield);
     648
     649                        if (M==0 | N==0){
     650                                _error_("array in parameters structure field %s is of size 0",name);
     651                        }
     652                        if (M==1 && N==1){
     653                                /*we have a simple bool: */
     654                                param= new BoolParam(enum_type,*mxGetLogicals(pfield));
     655                                parameters->AddObject(param);
     656
     657                        }
     658                        else{
     659                                _error_("Matrices of Booleans not supported yet in parameters");
     660                        }
     661                }
    645662                else if (mxIsClass(pfield,"char")){
    646663                        /* we have a string parameter:*/
    647664                       
    … …  
    717734                                xfree((void**)&ndims_array);
    718735                        }
    719736                }
    720                 else _error_("%s%i","unknow type in parameters structure field ",i);
     737                else _error_("Parameters structure field %s has a format that is not supported: %s",name,mxGetClassName(pfield));
    721738        }
    722739
    723740        /*Assign output pointers:*/
    724741        *pparameters=parameters;
    725 
    726742}
    727743/*}}}*/
    728744#endif

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/StringToEnumx/StringToEnumx.cpp

     
    377377              else if (strcmp(name,"P0")==0) return P0Enum;
    378378              else if (strcmp(name,"P1")==0) return P1Enum;
    379379              else if (strcmp(name,"P1DG")==0) return P1DGEnum;
     380              else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum;
    380381              else if (strcmp(name,"BoolElementResult")==0) return BoolElementResultEnum;
    381382              else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum;
    382383              else if (strcmp(name,"DoubleElementResult")==0) return DoubleElementResultEnum;
    383384              else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum;
    384               else if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum;
    385385         else stage=4;
    386386   }
    387387   if(stage==4){
    388               if (strcmp(name,"DoubleVecExternalResult")==0) return DoubleVecExternalResultEnum;
     388              if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum;
     389              else if (strcmp(name,"DoubleVecExternalResult")==0) return DoubleVecExternalResultEnum;
    389390              else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum;
    390391              else if (strcmp(name,"J")==0) return JEnum;
    391392              else if (strcmp(name,"Patch")==0) return PatchEnum;
    … …  
    394395              else if (strcmp(name,"PentaP1ElementResult")==0) return PentaP1ElementResultEnum;
    395396              else if (strcmp(name,"PetscVecExternalResult")==0) return PetscVecExternalResultEnum;
    396397              else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum;
     398              else if (strcmp(name,"Step")==0) return StepEnum;
    397399              else if (strcmp(name,"Time")==0) return TimeEnum;
    398400              else if (strcmp(name,"TriaP1ElementResult")==0) return TriaP1ElementResultEnum;
    399401              else if (strcmp(name,"WaterColumnOld")==0) return WaterColumnOldEnum;

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/EnumToStringx/EnumToStringx.cpp

     
    370370                case P0Enum : return "P0";
    371371                case P1Enum : return "P1";
    372372                case P1DGEnum : return "P1DG";
     373                case SaveResultsEnum : return "SaveResults";
    373374                case BoolElementResultEnum : return "BoolElementResult";
    374375                case BoolExternalResultEnum : return "BoolExternalResult";
    375376                case DoubleElementResultEnum : return "DoubleElementResult";
    … …  
    384385                case PentaP1ElementResultEnum : return "PentaP1ElementResult";
    385386                case PetscVecExternalResultEnum : return "PetscVecExternalResult";
    386387                case StringExternalResultEnum : return "StringExternalResult";
     388                case StepEnum : return "Step";
    387389                case TimeEnum : return "Time";
    388390                case TriaP1ElementResultEnum : return "TriaP1ElementResult";
    389391                case WaterColumnOldEnum : return "WaterColumnOld";

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/OutputResultsx/OutputResultsx.h

     
    1515
    1616#ifdef _SERIAL_
    1717#include <mex.h>
    18 void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters, Results** presults);
     18void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters, Results* results);
    1919#else
    20 void OutputResultsx(Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters, Results** presults);
     20void OutputResultsx(Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads,  Materials* materials, Parameters* parameters, Results* results);
    2121#endif
    2222
    2323#endif  /* _OUTPUTRESULTS_H */

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/OutputResultsx/OutputResultsx.cpp

     
    1616#include "../../objects/objects.h"
    1717               
    1818#ifdef _SERIAL_
    19 void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results** presults){
     19void OutputResultsx(mxArray** pdataref, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results* results){
    2020#else
    21 void OutputResultsx(                    Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results** presults){
     21void OutputResultsx(                    Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results* results){
    2222#endif
    2323
    2424        extern int  my_rank;
    … …  
    2828        bool        io_gather;
    2929        int         solutiontype;
    3030        char*       solutiontypestring      = NULL;
    31         Results    *results                 = NULL;
    3231        bool        dakota_analysis         = false;
    3332       
    3433        #ifdef _SERIAL_
    … …  
    3837        int          nfields=0;
    3938        #endif
    4039
    41         /*recover results dataset: */
    42         results=*presults;
    43 
    4440        /*retrieve parameters: */
    4541        parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    4642
    … …  
    114110                }
    115111                */
    116112        #endif
    117 
    118         /*Assign output pointers:*/
    119         *presults=results;
    120113}

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp

     
    9292        parameters->AddObject(new IntParam(SolutionTypeEnum,solution_type));
    9393        parameters->AddObject(new IntParam(AnalysisTypeEnum,analysis_type));
    9494        parameters->AddObject(new IntParam(AnalysisCounterEnum,analysis_counter));
    95         parameters->AddObject(new DoubleParam(TimeEnum,0.0));  //start at time 0 by default for all solutions
     95        parameters->AddObject(new DoubleParam(TimeEnum,0.0));  //start at time 0 by default for all solutions FIXME: to be deleted
     96        parameters->AddObject(new IntParam(StepEnum,1));  //start at time 0 by default for all solutions FIXME: to be deleted
    9697
    97         /*Requested output?*/
     98        /*By default, save all results*/
     99        parameters->AddObject(new BoolParam(SaveResultsEnum,true));
     100
     101        /*Requested outputs*/
    98102        iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,DiagnosticRequestedOutputsEnum);
    99103        parameters->AddObject(new IntParam(DiagnosticNumRequestedOutputsEnum,numoutputs));
    100104        if(numoutputs)parameters->AddObject(new IntVecParam(DiagnosticRequestedOutputsEnum,requestedoutputs,numoutputs));

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/InputToResultx/InputToResultx.h

     
    88#include "../../Container/Container.h"
    99
    1010/* local prototypes: */
    11 void InputToResultx(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,int enum_type,int step=1, double time=0);
     11void InputToResultx(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,int enum_type);
    1212
    1313#endif  /* _INPUTTORESULTX_H */
    14 

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/InputToResultx/InputToResultx.cpp

     
    88#include "../../toolkits/toolkits.h"
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void InputToResultx(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,int enum_type,int step, double time){
     11void InputToResultx(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,int enum_type){
    1212
    1313        /*intermediary:*/
    14         int      i;
     14        int      step;
     15        double   time;
    1516        Element *element = NULL;
    1617
     18        /*Get time and step*/
     19        parameters->FindParam(&step,StepEnum);
     20        parameters->FindParam(&time,TimeEnum);
     21
    1722        /*Go through elemnets, and ask each element to transfer the enum_type input into the results dataset, with step and time information: */
    18         for(i=0;i<elements->Size();i++){
     23        for(int i=0;i<elements->Size();i++){
    1924
    2025                element=(Element*)elements->GetObjectByOffset(i);
    2126                element->InputToResult(enum_type,step,time);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/RequestedOutputsx/RequestedOutputsx.h

     
    88#include "../../Container/Container.h"
    99
    1010/* local prototypes: */
    11 void RequestedOutputsx(Results* results,Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters, int* requested_outputs, int numoutputs, int step=1, double time=0);
     11void RequestedOutputsx(Results* results,Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters, int* requested_outputs, int numoutputs);
    1212
    1313#endif  /* _INPUTTORESULTX_H */
    1414

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/RequestedOutputsx/RequestedOutputsx.cpp

     
    88#include "../../toolkits/toolkits.h"
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void RequestedOutputsx(Results* results,Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters, int* requested_outputs, int numoutputs, int step, double time){
     11void RequestedOutputsx(Results* results,Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters, int* requested_outputs, int numoutputs){
    1212
    13         int  i,j;
    14         int  output_enum;
    15         double output_value;
    16         Element* element=NULL;
     13        int      output_enum;
     14        int      step;
     15        double   time;
     16        double   output_value;
     17        Element *element      = NULL;
    1718
    18         /*retrieve parameters: */
     19        /*Get time and step*/
     20        parameters->FindParam(&step,StepEnum);
     21        parameters->FindParam(&time,TimeEnum);
     22
     23        /*retrieve Inputs*/
    1924        if(numoutputs){
    20                 for(i=0;i<numoutputs;i++){
     25                for(int i=0;i<numoutputs;i++){
    2126                        output_enum=requested_outputs[i];
    2227
    2328                        switch(output_enum){
    … …  
    2833                                        break;
    2934                                default:
    3035                                        /*create this output in the element inputs, and then transfer to results:*/
    31                                         for(j=0;j<elements->Size();j++){
     36                                        for(int j=0;j<elements->Size();j++){
    3237                                                element=(Element*)elements->GetObjectByOffset(j);
    3338                                                element->RequestedOutput(output_enum,step,time);
    3439                                        }

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/mex/InputToResult/InputToResult.cpp

     
    4141        nodes->     Configure(elements,loads, nodes,vertices, materials,parameters);
    4242        loads->     Configure(elements, loads, nodes,vertices, materials,parameters);
    4343
    44         if(nrhs==9){
    45                 FetchMatlabData(&step,STEP);
    46                 FetchMatlabData(&time,TIME);
     44        /*Call core code: */
     45        InputToResultx( elements, nodes, vertices, loads, materials,parameters,enum_type);
    4746
    48                 /*!Call core code: */
    49                 InputToResultx( elements, nodes, vertices, loads, materials,parameters,enum_type, step,time);
    50         }
    51         else{
    52 
    53                 /*!Call core code: */
    54                 InputToResultx( elements, nodes, vertices, loads, materials,parameters,enum_type);
    55         }
    56 
    5747        /*write output : */
    5848        WriteMatlabData(ELEMENTSOUT,elements);
    5949

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/mex/OutputResults/OutputResults.cpp

     
    4242        loads->     Configure(elements, loads, nodes,vertices, materials,parameters);
    4343
    4444        /*Call "x" code layer: */
    45         OutputResultsx(&dataref, elements,nodes,vertices,loads,materials,parameters,&results);
     45        OutputResultsx(&dataref, elements,nodes,vertices,loads,materials,parameters,results);
    4646
    4747        /*write output datasets: */
    4848        plhs[0]=dataref;

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/enthalpy_core.m

     
    55%      femmodel=enthalpy_core(femmodel)
    66
    77        %recover parameters common to all solutions
    8         control_analysis=femmodel.parameters.InversionIscontrol;
     8        save_results=femmodel.parameters.SaveResults;
    99        solution_type=femmodel.parameters.SolutionType;
    1010
    1111        issmprintf(VerboseSolution,'\n%s',['   computing enthalpy']);
    1212        femmodel=enthalpy_core_step(femmodel);
    1313
    14         if (solution_type==EnthalpySolutionEnum & ~control_analysis),
     14        if (save_results),
    1515                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    1616                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,EnthalpyEnum);
    1717                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,TemperatureEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/steadystate_core.m

     
    77
    88        %recover parameters common to all solutions
    99        dim=femmodel.parameters.MeshDimension;
    10         control_analysis=femmodel.parameters.InversionIscontrol;
     10        save_results=femmodel.parameters.SaveResults;
    1111        solution_type=femmodel.parameters.SolutionType;
    1212        isenthalpy=femmodel.parameters.ThermalIsenthalpy;
    1313
    … …  
    4242                step=step+1;
    4343        end
    4444
    45         if (solution_type==SteadystateSolutionEnum & ~control_analysis),
     45        if (save_results),
    4646                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    4747                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VxEnum);
    4848                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VyEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/adjointdiagnostic_core.m

     
    77        %recover parameters common to all solutions
    88        isstokes=femmodel.parameters.FlowequationIsstokes;
    99        dim=femmodel.parameters.MeshDimension;
    10         control_analysis=femmodel.parameters.InversionIscontrol;
     10        save_results=femmodel.parameters.SaveResults;
    1111        solution_type=femmodel.parameters.SolutionType;
    1212        conserve_loads=true;
    1313
    … …  
    2525        femmodel=solver_adjoint_linear(femmodel);
    2626
    2727        %save results
    28         if(solution_type==AdjointSolutionEnum & ~control_analysis)
     28        if(save_results),
    2929                issmprintf(VerboseSolution,'   saving results');
    3030                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,AdjointxEnum);
    3131                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,AdjointyEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/bedslope_core.m

     
    77
    88        %Recover some parameters:
    99        dim=femmodel.parameters.MeshDimension;
    10         control_analysis=femmodel.parameters.InversionIscontrol;
     10        save_results=femmodel.parameters.SaveResults;
    1111        solution_type=femmodel.parameters.SolutionType;
    1212
    1313        issmprintf(VerboseSolution,'   computing bed slope');
    … …  
    1818        femmodel=SetCurrentConfiguration(femmodel,BedSlopeAnalysisEnum,BedSlopeYAnalysisEnum);
    1919        femmodel=solver_linear(femmodel);
    2020       
    21         if (solution_type==BedSlopeSolutionEnum & ~control_analysis),
     21        if (save_results),
    2222                issmprintf(VerboseSolution,'   saving results');
    2323                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,BedSlopeXEnum);
    2424                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,BedSlopeYEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/adjointbalancethickness_core.m

     
    55%      femmodel=adjointbalancethickness_core(femmodel)
    66
    77        %recover parameters common to all solutions
    8         control_analysis=femmodel.parameters.InversionIscontrol;
     8        save_results=femmodel.parameters.SaveResults;
    99        solution_type=femmodel.parameters.SolutionType;
    1010
    1111        %set analysis type to compute velocity:
    … …  
    2323
    2424        %Save results
    2525        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,AdjointEnum);
    26         if(solution_type==AdjointSolutionEnum & ~control_analysis)
     26        if(save_results),
    2727                issmprintf(VerboseSolution,'   saving results');
    2828                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,AdjointEnum);
    2929        end

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/control_core.m

     
    1818        gradient_only=femmodel.parameters.InversionGradientOnly;
    1919        dim=femmodel.parameters.MeshDimension;
    2020        isstokes=femmodel.parameters.FlowequationIsstokes;
     21        femmodel.parameters.SaveResults=false;
    2122
    2223        %Initialise options with maxiter
    2324        options.MaxIter=femmodel.parameters.InversionMaxiterPerStep;
    … …  
    7475
    7576        %generate output
    7677        issmprintf(VerboseControl,'   preparing final velocity solution');
    77         femmodel.parameters.InversionIscontrol=0;
     78        femmodel.parameters.SaveResults=true;
    7879        eval(['femmodel=' solutioncore '(femmodel);']);
    7980
    8081        %Some results not computed by diagnostic or steadystate

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/diagnostic_core.m

     
    1616        isstokes=femmodel.parameters.FlowequationIsstokes;
    1717        isnewton=femmodel.parameters.DiagnosticIsnewton;
    1818        dakota_analysis=femmodel.parameters.QmuIsdakota;
    19         control_analysis=femmodel.parameters.InversionIscontrol;
     19        save_results=femmodel.parameters.SaveResults;
    2020        solution_type=femmodel.parameters.SolutionType;
    2121
    2222        %for qmu analysis, be sure the velocity input we are starting from  is the one in the parameters:
    … …  
    7474                femmodel=solver_linear(femmodel);
    7575        end
    7676
    77         if (solution_type==DiagnosticSolutionEnum & ~control_analysis)
     77        if (save_results),
    7878                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    7979                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VxEnum);
    8080                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VyEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/prognostic_core.m

     
    55%      femmodel=prognostic_core(femmodel)
    66
    77        %recover parameters common to all solutions
    8         control_analysis=femmodel.parameters.InversionIscontrol;
     8        save_results=femmodel.parameters.SaveResults;
    99        solution_type=femmodel.parameters.SolutionType;
    1010
    1111        %Activate formulation
    … …  
    1414        issmprintf(VerboseSolution,'\n%s',['   call computational core']);
    1515        femmodel=solver_linear(femmodel);
    1616       
    17         if (solution_type==PrognosticSolutionEnum & ~control_analysis)
     17        if (save_results),
    1818                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    1919                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,ThicknessEnum);
    2020        end

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/surfaceslope_core.m

     
    77
    88        %Recover some parameters:
    99        dim=femmodel.parameters.MeshDimension;
    10         control_analysis=femmodel.parameters.InversionIscontrol;
     10        save_results=femmodel.parameters.SaveResults;
    1111        solution_type=femmodel.parameters.SolutionType;
    1212
    1313        %Call on core computations:
    … …  
    1717        femmodel=SetCurrentConfiguration(femmodel,SurfaceSlopeAnalysisEnum,SurfaceSlopeYAnalysisEnum);
    1818        femmodel=solver_linear(femmodel);
    1919       
    20         if (solution_type==SurfaceSlopeSolutionEnum),
     20        if (save_results),
    2121                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    2222                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,SurfaceSlopeXEnum);
    2323                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,SurfaceSlopeYEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/thermal_core.m

     
    66
    77
    88        %recover parameters common to all solutions
    9         control_analysis=femmodel.parameters.InversionIscontrol;
     9        save_results=femmodel.parameters.SaveResults;
    1010        solution_type=femmodel.parameters.SolutionType;
    1111
    1212        issmprintf(VerboseSolution,'\n%s',['   computing temperature']);
    1313        femmodel=thermal_core_step(femmodel);
    1414
    15         if (solution_type==ThermalSolutionEnum & ~control_analysis),
     15        if (save_results),
    1616                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    1717                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,TemperatureEnum);
    1818                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,BasalforcingsMeltingRateEnum);

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/balancethickness_core.m

     
    66
    77        %recover parameters common to all solutions
    88        dim=femmodel.parameters.MeshDimension;
    9         control_analysis=femmodel.parameters.InversionIscontrol;
     9        save_results=femmodel.parameters.SaveResults;
    1010        solution_type=femmodel.parameters.SolutionType;
    1111
    1212        %Activate formulation
    … …  
    1515        issmprintf(VerboseSolution,'   call computational core');
    1616        femmodel=solver_linear(femmodel);
    1717
    18         if (solution_type==BalancethicknessSolutionEnum & ~control_analysis),
     18        if (save_results),
    1919                issmprintf(VerboseSolution,'   saving results');
    2020                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,ThicknessEnum);
    2121        end

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/solutions/transient_core.m

     
    1010        finaltime=femmodel.parameters.TimesteppingFinalTime;
    1111        dt=femmodel.parameters.TimesteppingTimeStep;
    1212        yts=femmodel.parameters.ConstantsYts;
    13         control_analysis=femmodel.parameters.InversionIscontrol;
    1413        solution_type=femmodel.parameters.SolutionType;
    1514        output_frequency=femmodel.parameters.SettingsOutputFrequency;
    1615        time_adapt=femmodel.parameters.TimesteppingTimeAdapt;
    … …  
    5352                step=step+1;
    5453                time=time+dt;
    5554                femmodel.parameters.Time=time;
     55                femmodel.parameters.Step=step;
    5656
    5757                issmprintf(VerboseSolution,'\n%s%g%s%i%s%g\n','time [yr] ',time/yts,' iteration number: ',step,'/',floor((finaltime-starttime)/dt));
     58                if(mod(step,output_frequency)==0 | time==ndt),
     59                        save_results=true;
     60                else
     61                        save_results=false;
     62                end
     63                femmodel.parameters.SaveResults=save_results;
    5864
    5965                if (isthermal & dim==3)
    6066                        issmprintf(VerboseSolution,'\n%s',['   computing temperature']);
    … …  
    8490                                GroundinglineMigration(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    8591                end
    8692
    87                 if (solution_type==TransientSolutionEnum & ~control_analysis & (mod(step,output_frequency)==0 | time==finaltime)),
    88                         issmprintf(VerboseSolution,'\n%s',['   saving results']);
    89                         femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VxEnum,step,time);
    90                         femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VyEnum,step,time);
    91                         if (dim==3), femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VzEnum,step,time); end
    92                         if (isdiagnostic), femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VelEnum,step,time); end
    93                         if (isdiagnostic), femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,PressureEnum,step,time); end
    94                         femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,ThicknessEnum,step,time);
     93                if (save_results),
     94                        issmprintf(VerboseSolution,'\n%s',['   saving transient results']);
    9595                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,SurfaceEnum,step,time);
    9696                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,BedEnum,step,time);
    97                         if (dim==3 & isthermal), femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,TemperatureEnum,step,time);end
    98                         if (dim==3 & isenthalpy), femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,WaterfractionEnum,step,time);end
    99                         if (dim==3 & isenthalpy), femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,EnthalpyEnum,step,time);end
    100                         femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,BasalforcingsMeltingRateEnum,step,time);
    10197                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,SurfaceforcingsMassBalanceEnum,step,time);
    10298                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,MaskElementonfloatingiceEnum,step,time);
    10399                end

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/model/plot/plotmodel.m

     
    4747        try,
    4848                for i=1:numberofplots,
    4949                        plot_manager(getfieldvalue(options.list{i},'model',md),options.list{i},subplotwidth,nlines,ncols,i);
     50                        cbfreeze;
    5051                end
    5152        catch me,
    5253                %figure(figurenumber),close;

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/enum/StepEnum.m

     
     1function macro=StepEnum()
     2%STEPENUM - Enum of Step
     3%
     4%   WARNING: DO NOT MODIFY THIS FILE
     5%            this file has been automatically generated by src/c/EnumDefinitions/Synchronize.sh
     6%            Please read src/c/EnumDefinitions/README for more information
     7%
     8%   Usage:
     9%      macro=StepEnum()
     10
     11macro=StringToEnum('Step');

  • proj/ice/larour/issm-uci-clean/trunk-jpl/src/m/enum/SaveResultsEnum.m

     
     1function macro=SaveResultsEnum()
     2%SAVERESULTSENUM - Enum of SaveResults
     3%
     4%   WARNING: DO NOT MODIFY THIS FILE
     5%            this file has been automatically generated by src/c/EnumDefinitions/Synchronize.sh
     6%            Please read src/c/EnumDefinitions/README for more information
     7%
     8%   Usage:
     9%      macro=SaveResultsEnum()
     10
     11macro=StringToEnum('SaveResults');
Note: See TracBrowser for help on using the repository browser.