Changeset 4102

Timestamp:

06/21/10 16:37:39 (15 years ago)

Author:

seroussi

Message:

changes .m solutions, transient missing

Location:

issm/trunk/src/m/solutions/jpl

Files:

• balancedthickness.m (modified) (1 diff)
• balancedthickness2.m (modified) (1 diff)
• balancedvelocities.m (modified) (1 diff)
• bedslope.m (added)
• prognostic.m (modified) (1 diff)
• prognostic2.m (modified) (1 diff)
• steadystate.m (modified) (1 diff)
• surfaceslope.m (added)
• thermal.m (modified) (2 diffs)
• transient2d.m (modified) (1 diff)

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

@@ -8 +8 @@
         t1=clock;
 
-        %Build all models requested for diagnostic simulation
-        models.analysis_type=BalancedthicknessAnalysisEnum; %needed for processresults
-        
-        displaystring(md.verbose,'%s',['reading balancedthickness model data']);
-        md.analysis_type=BalancedthicknessAnalysisEnum; models.bt=CreateFemModel(md);
+        analysis_types=[BalancedThicknessAnalysisEnum];
+        solution_type=BalancedthicknessAnalysisEnum;
 
-        % figure out number of dof: just for information purposes.
-        md.dof=modelsize(models);
+        displaystring(md.verbose,'%s',['create finite element model']);
+        femmodel=NewFemModel(md,solution_type,analysis_types);
+
+        %retrieve parameters
+        verbose=femmodel.parameters.Verbose;
+        qmu_analysis=femmodel.parameters.QmuAnalysis;
 
         %compute solution
-        displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=balancedthickness_core(models,BalancedthicknessAnalysisEnum(),NoneAnalysisEnum());
-
-        displaystring(md.verbose,'\n%s',['load results...']);
-        if ~isstruct(md.results), md.results=struct(); end
-        md.results.BalancedthicknessAnalysis=processresults(models,results);
+        if ~qmu_analysis,
+                displaystring(verbose,'%s',['call computational core']);
+                balancedthickness_core(femmodel);
+        else
+                %launch dakota driver for diagnostic core solution
+                Qmu(femmodel);
+        end
 
         %stop timing
         t2=clock;
-        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']); 
+        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']);

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

@@ -5 +5 @@
 %      md=balancedthickness2(md)
 
-        %timing
-        t1=clock;
+        analysis_types=[Balancedthickness2AnalysisEnum];
+        solution_type=Balancedthickness2AnalysisEnum;
 
-        %Build all models requested for diagnostic simulation
-        models.analysis_type=Balancedthickness2AnalysisEnum; %needed for processresults
-        
-        displaystring(md.verbose,'%s',['reading balancedthickness2 model data']);
-        md.analysis_type=Balancedthickness2AnalysisEnum; models.p=CreateFemModel(md);
+        displaystring(md.verbose,'%s',['create finite element model']);
+        femmodel=NewFemModel(md,solution_type,analysis_types);
 
-        % figure out number of dof: just for information purposes.
-        md.dof=modelsize(models);
+        %retrieve parameters
+        verbose=femmodel.parameters.Verbose;
+        qmu_analysis=femmodel.parameters.QmuAnalysis;
 
-        %initialize inputs
-        displaystring(md.verbose,'\n%s',['setup inputs...']);
-        inputs=inputlist;
-        inputs=add(inputs,'vx',models.p.parameters.vx_g,'doublevec',1,models.p.parameters.NumberOfVertices);
-        inputs=add(inputs,'vy',models.p.parameters.vy_g,'doublevec',1,models.p.parameters.NumberOfVertices);
-        inputs=add(inputs,'thickness',models.p.parameters.h_g,'doublevec',1,models.p.parameters.NumberOfVertices);
-        inputs=add(inputs,'dhdt',models.p.parameters.dhdt_g,'doublevec',1,models.p.parameters.NumberOfVertices);
-        inputs=add(inputs,'melting',models.p.parameters.m_g,'doublevec',1,models.p.parameters.NumberOfVertices);
-        inputs=add(inputs,'accumulation',models.p.parameters.a_g,'doublevec',1,models.p.parameters.NumberOfVertices);
-
-        displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=balancedthickness2_core(models,Balancedthickness2AnalysisEnum(),NoneAnalysisEnum());
-
-        displaystring(md.verbose,'\n%s',['load results...']);
-        if ~isstruct(md.results), md.results=struct(); end
-        md.results.BalancedThicknessAnalysis2=processresults(models,results);
+        %compute solution
+        if ~qmu_analysis,
+                displaystring(verbose,'%s',['call computational core']);
+                balancedthickness2_core(femmodel);
+        else
+                %launch dakota driver for diagnostic core solution
+                Qmu(femmodel);
+        end
 
         %stop timing
         t2=clock;
