Changeset 3839

Timestamp:

05/19/10 09:57:00 (15 years ago)

Author:

seroussi

Message:

no inputs in arguments

Location:

issm/trunk/src/m/solutions/jpl

Files:

• ControlInitialization.m (modified) (2 diffs)
• SpawnCore.m (modified) (2 diffs)
• balancedthickness.m (modified) (1 diff)
• balancedthickness2.m (modified) (1 diff)
• balancedthickness2_core.m (modified) (1 diff)
• balancedthickness_core.m (modified) (1 diff)
• balancedvelocities.m (modified) (1 diff)
• balancedvelocities_core.m (modified) (1 diff)
• control_core.m (modified) (6 diffs)
• diagnostic_core_linear.m (modified) (1 diff)
• diagnostic_core_nonlinear.m (modified) (4 diffs)
• gradjcompute_core.m (modified) (4 diffs)
• objectivefunctionC.m (modified) (2 diffs)
• prognostic.m (modified) (1 diff)
• prognostic2.m (modified) (1 diff)
• prognostic2_core.m (modified) (1 diff)
• prognostic_core.m (modified) (1 diff)
• slopecompute.m (modified) (1 diff)
• slopecompute_core.m (modified) (1 diff)
• steadystate.m (modified) (3 diffs)
• steadystate_core.m (modified) (3 diffs)
• thermal.m (modified) (2 diffs)
• thermal_core.m (modified) (3 diffs)
• thermal_core_nonlinear.m (modified) (4 diffs)
• transient2d.m (modified) (2 diffs)
• transient3d.m (modified) (3 diffs)

issm/trunk/src/m/solutions/jpl/ControlInitialization.m

@@ -1 @@
-function [inputs models]=ControlInitialization(models,inputs);
+function models=ControlInitialization(models);
 
 %recover models
@@ -55 +55 @@
 % get pressure (reconditionned) and create 4d u_g
 displaystring(verbose,'\n%s',['computing pressure according to Pattyn...']);
