Changeset 697


Ignore:
Timestamp:
06/02/09 10:42:47 (15 years ago)
Author:
Mathieu Morlighem
Message:

improved some displays

Location:
issm/trunk/src/m/classes/public
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/m/classes/public/displaybc.m

    r1 r697  
    99%      displaybc(md)
    1010
    11 disp(sprintf('   Boundary conditions:'));
    12 disp(sprintf('      diagnostic:'));
    13 disp(sprintf('         gridondirichlet_diag: (%i)',length(md.gridondirichlet_diag)));
    14 disp(sprintf('         dirichletvalues_diag [m/a]: (%i,%i)',length(md.dirichletvalues_diag),2));
    15 disp(sprintf('         segmentonneumann_diag: (%i)',length(md.segmentonneumann_diag)));
    16 disp(sprintf('         neumannvalues_diag [N]: (%i)',length(md.neumannvalues_diag)));
     11fprintf('   Boundary conditions:\n');
    1712
    18 disp(sprintf('      prognostic:'));
    19 disp(sprintf('         gridondirichlet_prog: (%i)',length(md.gridondirichlet_prog)));
    20 disp(sprintf('         dirichletvalues_prog [m/a]: (%i)',length(md.dirichletvalues_prog)));
    21 disp(sprintf('         segmentonneumann_prog (flux): (%i)',length(md.segmentonneumann_prog)));
    22 disp(sprintf('         neumannvalues_prog [N]: (%i)',length(md.neumannvalues_prog)));
    23 disp(sprintf('         segmentonneumann_prog2 (thickness gradient): (%i)',length(md.segmentonneumann_prog2)));
    24 disp(sprintf('         neumannvalues_prog2 [N]: (%i)',length(md.neumannvalues_prog2)));
     13fprintf('\n      geography:\n');
     14fprintf('         gridonboundary: (%i)\n',length(md.gridonboundary));
     15fprintf('         elementoniceshelf: (%i)\n',length(md.elementoniceshelf));
     16fprintf('         gridoniceshelf: (%i)\n',length(md.gridoniceshelf));
     17fprintf('         elementonicesheet: (%i)\n',length(md.elementonicesheet));
     18fprintf('         gridonicesheet: (%i)\n',length(md.gridonicesheet));
    2519
    26 disp(sprintf('      thermal:'));
    27 disp(sprintf('         gridondirichlet_thermal: (%i)',length(md.gridondirichlet_thermal)));
    28 disp(sprintf('         dirichletvalues_thermal [K]: (%i)',length(md.dirichletvalues_thermal)));
    29 disp(sprintf('         melting [m/a]: (%i)',length(md.melting)));
     20fprintf('\n      diagnostic:\n');
     21fprintf('         gridondirichlet_diag: (%i)\n',length(md.gridondirichlet_diag));
     22fprintf('         dirichletvalues_diag [m/a]: (%i,%i)\n',length(md.dirichletvalues_diag),2);
     23fprintf('         segmentonneumann_diag: (%i)\n',length(md.segmentonneumann_diag));
     24fprintf('         neumannvalues_diag [N]: (%i)\n',length(md.neumannvalues_diag));
     25
     26fprintf('\n      prognostic:\n');
     27fprintf('         gridondirichlet_prog: (%i)\n',length(md.gridondirichlet_prog));
     28fprintf('         dirichletvalues_prog [m/a]: (%i)\n',length(md.dirichletvalues_prog));
     29fprintf('         segmentonneumann_prog (flux): (%i)\n',length(md.segmentonneumann_prog));
     30fprintf('         neumannvalues_prog [N]: (%i)\n',length(md.neumannvalues_prog));
     31fprintf('         segmentonneumann_prog2 (thickness gradient): (%i)\n',length(md.segmentonneumann_prog2));
     32fprintf('         neumannvalues_prog2 [N]: (%i)\n',length(md.neumannvalues_prog2));
     33
     34fprintf('\n      thermal:\n');
     35fprintf('         gridondirichlet_thermal: (%i)\n',length(md.gridondirichlet_thermal));
     36fprintf('         dirichletvalues_thermal [K]: (%i)\n',length(md.dirichletvalues_thermal));
     37fprintf('         melting [m/a]: (%i)\n',length(md.melting));

  • issm/trunk/src/m/classes/public/displaymaterials.m

    r1 r697  
    99%      displaymaterials(md)
    1010
    11 disp(sprintf('   Materials:'));
    12 disp(sprintf('      rho_ice: %g [kg/m^3]',md.rho_ice));
    13 disp(sprintf('      rho_water: %g [kg/m^3]',md.rho_water));
    14 if isempty(md.B), disp(sprintf('      B: N/A (flow law parameter)')); else disp(sprintf('      B: (%i) (flow law parameter [Pa/s^(1/n)])',length(md.B))); end
    15 if isempty(md.n), disp(sprintf('      n: N/A (flow law coefficient)')); else disp(sprintf('      n: (%i) (flow law coefficient)',length(md.n))); end
    16 disp(sprintf('      heatcapacity: %g [J/kg/K]',md.heatcapacity));
    17 disp(sprintf('      thermalconductivity: %g [W/m/K]',md.thermalconductivity));
    18 disp(sprintf('      meltingpoint: %g [K] (melting point of ice at 1atm in K)',md.meltingpoint));
    19 disp(sprintf('      latentheat: %g [J/kg] (latent heat of fusion)',md.latentheat));
    20 disp(sprintf('      beta: %g [K/Pa]',md.beta));
    21 disp(sprintf('      mixed_layer_capacity: %g [W/kg/K]',md.mixed_layer_capacity));
    22 disp(sprintf('      thermal_exchange_velocity: %g [m/s]',md.thermal_exchange_velocity));
     11fprintf('   Materials:\n');
     12fprintf('      rho_ice: %g [kg/m^3]\n',md.rho_ice);
     13fprintf('      rho_water: %g [kg/m^3]\n',md.rho_water);
     14if isempty(md.B), fprintf('      B: N/A (flow law parameter)'); else fprintf('      B: (%i) (flow law parameter [Pa/s^(1/n)])\n',length(md.B)); end
     15if isempty(md.n), fprintf('      n: N/A (flow law coefficient)'); else fprintf('      n: (%i) (flow law coefficient)\n',length(md.n)); end
     16fprintf('      heatcapacity: %g [J/kg/K]\n',md.heatcapacity);
     17fprintf('      thermalconductivity: %g [W/m/K]\n',md.thermalconductivity);
     18fprintf('      meltingpoint: %g [K] (melting point of ice at 1atm in K)\n',md.meltingpoint);
     19fprintf('      latentheat: %g [J/kg] (latent heat of fusion)\n',md.latentheat);
     20fprintf('      beta: %g [K/Pa]\n',md.beta);
     21fprintf('      mixed_layer_capacity: %g [W/kg/K]\n',md.mixed_layer_capacity);
     22fprintf('      thermal_exchange_velocity: %g [m/s]\n',md.thermal_exchange_velocity);

  • issm/trunk/src/m/classes/public/displaymesh.m

    r1 r697  
    99%      displaymesh(md)
    1010
    11 disp(sprintf('   Mesh:'));
    12 disp(sprintf('      type: %s',md.type));
     11fprintf('   Mesh:\n');
    1312
    14 if strcmpi(md.type,'2d'),
    15         disp(sprintf('      numberofelements: %i',md.numberofelements));
    16         disp(sprintf('      numberofgrids: %i',md.numberofgrids));
    17         if ~isnan(md.dof),
    18                 disp(sprintf('      number of dofs: %i',md.dof));
    19         end
    20         disp(sprintf('      elements: (%i-%i) (index into (x,y,z), coordinates of the grids)',md.numberofelements,size(md.elements,2)));
    21         disp(sprintf('      elements_type: (%i) (type of elements, according to number of grids per element)',md.numberofelements));
    22         disp(sprintf('      x: (%i) (grid x coordinates)',md.numberofgrids));
    23         disp(sprintf('      y: (%i) (grid y coordinates)',md.numberofgrids));
    24         disp(sprintf('      z: (%i) (grid z coordinates)',md.numberofgrids));
    25 elseif strcmpi(md.type,'3d'),
     13if strcmpi(md.type,'3d'),
    2614
    27         disp(sprintf('      Original 2d mesh:'));
    28         disp(sprintf('         numberofelements2d: %i',md.numberofelements2d));
    29         disp(sprintf('         numberofgrids2d: %i',md.numberofgrids2d));
    30         disp(sprintf('         elements2d: (%i-%i) (index into (x,y,z), coordinates of the grids)',md.numberofelements2d,size(md.elements2d,2)));
    31         disp(sprintf('         elements_type2d: (%i) (element types, according to number of grids)',md.numberofelements2d));
    32         disp(sprintf('         x2d: (%i) (grid x coordinates)',md.numberofgrids2d));
    33         disp(sprintf('         y2d: (%i) (grid y coordinates)',md.numberofgrids2d));
    34         disp(sprintf('         z2d: (%i) (grid z coordinates)',md.numberofgrids2d));
     15        fprintf('\n      Elements and nodes of the original 2d mesh:\n');
     16        fprintf('         numberofelements2d: %i (number of elements)\n',md.numberofelements2d);
     17        fprintf('         numberofgrids2d: %i (number of nodes)\n',md.numberofgrids2d);
     18        fprintf('         elements2d: (%i-%i) (index into (x,y,z), coordinates of the grids)\n',md.numberofelements2d,size(md.elements2d,2));
     19        fprintf('         elements_type2d: (%i) (element types, according to number of grids)\n',md.numberofelements2d);
     20        fprintf('         x2d: (%i) (node x coordinates)\n',length(md.x2d));
     21        fprintf('         y2d: (%i) (node y coordinates)\n',length(md.y2d));
     22        fprintf('         z2d: (%i) (node z coordinates)\n',length(md.z2d));
    3523
    36         disp(sprintf('      Extruded 3d mesh: '));
    37         disp(sprintf('         numberofelements: %i',md.numberofelements));
    38         disp(sprintf('         numberofgrids: %i',md.numberofgrids));
    39         if ~isnan(md.dof),
    40                 disp(sprintf('      number of dofs: %i',md.dof));
    41         end
    42         disp(sprintf('         elements: (%i-%i) (index into (x,y,z), coordinates of the grids)',md.numberofelements,size(md.elements,2)));
    43         disp(sprintf('         elements_type: (%i) (element types, according to number of grids)',md.numberofelements));
    44         disp(sprintf('         x: (%i) (grid x coordinates)',md.numberofgrids));
    45         disp(sprintf('         y: (%i) (grid y coordinates)',md.numberofgrids));
    46         disp(sprintf('         z: (%i) (grid z coordinates)',md.numberofgrids));
    47         disp(sprintf('         numlayers: (%i) (number of extrusion layers)',md.numlayers));
    48         disp(sprintf('         gridoncollapsed: (%i)',md.numberofgrids));
    49         disp(sprintf('         gridonnoncollapsed: (%i)',md.numberofgrids));
    50        
    51         disp(sprintf('      Penalties: (%i-%i) (penalties applied to connect 2d and 3d parts of 2d-3d mesh)',size(md.penalties,1),size(md.penalties,2)));
     24        fprintf('\n      Elements and nodes of the extruded 3d mesh:\n');
    5225else
    53         error('only ''2d'' and ''3d'' are allowed for model type');
     26
     27        fprintf('\n      Elements and nodes:\n');
    5428end
    5529
     30fprintf('         numberofelements: %i (number of elements)\n',md.numberofelements);
     31fprintf('         numberofgrids: %i (number of nodes)\n',md.numberofgrids);
     32if ~isnan(md.dof), fprintf('      dof: %i (maximum number of dofs solved)\n',md.dof); end
     33fprintf('         elements: (%i-%i) (index into (x,y,z), coordinates of the grids)\n',md.numberofelements,size(md.elements,2));
     34fprintf('         elements_type: (%i) (element types, according to number of grids)\n',md.numberofelements);
     35fprintf('         x: (%i) (node x coordinates)\n',length(md.x));
     36fprintf('         y: (%i) (node y coordinates)\n',length(md.y));
     37fprintf('         z: (%i) (node z coordinates)\n',length(md.z));
     38fprintf('         numlayers: %i (number of extrusion layers)\n',md.numlayers);
    5639
     40fprintf('\n      Properties:\n');
     41fprintf('         type: %s\n',md.type);
     42fprintf('         Penalties: (%i-%i))\n',size(md.penalties,1),size(md.penalties,2));
     43fprintf('         gridonbed: (%i) (lower nodes flags list)\n',length(md.gridonbed));
     44fprintf('         gridonsurface: (%i) (upper nodes flags list)\n',length(md.gridonsurface));
     45fprintf('         elementonbed: (%i) (lower elements flags list)\n',length(md.elementonbed));
     46fprintf('         elementonsurface: (%i) (upper elements flags list)\n',length(md.elementonsurface));

  • issm/trunk/src/m/classes/public/displayobservations.m

    r1 r697  
    99%      displayobservations(md)
    1010
    11 disp(sprintf('   Observations:'));
    12 disp(sprintf('      vx_obs [m/a]: (%i)',length(md.vx_obs)));
    13 disp(sprintf('      vy_obs [m/a]: (%i)',length(md.vy_obs)));
    14 disp(sprintf('      vel_obs [m/a]: (%i)',length(md.vel_obs)));
    15 disp(sprintf('      accumulation [m/a]: (%i)',length(md.accumulation)));
    16 disp(sprintf('      observed_temperature [K]: (%i)',length(md.observed_temperature)));
    17 disp(sprintf('      geothermalflux [W/m^2]: (%i)',length(md.geothermalflux)));
     11fprintf('   Observations:\n');
     12fprintf('      vx_obs [m/a]: (%i)\n',length(md.vx_obs));
     13fprintf('      vy_obs [m/a]: (%i)\n',length(md.vy_obs));
     14fprintf('      vel_obs [m/a]: (%i)\n',length(md.vel_obs));
     15fprintf('      accumulation [m/a]: (%i)\n',length(md.accumulation));
     16fprintf('      observed_temperature [K]: (%i)\n',length(md.observed_temperature));
     17fprintf('      geothermalflux [W/m^2]: (%i)\n',length(md.geothermalflux));

  • issm/trunk/src/m/classes/public/displayparallel.m

    r1 r697  
    99%      displayparallel(md)
    1010
    11 disp(sprintf('      ''%s''','parallelisation'));
    12 disp(sprintf('         cluster: %s      (set to ''cluster_name'' to run in cluster, ''none'' to run serially)',md.cluster));
    13 disp(sprintf('         np: %i      (number of CPUS requested on cluster)',md.np));
    14 disp(sprintf('         exclusive: %i      (set to 1 if CPUS used are not to be shared with other users, 0 otherwise)',md.exclusive));
    15 disp(sprintf('         time: %i      (amount of time requested on cluster)',md.time));
    16 disp(sprintf('         alloc_cleanup: %i      (allocation cleanup before starting a job, default 1)',md.alloc_cleanup));
    17 disp(sprintf('         waitonlock: %i      (wait for batch results 1, or return 0. default is to return )',md.waitonlock));
    18 disp(sprintf('         queue: %s      (special queue name on cluster? default is '''')',md.queue));
    19 disp(sprintf('      ''%s''','solver options'));
    20 disp(sprintf('         %s','''ice'''));
    21 disp(sprintf('            solver_type: %s      (solver type for Ice: ''lu'' or ''cholesky'')',md.solver_type));
    22 disp(sprintf('         %s','''cielo'''));
    23 disp(sprintf('            solverstring: %s (solver string for Petsc. See solversetto... routines. Default is asm)',md.solverstring));
     11fprintf('\n      parallelisation:\n');
     12fprintf('         cluster: %s      (set to ''cluster_name'' to run in cluster, ''none'' to run serially)\n',md.cluster);
     13fprintf('         np: %i      (number of CPUS requested on cluster)\n',md.np);
     14fprintf('         exclusive: %i      (set to 1 if CPUS used are not to be shared with other users, 0 otherwise)\n',md.exclusive);
     15fprintf('         time: %i      (amount of time requested on cluster)\n',md.time);
     16fprintf('         alloc_cleanup: %i      (allocation cleanup before starting a job, default 1)\n',md.alloc_cleanup);
     17fprintf('         waitonlock: %i      (wait for batch results 1, or return 0. default is to return )\n',md.waitonlock);
     18fprintf('         queue: %s      (special queue name on cluster? default is '''')\n',md.queue);fprintf('\n      solver options:\n');
     19
     20fprintf('\n      solver options:\n');
     21fprintf('         ice\n');
     22fprintf('            solver_type: %s  (solver type for Ice: ''lu'' or ''cholesky'')\n',md.solver_type);
     23fprintf('         cielo\n');
     24fprintf('            solverstring: %s \n            (solver string for Petsc. See solversetto... routines. Default is asm)\n',md.solverstring);

  • issm/trunk/src/m/classes/public/displayparameters.m

    r1 r697  
    99%      displayparameters(md)
    1010
    11 disp(sprintf('   Parameters:'));
    12 if isempty(md.surface), disp(sprintf('      surface: N/A')); else disp(sprintf('      surface [m]: (%i)',length(md.surface))); end
    13 if isempty(md.thickness), disp(sprintf('      thickness: N/A')); else disp(sprintf('      thickness [m]: (%i)',length(md.thickness))); end
    14 if isempty(md.new_thickness), disp(sprintf('      new_thickness: N/A')); else disp(sprintf('      new_thickness [m]: (%i)',length(md.new_thickness))); end
    15 if isempty(md.bed), disp(sprintf('      bed: N/A')); else disp(sprintf('      bed [m]: (%i)',length(md.bed))); end
    16 if isempty(md.firn_layer), disp(sprintf('      firn_layer: N/A')); else disp(sprintf('      firn_layer [m]: (%i)',length(md.firn_layer))); end
    17 disp(sprintf('      gridonboundary: (%i)',length(md.gridonboundary)));
    18 disp(sprintf('      elementoniceshelf: (%i)',length(md.elementoniceshelf)));
    19 disp(sprintf('      gridoniceshelf: (%i)',length(md.gridoniceshelf)));
    20 disp(sprintf('      elementonicesheet: (%i)',length(md.elementonicesheet)));
    21 disp(sprintf('      gridonicesheet: (%i)',length(md.gridonicesheet)));
    22 if strcmpi(md.type,'3d'), disp(sprintf('      elementonbed: (%i)',length(md.elementonbed))); end
    23 if strcmpi(md.type,'3d'), disp(sprintf('      elementonsurface: (%i)',length(md.elementonsurface))); end
    24 if strcmpi(md.type,'3d'), disp(sprintf('      gridonbed: (%i)',length(md.gridonbed))); end
    25 if strcmpi(md.type,'3d'), disp(sprintf('      gridonsurface: (%i)',length(md.gridonsurface))); end
    26 disp(sprintf('      g: %g [m/s^2]',md.g));
    27 disp(sprintf('      ''Friction parameters (Sigma= drag^2 * Neff ^r * u ^s, with Neff=rho_ice*g*thickness+rho_ice*g*bed, r=q/p and s=1/p)'''));
    28 if isempty(md.drag), disp(sprintf('         drag: N/A')); else disp(sprintf('         drag: (%i)',length(md.drag))); end
    29 disp(sprintf('         drag_type: %i (0: none, 1:plastic, 2:viscous):',md.drag_type));
    30 if isempty(md.p), disp(sprintf('         p: N/A')); else disp(sprintf('         p: (%i)',length(md.p))); end
    31 if isempty(md.q), disp(sprintf('         q: N/A')); else disp(sprintf('         q: (%i)',length(md.q))); end
     11fprintf('   Parameters:\n');
     12
     13fprintf('\n      geometry:\n');
     14if isempty(md.surface), fprintf('         surface: N/A'); else fprintf('         surface [m]: (%i)\n',length(md.surface)); end
     15if isempty(md.thickness), fprintf('         thickness: N/A'); else fprintf('         thickness [m]: (%i)\n',length(md.thickness)); end
     16if isempty(md.bed), fprintf('         bed: N/A'); else fprintf('         bed [m]: (%i)\n',length(md.bed)); end
     17if isempty(md.firn_layer), fprintf('         firn_layer: N/A'); else fprintf('         firn_layer [m]: (%i)\n',length(md.firn_layer)); end
     18if strcmpi(md.type,'3d'), fprintf('         elementonbed: (%i)\n',length(md.elementonbed)); end
     19if strcmpi(md.type,'3d'), fprintf('         elementonsurface: (%i)\n',length(md.elementonsurface)); end
     20if strcmpi(md.type,'3d'), fprintf('         gridonbed: (%i)\n',length(md.gridonbed)); end
     21if strcmpi(md.type,'3d'), fprintf('         gridonsurface: (%i)\n',length(md.gridonsurface)); end
     22
     23fprintf('\n      physical parameters:\n');
     24fprintf('         g: %g [m/s^2]\n',md.g);
     25
     26fprintf('\n      Friction parameters (Sigma= drag^2 * Neff ^r * u ^s, with Neff=rho_ice*g*thickness+rho_ice*g*bed, r=q/p and s=1/p)\n');
     27fprintf('         drag_type: %i (0: none, 1:plastic, 2:viscous):\n',md.drag_type);
     28if isempty(md.drag), fprintf('         drag: N/A'); else fprintf('         drag: (%i)\n',length(md.drag)); end
     29fprintf('         drag_type: %i (0: none, 1:plastic, 2:viscous):\n',md.drag_type);
     30if isempty(md.p), fprintf('         p: N/A'); else fprintf('         p: (%i)\n',length(md.p)); end
     31if isempty(md.q), fprintf('         q: N/A'); else fprintf('         q: (%i)\n',length(md.q)); end

  • issm/trunk/src/m/classes/public/displaysolutionparameters.m

    r45 r697  
    99%      displaysolutionparameters(md)
    1010
    11 disp(sprintf('   Solution parameters:'));
    12 disp(sprintf('      ''%s''','statics'));
    13 disp(sprintf('         %s','Newton convergence criteria'));
    14 disp(sprintf('            eps_rel: %g      (velocity relative convergence criterion)',md.eps_rel));
    15 disp(sprintf('            eps_abs: %g      (velocity absolute convergence criterion [m/yr], NaN -> no absolute criterion)',md.eps_abs));
    16 disp(sprintf('            viscosity_overshoot: %g      (over-shooting constant new=new+C*(new-old))',md.viscosity_overshoot));
    17 disp(sprintf('         penalty_offset: %g      (offset used by penalties: penalty = Kmax*10^offset)',md.penalty_offset));
    18 disp(sprintf('         penalty_melting: %g      (penalty used to keep T<Tpmp)',md.penalty_melting));
    19 disp(sprintf('         penalty_lock: %g      (counter used to lock penalties that zig zag)',md.penalty_lock));
    20 disp(sprintf('         lowmem: %i      (Set to 1 if you are running low on cluster memory)',md.lowmem));
    21 disp(sprintf('         sparsity: %g      (matrix sparsity. Set to .001 for < 1M dof, .0001 for 5M dof, and .00001 for > 10M dof',md.sparsity));
    22 disp(sprintf('         connectivity: %i      (element connectivity)',md.connectivity));
    23 disp(sprintf('         debug: %i      (output debug statements when possible yes-> 1, no -> 0. Default is 1',md.debug));
    24 disp(sprintf('         element_debug: %i      (output debug statements for elementswhen possible yes-> 1, no -> 0. Default is 0',md.element_debug));
    25 disp(sprintf('         element_debugid: %i      (if element_debug on, id of element for which to output messages',md.element_debugid));
    26 disp(sprintf('         debug: %i      (output debug statements when possible yes-> 1, no -> 0. Default is 1'));
    27 disp(sprintf('      ''%s''','transient'));
    28 disp(sprintf('         dt: %g ( time step in years)',md.dt/md.yts));
    29 disp(sprintf('         ndt: %g ( time span in years)',md.ndt/md.yts));
    30 disp(sprintf('         artificial_diffusivity: %i (yes->1, no->0)',md.artificial_diffusivity));
    31 disp(sprintf('         minh: %g (minimum thickness to avoid stiffness singularity)',md.minh));
    32 disp(sprintf('         timestepping: %i ( adptative time stepping implemented - default to 0)',md.timestepping));
    33 disp(sprintf('         deltaH: %g ( minimum thickness difference between two time steps)',md.deltaH));
    34 disp(sprintf('         DeltaH: %g ( maximum thickness difference between two time steps)',md.DeltaH));
    35 disp(sprintf('         deltaT: %g ( minimum temperature difference between two time steps)',md.deltaT));
    36 disp(sprintf('         DeltaT: %g ( maximum temperature difference between two time steps)',md.DeltaT));
    37 disp(sprintf('         timeacc: %g ( multiplier to time step when time stepping increases time step)',md.timeacc));
    38 disp(sprintf('         timedec: %g ( multiplier to time step when time stepping decresaes time step)',md.timedec));
    39 disp(sprintf('      ''%s''','control'));
     11fprintf('   Solution parameters:\n');
     12fprintf('\n      statics:\n');
     13fprintf('         %s\n','Newton convergence criteria');
     14fprintf('            eps_rel: %g      (velocity relative convergence criterion)\n',md.eps_rel);
     15fprintf('            eps_abs: %g      (velocity absolute convergence criterion [m/yr], NaN -> no absolute criterion)\n',md.eps_abs);
     16fprintf('            viscosity_overshoot: %g      (over-shooting constant new=new+C*(new-old))\n',md.viscosity_overshoot);
     17fprintf('         penalty_offset: %g      (offset used by penalties: penalty = Kmax*10^offset)\n',md.penalty_offset);
     18fprintf('         penalty_melting: %g      (penalty used to keep T<Tpmp)\n',md.penalty_melting);
     19fprintf('         penalty_lock: %g      (counter used to lock penalties that zig zag)\n',md.penalty_lock);
     20fprintf('         lowmem: %i      (Set to 1 if you are running low on cluster memory)\n',md.lowmem);
     21fprintf('         sparsity: %g      (matrix sparsity. Set to .001 for < 1M dof, .0001 for 5M dof, and .00001 for > 10M dof\n',md.sparsity);
     22fprintf('         connectivity: %i      (element connectivity)\n',md.connectivity);
     23fprintf('         debug: %i      (output debug statements when possible yes-> 1, no -> 0. Default is 1\n',md.debug);
     24fprintf('         element_debug: %i      (output debug statements for elementswhen possible yes-> 1, no -> 0. Default is 0\n',md.element_debug);
     25fprintf('         element_debugid: %i      (if element_debug on, id of element for which to output messages\n',md.element_debugid);
     26fprintf('         debug: %i      (output debug statements when possible yes-> 1, no -> 0. Default is 1');
     27fprintf('      ''%s''\n','transient');
     28fprintf('         dt: %g ( time step in years)\n',md.dt/md.yts);
     29fprintf('         ndt: %g ( time span in years)\n',md.ndt/md.yts);
     30fprintf('         artificial_diffusivity: %i (yes->1, no->0)\n',md.artificial_diffusivity);
     31fprintf('         minh: %g (minimum thickness to avoid stiffness singularity)\n',md.minh);
     32fprintf('         timestepping: %i ( adptative time stepping implemented - default to 0)\n',md.timestepping);
     33fprintf('         deltaH: %g ( minimum thickness difference between two time steps)\n',md.deltaH);
     34fprintf('         DeltaH: %g ( maximum thickness difference between two time steps)\n',md.DeltaH);
     35fprintf('         deltaT: %g ( minimum temperature difference between two time steps)\n',md.deltaT);
     36fprintf('         DeltaT: %g ( maximum temperature difference between two time steps)\n',md.DeltaT);
     37fprintf('         timeacc: %g ( multiplier to time step when time stepping increases time step)\n',md.timeacc);
     38fprintf('         timedec: %g ( multiplier to time step when time stepping decresaes time step)\n',md.timedec);
    4039
    41 %control type
    42 disp(sprintf('         control_type: %s (control type, ex: ''drag'', or ''B'')',md.control_type));
    43 disp(sprintf('         fit: (%g)      ( 0 -> absolute, 1 -> relative, 2 -> logarithmic. default is absolute)',length(md.fit)));
    44 disp(sprintf('         meanvel: %g      (velocity scaling factor when evaluating relative or logarithmic misfit)',md.meanvel));
    45 disp(sprintf('         epsvel: %g      ( for relative fit, avoids misfit becoming infinity, for logarithmic fit, threshold for velocity)',md.epsvel));
    46 disp(sprintf('         nsteps: %i      (number of optimization searches)',md.nsteps));
    47 disp(sprintf('         optscal: (%i %i)      (scaling factor on gradient direction during optimization, for each optimization step)',size(md.optscal,1),size(md.optscal,2)));
    48 disp(sprintf('         mincontrolconstraint: %f      (minimum contraint for the controlled parameters, NaN -> no constraint)',md.mincontrolconstraint));
    49 disp(sprintf('         maxcontrolconstraint: %f      (maximum contraint for the controlled parameters, NaN -> no constraint)',md.maxcontrolconstraint));
    50 disp(sprintf('         maxiter: (%i)      (maximum iterations during each optimization step)',length(md.maxiter)));
    51 disp(sprintf('         tolx: %f      (minimum tolerance which will stop one optimization search)',md.tolx));
    52 disp(sprintf('         plot: %i      (visualization of the results of each iteration yes -> 1 no -> 0. Default is 1)\n',md.plot));
     40fprintf('\n      control:\n');
     41fprintf('         control_type: %s (control type, ex: ''drag'', or ''B'')\n',md.control_type);
     42fprintf('         fit: (%g)      ( 0 -> absolute, 1 -> relative, 2 -> logarithmic. default is absolute)\n',length(md.fit));
     43fprintf('         meanvel: %g      (velocity scaling factor when evaluating relative or logarithmic misfit)\n',md.meanvel);
     44fprintf('         epsvel: %g      ( for relative fit, avoids misfit becoming infinity, for logarithmic fit, threshold for velocity)\n',md.epsvel);
     45fprintf('         nsteps: %i      (number of optimization searches)\n',md.nsteps);
     46fprintf('         optscal: (%i %i)      (scaling factor on gradient direction during optimization, for each optimization step)\n',size(md.optscal,1),size(md.optscal,2));
     47fprintf('         mincontrolconstraint: %f      (minimum contraint for the controlled parameters, NaN -> no constraint)\n',md.mincontrolconstraint);
     48fprintf('         maxcontrolconstraint: %f      (maximum contraint for the controlled parameters, NaN -> no constraint)\n',md.maxcontrolconstraint);
     49fprintf('         maxiter: (%i)      (maximum iterations during each optimization step)\n',length(md.maxiter));
     50fprintf('         tolx: %f      (minimum tolerance which will stop one optimization search)\n',md.tolx);
     51fprintf('         plot: %i      (visualization of the results of each iteration yes -> 1 no -> 0. Default is 1)\n',md.plot);
    5352
    54 
    55 %mesh
    56 disp(sprintf('      ''%s''','mesh'));
    57 disp(sprintf('         mesh_domainoutline: %s      (domain outlines)',md.mesh_domainoutline));
    58 disp(sprintf('         mesh_riftoutline: %s      (rift outlines)',md.mesh_riftoutline));
    59 disp(sprintf('         mesh_resolution: (%g)      (mesh resolutoin)\n',md.mesh_resolution));
     53fprintf('\n      mesh:\n');
     54fprintf('         mesh_domainoutline: %s      (domain outlines)\n',md.mesh_domainoutline);
     55fprintf('         mesh_riftoutline: %s      (rift outlines)\n',md.mesh_riftoutline);
     56fprintf('         mesh_resolution: (%g)      (mesh resolutoin)\n',md.mesh_resolution);
    6057
    6158%mesh2grid type
    62 disp(sprintf('      ''%s''','mesh2grid'));
     59fprintf('\n      mesh2grid:\n');
    6360mesh2grid_string='';
    6461for i=1:length(md.mesh2grid_parameters),
    6562        parameter=md.mesh2grid_parameters{i};
    66         %check this parameter is a field from model!
    67         if ~isfield(struct(md),parameter),
    68                 error('displaysolutionparameters error message: one of the mesh2grid type parameters does not exist!');
    69         end
    7063        mesh2grid_string=[mesh2grid_string parameter ' and '];
    7164end
    7265mesh2grid_string=mesh2grid_string(1:length(mesh2grid_string)-5);
    73 disp(sprintf('         mesh2grid_parameters: %s %s',mesh2grid_string,'(list of parameters for which mesh 2 grid interpolation is carried out; ex: {''drag''}, or {''drag'',''B''})'));
    74 
     66fprintf('         mesh2grid_parameters: %s %s\n',mesh2grid_string,'(list of parameters for which mesh 2 grid interpolation is carried out; ex: {''drag''}, or {''drag'',''B''})');
    7567%mesh2grid interpolation
    7668mesh2grid_interpstring='';
    … …  
    8072end
    8173mesh2grid_interpstring=mesh2grid_interpstring(1:length(mesh2grid_interpstring)-5);
    82 disp(sprintf('         mesh2grid_interpolation: %s %s',mesh2grid_interpstring,'(list of interpolation (''node'' or ''element'') for each parameter ex: {''node''}, or {''node'',''element''})'));
     74fprintf('         mesh2grid_interpolation: %s %s\n',mesh2grid_interpstring,'(list of interpolation (''node'' or ''element'') for each parameter ex: {''node''}, or {''node'',''element''})');
    8375
    8476%mesh2grid filter
    … …  
    8981end
    9082mesh2grid_filterstring=mesh2grid_filterstring(1:length(mesh2grid_filterstring)-5);
    91 disp(sprintf('         mesh2grid_filter: %s %s',mesh2grid_filterstring,'(list of filter (''average'' or ''nearest'') for each parameter ex: {''average''}, or {''average'',''nearest''})'));
    92 
    93 
    94 disp(sprintf('         mesh2grid_cornereast: %g ( corner east of square grid)',md.mesh2grid_cornereast));
    95 disp(sprintf('         mesh2grid_cornernorth: %g ( corner north of square grid)',md.mesh2grid_cornernorth));
    96 disp(sprintf('         mesh2grid_xposting: %g (x  posting of grid (in m))',md.mesh2grid_xposting));
    97 disp(sprintf('         mesh2grid_yposting: %g (y  posting of grid (in m))',md.mesh2grid_yposting));
    98 disp(sprintf('         mesh2grid_nlines: %g ( number of grid lines)',md.mesh2grid_nlines));
    99 disp(sprintf('         mesh2grid_ncolumns: %g ( number of grid columns)',md.mesh2grid_ncolumns));
    100 disp(sprintf('         mesh2grid_windowsize: %g ( size of filter )\n',md.mesh2grid_windowsize));
     83fprintf('         mesh2grid_filter: %s %s\n',mesh2grid_filterstring,'(list of filter (''average'' or ''nearest'') for each parameter ex: {''average''}, or {''average'',''nearest''})');
     84fprintf('         mesh2grid_cornereast: %g ( corner east of square grid)\n',md.mesh2grid_cornereast);
     85fprintf('         mesh2grid_cornernorth: %g ( corner north of square grid)\n',md.mesh2grid_cornernorth);
     86fprintf('         mesh2grid_xposting: %g (x  posting of grid (in m))\n',md.mesh2grid_xposting);
     87fprintf('         mesh2grid_yposting: %g (y  posting of grid (in m))\n',md.mesh2grid_yposting);
     88fprintf('         mesh2grid_nlines: %g ( number of grid lines)\n',md.mesh2grid_nlines);
     89fprintf('         mesh2grid_ncolumns: %g ( number of grid columns)\n',md.mesh2grid_ncolumns);
     90fprintf('         mesh2grid_windowsize: %g ( size of filter )\n',md.mesh2grid_windowsize);
    10191
    10292%parallelisation
    … …  
    10797for i=1:length(md.parameteroutput),
    10898        parameter=md.parameteroutput{i};
    109         %check this parameter is a field from model!
    110         if ~isfield(struct(md),parameter),
    111                 error('displaysolutionparameters error message: one of the parameteroutput type parameters does not exist!');
    112         end
    11399        parameteroutput_string=[parameteroutput_string parameter ' and '];
    114100end
    115101parameteroutput_string=parameteroutput_string(1:length(parameteroutput_string)-5);
    116102
    117 disp(sprintf('      ''%s''','output'));
    118 disp(sprintf('         parameteroutput: %s %s',parameteroutput_string,...
    119                        '(list of output parameters recovered in the solution sequences: ex: {''viscousheating''}, or {''viscousheating'',''deviatoricstress''})'));
    120 
    121 %qmu
    122 disp(sprintf('\n'));
    123 displayqmu(md);
     103fprintf('\n      output:\n');
     104fprintf('         parameteroutput: %s %s\n',parameteroutput_string,...
     105                       '(list of output parameters recovered in the solution sequences: ex: {''viscousheating'',''stress''})\n');
Note: See TracChangeset for help on using the changeset viewer.