-        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']); 
+        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']);

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

@@ -8 +8 @@
         t1=clock;
 
-        %Build all models requested for diagnostic simulation
-        models.analysis_type=BalancedvelocitiesAnalysisEnum; %needed for processresults
-        
-        displaystring(md.verbose,'%s',['reading balancedvelocities model data']);
-        md.analysis_type=BalancedvelocitiesAnalysisEnum; models.p=CreateFemModel(md);
+        analysis_types=[BalancedvelocitiesAnalysisEnum];
+        solution_type=BalancedvelocitiesAnalysisEnum;
 
-        % figure out number of dof: just for information purposes.
-        md.dof=modelsize(models);
+        displaystring(md.verbose,'%s',['create finite element model']);
+        femmodel=NewFemModel(md,solution_type,analysis_types);
 
-        %initialize inputs
-        displaystring(md.verbose,'\n%s',['setup inputs...']);
-        inputs=inputlist;
-        inputs=add(inputs,'velocity',models.p.parameters.u_g,'doublevec',3,models.p.parameters.NumberOfNodes);
-        inputs=add(inputs,'thickness',models.p.parameters.h_g,'doublevec',1,models.p.parameters.NumberOfNodes);
-        inputs=add(inputs,'melting',models.p.parameters.m_g,'doublevec',1,models.p.parameters.NumberOfNodes);
-        inputs=add(inputs,'accumulation',models.p.parameters.a_g,'doublevec',1,models.p.parameters.NumberOfNodes);
-        inputs=add(inputs,'dt',models.p.parameters.Dt*models.p.parameters.Yts,'double');
+        %retrieve parameters
+        verbose=femmodel.parameters.Verbose;
+        qmu_analysis=femmodel.parameters.QmuAnalysis;
 
-        displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=balancedvelocities_core(models,BalancedvelocitiesAnalysisEnum(),NoneAnalysisEnum());
-
-        displaystring(md.verbose,'\n%s',['load results...']);
-        if ~isstruct(md.results), md.results=struct(); end
-        md.results.BalancedVelocitiesAnalysis=processresults(models, results);
+        %compute solution
+        if ~qmu_analysis,
+                displaystring(verbose,'%s',['call computational core']);
+                balancedvelocities_core(femmodel);
+        else
+                %launch dakota driver for diagnostic core solution
+                Qmu(femmodel);
+        end
 
         %stop timing
         t2=clock;
-        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']); 
+        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']);

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

@@ -9 +9 @@
 
         %Build all models requested for diagnostic simulation
-        models.analysis_type=PrognosticAnalysisEnum; %needed for processresults
+        analysis_types=[PrognosticAnalysisEnum];
+        solution_type=PrognosticAnalysisEnum;
         
         displaystring(md.verbose,'%s',['reading prognostic model data']);
-        md.analysis_type=PrognosticAnalysisEnum; models.p=CreateFemModel(md);
+        femmodel=NewFemModel(md,solution_type,analysis_types);
 
         % figure out number of dof: just for information purposes.
-        md.dof=modelsize(models);
+        verbose=femmodel.parameters.Verbose;
+        qmu_analysis=femmodel.parameters.QmuAnalysis;
 
-        displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=prognostic_core(models,PrognosticAnalysisEnum(),NoneAnalysisEnum());
-
-        displaystring(md.verbose,'\n%s',['load results...']);
-        if ~isstruct(md.results), md.results=struct(); end
-        md.results.PrognosticAnalysis=processresults(models, results);
+        %compute solution
+        if ~qmu_analysis,
+                displaystring(verbose,'%s',['call computational core']);
+                prognostic_core(femmodel);
+        else
+                %launch dakota driver for diagnostic core solution
+                Qmu(femmodel);
+        end
 
         %stop timing

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

@@ -8 +8 @@
         t1=clock;
 
-        %Build all models requested for diagnostic simulation
-        models.analysis_type=Prognostic2AnalysisEnum; %needed for processresults
-        
-        displaystring(md.verbose,'%s',['reading prognostic2 model data']);
-        md.analysis_type=Prognostic2AnalysisEnum; models.p=CreateFemModel(md);
+        analysis_types=[Prognostic2AnalysisEnum];
+        solution_type=Prognostic2AnalysisEnum;
 
-        % figure out number of dof: just for information purposes.
-        md.dof=modelsize(models);
+        displaystring(md.verbose,'%s',['create finite element model']);
+        femmodel=NewFemModel(md,solution_type,analysis_types);
 
