FEApp_InitPostOps.hpp

Go to the documentation of this file.

// $Id: FEApp_InitPostOps.hpp,v 1.5 2007/07/09 17:04:02 etphipp Exp $ 
// $Source: /space/CVS/Trilinos/packages/sacado/example/FEApp/FEApp_InitPostOps.hpp,v $ 
// @HEADER
// ***********************************************************************
// 
//                           Sacado Package
//                 Copyright (2006) Sandia Corporation
// 
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
// 
// 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
// Questions? Contact David M. Gay (dmgay@sandia.gov) or Eric T. Phipps
// (etphipp@sandia.gov).
// 
// ***********************************************************************
// @HEADER

#ifndef FEAPP_INITPOSTOPS_HPP
#define FEAPP_INITPOSTOPS_HPP

#include "Teuchos_RCP.hpp"
#include "Teuchos_SerialDenseMatrix.hpp"
#include "Epetra_Vector.h"
#include "Epetra_CrsMatrix.h"

#include "FEApp_AbstractInitPostOp.hpp"

#include "Sacado_Fad_DFad.hpp"
#include "Sacado_ScalarParameterVector.hpp"

namespace FEApp {

  class ResidualOp : public FEApp::AbstractInitPostOp<double> {
  public:
    

    ResidualOp(
      const Teuchos::RCP<const Epetra_Vector>& overlapped_xdot,
      const Teuchos::RCP<const Epetra_Vector>& overlapped_x,
      const Teuchos::RCP<Epetra_Vector>& overlapped_f);

    virtual ~ResidualOp();
    
    virtual void elementInit(const FEApp::AbstractElement& e,
           unsigned int neqn,
           std::vector<double>* elem_xdot,
           std::vector<double>& elem_x);

    virtual void elementPost(const FEApp::AbstractElement& e,
           unsigned int neqn,
           std::vector<double>& elem_f);

    virtual void nodeInit(const FEApp::NodeBC& bc,
        unsigned int neqn,
        std::vector<double>* node_xdot,
        std::vector<double>& node_x);

    virtual void nodePost(const FEApp::NodeBC& bc,
        unsigned int neqn,
        std::vector<double>& node_f);

  private:
    
    ResidualOp(const ResidualOp&);

    ResidualOp& operator=(const ResidualOp&);

  protected:

    Teuchos::RCP<const Epetra_Vector> xdot;

    Teuchos::RCP<const Epetra_Vector> x;

    Teuchos::RCP<Epetra_Vector> f;

  };

  class JacobianOp : 
    public FEApp::AbstractInitPostOp< Sacado::Fad::DFad<double> > {
  public:


    JacobianOp(
      double alpha, double beta,
      const Teuchos::RCP<const Epetra_Vector>& overlapped_xdot,
      const Teuchos::RCP<const Epetra_Vector>& overlapped_x,
      const Teuchos::RCP<Epetra_Vector>& overlapped_f,
      const Teuchos::RCP<Epetra_CrsMatrix>& overlapped_jac);

    virtual ~JacobianOp();

    virtual void elementInit(
       const FEApp::AbstractElement& e,
       unsigned int neqn,
       std::vector< Sacado::Fad::DFad<double> >* elem_xdot,
       std::vector< Sacado::Fad::DFad<double> >& elem_x);

    virtual void elementPost(const FEApp::AbstractElement& e,
           unsigned int neqn,
           std::vector< Sacado::Fad::DFad<double> >& elem_f);

    virtual void nodeInit(const FEApp::NodeBC& bc,
        unsigned int neqn,
        std::vector< Sacado::Fad::DFad<double> >* node_xdot,
        std::vector< Sacado::Fad::DFad<double> >& node_x);

    virtual void nodePost(const FEApp::NodeBC& bc,
        unsigned int neqn,
        std::vector< Sacado::Fad::DFad<double> >& node_f);

  private:
    
    JacobianOp(const JacobianOp&);
    
    JacobianOp& operator=(const JacobianOp&);

  protected:

    double m_coeff;

    double j_coeff;

    Teuchos::RCP<const Epetra_Vector> xdot;

    Teuchos::RCP<const Epetra_Vector> x;

    Teuchos::RCP<Epetra_Vector> f;

    Teuchos::RCP<Epetra_CrsMatrix> jac;

  };

  class TangentOp : 
    public FEApp::AbstractInitPostOp< Sacado::Fad::DFad<double> > {
  public:


    TangentOp(
  double alpha, double beta, bool sum_derivs,
  const Teuchos::RCP<const Epetra_Vector>& overlapped_xdot,
  const Teuchos::RCP<const Epetra_Vector>& overlapped_x,
  const Teuchos::RCP<Sacado::ScalarParameterVector>& p,
  const Teuchos::RCP<const Epetra_MultiVector>& overlapped_Vx,
  const Teuchos::RCP<const Epetra_MultiVector>& overlapped_Vxdot,
  const Teuchos::RCP<const Teuchos::SerialDenseMatrix<int,double> >& Vp,
  const Teuchos::RCP<Epetra_Vector>& overlapped_f,
  const Teuchos::RCP<Epetra_MultiVector>& overlapped_JV,
  const Teuchos::RCP<Epetra_MultiVector>& overlapped_fp);

    virtual ~TangentOp();

    virtual void elementInit(
       const FEApp::AbstractElement& e,
       unsigned int neqn,
       std::vector< Sacado::Fad::DFad<double> >* elem_xdot,
       std::vector< Sacado::Fad::DFad<double> >& elem_x);

    virtual void elementPost(const FEApp::AbstractElement& e,
           unsigned int neqn,
           std::vector< Sacado::Fad::DFad<double> >& elem_f);

    virtual void nodeInit(const FEApp::NodeBC& bc,
        unsigned int neqn,
        std::vector< Sacado::Fad::DFad<double> >* node_xdot,
        std::vector< Sacado::Fad::DFad<double> >& node_x);

    virtual void nodePost(const FEApp::NodeBC& bc,
        unsigned int neqn,
        std::vector< Sacado::Fad::DFad<double> >& node_f);

  private:
    
    TangentOp(const TangentOp&);
    
    TangentOp& operator=(const TangentOp&);

  protected:

    double m_coeff;

    double j_coeff;

    bool sum_derivs;

    Teuchos::RCP<const Epetra_Vector> xdot;

    Teuchos::RCP<const Epetra_Vector> x;

    Teuchos::RCP<Sacado::ScalarParameterVector> params;

    Teuchos::RCP<const Epetra_MultiVector> Vx;

    Teuchos::RCP<const Epetra_MultiVector> Vxdot;

    Teuchos::RCP<const Teuchos::SerialDenseMatrix<int,double> > Vp;

    Teuchos::RCP<Epetra_Vector> f;

    Teuchos::RCP<Epetra_MultiVector> JV;
    
    Teuchos::RCP<Epetra_MultiVector> fp;

    int num_cols_x;

    int num_cols_p;

    int num_cols_tot;

    int param_offset;

  };

}

#endif // FEAPP_INITPOSTOPS_HPP

---