Home
Publications
Presentations
Support
Download
Examples
Developers
Class Docs
Namespaces
Classes
Files
Mailing Lists
Gallery
Wiki

diff_system.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2012 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
  
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
  
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



#ifndef LIBMESH_DIFF_SYSTEM_H
#define LIBMESH_DIFF_SYSTEM_H

// Local Includes
#include "libmesh/auto_ptr.h"
#include "libmesh/diff_context.h"
#include "libmesh/diff_physics.h"
#include "libmesh/diff_qoi.h"
#include "libmesh/implicit_system.h"
#include "libmesh/time_solver.h"

// C++ includes

namespace libMesh
{

// Forward Declarations
class TimeSolver;

template <typename T> class NumericVector;

// ------------------------------------------------------------
// DifferentiableSystem class definition

class DifferentiableSystem : public ImplicitSystem,
                             public virtual DifferentiablePhysics,
                             public virtual DifferentiableQoI
{
public:

  DifferentiableSystem (EquationSystems& es,
                        const std::string& name,
                        const unsigned int number);

  virtual ~DifferentiableSystem ();

  typedef DifferentiableSystem sys_type;

  typedef ImplicitSystem Parent;
  
  virtual void clear ();

  virtual void reinit ();
   
  virtual void assemble ();

  virtual LinearSolver<Number> *get_linear_solver() const;

  virtual std::pair<unsigned int, Real>
    get_linear_solve_parameters() const;

  virtual void release_linear_solver(LinearSolver<Number> *) const;

  virtual void assembly (bool get_residual, bool get_jacobian) = 0;

  virtual void solve ();

  virtual std::pair<unsigned int, Real> adjoint_solve (const QoISet& qoi_indices = QoISet());

  virtual AutoPtr<DifferentiablePhysics> clone_physics()
  { libmesh_error(); 
    // dummy
    return AutoPtr<DifferentiablePhysics>(this); }

  virtual AutoPtr<DifferentiableQoI> clone()
  { libmesh_error(); 
    // dummy
    return AutoPtr<DifferentiableQoI>(this); }

  const DifferentiablePhysics* get_physics() const
  { return this->_diff_physics; }

  DifferentiablePhysics* get_physics()
  { return this->_diff_physics; }

  void attach_physics( DifferentiablePhysics* physics_in )
  { this->_diff_physics = (physics_in->clone_physics()).release();
    this->_diff_physics->init_physics(*this);}

  const DifferentiableQoI* get_qoi() const
  { return this->diff_qoi; }

  DifferentiableQoI* get_qoi()
  { return this->diff_qoi; }

  void attach_qoi( DifferentiableQoI* qoi_in )
  { this->diff_qoi = (qoi_in->clone()).release();
    // User needs to resize qoi system qoi accordingly
    this->diff_qoi->init_qoi( this->qoi );}
 
  AutoPtr<TimeSolver> time_solver;

  void set_time_solver(AutoPtr<TimeSolver> _time_solver)
  {
    time_solver = _time_solver;
  }

  TimeSolver& get_time_solver();

  const TimeSolver& get_time_solver() const;

  Real deltat;

  virtual AutoPtr<DiffContext> build_context();

  virtual void postprocess (){}

  virtual void element_postprocess (DiffContext &) {}
  
  virtual void side_postprocess (DiffContext &) {}

  bool postprocess_sides;

  bool print_solution_norms;

  bool print_solutions;

  bool print_residual_norms;

  bool print_residuals;

  bool print_jacobian_norms;

  bool print_jacobians;

  bool print_element_jacobians;

protected:

  DifferentiablePhysics *_diff_physics;
 
  DifferentiableQoI* diff_qoi;

  virtual void init_data ();
};

// --------------------------------------------------------------
// DifferentiableSystem inline methods
inline
  TimeSolver& DifferentiableSystem::get_time_solver() 
{
  libmesh_assert(time_solver.get());
  libmesh_assert_equal_to (&(time_solver->system()), this);
  return *time_solver;
}

inline
 const TimeSolver& DifferentiableSystem::get_time_solver() const
{
  libmesh_assert(time_solver.get());
  libmesh_assert_equal_to (&(time_solver->system()), this);
  return *time_solver;
}

} // namespace libMesh


#endif // LIBMESH_DIFF_SYSTEM_H

---

Site Created By: libMesh Developers
Last modified: February 05 2013 19:54:46 UTC

Hosted By: