#include <unsteady_visualization.h>

Inheritance diagram for GRINS::UnsteadyVisualization:

Collaboration diagram for GRINS::UnsteadyVisualization:

Public Member Functions
	UnsteadyVisualization (const GetPot &input, const libMesh::Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD)

	~UnsteadyVisualization ()

virtual void	output_residual (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system, const unsigned int time_step, const libMesh::Real time)

virtual void	output_residual_sensitivities (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system, const libMesh::ParameterVector &params, const unsigned int time_step, const libMesh::Real time)

virtual void	output_adjoint (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system, const unsigned int time_step, const libMesh::Real time)

virtual void	output_solution_sensitivities (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system, const libMesh::ParameterVector &params, const unsigned int time_step, const libMesh::Real time)

void	output (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system)

void	output (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, const unsigned int time_step, const libMesh::Real time)

void	output_residual (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system)

void	output_residual_sensitivities (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system, const libMesh::ParameterVector &params)

void	output_adjoint (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system)

void	output_solution_sensitivities (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, GRINS::MultiphysicsSystem *system, const libMesh::ParameterVector &params)

void	dump_visualization (std::tr1::shared_ptr< libMesh::EquationSystems > equation_system, const std::string &filename_prefix, const libMesh::Real time)

Protected Attributes
std::string	_vis_output_file_prefix

std::vector< std::string >	_output_format

Detailed Description

Definition at line 34 of file unsteady_visualization.h.

Constructor & Destructor Documentation

GRINS::UnsteadyVisualization::UnsteadyVisualization	(	const GetPot &	input,
		const libMesh::Parallel::Communicator &comm	LIBMESH_CAN_DEFAULT_TO_COMMWORLD
	)

Definition at line 42 of file unsteady_visualization.C.

     : Visualization(input, comm)
   {
     return;
   }

GRINS::UnsteadyVisualization::~UnsteadyVisualization ( )

Definition at line 49 of file unsteady_visualization.C.

   {
     return;
   }

Member Function Documentation

void GRINS::Visualization::dump_visualization	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		const std::string &	filename_prefix,
		const libMesh::Real	time
	)

inherited

Definition at line 154 of file visualization.C.

Referenced by GRINS::Visualization::output(), GRINS::SteadyVisualization::output_adjoint(), and GRINS::SteadyVisualization::output_residual().

   {
     libMesh::MeshBase& mesh = equation_system->get_mesh();
 
     if( this->_vis_output_file_prefix == "unknown" )
       {
         // TODO: Need consisent way to print warning messages.
         std::cout << " WARNING in Visualization::dump_visualization :"
                   << " using 'unknown' as file prefix since it was not set "
                   << std::endl;
       }
 
     // If we're asked to put files in a subdirectory, let's make sure
     // it exists
     if (!mesh.comm().rank())
       for (std::size_t pos = this->_vis_output_file_prefix.find('/');
            pos != std::string::npos;
            pos = this->_vis_output_file_prefix.find('/',++pos))
         if (mkdir(this->_vis_output_file_prefix.substr(0,pos).c_str(),
                   0777) != 0 && errno != EEXIST)
           libmesh_file_error(this->_vis_output_file_prefix.substr(0,pos));
 
     for( std::vector<std::string>::const_iterator format = _output_format.begin();
          format != _output_format.end();
          format ++ )
       {
         // The following is a modifed copy from the FIN-S code.
         if ((*format) == "tecplot" ||
             (*format) == "dat")
           {
             std::string filename = filename_prefix+".dat";
             libMesh::TecplotIO(mesh,false).write_equation_systems( filename,
                                                                    *equation_system );
           }
         else if ((*format) == "tecplot_binary" ||
                  (*format) == "plt")
           {
             std::string filename = filename_prefix+".plt";
             libMesh::TecplotIO(mesh,true).write_equation_systems( filename,
                                                                   *equation_system );
           }
         else if ((*format) == "gmv")
           {
             std::string filename = filename_prefix+".gmv";
             libMesh::GMVIO(mesh).write_equation_systems( filename,
                                                 *equation_system );
           }
         else if ((*format) == "pvtu")
           {
             std::string filename = filename_prefix+".pvtu";
             libMesh::VTKIO(mesh).write_equation_systems( filename,
                                                 *equation_system );
           }
         else if ((*format) == "ExodusII")
           {
             std::string filename = filename_prefix+".exo";
 
             // The "1" is hardcoded for the number of time steps because the ExodusII manual states that
             // it should be the number of timesteps within the file. Here, we are explicitly only doing
             // one timestep per file.
             libMesh::ExodusII_IO(mesh).write_timestep
               ( filename, *equation_system, 1, time );
           }
         else if ((*format) == "Nemesis")
           {
             std::string filename = filename_prefix+".nem";
 
             // The "1" is hardcoded for the number of time steps because the ExodusII manual states that
             // it should be the number of timesteps within the file. Here, we are explicitly only doing
             // one timestep per file.
             libMesh::Nemesis_IO(mesh).write_timestep
               ( filename, *equation_system, 1, time );
           }
         else if ((*format).find("xda") != std::string::npos ||
                  (*format).find("xdr") != std::string::npos)
           {
             std::string filename = filename_prefix+"."+(*format);
             const bool binary = ((*format).find("xdr") != std::string::npos);
             equation_system->write( filename,
                                     binary ? GRINSEnums::ENCODE : GRINSEnums::WRITE,
                                     libMesh::EquationSystems::WRITE_DATA |
                                     libMesh::EquationSystems::WRITE_ADDITIONAL_DATA );
           }
         else if ((*format) == "mesh_only" )
           {
             std::string filename = filename_prefix+"_mesh.xda";
             equation_system->get_mesh().write( filename );
           }
         else
           {
             // TODO: Do we want to use this to error throughout the code?
             // TODO: (at least need to pass/print some message/string) - sahni
             libmesh_error();
           }
       } // End loop over formats
 
     return;
   }