-        %initialize inputs
-        displaystring(md.verbose,'\n%s',['setup inputs...']);
-        inputs=inputlist;
-        inputs=add(inputs,'vx',models.p.parameters.vx_g,'doublevec',1,models.p.parameters.numberofvertices);
-        inputs=add(inputs,'vy',models.p.parameters.vy_g,'doublevec',1,models.p.parameters.numberofvertices);
-        inputs=add(inputs,'thickness',models.p.parameters.h_g,'doublevec',1,models.p.parameters.numberofvertices);
-        inputs=add(inputs,'melting',models.p.parameters.m_g,'doublevec',1,models.p.parameters.numberofvertices);
-        inputs=add(inputs,'accumulation',models.p.parameters.a_g,'doublevec',1,models.p.parameters.numberofvertices);
-        inputs=add(inputs,'dt',models.p.parameters.dt*models.p.parameters.yts,'double');
+        %retrieve parameters
+        verbose=femmodel.parameters.Verbose;
+        qmu_analysis=femmodel.parameters.QmuAnalysis;
 
-        displaystring(md.verbose,'\n%s',['call computational core:']);
-        results=prognostic2_core(models,Prognostic2AnalysisEnum(),NoneAnalysisEnum());
-
-        displaystring(md.verbose,'\n%s',['load results...']);
-        if ~isstruct(md.results), md.results=struct(); end
-        md.results.PrognosticAnalysis2=processresults(models, results);
+        %compute solution
+        if ~qmu_analysis,
+                displaystring(verbose,'%s',['call computational core']);
+                prognostic2_core(femmodel);
+        else
+                %launch dakota driver for diagnostic core solution
+                Qmu(femmodel);
+        end
 
         %stop timing
         t2=clock;
-        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']); 
+        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']);

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

@@ -9 +9 @@
         t1=clock;
 
-        models.analysis_type=SteadystateAnalysisEnum; %needed for processresults
-        
-        %Build all models requested for diagnostic simulation
-        displaystring(md.verbose,'%s',['reading diagnostic horiz model data']);
-        md.analysis_type=DiagnosticAnalysisEnum; md.sub_analysis_type=HorizAnalysisEnum; models.dh=CreateFemModel(md);
-        
-        displaystring(md.verbose,'\n%s',['reading diagnostic vert model data']);
-        md.analysis_type=DiagnosticAnalysisEnum; md.sub_analysis_type=VertAnalysisEnum; models.dv=CreateFemModel(md);
-        
-        displaystring(md.verbose,'\n%s',['reading diagnostic stokes model data']);
-        md.analysis_type=DiagnosticAnalysisEnum; md.sub_analysis_type=StokesAnalysisEnum; models.ds=CreateFemModel(md);
-        
-        displaystring(md.verbose,'\n%s',['reading diagnostic hutter model data']);
-        md.analysis_type=DiagnosticAnalysisEnum; md.sub_analysis_type=HutterAnalysisEnum; models.dhu=CreateFemModel(md);
-        
-        displaystring(md.verbose,'\n%s',['reading surface and bed slope computation model data']);
-        md.analysis_type=SlopecomputeAnalysisEnum; md.sub_analysis_type=NoneAnalysisEnum; models.sl=CreateFemModel(md);
+        analysis_types=[DiagnosticHorizAnalysisEnum,DiagnosticVertAnalysisEnum,DiagnosticStokesAnalysisEnum,DiagnosticHutterAnalysisEnum,SlopeAnalysisEnum,ThermalAnalysisEnum,MeltingAnalysisEnum];
+        solution_type=SteadyStateAnalysisEnum;
 
-        %Build all models requested for thermal simulation
-        displaystring(md.verbose,'%s',['reading thermal model data']);
-        md.analysis_type=ThermalAnalysisEnum(); md.sub_analysis_type=NoneAnalysisEnum(); models.t=CreateFemModel(md);
+        displaystring(md.verbose,'%s',['create finite element model']);
+        femmodel=NewFemModel(md,solution_type,analysis_types);
 
