SecondOrderOperator.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, or (at your option)
//  any later version.

//  This program 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 General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: SecondOrderOperator.hpp,v 1.5 2007/11/20 22:00:05 delpinux Exp $

#ifndef SECOND_ORDER_OPERATOR_HPP
#define SECOND_ORDER_OPERATOR_HPP

#include <TinyMatrix.hpp>
#include <PDEOperator.hpp>

class SecondOrderOperator
  : public PDEOperator
{
public:
  typedef
  TinyMatrix<3,3, ConstReferenceCounting<ScalarFunctionBase> >
  Matrix;                       
private:
  ConstReferenceCounting<SecondOrderOperator::Matrix>
  __A;                          
public:
  bool isSet(const int&i,
             const int&j) const
  {
    return ((*__A)(i,j) != 0);
  }

  std::string typeName() const
  {
    return "SecondOrderOperator";
  }

  ConstReferenceCounting<ScalarFunctionBase>
  A(const int&i, const int&j) const
  {
    return (*__A)(i,j);
  }

  ConstReferenceCounting<SecondOrderOperator::Matrix>
  A() const
  {
    return __A;
  }

  ConstReferenceCounting<PDEOperator>
  operator*(const ConstReferenceCounting<ScalarFunctionBase>& c) const
  {
    ReferenceCounting<SecondOrderOperator::Matrix> A2
      = new SecondOrderOperator::Matrix;

    for (size_t i=0; i<3; ++i)
      for (size_t j=0; j<3; ++j) {
        if ((*__A)(i,j) != 0) {
          ScalarFunctionBuilder functionBuilder;
          functionBuilder.setFunction((*__A)(i,j));
          functionBuilder.setBinaryOperation(BinaryOperation::product,c);
          (*A2)(i,j) = functionBuilder.getBuiltFunction();
        }
      }

    return (new SecondOrderOperator(A2));
  }


  ConstReferenceCounting<PDEOperator>
  operator-() const
 {
   ReferenceCounting<SecondOrderOperator::Matrix> A2
     = new SecondOrderOperator::Matrix;

    for (size_t i=0; i<3; ++i)
      for (size_t j=0; j<3; ++j) {
        if ((*__A)(i,j) != 0) {
          ScalarFunctionBuilder functionBuilder;
          functionBuilder.setFunction((*__A)(i,j));
          functionBuilder.setUnaryMinus();
          (*A2)(i,j) = functionBuilder.getBuiltFunction();
        }
      }

    return (new SecondOrderOperator(A2));
  }

  SecondOrderOperator(ReferenceCounting<SecondOrderOperator::Matrix> A)
    : PDEOperator(PDEOperator::secondorderop,
                  9),
      __A(A)
  {
    ;
  }

  SecondOrderOperator(const SecondOrderOperator& O)
    : PDEOperator(O),
      __A(O.__A)
  {
    ;
  }

  ~SecondOrderOperator()
  {
    ;
  }
};

#endif // SECOND_ORDER_OPERATOR_HPP

---