void GRINS::Visualization::output ( std::tr1::shared_ptr< libMesh::EquationSystems > equation_system )

inherited

Definition at line 98 of file visualization.C.

References GRINS::Visualization::_vis_output_file_prefix, and GRINS::Visualization::dump_visualization().

   {
     this->dump_visualization( equation_system, _vis_output_file_prefix, 0.0 );
 
     return;
   }

void GRINS::Visualization::output	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		const unsigned int	time_step,
		const libMesh::Real	time
	)

inherited

Definition at line 106 of file visualization.C.

   {
     std::stringstream suffix;
 
     suffix << time_step;
 
     std::string filename = this->_vis_output_file_prefix;
     filename+="."+suffix.str();
 
     this->dump_visualization( equation_system, filename, time );
 
     return;
   }

void GRINS::UnsteadyVisualization::output_adjoint	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system,
		const unsigned int	time_step,
		const libMesh::Real	time
	)

virtual

Implements GRINS::Visualization.

Definition at line 130 of file unsteady_visualization.C.

References GRINS::CompositeQoI::get_qoi(), GRINS::CompositeQoI::n_qois(), and GRINS::QoIBase::name().

   {
     std::stringstream suffix;
     suffix << time_step;
 
     const libMesh::DifferentiableQoI* raw_qoi = system->get_qoi();
     const CompositeQoI* qoi = dynamic_cast<const CompositeQoI*>( raw_qoi );
 
     unsigned int n_qois = qoi->n_qois();
 
     for( unsigned int q = 0; q < n_qois; q++ )
       {
         libMesh::NumericVector<libMesh::Number>& dual_solution = system->get_adjoint_solution(q);
 
         const std::string& qoi_name = qoi->get_qoi(q).name();
         std::string filename = this->_vis_output_file_prefix+"_unsteady_adjoint_"+qoi_name;
         filename+="."+suffix.str();
 
         system->solution->swap( dual_solution );
         equation_system->update();
 
         this->dump_visualization( equation_system, filename, time );
 
         // Now swap back and reupdate
         system->solution->swap( dual_solution );
         equation_system->update();
       }
   }

void GRINS::Visualization::output_adjoint	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system
	)

inherited

Definition at line 138 of file visualization.C.

   {
     this->output_adjoint( equation_system, system, 0, 0.0 );
   }

void GRINS::UnsteadyVisualization::output_residual	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system,
		const unsigned int	time_step,
		const libMesh::Real	time
	)

virtual

Implements GRINS::Visualization.