-p_g=ComputePressure(m_dh.elements,m_dh.nodes,mdh.vertices,m_dh.loads,m_dh.materials,m_dh.parameters,inputs,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
+p_g=ComputePressure(m_dh.elements,m_dh.nodes,mdh.vertices,m_dh.loads,m_dh.materials,m_dh.parameters,DiagnosticAnalysisEnum(),HorizAnalysisEnum());
 p_g=p_g/m_ds.parameters.stokesreconditioning;
 u_g_stokes=zeros(m_ds.nodesets.gsize,1);

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

@@ -1 @@
-function responses=SpawnCore(models,inputs,variables,variabledescriptors,analysis_type,sub_analysis_type,counter);
+function responses=SpawnCore(models,variables,variabledescriptors,analysis_type,sub_analysis_type,counter);
 %SPAWNCORE - for Qmu analysis, using Dakota. Spawn the core solution.
 %
 %   Usage:
-%      responses=SpawnCore(models,inputs,variables,variabledescriptors)
+%      responses=SpawnCore(models,variables,variabledescriptors)
 %
 
@@ -47 +47 @@
 if analysis_type==DiagnosticAnalysisEnum(),
 
-        results=diagnostic_core(models,inputs);
+        results=diagnostic_core(models);
 
 else

issm/trunk/src/m/solutions/jpl/balancedthickness.m

@@ -25 +25 @@
 
         displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=balancedthickness_core(models,inputs,BalancedthicknessAnalysisEnum(),NoneAnalysisEnum());
+        results=balancedthickness_core(models,BalancedthicknessAnalysisEnum(),NoneAnalysisEnum());
 
         displaystring(md.verbose,'\n%s',['load results...']);

issm/trunk/src/m/solutions/jpl/balancedthickness2.m

@@ -28 +28 @@
 
         displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=balancedthickness2_core(models,inputs,Balancedthickness2AnalysisEnum(),NoneAnalysisEnum());
+        results=balancedthickness2_core(models,Balancedthickness2AnalysisEnum(),NoneAnalysisEnum());
 
         displaystring(md.verbose,'\n%s',['load results...']);

issm/trunk/src/m/solutions/jpl/balancedthickness2_core.m

@@ -1 @@
-function results=balancedthickness2_core(models,inputs,analysis_type,sub_analysis_type)
+function results=balancedthickness2_core(models,analysis_type,sub_analysis_type)
 %BALANCEDTHICKNESS_CORE - linear solution sequence
 %
 %   Usage:
-%      h_g=balancedthickness2_core(m,inputs,analysis_type,sub_analysis_type)
+%      h_g=balancedthickness2_core(m,analysis_type,sub_analysis_type)
 
         %get FE model

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

@@ -1 @@
-function results=balancedthickness_core(models,inputs,analysis_type,sub_analysis_type)
+function results=balancedthickness_core(models,analysis_type,sub_analysis_type)
 %BALANCEDTHICKNESS_CORE - linear solution sequence
 %
 %   Usage:
-%      h_g=balancedthickness_core(m,inputs,analysis_type,sub_analysis_type)
+%      h_g=balancedthickness_core(m,analysis_type,sub_analysis_type)
 
         %get FE model

issm/trunk/src/m/solutions/jpl/balancedvelocities.m

@@ -27 +27 @@
 
         displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=balancedvelocities_core(models,inputs,BalancedvelocitiesAnalysisEnum(),NoneAnalysisEnum());
+        results=balancedvelocities_core(models,BalancedvelocitiesAnalysisEnum(),NoneAnalysisEnum());
 
         displaystring(md.verbose,'\n%s',['load results...']);

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

@@ -1 @@
-function results=balancedvelocities_core(models,inputs,analysis_type,sub_analysis_type)
+function results=balancedvelocities_core(models,analysis_type,sub_analysis_type)
 %BALANCEDVELOCITIES_CORE - linear solution sequence
 %
 %   Usage:
-%      v_g=balancedvelocities_core(m,inputs,analysis_type,sub_analysis_type)
+%      v_g=balancedvelocities_core(m,analysis_type,sub_analysis_type)
 
         %get FE model

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

@@ -1 @@
-function results=control_core(models,inputs)
+function results=control_core(models)
 %CONTROL_CORE - compute the core inversion
 %
 %   Usage:
-%      results=control_core(models,inputs);
+%      results=control_core(models);
 %
 
 %Preprocess models
-[inputs models]=ControlInitialization(models,inputs);
+models=ControlInitialization(models);
 
 %recover active model.
@@ -37 +37 @@
         %In case we are running a steady state control method, compute new temperature field using new parameter distribution: 
         if model.parameters.ControlSteady;
-                steadystate_results=steadystate_core(models,inputs); t_g=steadystate_results.t_g; 
+                steadystate_results=steadystate_core(models); t_g=steadystate_results.t_g; 
                 inputs=add(inputs,'temperature',t_g,'doublevec',1,model.parameters.NumberOfNodes);
         end
@@ -46 +46 @@
 
         %Update inputs in datasets
-        [model.elements,model.nodes,model.vertices,model.loads,model.materials,model.parameters]=UpdateFromInputs(model.elements,model.nodes,model.vertices,model.loads,model.materials,model.parameters,inputs);
+        [model.elements,model.nodes,model.vertices,model.loads,model.materials,model.parameters]=UpdateFromInputs(model.elements,model.nodes,model.vertices,model.loads,model.materials,model.parameters);
 
         displaystring(verbose,'\n%s',['      computing gradJ...']);
-        results_grad=gradjcompute_core(models,inputs);
+        results_grad=gradjcompute_core(models);
         u_g=results_grad.u_g; c(n).grad_g=results_grad.grad_g;
         if dim==3,
@@ -78 +78 @@
 
         displaystring(verbose,'\n%s',['      optimizing along gradient direction...']);
-        [search_scalar c(n).J]=ControlOptimization('objectivefunctionC',0,1,options,models,inputs,param_g,c(n).grad_g,n,model.parameters);
+        [search_scalar c(n).J]=ControlOptimization('objectivefunctionC',0,1,options,models,param_g,c(n).grad_g,n,model.parameters);
 
         displaystring(verbose,'\n%s',['      updating parameter using optimized search scalar...']);
@@ -119 +119 @@
 if model.parameters.ControlSteady;
         inputs=add(inputs,model.parameters.ControlType,param_g,'doublevec',1,model.parameters.NumberOfNodes);
-        steadystate_results=steadystate_core(models,inputs); t_g=steadystate_results.t_g; 
+        steadystate_results=steadystate_core(models); t_g=steadystate_results.t_g; 
         u_g=steadystate_results.u_g;
         t_g=steadystate_results.t_g;
@@ -125 +125 @@
 else
         inputs=add(inputs,model.parameters.ControlType,param_g,'doublevec',1,model.parameters.NumberOfNodes);
-        results_diag=diagnostic_core(models,inputs);
+        results_diag=diagnostic_core(models);
         u_g=results_diag.u_g;
 end

issm/trunk/src/m/solutions/jpl/diagnostic_core_linear.m

@@ -9 +9 @@
 
         %Update inputs in datasets
-        [m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters]=UpdateFromInputs(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,inputs);
+        [m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters]=UpdateFromInputs(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters);
         
         %system matrices
-        [K_gg, p_g]=SystemMatrices(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
-        [K_gg, p_g,kmax]=PenaltySystemMatrices(K_gg,p_g,m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+        [K_gg, p_g]=SystemMatrices(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
+        [K_gg, p_g,kmax]=PenaltySystemMatrices(K_gg,p_g,m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
         
         %Reduce tangent matrix from g size to f size

issm/trunk/src/m/solutions/jpl/diagnostic_core_nonlinear.m

@@ -34 +34 @@
         
                 %penalties
-                [K_gg , p_g, kmax]=PenaltySystemMatrices(K_gg_nopenalty,p_g_nopenalty,m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+                [K_gg , p_g, kmax]=PenaltySystemMatrices(K_gg_nopenalty,p_g_nopenalty,m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
 
                 %Reduce tangent matrix from g size to f size
@@ -58 +58 @@
                 
                 %penalty constraints
-                [loads,constraints_converged,num_unstable_constraints] =PenaltyConstraints( m.elements,m.nodes,m.vertices,loads, m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+                [loads,constraints_converged,num_unstable_constraints] =PenaltyConstraints( m.elements,m.nodes,m.vertices,loads, m.materials,m.parameters,analysis_type,sub_analysis_type);
                 error;
                 
@@ -66 +66 @@
                 converged=convergence(K_ff,p_f,soln(count).u_f,soln(count-1).u_f,m.parameters);
                         
-                %add convergence status into inputs
+                %add convergence status into 
                 inputs=add(inputs,'converged',converged,'double');
 
@@ -85 +85 @@
                 inputs=add(inputs,'velocity',u_g,'doublevec',m.parameters.NumberOfDofsPerNode,m.parameters.NumberOfNodes);
                 m.parameters.Kflag=1; m.parameters.Pflag=0; 
-                [K_gg, p_g]=SystemMatrices(m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+                [K_gg, p_g]=SystemMatrices(m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
                 [K_ff, K_fs] = Reducematrixfromgtof( K_gg, m.Gmn, m.nodesets); 
                 varargout(1)={K_ff};

issm/trunk/src/m/solutions/jpl/gradjcompute_core.m

@@ -1 @@
-function results=gradjcompute_core(models,inputs);
+function results=gradjcompute_core(models);
 
 %recover active models
@@ -21 +21 @@
 %Buid Du, difference between observed velocity and model velocity.
 displaystring(verbose,'%s','          computing Du...');
-[Du_g]=Du(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+[Du_g]=Du(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
 
 %Reduce adjoint load from g-set to f-set
@@ -35 +35 @@
 
 %Compute gradJ 
-grad_g=Gradj(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+grad_g=Gradj(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
 if (dim==3 & extrude_param),
         displaystring(verbose,'%s','          extruding gradient...');
@@ -44 +44 @@
         %compute initial velocity from diagnostic_core (horiz+vertical)
         displaystring(verbose,'%s','          compute 3d initial velocity...');
-        results_diag=diagnostic_core(models,inputs);
+        results_diag=diagnostic_core(models);
         u_g=results_diag.u_g;
 end

issm/trunk/src/m/solutions/jpl/objectivefunctionC.m

@@ -1 @@
-function J =objectivefunctionC(search_scalar,models,inputs,p_g,grad_g,n,analysis_type,sub_analysis_type);
+function J =objectivefunctionC(search_scalar,models,p_g,grad_g,n,analysis_type,sub_analysis_type);
 
 %recover active model.
@@ -23 +23 @@
 
 %Compute misfit for this velocity field. 
-J=CostFunction(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+J=CostFunction(m.elements,m.nodes,m.vertices,m.loads,m.materials,m.parameters,analysis_type,sub_analysis_type);

issm/trunk/src/m/solutions/jpl/prognostic.m

@@ -27 +27 @@
 
         displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=prognostic_core(models,inputs,PrognosticAnalysisEnum(),NoneAnalysisEnum());
+        results=prognostic_core(models,PrognosticAnalysisEnum(),NoneAnalysisEnum());
 
         displaystring(md.verbose,'\n%s',['load results...']);

issm/trunk/src/m/solutions/jpl/prognostic2.m

@@ -28 +28 @@
 
         displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=prognostic2_core(models,inputs,Prognostic2AnalysisEnum(),NoneAnalysisEnum());
+        results=prognostic2_core(models,Prognostic2AnalysisEnum(),NoneAnalysisEnum());
 
         displaystring(md.verbose,'\n%s',['load results...']);

issm/trunk/src/m/solutions/jpl/prognostic2_core.m

@@ -1 @@
-function results=prognostic2_core(models,inputs,analysis_type,sub_analysis_type)
+function results=prognostic2_core(models,analysis_type,sub_analysis_type)
 %PROGNOSTIC2_CORE - linear solution sequence
 %
 %   Usage:
-%      h_g=prognostic2_core(m,inputs,analysis_type,sub_analysis_type)
+%      h_g=prognostic2_core(m,analysis_type,sub_analysis_type)
 
         %get FE model

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

@@ -1 @@
-function results=prognostic_core(models,inputs,analysis_type,sub_analysis_type)
+function results=prognostic_core(models,analysis_type,sub_analysis_type)
 %PROGNOSTIC_CORE - linear solution sequence
 %
 %   Usage:
-%      h_g=prognostic_core(m,inputs,analysis_type,sub_analysis_type)
+%      h_g=prognostic_core(m,analysis_type,sub_analysis_type)
 
         %get FE model

issm/trunk/src/m/solutions/jpl/slopecompute.m

@@ -17 +17 @@
         md.dof=modelsize(models);
 
-        %initialize inputs
-        inputs=inputlist;
-
         %compute solution
         displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=slopecompute_core(models,inputs,SlopecomputeAnalysisEnum(),NoneAnalysisEnum());
+        results=slopecompute_core(models,SlopecomputeAnalysisEnum(),NoneAnalysisEnum());
 
         displaystring(md.verbose,'\n%s',['load results...']);

issm/trunk/src/m/solutions/jpl/slopecompute_core.m

@@ -1 @@
-function results=slopecompute_core(models,inputs,analysis_type,sub_analysis_type)
+function results=slopecompute_core(models,analysis_type,sub_analysis_type)
 %SLOPECOMPUTE_CORE - linear solution sequence
 %
 %   Usage:
-%      [sx_g sy_g]=slopecompute_core(m,inputs,analysis_type,sub_analysis_type)
+%      [sx_g sy_g]=slopecompute_core(m,analysis_type,sub_analysis_type)
 
         %get FE model

issm/trunk/src/m/solutions/jpl/steadystate.m

@@ -55 +55 @@
                         models.ds.parameters.ControlSteady=1;
                         %launch core of control solution.
-                        results=control_core(models,inputs);
+                        results=control_core(models);
 
                         %process results
@@ -62 +62 @@
                 else,
                         %launch core of steadystate solution.
-                        results=steadystate_core(models,inputs);
+                        results=steadystate_core(models);
                 
                         %process results
@@ -70 +70 @@
         else
                 %launch dakota driver for steadystate core solution
-                Qmu(models,inputs,models.dh.parameters);
+                Qmu(models,models.dh.parameters);
         end
 

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

@@ -1 @@
-function results=steadystate_core(models,inputs);
+function results=steadystate_core(models);
 %STEADYSTATE_CORE - compute the core temperature and velocity field  at thermal steady state.
 %
 %   Usage:
-%      results=steadystate_core(models,inputs);
+%      results=steadystate_core(models);
 %
 
@@ -42 +42 @@
                 inputs=add(inputs,'velocity',results_diagnostic.u_g,'doublevec',ndof,m_t.parameters.NumberOfNodes);
         end
-        results_thermal=thermal_core(models,inputs);
+        results_thermal=thermal_core(models);
         
         %add temperature to inputs.
@@ -51 +51 @@
         
         %now compute diagnostic velocity using the steady state temperature.
-        results_diagnostic=diagnostic_core(models,inputs);
+        results_diagnostic=diagnostic_core(models);
         
         %convergence? 

issm/trunk/src/m/solutions/jpl/thermal.m

@@ -30 +30 @@
         if ~models.t.parameters.QmuAnalysis,
                 %launch core of diagnostic solution.
-                results=thermal_core(models,inputs);
+                results=thermal_core(models);
         
                 %process results
@@ -37 +37 @@
         else
                 %launch dakota driver for diagnostic core solution
-                Qmu(models,inputs,models.t.parameters);
+                Qmu(models,models.t.parameters);
         end
 

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

@@ -1 @@
-function results=thermal_core(models,inputs)
+function results=thermal_core(models)
 %THERMAL_CORE - core of thermal solution
 %
 %   Usage:
-%      solution=thermal_core(models,inputs)
+%      solution=thermal_core(models)
 
 %get FE model
@@ -15 +15 @@
 
         displaystring(m_t.parameters.Verbose,'\n%s',['computing temperatures...']);
-        [results.t_g m_t.loads melting_offset]=thermal_core_nonlinear(m_t,inputs,ThermalAnalysisEnum(),NoneAnalysisEnum());
+        [results.t_g m_t.loads melting_offset]=thermal_core_nonlinear(m_t,,ThermalAnalysisEnum(),NoneAnalysisEnum());
 
         displaystring(m_t.parameters.Verbose,'\n%s',['computing melting...']);
@@ -43 +43 @@
                 displaystring(m_t.parameters.Verbose,'\n%s',['    computing temperatures...']);
                 inputs=add(inputs,'temperature',results(n).t_g,'doublevec',1,m_t.parameters.NumberOfNodes);
-                [results(n+1).t_g m_t.loads melting_offset]=thermal_core_nonlinear(m_t,inputs,ThermalAnalysisEnum(),NoneAnalysisEnum());
+                [results(n+1).t_g m_t.loads melting_offset]=thermal_core_nonlinear(m_t,ThermalAnalysisEnum(),NoneAnalysisEnum());
 
                 displaystring(m_t.parameters.Verbose,'\n%s',['    computing melting...']);

issm/trunk/src/m/solutions/jpl/thermal_core_nonlinear.m

@@ -1 @@
-function [t_g ,loads, melting_offset]=thermal_core_nonlinear(m,inputs,analysis_type,sub_analysis_type)
+function [t_g ,loads, melting_offset]=thermal_core_nonlinear(m,analysis_type,sub_analysis_type)
 %THERMAL_CORE_NONLINEAR - core of thermal solution sequence.
 %   model is return together with temperature
 %
 %   Usage:
-%      [t_g ,loads, melting_offset]=thermal_core_nonlinear(m,inputs,analysis_type,sub_analysis_type);
+%      [t_g ,loads, melting_offset]=thermal_core_nonlinear(m,analysis_type,sub_analysis_type);
 
         count=1;
@@ -20 +20 @@
 
                 %Update inputs in datasets
-                [m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters]=UpdateFromInputs(m.elements,m.nodes,m.vertices, loads,m.materials,m.parameters,inputs);
+                [m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters]=UpdateFromInputs(m.elements,m.nodes,m.vertices, loads,m.materials,m.parameters);
 
                 %system matrices 
@@ -26 +26 @@
                         if count==1
                                 displaystring(m.parameters.Verbose,'%s',['   system matrices']);
-                                [K_gg_nopenalty, p_g_nopenalty]=SystemMatrices(m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+                                [K_gg_nopenalty, p_g_nopenalty]=SystemMatrices(m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
                         end
                         displaystring(m.parameters.Verbose,'%s',['   penalty system matrices']);
-                        [K_gg , p_g, melting_offset]=PenaltySystemMatrices(K_gg_nopenalty,p_g_nopenalty,m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+                        [K_gg , p_g, melting_offset]=PenaltySystemMatrices(K_gg_nopenalty,p_g_nopenalty,m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
                 else
                         displaystring(m.parameters.Verbose,'%s',['   system matrices']);
-                        [K_gg , p_g]=SystemMatrices(m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+                        [K_gg , p_g]=SystemMatrices(m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
                         displaystring(m.parameters.Verbose,'%s',['   penalty system matrices']);
-                        [K_gg , p_g, melting_offset]=PenaltySystemMatrices(K_gg,p_g,m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+                        [K_gg , p_g, melting_offset]=PenaltySystemMatrices(K_gg,p_g,m.elements,m.nodes,m.vertices,loads,m.materials,m.parameters,analysis_type,sub_analysis_type);
                 end
 
@@ -54 +54 @@
                 inputs=add(inputs,'temperature',t_g,'doublevec',m.parameters.NumberOfDofsPerNode,m.parameters.NumberOfNodes);
                 displaystring(m.parameters.Verbose,'%s',['   update inputs']);
-                [m.elements,m.nodes,m.vertices, loads,m.materials,m.parameters]=UpdateFromInputs(m.elements,m.nodes,m.vertices, loads,m.materials,m.parameters,inputs);
+                [m.elements,m.nodes,m.vertices, loads,m.materials,m.parameters]=UpdateFromInputs(m.elements,m.nodes,m.vertices, loads,m.materials,m.parameters);
         
                 %penalty constraints
                 displaystring(m.parameters.Verbose,'%s',['   penalty constraints']);
-                [loads,constraints_converged,num_unstable_constraints] =PenaltyConstraints(m.elements,m.nodes,m.vertices,loads, m.materials,m.parameters,inputs,analysis_type,sub_analysis_type);
+                [loads,constraints_converged,num_unstable_constraints] =PenaltyConstraints(m.elements,m.nodes,m.vertices,loads, m.materials,m.parameters,analysis_type,sub_analysis_type);
         
                 if ~converged,

issm/trunk/src/m/solutions/jpl/transient2d.m

@@ -71 +71 @@
 
         %Get horizontal solution. 
-        rawresults=diagnostic_core(models,inputs);
+        rawresults=diagnostic_core(models);
         solution(n+1).u_g=rawresults.u_g; solution(n+1).p_g=rawresults.p_g;
 
@@ -77 +77 @@
         disp(sprintf('%s','   computing new thickness...'));
         inputs=add(inputs,'velocity',solution(n+1).u_g,'doublevec',2,models.p.parameters.NumberOfNodes);
-        rawresults=prognostic_core(models,inputs,PrognosticAnalysisEnum(),NoneAnalysisEnum());
+        rawresults=prognostic_core(models,PrognosticAnalysisEnum(),NoneAnalysisEnum());
         new_thickness=rawresults.h_g;
 

issm/trunk/src/m/solutions/jpl/transient3d.m

@@ -84 +84 @@
         %Deal with temperature first 
         displaystring(md.verbose,'\n%s',['    computing temperatures...']);
-        [results(n+1).t_g models.t.loads melting_offset]=thermal_core_nonlinear(models.t,inputs,ThermalAnalysisEnum(),TransientAnalysisEnum());
+        [results(n+1).t_g models.t.loads melting_offset]=thermal_core_nonlinear(models.t,ThermalAnalysisEnum(),TransientAnalysisEnum());
         inputs=add(inputs,'temperature',results(n+1).t_g,'doublevec',1,models.t.parameters.NumberOfNodes);
         
@@ -96 +96 @@
 
         %Deal with velocities.
-        rawresults=diagnostic_core(models,inputs);
+        rawresults=diagnostic_core(models);
         results(n+1).u_g=rawresults.u_g; results(n+1).p_g=rawresults.p_g;
 
@@ -102 +102 @@
         displaystring(md.verbose,'\n%s',['    computing new thickness...']);
         inputs=add(inputs,'velocity',results(n+1).u_g,'doublevec',3,models.p.parameters.NumberOfNodes);
-        rawresults=prognostic_core(models,inputs,PrognosticAnalysisEnum(),NoneAnalysisEnum());
+        rawresults=prognostic_core(models,PrognosticAnalysisEnum(),NoneAnalysisEnum());
         new_thickness=rawresults.h_g;