-        displaystring(md.verbose,'%s',['reading melting model data']);
-        md.analysis_type=MeltingAnalysisEnum(); md.sub_analysis_type=NoneAnalysisEnum(); models.m=CreateFemModel(md);
-
-        % figure out number of dof: just for information purposes.
-        md.dof=modelsize(models);
-
-        %initialize inputs
-        displaystring(md.verbose,'\n%s',['setup inputs...']);
-        inputs=inputlist;
-        inputs=add(inputs,'velocity',models.dh.parameters.u_g,'doublevec',3,models.dh.parameters.NumberOfNodes);
-        inputs=add(inputs,'pressure',models.t.parameters.p_g,'doublevec',1,models.t.parameters.NumberOfNodes);
-        inputs=add(inputs,'dt',models.t.parameters.Dt*models.t.parameters.Yts,'double');
-        if md.control_analysis,
-                inputs=add(inputs,'velocity_obs',models.dh.parameters.u_g_obs,'doublevec',2,models.dh.parameters.NumberOfNodes);
-                inputs=add(inputs,'weights',models.dh.parameters.Weights,'doublevec',1,models.dh.parameters.NumberOfNodes);
-        end
+        %retrieve parameters
+        verbose=femmodel.parameters.Verbose;
+        qmu_analysis=femmodel.parameters.QmuAnalysis;
+        control_analysis=femmodel.parameters.ControlAnalysis;
         
         %compute solution
-        if ~models.dh.parameters.QmuAnalysis,
-                if md.control_analysis,
-                        %change control_steady to 1
-                        models.dh.parameters.ControlSteady=1;
-                        models.ds.parameters.ControlSteady=1;
-                        %launch core of control solution.
-                        results=control_core(models);
+        if ~qmu_analysis,
+                if ~control_analysis,
+                        
+                        displaystring(verbose,'%s',['call computational core']);
+                        steadystate_core(femmodel);
 
-                        %process results
-                        if ~isstruct(md.results), md.results=struct(); end
-                        md.results.SteadystateAnalysis=processresults(models,results);
                 else,
-                        %launch core of steadystate solution.
-                        results=steadystate_core(models);
-                
-                        %process results
-                        if ~isstruct(md.results), md.results=struct(); end
-                        md.results.SteadystateAnalysis=processresults(models,results);
+                        
+                        displaystring(verbose,'%s',['call computational core']);
+                        control_core(femmodel);
+
                 end
         else
-                %launch dakota driver for steadystate core solution
-                Qmu(models,models.dh.parameters);
+                %launch dakota driver for diagnostic core solution
+                Qmu(femmodel);
         end
 

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

@@ -8 +8 @@
         t1=clock;
         
-        %Build all models requested for thermal simulation
-        models.analysis_type=ThermalAnalysisEnum(); %needed for processresults
+        analysis_types=[ThermalAnalysisEnum,MeltingAnalysisEnum];
+        solution_type=ThermalAnalysisEnum;
 
         displaystring(md.verbose,'%s',['reading thermal model data']);
-        md.analysis_type=ThermalAnalysisEnum(); models.t=CreateFemModel(md);
+        femmodel=NewFemModel(md,solution_type,analysis_types);
 
-        displaystring(md.verbose,'%s',['reading melting model data']);
-        md.analysis_type=MeltingAnalysisEnum(); models.m=CreateFemModel(md);
-
-        % figure out number of dof: just for information purposes.
-        md.dof=modelsize(models);
+        %retrieve parameters
+        verbose=femmodel.parameters.Verbose;
+        qmu_analysis=femmodel.parameters.QmuAnalysis;
 
         %compute solution
-        if ~models.t.parameters.QmuAnalysis,
-                %launch core of diagnostic solution.
-                results=thermal_core(models);
-        
-                %process results
-                if ~isstruct(md.results), md.results=struct(); end
-                md.results.ThermalAnalysis=processresults(models,results);
+        if ~qmu_analysis,
+                displaystring(verbose,'%s',['call computational core']);
+                thermal_core(femmodel);
         else
                 %launch dakota driver for diagnostic core solution
@@ -35 +29 @@
         %stop timing
         t2=clock;
-        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']); 
+        displaystring(md.verbose,'\n%s\n',['solution converged in ' num2str(etime(t2,t1)) ' seconds']);

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

@@ -32 +32 @@
 solution.step=1;
 solution.time=0;
-solution.u_g=models.dh.parameters.u_g(dofsetgen([1,2],3,length(models.dh.parameters.u_g)));
+%solution.u_g=models.dh.parameters.u_g(dofsetgen([1,2],3,length(models.dh.parameters.u_g)));
+solution.u_g=[];
 solution.p_g=[];
-solution.h_g=models.p.parameters.h_g;
-solution.s_g=models.p.parameters.s_g;
-solution.b_g=models.p.parameters.b_g;
+%solution.h_g=models.p.parameters.h_g;
+solution.h_g=md.thickness;
+solution.s_g=md.surface;
+%solution.s_g=models.p.parameters.s_g;
+solution.b_g=md.bed;
+%solution.b_g=models.p.parameters.b_g;
 
 %initialize inputs