Definition at line 55 of file unsteady_visualization.C.

   {
     std::stringstream suffix;
     suffix << time_step;
 
     std::string filename = this->_vis_output_file_prefix+"_unsteady_residual";
 
     filename+="."+suffix.str();
 
     // For the unsteady residual, we just want to evaluate F(u) from
     // dU/dt = F(u). What we do is swap out the time solver to a
     // SteadySolver and reassemble the residual. Then, we'll need to swap
     // the solution and the rhs vector stashed in the system. Once we're done,
     // we'll reset the time solver pointer back to the original guy.
 
     libMesh::AutoPtr<libMesh::TimeSolver> prev_time_solver(system->time_solver);
 
     libMesh::SteadySolver* steady_solver = new libMesh::SteadySolver( *(system) );
 
     system->time_solver = libMesh::AutoPtr<libMesh::TimeSolver>(steady_solver);
 
     system->assembly( true /*residual*/, false /*jacobian*/ );
     system->rhs->close();
 
     // Swap solution with newly computed residual
     system->solution->swap( *(system->rhs) );
     // Update equation systems
     equation_system->update();
 
     this->dump_visualization( equation_system, filename, time );
 
     // Now swap back and reupdate
     system->solution->swap( *(system->rhs) );
     equation_system->update();
 
     system->time_solver = prev_time_solver;
 
     return;
   }

void GRINS::Visualization::output_residual	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system
	)

inherited

Definition at line 122 of file visualization.C.

   {
     this->output_residual( equation_system, system, 0, 0.0 );
     return;
   }

void GRINS::UnsteadyVisualization::output_residual_sensitivities	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system,
		const libMesh::ParameterVector &	params,
		const unsigned int	time_step,
		const libMesh::Real	time
	)

virtual

Implements GRINS::Visualization.

Definition at line 99 of file unsteady_visualization.C.

   {
     for (unsigned int p=0; p != params.size(); ++p)
       {
         std::stringstream suffix;
         suffix << time_step;
 
         std::stringstream pstr;
         pstr << p;
 
         std::string filename =
           this->_vis_output_file_prefix + "_unsteady_dRdp" +
           pstr.str() + '.' + suffix.str();
 
         // Swap solution with precomputed sensitivity rhs
         system->solution->swap(system->get_sensitivity_rhs(p));
         equation_system->update();
 
         this->dump_visualization( equation_system, filename, time );
 
         // Now swap back and reupdate
         system->solution->swap(system->get_sensitivity_rhs(p));
         equation_system->update();
       }
   }

void GRINS::Visualization::output_residual_sensitivities	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system,
		const libMesh::ParameterVector &	params
	)

inherited

Definition at line 130 of file visualization.C.

   {
     this->output_residual_sensitivities
       ( equation_system, system, params, 0, 0.0 );
   }

void GRINS::UnsteadyVisualization::output_solution_sensitivities	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system,
		const libMesh::ParameterVector &	params,
		const unsigned int	time_step,
		const libMesh::Real	time
	)

virtual

Implements GRINS::Visualization.

Definition at line 163 of file unsteady_visualization.C.

   {
     for (unsigned int p=0; p != params.size(); ++p)
       {
         std::stringstream suffix;
         suffix << time_step;
 
         std::stringstream pstr;
         pstr << p;
 
         std::string filename =
           this->_vis_output_file_prefix + "_unsteady_dudp" +
           pstr.str() + '.' + suffix.str();
 
         // Swap solution with precomputed sensitivity solution
         system->solution->swap(system->get_sensitivity_solution(p));
         equation_system->update();
 
         this->dump_visualization( equation_system, filename, time );
 
         // Now swap back and reupdate
         system->solution->swap(system->get_sensitivity_solution(p));
         equation_system->update();
       }
   }

void GRINS::Visualization::output_solution_sensitivities	(	std::tr1::shared_ptr< libMesh::EquationSystems >	equation_system,
		GRINS::MultiphysicsSystem *	system,
		const libMesh::ParameterVector &	params
	)

inherited

Definition at line 145 of file visualization.C.

   {
     this->output_solution_sensitivities
       ( equation_system, system, params, 0, 0.0 );
   }

Member Data Documentation

std::vector<std::string> GRINS::Visualization::_output_format

protectedinherited

Definition at line 106 of file visualization.h.

Referenced by GRINS::Visualization::Visualization().

std::string GRINS::Visualization::_vis_output_file_prefix

protectedinherited

Definition at line 105 of file visualization.h.

Referenced by GRINS::Visualization::output(), GRINS::SteadyVisualization::output_adjoint(), and GRINS::SteadyVisualization::output_residual().

The documentation for this class was generated from the following files:

src/visualization/include/grins/unsteady_visualization.h
src/visualization/src/unsteady_visualization.C

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation