Changeset 6323


Ignore:
Timestamp:
10/15/10 16:13:34 (14 years ago)
Author:
Mathieu Morlighem
Message:

Added some verbosity levels and generalized

Location:
issm/trunk/src
Files:
3 added
4 deleted
69 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/modules/ConfigureObjectsx/ConfigureObjectsx.cpp

    r5420 r6323  
    2424        parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    2525       
    26         //_printf_("      Configuring elements...\n");
     26        ISSMPRINTF(VerboseMProcessor(),"      Configuring elements...\n");
    2727        for (i=0;i<elements->Size();i++){
    2828                element=(Element*)elements->GetObjectByOffset(i);
    2929                element->Configure(elements,loads,nodes,materials,parameters);
    3030        }
    31         //_printf_("      Configuring loads...\n");
     31        ISSMPRINTF(VerboseMProcessor(),"      Configuring loads...\n");
    3232        for (i=0;i<loads->Size();i++){
    3333                load=(Load*)loads->GetObjectByOffset(i);
    … …  
    3636                }
    3737        }
    38         //_printf_("      Configuring nodes...\n");
     38        ISSMPRINTF(VerboseMProcessor(),"      Configuring nodes...\n");
    3939        for (i=0;i<nodes->Size();i++){
    4040                node=(Node*)nodes->GetObjectByOffset(i);
    … …  
    4444        }
    4545       
    46         //_printf_("      Configuring materials...\n");
     46        ISSMPRINTF(VerboseMProcessor(),"      Configuring materials...\n");
    4747        for (i=0;i<materials->Size();i++){
    4848                material=(Material*)materials->GetObjectByOffset(i);

  • issm/trunk/src/c/modules/InputConvergencex/InputConvergencex.cpp

    r4890 r6323  
    1717        double     *eps       = NULL;
    1818        Element*    element=NULL;
    19         int         verbose;
    2019
    21         /*retrieve parameters: */
    22         parameters->FindParam(&verbose,VerboseEnum);
    23        
    2420        /*allocate dynamic memory: */
    2521        eps=(double*)xmalloc(num_criterionenums*sizeof(double));
    … …  
    3733        num_notconverged=total_notconverged;
    3834        #endif
    39         _printf_("      #elements above convergence criterion = %i\n",num_notconverged);
     35        ISSMPRINTF(VerboseConvergence(),"      #elements above convergence criterion = %i\n",num_notconverged);
    4036
    4137        /*Free ressources:*/

  • issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp

    r6231 r6323  
    1515        int     dummy;
    1616       
    17         int     verbose;
    1817        int     numberofvertices;
    1918        int     qmu_npart;
    … …  
    2625
    2726        /*retrieve parameters: */
    28         parameters->FindParam(&verbose,VerboseEnum);
    2927        parameters->FindParam(&qmu_npart,QmuNPartEnum);
    3028        parameters->FindParam(&qmu_part,&dummy,QmuPartEnum);

  • issm/trunk/src/c/modules/Mergesolutionfromftogx/Mergesolutionfromftogx.cpp

    r5703 r6323  
    1313       
    1414        /*Display message*/
    15         int verbose; parameters->FindParam(&verbose,VerboseEnum);
    16         if (verbose) _printf_("   Merging solution vector from fset to gset\n");
     15        ISSMPRINTF(VerboseModule(),"   Merging solution vector from fset to gset\n");
    1716
    1817        /*Merge f set back into g set: */

  • issm/trunk/src/c/modules/ModelProcessorx/CreateParameters.cpp

    r6215 r6323  
    4444        parameters->AddObject(new BoolParam(IsMacAyealPattynEnum,iomodel->ismacayealpattyn));
    4545        parameters->AddObject(new BoolParam(IsStokesEnum,iomodel->isstokes));
    46         parameters->AddObject(new IntParam(VerboseEnum,iomodel->verbose));
    4746        parameters->AddObject(new IntParam(OutputFrequencyEnum,iomodel->output_frequency));
    4847        parameters->AddObject(new DoubleParam(EpsResEnum,iomodel->eps_res));

  • issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp

    r6322 r6323  
    3030        Parameters* parameters=NULL;
    3131
    32 
    3332        /*intermediary: */
    3433        IoModel* iomodel=NULL;
    3534
    36         _printf_("   fill model with matlab workspace data\n");
    3735        iomodel = new IoModel(IOMODEL);
    3836        SetVerbosityLevel(iomodel->verbose);

  • issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.cpp

    r5703 r6323  
    2424
    2525        /*Display message*/
    26         int verbose; parameters->FindParam(&verbose,VerboseEnum);
    27         if (verbose) _printf_("   Constraining penalties\n");
     26        ISSMPRINTF(VerboseModule(),"   Constraining penalties\n");
    2827
    2928        /*recover parameters: */

  • issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.cpp

    r5838 r6323  
    5555        }
    5656        else if(num_unstable_constraints<=min_mechanical_constraints){
    57                 _printf_("   freezing constraints\n");
     57                ISSMPRINTF(VerboseModule(),"   freezing constraints\n");
    5858                RiftFreezeConstraints(loads,configuration_type);
    5959        }

  • issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp

    r6231 r6323  
    4646        char    *string                    = NULL;
    4747        int      string_length;
    48         int      verbose                   = 0;
    4948        int      solution_type;
    5049        bool     control_analysis          = false;
    … …  
    5352        /*synchronize all cpus, as CPU 0 is probably late (it is starting the entire dakota strategy!) : */
    5453        MPI_Barrier(MPI_COMM_WORLD);
    55         _printf_("qmu iteration: %i\n",counter);
     54        ISSMPRINTF(VerboseQmu(),"qmu iteration: %i\n",counter);
    5655       
    5756        /*retrieve parameters: */
    58         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    5957        femmodel->parameters->FindParam(&responses_descriptors,&numresponsedescriptors,ResponseDescriptorsEnum);
    6058        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    … …  
    6866
    6967        /*Determine solution sequence: */
    70         if(verbose)_printf_("%s%s%s\n","Starting ",EnumToString(solution_type)," core:");
     68        ISSMPRINTF(VerboseQmu(),"%s%s%s\n","Starting ",EnumToString(solution_type)," core:");
    7169        SolutionConfiguration(NULL,NULL,&solutioncore,solution_type);
    7270        if(control_analysis)solutioncore=&control_core;
    … …  
    7674
    7775        /*compute responses: */
    78         if(verbose)_printf_("compute dakota responses:\n");
     76        ISSMPRINTF(VerboseQmu(),"compute dakota responses:\n");
    7977        DakotaResponsesx(d_responses,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,responses_descriptors,numresponsedescriptors,d_numresponses);
    8078       

  • issm/trunk/src/c/modules/Reduceloadfromgtofx/Reduceloadfromgtofx.cpp

    r5895 r6323  
    2323
    2424        /*Parameters: */
    25         int verbose;
    2625        bool kffpartition=false;
    2726        bool fromlocalsize=true;
    2827
    29         parameters->FindParam(&verbose,VerboseEnum);
    3028        parameters->FindParam(&kffpartition,KffEnum);
    31         if (verbose) _printf_("   Reducing Load vector from gset to fset\n");
     29        ISSMPRINTF(VerboseModule(),"   Reducing Load vector from gset to fset\n");
    3230
    3331        if(!pg){

  • issm/trunk/src/c/modules/Reduceloadx/Reduceloadx.cpp

    r6011 r6323  
    2121        int         verbose;
    2222
    23         parameters->FindParam(&verbose,VerboseEnum);
    24         if (verbose) _printf_("   Dirichlet lifting applied to load vector\n");
     23        ISSMPRINTF(VerboseModule(),"   Dirichlet lifting applied to load vector\n");
    2524       
    2625        if(pf && Kfs){

  • issm/trunk/src/c/modules/Reducematrixfromgtofx/Reducematrixfromgtofx.cpp

    r5703 r6323  
    1111
    1212        /*Display message*/
    13         int verbose; parameters->FindParam(&verbose,VerboseEnum);
    14         if (verbose) _printf_("   Reducing Stiffness Matrix from gset to fset\n");
     13        ISSMPRINTF(VerboseModule(),"   Reducing Stiffness Matrix from gset to fset\n");
    1514
    1615        //Reduce matrix from g-size to f-size

  • issm/trunk/src/c/modules/Solverx/Solverx.cpp

    r6203 r6323  
    3030        int        solver_type;
    3131        bool       fromlocalsize    = true;
    32         int        verbose;
    3332
    3433
    3534        /*Display message*/
    36         parameters->FindParam(&verbose,VerboseEnum); if (verbose) _printf_("   Solving\n");
    37         if(verbose==2)PetscOptionsPrint(stdout);
     35        ISSMPRINTF(VerboseModule(),"   Solving\n");
     36        if(VerboseSolver())PetscOptionsPrint(stdout);
    3837
    3938        /*First, check that f-set is not NULL, ie model is fully constrained: */
    … …  
    108107        }
    109108       
    110         if(verbose==2)KSPView(ksp,PETSC_VIEWER_STDOUT_WORLD);
     109        if(VerboseSolver())KSPView(ksp,PETSC_VIEWER_STDOUT_WORLD);
    111110
    112111        /*Solve: */

  • issm/trunk/src/c/modules/SystemMatricesx/SystemMatricesx.cpp

    r5903 r6323  
    2929
    3030        /*Display message*/
    31         int verbose; parameters->FindParam(&verbose,VerboseEnum);
    32         if (verbose) _printf_("   Generating matrices\n");
     31        ISSMPRINTF(VerboseModule(),"   Generating matrices\n");
    3332
    3433        /*retrive parameters: */

  • issm/trunk/src/c/objects/FemModel.cpp

    r6322 r6323  
    125125void FemModel::SetCurrentConfiguration(int configuration_type,int analysis_type){
    126126
    127         int verbose=0;
    128 
    129         /*retrieve parameters: */
    130         this->parameters->FindParam(&verbose,VerboseEnum);
    131        
    132127        /*Use configuration_type to setup the analysis counter, the configurations of objects etc ... but use
    133128         * analysis_type to drive the element numerics. This allows for use of 1 configuration_type for several
    … …  
    161156        /*take care of petsc options, that depend on this analysis type: */
    162157        PetscOptionsFromAnalysis(this->parameters,analysis_type);
    163 
    164         if(verbose){
    165                 _printf_("      petsc Options set for analysis type: %s\n",EnumToString(analysis_type));
    166         }
    167 
     158        ISSMPRINTF(VerboseSolver(),"      petsc Options set for analysis type: %s\n",EnumToString(analysis_type));
    168159
    169160}

  • issm/trunk/src/c/shared/Numerics/BrentSearch.cpp

    r5323 r6323  
    5959
    6060        //display result
    61         _printf_("\n        Iteration         x           f(x)       Tolerance         Procedure\n\n");
    62         _printf_("        %s    %12.6g  %12.6g  %s","   N/A",xmin,fxmin,"         N/A         boundary\n");
     61        ISSMPRINTF(VerboseControl(),"\n        Iteration         x           f(x)       Tolerance         Procedure\n\n");
     62        ISSMPRINTF(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",xmin,fxmin,"         N/A         boundary\n");
    6363
    6464        //get the value of the function at the first boundary xmax and display result
    6565        fxmax = (*f)(xmax,optargs);
    6666        if isnan(fxmax) ISSMERROR("Function evaluation returned NaN");
    67         _printf_("        %s    %12.6g  %12.6g  %s","   N/A",xmax,fxmax,"         N/A         boundary\n");
     67        ISSMPRINTF(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",xmax,fxmax,"         N/A         boundary\n");
    6868
    6969        //test if jump option activated and xmin==0
    … …  
    109109
    110110        //4: print result
    111         _printf_("         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,xbest,fxbest,pow(pow(xbest-xm,2),0.5),"       initial");
     111        ISSMPRINTF(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,xbest,fxbest,pow(pow(xbest-xm,2),0.5),"       initial");
    112112
    113113        //Main Loop
    … …  
    230230                //print result
    231231                if (goldenflag){
    232                         _printf_("         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,x,fx,pow(pow(xbest-xm,2),0.5),"       golden");
    233                 }
    234                 else{
    235                         _printf_("         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,x,fx,pow(pow(xbest-xm,2),0.5),"       parabolic");
     232                        ISSMPRINTF(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,x,fx,pow(pow(xbest-xm,2),0.5),"       golden");
     233                }
     234                else{
     235                        ISSMPRINTF(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,x,fx,pow(pow(xbest-xm,2),0.5),"       parabolic");
    236236                }
    237237
    238238                //Stop the optimization?
    239239                if (sqrt(pow(xbest-xm,2)) < (tol2-0.5*(xmax-xmin))){
    240                         _printf_("      %s%g\n","optimization terminated: the current x satisfies the termination criteria using 'tolx' of" ,tolerance);
     240                        ISSMPRINTF(VerboseControl(),"      %s%g\n","optimization terminated: the current x satisfies the termination criteria using 'tolx' of" ,tolerance);
    241241                        loop=0;
    242242                }
    243243                else if (iter>=maxiter){
    244                         _printf_("      %s\n","exiting: Maximum number of iterations has been exceeded  - increase 'maxiter'\n");
     244                        ISSMPRINTF(VerboseControl(),"      %s\n","exiting: Maximum number of iterations has been exceeded  - increase 'maxiter'\n");
    245245                        loop=0;
    246246                }

  • issm/trunk/src/c/shared/Numerics/OptimalSearch.cpp

    r5607 r6323  
    4141        fx1= (*f)(x1,optargs);
    4242        if isnan(fx1) ISSMERROR("Function evaluation returned NaN");
    43         _printf_("\n        Iteration         x           f(x)       Tolerance\n\n");
    44         _printf_("        %s    %12.6g  %12.6g  %s","   N/A",x1,fx1,"         N/A\n");
     43        ISSMPRINTF(VerboseControl(),"\n        Iteration         x           f(x)       Tolerance\n\n");
     44        ISSMPRINTF(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",x1,fx1,"         N/A\n");
    4545
    4646        //update tolerances
    … …  
    5454                fx2 = (*f)(x2,optargs);
    5555                if isnan(fx2) ISSMERROR("Function evaluation returned NaN");
    56                 _printf_("         %5i    %12.6g  %12.6g  %12.6g\n",iter,x2,fx2,fabs(x2-x1)>fabs(fx2-fx1)?fabs(fx2-fx1):fabs(x2-x1));
     56                ISSMPRINTF(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g\n",iter,x2,fx2,fabs(x2-x1)>fabs(fx2-fx1)?fabs(fx2-fx1):fabs(x2-x1));
    5757
    5858                //Stop the optimization?
    5959                if ((fabs(x2-x1)+seps)<tolerance || (fabs(fx2-fx1)+seps)<tolerance){
    60                         _printf_("      %s%g\n","optimization terminated: the current x satisfies the termination criteria using 'tolx' of " ,tolerance);
     60                        ISSMPRINTF(VerboseControl(),"      %s%g\n","optimization terminated: the current x satisfies the termination criteria using 'tolx' of " ,tolerance);
    6161                        loop=false;
    6262                }
    6363                else if (iter>=maxiter){
    64                         _printf_("      %s\n","exiting: Maximum number of iterations has been exceeded  - increase 'maxiter'\n");
     64                        ISSMPRINTF(VerboseControl(),"      %s\n","exiting: Maximum number of iterations has been exceeded  - increase 'maxiter'\n");
    6565                        loop=false;
    6666                }

  • issm/trunk/src/c/shared/Numerics/Verbosity.cpp

    r6317 r6323  
    2424
    2525/*Verbosityt levels*/
    26 bool VerboseModule(void){return (GetVerbosityLevel() & 1);} /* 2^0*/
    27 bool VerboseConvergence(void){return (GetVerbosityLevel() & 2);} /* 2^1*/
    28 bool VerboseMProcessor(void){return (GetVerbosityLevel() & 4);} /* 2^2*/
     26bool VerboseMProcessor(void){return (GetVerbosityLevel() & 1);} /* 2^0*/
     27bool VerboseModule(void){return (GetVerbosityLevel() & 2);} /* 2^1*/
     28bool VerboseSolution(void){return (GetVerbosityLevel() & 4);} /* 2^2*/
    2929bool VerboseSolver(void){return (GetVerbosityLevel() & 8);} /* 2^3*/
     30bool VerboseConvergence(void){return (GetVerbosityLevel() & 16);} /* 2^4*/
     31bool VerboseControl(void){return (GetVerbosityLevel() & 32);} /* 2^5*/
     32bool VerboseQmu(void){return (GetVerbosityLevel() & 64);} /* 2^6*/
    3033
    3134/*Verbosity Setup*/

  • issm/trunk/src/c/shared/Numerics/Verbosity.h

    r6317 r6323  
    77
    88/*List of Verbosity levels (Add your own and Synchronize: must begin with "Verb")*/
     9bool VerboseMProcessor(void);
    910bool VerboseModule(void);
     11bool VerboseSolution(void);
     12bool VerboseSolver(void);
    1013bool VerboseConvergence(void);
    11 bool VerboseMProcessor(void);
    12 bool VerboseSolver(void);
     14bool VerboseControl(void);
     15bool VerboseQmu(void);
    1316
    1417/*Setup Verbosity level*/

  • issm/trunk/src/c/solutions/ResetBoundaryConditions.cpp

    r5787 r6323  
    99void ResetBoundaryConditions(FemModel* femmodel, int analysis_type){
    1010       
    11         int verbose=0;
    1211        Vec yg=NULL;
    1312        Vec ys=NULL;
    1413        int analysis_counter;
    1514                       
    16         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    17         if(verbose)_printf_("%s\n"," updating boundary conditions...");
     15        ISSMPRINTF(VerboseSolution(),"%s\n","   updating boundary conditions...");
    1816                       
    1917        /*set current analysis: */

  • issm/trunk/src/c/solutions/adjointbalancedthickness_core.cpp

    r6133 r6323  
    1616        /*parameters: */
    1717        bool control_analysis;
    18         int  verbose = 0;
    1918        int  solution_type;
    2019
    2120        /*retrieve parameters:*/
    22         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    2321        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    2422        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2523
    2624        /*compute thickness */
    27         _printf_("%s\n","      computing thickness");
     25        ISSMPRINTF(VerboseSolution(),"%s\n","   computing thickness");
    2826        femmodel->SetCurrentConfiguration(BalancedthicknessAnalysisEnum);
    2927        solver_linear(femmodel);
    … …  
    3331
    3432        /*compute adjoint*/
    35         _printf_("%s\n","      computing adjoint");
     33        ISSMPRINTF(VerboseSolution(),"%s\n","   computing adjoint");
    3634        femmodel->SetCurrentConfiguration(BalancedthicknessAnalysisEnum,AdjointBalancedthicknessAnalysisEnum);
    3735        solver_adjoint_linear(femmodel);
    … …  
    3937        /*Save results*/
    4038        if(solution_type==AdjointSolutionEnum && !control_analysis){
    41                 if(verbose)_printf_("saving results:\n");
     39                ISSMPRINTF(VerboseSolution(),"   saving results\n");
    4240                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointEnum);
    4341        }

  • issm/trunk/src/c/solutions/adjointdiagnostic_core.cpp

    r5585 r6323  
    1818        bool control_analysis;
    1919        bool conserve_loads   = true;
    20         int  verbose          = 0;
    2120        int  solution_type;
    2221
    2322        /*retrieve parameters:*/
    24         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    2523        femmodel->parameters->FindParam(&isstokes,IsStokesEnum);
    2624        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    … …  
    2826
    2927        /*Compute velocities*/
    30         _printf_("%s\n","      computing velocities");
     28        ISSMPRINTF(VerboseSolution(),"%s\n","   computing velocities");
    3129        femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
    3230        solver_diagnostic_nonlinear(femmodel,conserve_loads);
    … …  
    3634
    3735        /*Compute adjoint*/
    38         _printf_("%s\n","      computing adjoint");
     36        ISSMPRINTF(VerboseSolution(),"%s\n","   computing adjoint");
    3937        femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum,AdjointHorizAnalysisEnum);
    4038        solver_adjoint_linear(femmodel);
    … …  
    4240        /*Save results*/
    4341        if(solution_type==AdjointSolutionEnum && !control_analysis){
    44                 if(verbose)_printf_("saving results:\n");
     42                ISSMPRINTF(VerboseSolution(),"   saving results\n");
    4543                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointxEnum);
    4644                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointyEnum);

  • issm/trunk/src/c/solutions/balancedthickness_core.cpp

    r5318 r6323  
    1515
    1616        /*parameters: */
    17         int  verbose = 0;
    1817        int  dim;
    1918        int  solution_type;
    … …  
    2423       
    2524        /*recover parameters: */
    26         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    2725        femmodel->parameters->FindParam(&dim,DimEnum);
    2826        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    2927        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    3028
    31         _printf_("call computational core:\n");
     29        ISSMPRINTF(VerboseSolution(),"call computational core:\n");
    3230        solver_linear(femmodel);
    3331
    3432        if(solution_type==BalancedthicknessSolutionEnum && !control_analysis){
    35                 if(verbose)_printf_("saving results:\n");
     33                ISSMPRINTF(VerboseSolution(),"   saving results\n");
    3634                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
    3735        }

  • issm/trunk/src/c/solutions/balancedvelocities_core.cpp

    r5318 r6323  
    1414
    1515        /*flags: */
    16         int  verbose          = 0;
    1716        int  dim;
    1817        bool control_analysis;
    … …  
    2322       
    2423        /*recover parameters: */
    25         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    2624        femmodel->parameters->FindParam(&dim,DimEnum);
    2725        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    2826        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2927
    30         _printf_("call computational core:\n");
     28        ISSMPRINTF(VerboseSolution(),"   call computational core\n");
    3129        solver_linear(femmodel);
    3230
    3331        if(solution_type==BalancedvelocitiesSolutionEnum && !control_analysis){
    34                 if(verbose)_printf_("saving results:\n");
     32                ISSMPRINTF(VerboseSolution(),"   saving results\n");
    3533                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VelEnum);
    3634        }

  • issm/trunk/src/c/solutions/bedslope_core.cpp

    r5318 r6323  
    1313
    1414        /*parameters: */
    15         int  verbose;
    1615        int  dim;
    1716        bool isstokes;
    … …  
    2120
    2221        /*Recover some parameters: */
    23         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    2422        femmodel->parameters->FindParam(&dim,DimEnum);
    2523        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    2624        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2725
    28         if(verbose)_printf_("%s\n","computing slope...");
     26        ISSMPRINTF(VerboseSolution(),"%s\n","   computing slope");
    2927
    3028        /*Call on core computations: */
    … …  
    3533       
    3634        if(solution_type==BedSlopeSolutionEnum && !control_analysis){
    37                 if(verbose)_printf_("saving results:\n");
     35                ISSMPRINTF(VerboseSolution(),"   saving results\n");
    3836                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedSlopeXEnum);
    3937                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedSlopeYEnum);

  • issm/trunk/src/c/solutions/control_core.cpp

    r6226 r6323  
    1717       
    1818        /*parameters: */
    19         int     verbose=0;
    2019        int     num_controls;
    2120        int     nsteps;
    … …  
    6766
    6867        /*Launch once a complete solution to set up all inputs*/
    69         _printf_("%s\n","      preparing initial solution");
     68        ISSMPRINTF(VerboseControl(),"%s\n","   preparing initial solution");
    7069        if (isstokes) solutioncore(femmodel);
    7170
    … …  
    8180
    8281                /*Display info*/
    83                 _printf_("\n%s%i%s%i\n","   control method step ",n+1,"/",nsteps);
     82                ISSMPRINTF(VerboseControl(),"\n%s%i%s%i\n","   control method step ",n+1,"/",nsteps);
    8483                InputUpdateFromConstantx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,(int)responses[n],CmResponseEnum);
    8584               
    … …  
    8786                if (solution_type==SteadystateSolutionEnum) solutioncore(femmodel);
    8887
    89                 _printf_("%s\n","      compute adjoint state:");
     88                ISSMPRINTF(VerboseControl(),"%s\n","   compute adjoint state:");
    9089                adjointcore(femmodel);
    9190       
    92                 _printf_("%s\n","      computing gradJ...");
    9391                gradient_core(femmodel,n,search_scalar);
    9492
    … …  
    9997                }
    10098
    101                 _printf_("%s\n","      optimizing along gradient direction");
     99                ISSMPRINTF(VerboseControl(),"%s\n","   optimizing along gradient direction");
    102100                optargs.n=n; optpars.maxiter=(int)maxiter[n]; optpars.cm_jump=cm_jump[n];
    103101                BrentSearch(&search_scalar,J+n,&optpars,&objectivefunctionC,&optargs);
    104102                //OptimalSearch(&search_scalar,J+n,&optpars,&objectivefunctionC,&optargs);
    105103
    106                 _printf_("%s\n","      updating parameter using optimized search scalar..."); //true means update save controls
     104                ISSMPRINTF(VerboseControl(),"%s\n","   updating parameter using optimized search scalar"); //true means update save controls
    107105                InputControlUpdatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,search_scalar,true);
    108106               
    … …  
    111109                /*Temporary saving every 5 control steps: */
    112110                if (((n+1)%5)==0){
    113                         _printf_("%s\n","      saving temporary results...");
     111                        ISSMPRINTF(VerboseControl(),"%s\n","   saving temporary results");
    114112                        controlrestart(femmodel,J);
    115113                }
    116114        }
    117115
    118         _printf_("%s\n","      preparing final solution");
     116        ISSMPRINTF(VerboseControl(),"%s\n","   preparing final solution");
    119117        femmodel->parameters->SetParam(false,ControlAnalysisEnum); //needed to turn control result output in solutioncore
    120118        solutioncore(femmodel);

  • issm/trunk/src/c/solutions/controlconvergence.cpp

    r5713 r6323  
    3232                                        //convergence if convergence criteria fullfilled
    3333                                        converged=true;
    34                                         _printf_("%s%g%s%g\n","      Convergence criterion: dJ/J = ",(J[i]-J[n])/J[n],"<",eps_cm);
     34                                        ISSMPRINTF(VerboseConvergence(),"%s%g%s%g\n","      Convergence criterion: dJ/J = ",(J[i]-J[n])/J[n],"<",eps_cm);
    3535                                }
    3636                                else{
    37                                         _printf_("%s%g%s%g\n","      Convergence criterion: dJ/J = ",(J[i]-J[n])/J[n],">",eps_cm);
     37                                        ISSMPRINTF(VerboseConvergence(),"%s%g%s%g\n","      Convergence criterion: dJ/J = ",(J[i]-J[n])/J[n],">",eps_cm);
    3838                                }
    3939                                break;

  • issm/trunk/src/c/solutions/diagnostic_core.cpp

    r6024 r6323  
    1515
    1616        /*parameters: */
    17         int    verbose              = 0;
    1817        bool   qmu_analysis         = false;
    1918        int    dim                  = -1;
    … …  
    2827
    2928        /* recover parameters:*/
    30         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    3129        femmodel->parameters->FindParam(&dim,DimEnum);
    3230        femmodel->parameters->FindParam(&ishutter,IsHutterEnum);
    … …  
    5250        if(ishutter){
    5351                       
    54                 if(verbose)_printf_("%s\n"," computing hutter velocities...");
     52                ISSMPRINTF(VerboseControl(),"%s\n","   computing hutter velocities");
    5553
    5654                //Take the last velocity into account so that the velocity on the MacAyeal domain is not zero
    … …  
    6563        if (ismacayealpattyn^isstokes){
    6664               
    67                 if(verbose)_printf_("%s\n"," computing horizontal velocities...");
     65                ISSMPRINTF(VerboseControl(),"%s\n","   computing velocities");
    6866                femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
    6967                solver_diagnostic_nonlinear(femmodel,modify_loads);
    … …  
    7270        if (ismacayealpattyn && isstokes){
    7371
    74                 if(verbose)_printf_("%s\n"," computing coupling macayealpattyn and stokes velocities and pressure ...");
     72                ISSMPRINTF(VerboseControl(),"%s\n","   computing coupling macayealpattyn and stokes velocities and pressure ");
    7573                solver_stokescoupling_nonlinear(femmodel,conserve_loads);
    7674        }
    … …  
    7876        if (dim==3 & (ishutter || ismacayealpattyn)){
    7977
    80                 if(verbose)_printf_("%s\n"," computing vertical velocities...");
     78                ISSMPRINTF(VerboseControl(),"%s\n","   computing vertical velocities");
    8179                femmodel->SetCurrentConfiguration(DiagnosticVertAnalysisEnum);
    8280                solver_linear(femmodel);
    … …  
    8583
    8684        if(solution_type==DiagnosticSolutionEnum && !control_analysis){
    87                 if(verbose)_printf_("saving results:\n");
     85                ISSMPRINTF(VerboseControl(),"   saving results\n");
    8886                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum);
    8987                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum);

  • issm/trunk/src/c/solutions/gradient_core.cpp

    r6240 r6323  
    1717        /*parameters: */
    1818        bool    control_steady;
    19         int     verbose;
    2019        int     num_controls;
    2120        int    *control_type   = NULL;
    … …  
    3332        femmodel->parameters->FindParam(&control_type,NULL,ControlTypeEnum);
    3433        femmodel->parameters->FindParam(&optscal_list,NULL,NULL,OptScalEnum);
    35         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    3634
    3735        /*Compute and norm gradient of all controls*/
    3836        for (int i=0;i<num_controls;i++){
    3937
    40                 if(verbose)_printf_("      compute gradient of J with respect to %s\n",EnumToString(control_type[i]));
     38                ISSMPRINTF(VerboseControl(),"   compute gradient of J with respect to %s\n",EnumToString(control_type[i]));
    4139                Gradjx(&gradient, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,femmodel->parameters, control_type[i]);
    4240
    … …  
    4442
    4543                if (step>0 && search_scalar==0){
    46                         _printf_("%s","      orthogonalization...\n");
     44                        ISSMPRINTF(VerboseControl(),"   orthogonalization\n");
    4745                        ControlInputGetGradientx(&old_gradient,femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,femmodel->parameters,control_type[i]);
    4846                        Orthx(&new_gradient,gradient,old_gradient); VecFree(&old_gradient); VecFree(&gradient);
    4947                }
    5048                else{
    51                         _printf_("%s","      normalizing directions...\n");
     49                        ISSMPRINTF(VerboseControl(),"   normalizing directions\n");
    5250                        Orthx(&new_gradient,gradient,NULL); VecFree(&gradient);
    5351                }

  • issm/trunk/src/c/solutions/issm.cpp

    r6014 r6323  
    5151        MPI_Comm_size(MPI_COMM_WORLD,&num_procs);
    5252
    53         _printf_("recover solution and file names:\n");
     53        _printf_("Launching solution sequence\n");
    5454        solution_type=StringToEnum(argv[1]);
    5555        inputfilename=argv[3];
    … …  
    6969        output_fid=pfopen(outputfilename,"wb");
    7070
    71         _printf_("create finite element model:\n");
    7271        femmodel=new FemModel(input_fid,solution_type,analyses,numanalyses);
    7372

  • issm/trunk/src/c/solutions/prognostic_core.cpp

    r5318 r6323  
    1414
    1515        /*parameters: */
    16         int verbose=0;
    1716        int solution_type;
    1817        bool control_analysis;
    … …  
    2221       
    2322        /*recover parameters: */
    24         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    2523        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    2624        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2725
    28         _printf_("call computational core:\n");
     26        ISSMPRINTF(VerboseSolution(),"   call computational core\n");
    2927        solver_linear(femmodel);
    3028               
    3129        if(solution_type==PrognosticSolutionEnum && !control_analysis){
    32                 if(verbose)_printf_("saving results:\n");
     30                ISSMPRINTF(VerboseSolution(),"   saving results\n");
    3331                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
    3432        }

  • issm/trunk/src/c/solutions/steadystate_core.cpp

    r5318 r6323  
    1818
    1919        /*parameters: */
    20         int verbose;
    2120        int dim;
    2221        int solution_type;
    … …  
    2423       
    2524        /* recover parameters:*/
    26         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    2725        femmodel->parameters->FindParam(&dim,DimEnum);
    2826        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    … …  
    3432        for(;;){
    3533       
    36                 if(verbose)_printf_("%s%i\n","   computing temperature and velocity for step: ",step);
     34                ISSMPRINTF(VerboseSolution(),"%s%i\n","   computing temperature and velocity for step: ",step);
    3735                thermal_core(femmodel);
    3836
    39                 if(verbose)_printf_("%s\n","computing new velocity");
     37                ISSMPRINTF(VerboseSolution(),"%s\n","   computing new velocity");
    4038                diagnostic_core(femmodel);
    4139
    4240                if (step>1){
    43                         if(verbose)_printf_("%s\n","checking velocity, temperature and pressure convergence");
     41                        ISSMPRINTF(VerboseSolution(),"%s\n","   checking velocity, temperature and pressure convergence");
    4442                        if(steadystateconvergence(femmodel)) break;
    4543                }
    4644               
    47                 if(verbose)_printf_("%s\n","saving velocity, temperature and pressure to check for convergence at next step");
     45                ISSMPRINTF(VerboseSolution(),"%s\n","   saving velocity, temperature and pressure to check for convergence at next step");
    4846                InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,VxOldEnum);
    4947                InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,VyOldEnum);
    … …  
    5755       
    5856        if(solution_type==SteadystateSolutionEnum && !control_analysis){
    59                 if(verbose)_printf_("saving results:\n");
     57                ISSMPRINTF(VerboseSolution(),"   saving results\n");
    6058                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum);
    6159                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum);

  • issm/trunk/src/c/solutions/surfaceslope_core.cpp

    r5318 r6323  
    1313
    1414        /*parameters: */
    15         int verbose;
    1615        int dim;
    1716        bool isstokes;
    … …  
    2120
    2221        /*Recover some parameters: */
    23         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    2422        femmodel->parameters->FindParam(&dim,DimEnum);
    2523        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    2624        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2725
    28         if(verbose)_printf_("%s\n","computing slope...");
     26        ISSMPRINTF(VerboseSolution(),"%s\n","computing slope...");
    2927
    3028        /*Call on core computations: */
    … …  
    3533       
    3634        if(solution_type==SurfaceSlopeSolutionEnum && !control_analysis){
    37                 if(verbose)_printf_("saving results:\n");
     35                ISSMPRINTF(VerboseSolution(),"saving results:\n");
    3836                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceSlopeXEnum);
    3937                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceSlopeYEnum);

  • issm/trunk/src/c/solutions/thermal_core.cpp

    r5318 r6323  
    1818        /*intermediary*/
    1919        double time;
    20         int    verbose;
    2120        int    nsteps;
    2221        double ndt;
    … …  
    2726
    2827        //first recover parameters common to all solutions
    29         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    3028        femmodel->parameters->FindParam(&ndt,NdtEnum);
    3129        femmodel->parameters->FindParam(&dt,DtEnum);
    … …  
    4341        for(i=0;i<nsteps;i++){
    4442               
    45                 if(verbose)_printf_("time step: %i/%i\n",i+1,nsteps);
     43                if(nsteps)ISSMPRINTF(VerboseSolution(),"time step: %i/%i\n",i+1,nsteps);
    4644                time=(i+1)*dt;
    4745
    … …  
    5048
    5149                if(solution_type==ThermalSolutionEnum && !control_analysis){
    52                         if(verbose)_printf_("saving results:\n");
     50                        ISSMPRINTF(VerboseSolution(),"   saving results\n");
    5351                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,TemperatureEnum,i+1,time);
    5452                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,MeltingRateEnum,i+1,time);

  • issm/trunk/src/c/solutions/thermal_core_step.cpp

    r4839 r6323  
    1414void thermal_core_step(FemModel* femmodel,int step, double time){
    1515
    16         int verbose;
    17 
    18         //first recover parameters common to all solutions
    19         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    20 
    21         if(verbose)_printf_("computing temperatures:\n");
     16        ISSMPRINTF(VerboseSolution(),"   computing temperatures\n");
    2217        femmodel->SetCurrentConfiguration(ThermalAnalysisEnum);
    2318        solver_thermal_nonlinear(femmodel);
    2419
    25         if(verbose)_printf_("computing melting:\n");
     20        ISSMPRINTF(VerboseSolution(),"   computing melting\n");
    2621        femmodel->SetCurrentConfiguration(MeltingAnalysisEnum);
    2722        solver_linear(femmodel);

  • issm/trunk/src/c/solutions/transient2d_core.cpp

    r6130 r6323  
    1616
    1717        /*parameters: */
    18         int    verbose          = 0;
    1918        double finaltime;
    2019        double dt                 ,yts;
    … …  
    2928
    3029        /* recover parameters: */
    31         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    3230        femmodel->parameters->FindParam(&finaltime,NdtEnum);
    3331        femmodel->parameters->FindParam(&dt,DtEnum);
    … …  
    4947                step+=1;
    5048
    51                 _printf_("%s%g%s%i%s%g%s%g\n","time [yr]: ",time/yts,"    iteration number: ",step,"/",floor(finaltime/dt)," dt [yr]: ",dt/yts);
     49                ISSMPRINTF(VerboseSolution(),"%s%g%s%i%s%g%s%g\n","time [yr]: ",time/yts,"    iteration number: ",step,"/",floor(finaltime/dt)," dt [yr]: ",dt/yts);
    5250
    53                 if(verbose)_printf_("%s\n","computing new velocity");
     51                ISSMPRINTF(VerboseSolution(),"%s\n","   computing new velocity");
    5452                diagnostic_core(femmodel);
    5553
    56                 if(verbose)_printf_("%s\n","computing new thickness");
     54                ISSMPRINTF(VerboseSolution(),"%s\n","   computing new thickness");
    5755                prognostic_core(femmodel);
    5856       
    59                 if(verbose)_printf_("%s\n","updating geometry");
     57                ISSMPRINTF(VerboseSolution(),"%s\n","   updating geometry");
    6058                UpdateGeometryx(femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
    6159
    6260                if(solution_type==Transient2DSolutionEnum && !control_analysis && (step%output_frequency==0)){
    63                         if(verbose)_printf_("%s\n","saving results:\n");
     61                        ISSMPRINTF(VerboseSolution(),"%s\n","   saving results\n");
    6462                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,step,time);
    6563                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,step,time);
    … …  
    7169
    7270                        /*unload results*/
    73                         if(verbose)_printf_("%s","      saving temporary results...");
     71                        ISSMPRINTF(VerboseSolution(),"%s","   saving temporary results");
    7472                        OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results,step,time);
    7573                }

  • issm/trunk/src/c/solutions/transient3d_core.cpp

    r6130 r6323  
    1616
    1717        /*parameters: */
    18         int    verbose       = 0;
    1918        double finaltime;
    2019        double dt,yts;
    … …  
    2928
    3029        //first recover parameters common to all solutions
    31         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    3230        femmodel->parameters->FindParam(&finaltime,NdtEnum);
    3331        femmodel->parameters->FindParam(&dt,DtEnum);
    … …  
    4947                time+=dt;
    5048
    51                 _printf_("%s%g%s%i%s%g%s%g\n","time [yr]: ",time/yts,"    iteration number: ",step,"/",floor(finaltime/dt)," dt [yr]: ",dt/yts);
     49                ISSMPRINTF(VerboseSolution(),"%s%g%s%i%s%g%s%g\n","time [yr]: ",time/yts,"    iteration number: ",step,"/",floor(finaltime/dt)," dt [yr]: ",dt/yts);
    5250
    53                 if(verbose)_printf_("computing temperatures:\n");
     51                ISSMPRINTF(VerboseSolution(),"   computing temperatures:\n");
    5452                thermal_core_step(femmodel,step,time);
    5553
    56                 if(verbose)_printf_("%s\n","computing new velocity");
     54                ISSMPRINTF(VerboseSolution(),"%s\n","   computing new velocity");
    5755                diagnostic_core(femmodel);
    5856
    59                 if(verbose)_printf_("%s\n","computing new thickness");
     57                ISSMPRINTF(VerboseSolution(),"%s\n","   computing new thickness");
    6058                prognostic_core(femmodel);
    6159       
    62                 if(verbose)_printf_("   updating geometry\n");
     60                ISSMPRINTF(VerboseSolution(),"   updating geometry\n");
    6361                UpdateGeometryx(femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
    6462               
    65                 if(verbose)_printf_("%s\n","updating vertices positions");
     63                ISSMPRINTF(VerboseSolution(),"%s\n","   updating vertices positions");
    6664                UpdateVertexPositionsx(femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
    6765
    6866                if(solution_type==Transient3DSolutionEnum && !control_analysis && (step%output_frequency==0)){
    69                         if(verbose)_printf_("%s\n","saving results:\n");
     67                        ISSMPRINTF(VerboseSolution(),"%s\n","   saving results\n");
    7068                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,step,time);
    7169                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,step,time);
    … …  
    8078
    8179                        /*unload results*/
    82                         if(verbose)_printf_("%s","      saving temporary results...");
     80                        ISSMPRINTF(VerboseSolution(),"%s","   saving temporary results");
    8381                        OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results,step,time);
    8482                }

  • issm/trunk/src/c/solvers/solver_diagnostic_nonlinear.cpp

    r6011 r6323  
    2323
    2424        /*parameters:*/
    25         int  verbose=0;
    2625        bool kffpartitioning=false;
    2726        int min_mechanical_constraints;
    … …  
    2928
    3029        /*Recover parameters: */
    31         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    3230        femmodel->parameters->FindParam(&kffpartitioning,KffEnum);
    3331        femmodel->parameters->FindParam(&min_mechanical_constraints,MinMechanicalConstraintsEnum);
    … …  
    7169
    7270                PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters);
    73                 if(verbose)_printf_("   number of unstable constraints: %i\n",num_unstable_constraints);
     71                ISSMPRINTF(VerboseConvergence(),"   number of unstable constraints: %i\n",num_unstable_constraints);
    7472
    7573                convergence(&converged,Kff,pf,uf,old_uf,femmodel->parameters); MatFree(&Kff);VecFree(&pf);

  • issm/trunk/src/c/solvers/solver_stokescoupling_nonlinear.cpp

    r6024 r6323  
    2525
    2626        /*parameters:*/
    27         int  verbose=0;
    2827        bool kffpartitioning=false;
    2928        int min_mechanical_constraints;
    … …  
    3130
    3231        /*Recover parameters: */
    33         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    3432        femmodel->parameters->FindParam(&kffpartitioning,KffEnum);
    3533        femmodel->parameters->FindParam(&min_mechanical_constraints,MinMechanicalConstraintsEnum);

  • issm/trunk/src/c/solvers/solver_thermal_nonlinear.cpp

    r6011 r6323  
    3232        /*parameters:*/
    3333        int kflag,pflag;
    34         int verbose=0;
    3534        bool lowmem=0;
    3635        bool kffpartitioning;
    … …  
    3938        kflag=1; pflag=1;
    4039        femmodel->parameters->FindParam(&kffpartitioning,KffEnum);
    41         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    4240        femmodel->parameters->FindParam(&lowmem,LowmemEnum);
    4341        femmodel->parameters->FindParam(&min_thermal_constraints,MinThermalConstraintsEnum);
    … …  
    4644        converged=false;
    4745
    48         if(verbose)_printf_("%s\n","starting direct shooting method");
     46        ISSMPRINTF(VerboseSolution(),"%s\n","starting direct shooting method");
    4947        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,reset_penalties,ResetPenaltiesEnum);
    5048        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,false,ConvergedEnum);
    … …  
    7371
    7472                if (!converged){
    75                         if(verbose)_printf_("%s%i\n","   #unstable constraints = ",num_unstable_constraints);
     73                        ISSMPRINTF(VerboseConvergence(),"%s%i\n","   #unstable constraints = ",num_unstable_constraints);
    7674                        if (num_unstable_constraints <= min_thermal_constraints)converged=true;
    7775                }

  • issm/trunk/src/m/classes/@model/setdefaultparameters.m

    r6304 r6323  
    8888%parameter used to print temporary results (convergence criterion,
    8989%current step,...)
    90 md.verbose=verbose;
     90md.verbose=verbose('solution',true,'qmu',true,'control',true);
    9191
    9292%Stokes mesh

  • issm/trunk/src/m/classes/verbose.m

    r6319 r6323  
    1414                % {{{1
    1515                %BEGINFIELDS
     16                mprocessor=false;
    1617                module=false;
     18                solution=false;
     19                solver=false;
    1720                convergence=false;
    18                 mprocessor=false;
    19                 solver=false;
     21                control=false;
     22                qmu=false;
    2023                %ENDFIELDS
    2124                % }}}
    … …  
    5356                %BEGINVERB2BIN
    5457                binary=0;
    55                 if (verbose.module), binary=bitor(binary,1); end
    56                 if (verbose.convergence), binary=bitor(binary,2); end
    57                 if (verbose.mprocessor), binary=bitor(binary,4); end
     58                if (verbose.mprocessor), binary=bitor(binary,1); end
     59                if (verbose.module), binary=bitor(binary,2); end
     60                if (verbose.solution), binary=bitor(binary,4); end
    5861                if (verbose.solver), binary=bitor(binary,8); end
     62                if (verbose.convergence), binary=bitor(binary,16); end
     63                if (verbose.control), binary=bitor(binary,32); end
     64                if (verbose.qmu), binary=bitor(binary,64); end
    5965                %ENDVERB2BIN
    6066
    … …  
    6470
    6571                %BEGINBIN2VERB
    66                 if bitand(binary,1), verbose.module=true; else verbose.module=false; end
    67                 if bitand(binary,2), verbose.convergence=true; else verbose.convergence=false; end
    68                 if bitand(binary,4), verbose.mprocessor=true; else verbose.mprocessor=false; end
     72                if bitand(binary,1), verbose.mprocessor=true; else verbose.mprocessor=false; end
     73                if bitand(binary,2), verbose.module=true; else verbose.module=false; end
     74                if bitand(binary,4), verbose.solution=true; else verbose.solution=false; end
    6975                if bitand(binary,8), verbose.solver=true; else verbose.solver=false; end
     76                if bitand(binary,16), verbose.convergence=true; else verbose.convergence=false; end
     77                if bitand(binary,32), verbose.control=true; else verbose.control=false; end
     78                if bitand(binary,64), verbose.qmu=true; else verbose.qmu=false; end
    7079                %ENDBIN2VERB
    7180
    … …  
    7685                %BEGINDISP
    7786                disp(sprintf('class ''%s''  = ',class(verbose)));
     87                disp(sprintf('   %10s : %s','mprocessor',mat2str(verbose.mprocessor)));
    7888                disp(sprintf('   %10s : %s','module',mat2str(verbose.module)));
     89                disp(sprintf('   %10s : %s','solution',mat2str(verbose.solution)));
     90                disp(sprintf('   %10s : %s','solver',mat2str(verbose.solver)));
    7991                disp(sprintf('   %10s : %s','convergence',mat2str(verbose.convergence)));
    80                 disp(sprintf('   %10s : %s','mprocessor',mat2str(verbose.mprocessor)));
    81                 disp(sprintf('   %10s : %s','solver',mat2str(verbose.solver)));
     92                disp(sprintf('   %10s : %s','control',mat2str(verbose.control)));
     93                disp(sprintf('   %10s : %s','qmu',mat2str(verbose.qmu)));
    8294                %ENDDISP
    8395

  • issm/trunk/src/m/model/solve.m

    r6304 r6323  
    4343assignin('base',inputname(1),md);
    4444
    45 disp('launching solution sequence');
    46 
    4745%If running in parallel, we have a different way of launching the solution
    4846%sequences.

  • issm/trunk/src/m/shared/VerboseConvergence.m

    r6318 r6323  
    99%      bool=VerboseConvergence()
    1010
    11 bool=logical(bitand(GetVerbosityLevel(),2));
     11bool=logical(bitand(GetVerbosityLevel(),16));

  • issm/trunk/src/m/shared/VerboseMProcessor.m

    r6318 r6323  
    99%      bool=VerboseMProcessor()
    1010
    11 bool=logical(bitand(GetVerbosityLevel(),4));
     11bool=logical(bitand(GetVerbosityLevel(),1));

  • issm/trunk/src/m/shared/VerboseModule.m

    r6318 r6323  
    99%      bool=VerboseModule()
    1010
    11 bool=logical(bitand(GetVerbosityLevel(),1));
     11bool=logical(bitand(GetVerbosityLevel(),2));

  • issm/trunk/src/m/solutions/ResetBoundaryConditions.m

    r6321 r6323  
    77%      femmodel=ResetBoundaryConditions(femmodel,analysis_type)
    88
    9 
    10         %recover parameters common to all solutions
    11         verbose=femmodel.parameters.Verbose;
    12 
    13         issmprintf(verbose,'\n%s',['updating boundary condition ...']);
     9        issmprintf(VerboseSolution,'\n%s',['   updating boundary condition ...']);
    1410
    1511        %set current analysis:

  • issm/trunk/src/m/solutions/SpawnCore.m

    r6321 r6323  
    77
    88%retrieve parameters
    9 verbose=femmodel.parameters.Verbose;
    109responsedescriptors=femmodel.parameters.ResponseDescriptors;
    1110solution_type=femmodel.parameters.SolutionType;
    1211control_analysis=femmodel.parameters.ControlAnalysis;
    1312
    14 issmprintf(1,'%s%i',['   qmu iteration:'],counter);
     13issmprintf(VerboseQmu(),'%s%i',['   qmu iteration:'],counter);
    1514
    1615%first update the inputs to the femmodel using the variables provided to us by dakota.

  • issm/trunk/src/m/solutions/adjointbalancedthickness_core.m

    r6321 r6323  
    66
    77        %recover parameters common to all solutions
    8         verbose=femmodel.parameters.Verbose;
    98        control_analysis=femmodel.parameters.ControlAnalysis;
    109        solution_type=femmodel.parameters.SolutionType;
    1110
    1211        %set analysis type to compute velocity:
    13         issmprintf('\n%s',['      computing thickness']);
     12        issmprintf(VerboseSolution,'   computing thickness');
    1413        femmodel=SetCurrentConfiguration(femmodel,BalancedthicknessAnalysisEnum);
    1514        femmodel=solver_linear(femmodel);
    … …  
    1918
    2019        %compute adjoint
    21         issmprintf('\n%s',['      computing adjoint']);
     20        issmprintf(VerboseSolution,'   computing adjoint');
    2221        femmodel=SetCurrentConfiguration(femmodel,BalancedthicknessAnalysisEnum,AdjointBalancedthicknessAnalysisEnum);
    2322        femmodel=solver_adjoint_linear(femmodel);
    … …  
    2625        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,AdjointEnum);
    2726        if(solution_type==AdjointSolutionEnum & ~control_analysis)
    28                 issmprintf(verbose,'\n%s',['      saving results...']);
     27                issmprintf(VerboseSolution,'   saving results');
    2928                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,AdjointEnum);
    3029        end

  • issm/trunk/src/m/solutions/adjointdiagnostic_core.m

    r6321 r6323  
    66
    77        %recover parameters common to all solutions
    8         verbose=femmodel.parameters.Verbose;
    98        isstokes=femmodel.parameters.IsStokes;
    109        dim=femmodel.parameters.Dim;
    … …  
    1413
    1514        %set analysis type to compute velocity:
    16         issmprintf('\n%s',['      computing velocities']);
     15        issmprintf(VerboseSolution,'   computing velocities');
    1716        femmodel=SetCurrentConfiguration(femmodel,DiagnosticHorizAnalysisEnum);
    1817        femmodel=solver_diagnostic_nonlinear(femmodel,conserve_loads);
    … …  
    2221
    2322        %compute adjoint
    24         issmprintf('\n%s',['      computing adjoint']);
     23        issmprintf(VerboseSolution,'   computing adjoint');
    2524        femmodel=SetCurrentConfiguration(femmodel,DiagnosticHorizAnalysisEnum,AdjointHorizAnalysisEnum);
    2625        femmodel=solver_adjoint_linear(femmodel);
    … …  
    2827        %save results
    2928        if(solution_type==AdjointSolutionEnum & ~control_analysis)
    30                 issmprintf(verbose,'\n%s',['      saving results...']);
     29                issmprintf(VerboseSolution,'   saving results');
    3130                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,AdjointxEnum);
    3231                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,AdjointyEnum);

  • issm/trunk/src/m/solutions/balancedthickness_core.m

    r6321 r6323  
    66
    77        %recover parameters common to all solutions
    8         verbose=femmodel.parameters.Verbose;
    98        dim=femmodel.parameters.Dim;
    109        control_analysis=femmodel.parameters.ControlAnalysis;
    … …  
    1413        femmodel=SetCurrentConfiguration(femmodel,BalancedthicknessAnalysisEnum);
    1514
    16         issmprintf(verbose,'\n%s',['call computational core...']);
     15        issmprintf(VerboseSolution,'   call computational core');
    1716        femmodel=solver_linear(femmodel);
    1817
    1918        if (solution_type==BalancedthicknessSolutionEnum & ~control_analysis),
    20                 issmprintf(verbose,'\n%s',['saving results...']);
     19                issmprintf(VerboseSolution,'   saving results');
    2120                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,ThicknessEnum);
    2221        end

  • issm/trunk/src/m/solutions/balancedvelocities_core.m

    r6321 r6323  
    66
    77        %recover parameters common to all solutions
    8         verbose=femmodel.parameters.Verbose;
    98        dim=femmodel.parameters.Dim;
    109        control_analysis=femmodel.parameters.ControlAnalysis;
    … …  
    1413        femmodel=SetCurrentConfiguration(femmodel,BalancedvelocitiesAnalysisEnum);
    1514
    16         issmprintf(verbose,'\n%s',['call computational core...']);
     15        issmprintf(VerboseSolution,'   call computational core');
    1716        femmodel=solver_linear(femmodel);
    1817       
    1918        if (solution_type==BalancedvelocitiesSolutionEnum & ~control_analysis),
    20                 issmprintf(verbose,'\n%s',['saving results...']);
     19                issmprintf(VerboseSolution,'   saving results');
    2120                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VelEnum);
    2221        end

  • issm/trunk/src/m/solutions/bedslope_core.m

    r6321 r6323  
    77
    88        %Recover some parameters:
    9         verbose=femmodel.parameters.Verbose;
    109        dim=femmodel.parameters.Dim;
    1110        control_analysis=femmodel.parameters.ControlAnalysis;
    1211        solution_type=femmodel.parameters.SolutionType;
    1312
    14         issmprintf(verbose,'\n%s',['computing bed slope...']);
     13        issmprintf(VerboseSolution,'   computing bed slope');
    1514
    1615        %Call on core computations:
    … …  
    2120       
    2221        if (solution_type==BedSlopeSolutionEnum & ~control_analysis),
    23                 issmprintf(verbose,'\n%s',['saving results...']);
     22                issmprintf(VerboseSolution,'   saving results');
    2423                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,BedSlopeXEnum);
    2524                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,BedSlopeYEnum);

  • issm/trunk/src/m/solutions/control_core.m

    r6321 r6323  
    77
    88        %recover parameters common to all solutions
    9         verbose=femmodel.parameters.Verbose;
    109        nsteps=femmodel.parameters.NSteps;
    1110        num_controls=femmodel.parameters.NumControls;
    … …  
    3433
    3534        %Launch once a complete solution to set up all inputs
    36         disp('      preparing initial solution');
     35        issmprintf(VerboseControl,'   preparing initial solution');
    3736        if isstokes,
    3837                eval(['femmodel=' solutioncore '(femmodel);']);
    … …  
    4140        for n=1:nsteps,
    4241
    43                 disp(sprintf('\n%s%s%s%s\n',['   control method step ' num2str(n) '/' num2str(femmodel.parameters.NSteps)]));
     42                issmprintf(VerboseControl(),['control method step ' num2str(n) '/' num2str(femmodel.parameters.NSteps)]);
    4443                [femmodel.elements,femmodel.loads]=InputUpdateFromConstant(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,responses(n),CmResponseEnum);
    4544
    … …  
    4948                end
    5049
    51                 issmprintf(verbose,'\n%s',['      compute adjoint state...']);
     50                issmprintf(VerboseControl,'   compute adjoint state');
    5251                eval(['femmodel=' adjointcore '(femmodel);']);
    5352
    54                 issmprintf(verbose,'\n%s',['      computing gradJ...']);
    5553                femmodel=gradient_core(femmodel,n,search_scalar);
    5654
    … …  
    6159                end
    6260
    63                 issmprintf(verbose,'\n%s',['      optimizing along gradient direction...']);
     61                issmprintf(VerboseControl,'   optimizing along gradient direction');
    6462                [search_scalar J(n)]=ControlOptimization('objectivefunctionC',0,1,options,femmodel,n,femmodel.parameters);
    6563
    66                 issmprintf('\n%s',['      updating parameter using optimized search scalar:']);
     64                issmprintf(VerboseControl,'   updating parameter using optimized search scalar');
    6765                [femmodel.elements,femmodel.nodes,femmmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters]=InputControlUpdate(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,search_scalar,1);
    68 
    69                 disp(['      value of misfit J after optimization #' num2str(n) ':' num2str(J(n))]);
     66                issmprintf(VerboseControl,['   value of misfit J after optimization #' num2str(n) ':' num2str(J(n))]);
    7067
    7168                %Has convergence been reached?
    … …  
    7875
    7976        %generate output
    80         issmprintf(verbose,'\n%s',['      preparing final velocity solution...']);
     77        issmprintf(VerboseControl,'   preparing final velocity solution');
    8178        femmodel.parameters.ControlAnalysis=0;
    8279        eval(['femmodel=' solutioncore '(femmodel);']);

  • issm/trunk/src/m/solutions/controlconvergence.m

    r6321 r6323  
    1515                                        %convergence if convergence criteria fullfilled
    1616                                        convergence=true;
    17                                         issmprintf('\n%s%g%s%g\n','      Convergence criterion: dJ/J = ',(J(i)-J(n))/J(n),'<',eps_cm);
     17                                        issmprintf(VerboseConvergence(),'\n%s%g%s%g\n','      Convergence criterion: dJ/J = ',(J(i)-J(n))/J(n),'<',eps_cm);
    1818                                else
    19                                         issmprintf('\n%s%g%s%g\n','      Convergence criterion: dJ/J = ',(J(i)-J(n))/J(n),'>',eps_cm);
     19                                        issmprintf(VerboseConvergence(),'\n%s%g%s%g\n','      Convergence criterion: dJ/J = ',(J(i)-J(n))/J(n),'>',eps_cm);
    2020                                end
    2121                                break;

  • issm/trunk/src/m/solutions/diagnostic_core.m

    r6321 r6323  
    1111
    1212        %recover parameters common to all solutions
    13         verbose=femmodel.parameters.Verbose;
    1413        dim=femmodel.parameters.Dim;
    1514        ishutter=femmodel.parameters.IsHutter;
    … …  
    3534        if ishutter,
    3635
    37                 issmprintf(verbose,'\n%s',['computing hutter velocities...']);
     36                issmprintf(VerboseSolution,'\n%s',['   computing hutter velocities']);
    3837
    3938                %Take the last velocity into account so that the velocity on the MacAyeal domain is not zero
    … …  
    4948        if xor(ismacayealpattyn,isstokes), %if macayealpattyn and stokes, we must use stokescoupling
    5049
    51                 issmprintf(verbose,'\n%s',['computing horizontal velocities...']);
     50                issmprintf(VerboseSolution,'\n%s',['   computing horizontal velocities']);
    5251                femmodel=SetCurrentConfiguration(femmodel,DiagnosticHorizAnalysisEnum);
    5352                femmodel=solver_diagnostic_nonlinear(femmodel,modify_loads);
    … …  
    5655        if ismacayealpattyn & isstokes,
    5756
    58                 issmprintf(verbose,'\n%s',['computing coupling velocities for macayealpattyn and stokes...']);
     57                issmprintf(VerboseSolution,'\n%s',['   computing coupling velocities for macayealpattyn and stokes']);
    5958                femmodel=SetCurrentConfiguration(femmodel,DiagnosticHorizAnalysisEnum);
    6059                femmodel=solver_stokescoupling_nonlinear(femmodel,conserve_loads);
    … …  
    6362        if dim==3 & (ismacayealpattyn | ishutter) & ~isstokes,
    6463       
    65                 issmprintf(verbose,'\n%s',['computing vertical velocities...']);
     64                issmprintf(VerboseSolution,'\n%s',['   computing vertical velocities']);
    6665                femmodel=SetCurrentConfiguration(femmodel,DiagnosticVertAnalysisEnum);
    6766                femmodel=solver_linear(femmodel);
    … …  
    6968
    7069        if (solution_type==DiagnosticSolutionEnum & ~control_analysis)
    71                 issmprintf(verbose,'\n%s',['saving results...']);
     70                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    7271                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VxEnum);
    7372                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VyEnum);

  • issm/trunk/src/m/solutions/gradient_core.m

    r6321 r6323  
    2121
    2222        %recover parameters common to all solutions
    23         verbose=femmodel.parameters.Verbose;
    2423        num_controls=femmodel.parameters.NumControls;
    2524        control_type=femmodel.parameters.ControlType;
    … …  
    2928        for i=1:num_controls,
    3029
    31                 issmprintf(verbose,['      compute gradient of J with respect to %s\n'],EnumToString(control_type(i)));
     30                issmprintf(VerboseControl,['   compute gradient of J with respect to %s'],EnumToString(control_type(i)));
    3231                grad=Gradj(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,control_type(i));
    3332
    … …  
    3736
    3837                if (step>1 && search_scalar==0),
    39                         issmprintf(verbose,'%s\n',['      orthogonalization...']);
     38                        issmprintf(VerboseControl,'%s',['   orthogonalization']);
    4039                        old_gradient=ControlInputGetGradient(femmodel.elements,femmodel.nodes, femmodel.vertices,femmodel.loads, femmodel.materials,femmodel.parameters,control_type(i));
    4140                        new_gradient=Orth(grad,old_gradient);
    4241                else
    43                         issmprintf(verbose,'%s\n',['      normalizing direction...']);
     42                        issmprintf(VerboseControl,'%s',['   normalizing direction']);
    4443                        new_gradient=Orth(grad,[]);
    4544                end

  • issm/trunk/src/m/solutions/issm.m

    r6321 r6323  
    77        %timing
    88        t1=clock;
     9        disp('launching solution sequence');
    910
    1011        %out of solution_type, figure out solution core function pointer, and types of analyses needed:
    1112        [analyses,numanalyses,solutioncore]=SolutionConfiguration(solution_type);
    1213
    13         disp('create finite element model');
     14        %create finite element model
    1415        femmodel=NewFemModel(md,solution_type,analyses,numanalyses);
    1516
    1617        %retrieve parameters
    17         verbose=femmodel.parameters.Verbose;
    1818        qmu_analysis=femmodel.parameters.QmuAnalysis;
    1919        control_analysis=femmodel.parameters.ControlAnalysis;
    … …  
    2525        if ~qmu_analysis,
    2626                       
    27                 issmprintf(verbose,'%s',['call computational core']);
     27                issmprintf(VerboseSolution,'%s',['call computational core']);
    2828                eval(['femmodel=' solutioncore '(femmodel);']);
    2929
    30                 issmprintf(verbose,'%s',['write results'])
     30                issmprintf(VerboseSolution,'%s',['write results'])
    3131                md.results.(EnumToString(solution_type))=OutputResults(femmodel.elements, femmodel.nodes , femmodel.vertices , femmodel.loads , femmodel.materials, femmodel.parameters, femmodel.results);
    3232        else

  • issm/trunk/src/m/solutions/prognostic_core.m

    r6321 r6323  
    66
    77        %recover parameters common to all solutions
    8         verbose=femmodel.parameters.Verbose;
    98        control_analysis=femmodel.parameters.ControlAnalysis;
    109        solution_type=femmodel.parameters.SolutionType;
    … …  
    1312        femmodel=SetCurrentConfiguration(femmodel,PrognosticAnalysisEnum);
    1413
    15         issmprintf(verbose,'\n%s',['call computational core...']);
     14        issmprintf(VerboseSolution,'\n%s',['   call computational core']);
    1615        femmodel=solver_linear(femmodel);
    1716       
    1817        if (solution_type==PrognosticSolutionEnum & ~control_analysis)
    19                 issmprintf(verbose,'\n%s',['saving results...']);
     18                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    2019                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,ThicknessEnum);
    2120        end

  • issm/trunk/src/m/solutions/steadystate_core.m

    r6321 r6323  
    77
    88        %recover parameters common to all solutions
    9         verbose=femmodel.parameters.Verbose;
    109        dim=femmodel.parameters.Dim;
    1110        control_analysis=femmodel.parameters.ControlAnalysis;
    … …  
    1716        while true,
    1817
    19                 issmprintf(verbose,'\n%s%i\n','computing velocities and temperatures for step: ',step);
     18                issmprintf(VerboseSolution,'\n%s%i\n','   computing velocities and temperatures for step: ',step);
    2019                femmodel=thermal_core(femmodel);
    2120
    22                 issmprintf(verbose,'\n%s',['computing new velocity...']);
     21                issmprintf(VerboseSolution,'\n%s',['   computing new velocity']);
    2322                femmodel=diagnostic_core(femmodel);
    2423
    2524                if step>1,
    26                         issmprintf(verbose,'\n%s',['checking temperature, velocity and pressure convergence...']);
     25                        issmprintf(VerboseSolution,'\n%s',['   checking temperature, velocity and pressure convergence']);
    2726                        if steadystateconvergence(femmodel), break; end
    2827                end
    2928
    30                 issmprintf(verbose,'\n%s',['saving velocities, temperature and pressure for convergence...']);
     29                issmprintf(VerboseSolution,'\n%s',['   saving velocities, temperature and pressure for convergence']);
    3130                femmodel.elements=InputDuplicate(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VxEnum,VxOldEnum);
    3231                femmodel.elements=InputDuplicate(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VyEnum,VyOldEnum);
    … …  
    4039
    4140        if (solution_type==SteadystateSolutionEnum & ~control_analysis),
    42                 issmprintf(verbose,'\n%s',['saving results...']);
     41                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    4342                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VxEnum);
    4443                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VyEnum);

  • issm/trunk/src/m/solutions/surfaceslope_core.m

    r6321 r6323  
    77
    88        %Recover some parameters:
    9         verbose=femmodel.parameters.Verbose;
    109        dim=femmodel.parameters.Dim;
    1110        control_analysis=femmodel.parameters.ControlAnalysis;
    1211        solution_type=femmodel.parameters.SolutionType;
    1312
    14         issmprintf(verbose,'\n%s',['computing surface slope...']);
    15 
    1613        %Call on core computations:
     14        issmprintf(VerboseSolution,'\n%s',['   computing surface slope']);
    1715        femmodel=SetCurrentConfiguration(femmodel,SurfaceSlopeAnalysisEnum,SurfaceSlopeXAnalysisEnum);
    1816        femmodel=solver_linear(femmodel);
    … …  
    2119       
    2220        if (solution_type==SurfaceSlopeSolutionEnum),
    23                 issmprintf(verbose,'\n%s',['saving results...']);
     21                issmprintf(VerboseSolution,'\n%s',['   saving results']);
    2422                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,SurfaceSlopeXEnum);
    2523                femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,SurfaceSlopeYEnum);

  • issm/trunk/src/m/solutions/thermal_core.m

    r6321 r6323  
    77
    88        %recover parameters common to all solutions
    9         verbose=femmodel.parameters.Verbose;
    109        ndt=femmodel.parameters.Ndt;
    1110        dt=femmodel.parameters.Dt;
    … …  
    2322        %Loop through time
    2423        for i=1:nsteps,
    25                 issmprintf(verbose,'\n%s%i/%i\n','time step: ',i,nsteps);
     24                issmprintf(VerboseSolution,'\n%s%i/%i\n','time step: ',i,nsteps);
    2625                time=(i+1)*dt;
    2726
    28                 issmprintf(verbose,'\n%s',['computing temperature...']);
     27                issmprintf(VerboseSolution,'\n%s',['   computing temperature']);
    2928                femmodel=thermal_core_step(femmodel,i,time);
    3029
    3130                if (solution_type==ThermalSolutionEnum & ~control_analysis),
    32                         issmprintf(verbose,'\n%s',['saving results...']);
     31                        issmprintf(VerboseSolution,'\n%s',['   saving results']);
    3332                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,TemperatureEnum,i,time);
    3433                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,MeltingRateEnum,i,time);

  • issm/trunk/src/m/solutions/thermal_core_step.m

    r6321 r6323  
    55%      femmodel=thermal_core_step(femmodel,step,time)
    66
    7         %recover parameters common to all solutions
    8         verbose=femmodel.parameters.Verbose;
    9 
    10         issmprintf(verbose,'\n%s',['computing temperature...']);
     7        issmprintf(VerboseSolution,'\n%s',['   computing temperature']);
    118        femmodel=SetCurrentConfiguration(femmodel,ThermalAnalysisEnum);
    129        femmodel=solver_thermal_nonlinear(femmodel);
    1310
    14         issmprintf(verbose,'\n%s',['compute melting...']);
     11        issmprintf(VerboseSolution,'\n%s',['   computing melting']);
    1512        femmodel=SetCurrentConfiguration(femmodel,MeltingAnalysisEnum);
    1613        femmodel=solver_linear(femmodel);

  • issm/trunk/src/m/solutions/transient2d_core.m

    r6321 r6323  
    66
    77        %recover parameters common to all solutions
    8         verbose=femmodel.parameters.Verbose;
    98        ndt=femmodel.parameters.Ndt;
    109        dt=femmodel.parameters.Dt;
    … …  
    2726                time=time+dt;
    2827
    29                 issmprintf(verbose,'\n%s%g%s%i%s%g\n','time [yr]: ',time,' iteration number: ',step,'/',floor(ndt/dt));
     28                issmprintf(VerboseSolution,'\n%s%g%s%i%s%g\n','time [yr]: ',time,' iteration number: ',step,'/',floor(ndt/dt));
    3029
    31                 issmprintf(verbose,'\n%s',['computing new velocities...']);
     30                issmprintf(VerboseSolution,'\n%s',['   computing new velocities']);
    3231                femmodel=diagnostic_core(femmodel);
    3332
    34                 issmprintf(verbose,'\n%s',['computing new thickness...']);
     33                issmprintf(VerboseSolution,'\n%s',['   computing new thickness']);
    3534                femmodel=prognostic_core(femmodel);
    3635
    37                 issmprintf(verbose,'\n%s',['updating geometry...']);
     36                issmprintf(VerboseSolution,'\n%s',['   updating geometry']);
    3837                [femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters]=UpdateGeometry(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    3938
    4039                if (solution_type==Transient2DSolutionEnum & ~control_analysis & mod(step,output_frequency)==0),
    41                         issmprintf(verbose,'\n%s',['saving results...']);
     40                        issmprintf(VerboseSolution,'\n%s',['   saving results']);
    4241                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VxEnum,step,time);
    4342                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VyEnum,step,time);

  • issm/trunk/src/m/solutions/transient3d_core.m

    r6321 r6323  
    66
    77        %recover parameters common to all solutions
    8         verbose=femmodel.parameters.Verbose;
    98        ndt=femmodel.parameters.Ndt;
    109        dt=femmodel.parameters.Dt;
    … …  
    2726                time=time+dt;
    2827
    29                 issmprintf(verbose,'\n%s%g%s%i%s%g\n','time [yr] ',time,' iteration number: ',step,'/',floor(ndt/dt));
     28                issmprintf(VerboseSolution,'\n%s%g%s%i%s%g\n','time [yr] ',time,' iteration number: ',step,'/',floor(ndt/dt));
    3029
    31                 issmprintf(verbose,'\n%s',['computing temperature...']);
     30                issmprintf(VerboseSolution,'\n%s',['   computing temperature']);
    3231                femmodel=thermal_core_step(femmodel);
    3332
    34                 issmprintf(verbose,'\n%s',['computing new velocities...']);
     33                issmprintf(VerboseSolution,'\n%s',['   computing new velocities']);
    3534                femmodel=diagnostic_core(femmodel);
    3635
    37                 issmprintf(verbose,'\n%s',['computing new thickness...']);
     36                issmprintf(VerboseSolution,'\n%s',['   computing new thickness']);
    3837                femmodel=prognostic_core(femmodel);
    3938
    40                 issmprintf(verbose,'\n%s',['updating geometry...']);
     39                issmprintf(VerboseSolution,'\n%s',['   updating geometry']);
    4140                [femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters]=UpdateGeometry(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    4241
    43                 issmprintf(verbose,'\n%s',['updating vertices position...']);
     42                issmprintf(VerboseSolution,'\n%s',['   updating vertices position']);
    4443                [femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters]=UpdateVertexPositions(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    4544
    4645                if (solution_type==Transient3DSolutionEnum & ~control_analysis & mod(step,output_frequency)==0),
    47                         issmprintf(verbose,'\n%s',['saving results...']);
     46                        issmprintf(VerboseSolution,'\n%s',['   saving results']);
    4847                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VxEnum,step,time);
    4948                        femmodel.elements=InputToResult(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,VyEnum,step,time);

  • issm/trunk/src/m/solvers/solver_adjoint_linear.m

    r6321 r6323  
    1717        end
    1818
    19         issmprintf(femmodel.parameters.Verbose>1,'%s%g','      condition number of stiffness matrix: ',condest(K_ff));
     19        issmprintf(VerboseSolver(),'%s%g','      condition number of stiffness matrix: ',condest(K_ff));
    2020        u_f=Solver(K_ff,p_f,[],femmodel.parameters);
    2121        u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodesets,femmodel.parameters,true);

  • issm/trunk/src/m/solvers/solver_diagnostic_nonlinear.m

    r6321 r6323  
    4343                [loads,constraints_converged,num_unstable_constraints] =PenaltyConstraints( femmodel.elements,femmodel.nodes,femmodel.vertices,loads, femmodel.materials,femmodel.parameters);
    4444
    45                 issmprintf(femmodel.parameters.Verbose,'%s%i','      number of unstable constraints: ',num_unstable_constraints);
     45                issmprintf(VerboseConvergence(),'%s%i','      number of unstable constraints: ',num_unstable_constraints);
    4646
    4747                %Figure out if convergence have been reached
    … …  
    6666                if(converged==1)break;
    6767                        if(count>max_nonlinear_iterations),
    68                                 issmprintf(femmodel.parameters.Verbose,'%s%i%s','      maximum number of iterations ',max_nonlinear_iterations,' exceeded');
     68                                issmprintf(true,'%s%i%s','      maximum number of iterations ',max_nonlinear_iterations,' exceeded');
    6969                        end
    7070                end

  • issm/trunk/src/m/solvers/solver_linear.m

    r6321 r6323  
    1717        end
    1818
    19         issmprintf(femmodel.parameters.Verbose>1,'%s%g','      condition number of stiffness matrix: ',condest(K_ff));
     19        issmprintf(VerboseSolver()>1,'%s%g','      condition number of stiffness matrix: ',condest(K_ff));
    2020        u_f=Solver(K_ff,p_f,[],femmodel.parameters);
    2121        u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodesets,femmodel.parameters);

  • issm/trunk/src/m/solvers/solver_thermal_nonlinear.m

    r6321 r6323  
    1515        femmodel.parameters.Kflag=1; femmodel.parameters.Pflag=1;
    1616
    17         issmprintf(femmodel.parameters.Verbose,'\n%s',['   starting direct shooting method']);
     17        issmprintf(VerboseConvergence(),'\n%s',['   starting direct shooting method']);
    1818
    1919        %Reset penalties and initialize convergence as false
    … …  
    3232                end
    3333
    34                 issmprintf(femmodel.parameters.Verbose,'%s%g','   condition number of stiffness matrix: ',condest(K_ff));
     34                issmprintf(VerboseSolver(),'%s%g','   condition number of stiffness matrix: ',condest(K_ff));
    3535                t_f=Solver(K_ff,p_f,[],femmodel.parameters);
    3636                t_g= Mergesolutionfromftog( t_f, femmodel.ys, femmodel.nodesets,femmodel.parameters);
    … …  
    4040       
    4141                if ~converged,
    42                         issmprintf(femmodel.parameters.Verbose,'%s%i','   #unstable constraints ',num_unstable_constraints);
     42                        issmprintf(VerboseConvergence(),'%s%i','   #unstable constraints ',num_unstable_constraints);
    4343                        if num_unstable_constraints<=femmodel.parameters.MinThermalConstraints,
    4444                                converged=1;
Note: See TracChangeset for help on using the changeset viewer.