VariationalOperatorExpression.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: VariationalOperatorExpression.hpp,v 1.18 2007/11/20 22:24:41 delpinux Exp $

#ifndef VARIATIONAL_OPERATOR_EXPRESSION_HPP
#define VARIATIONAL_OPERATOR_EXPRESSION_HPP

#include <Expression.hpp>

#include <Variable.hpp>

#include <ReferenceCounting.hpp>
#include <FunctionExpression.hpp>

#include <BoundaryExpression.hpp>

#include <VariationalOperator.hpp>

class VariationalBilinearOperatorExpression
  : public Expression
{
public:
  enum OperatorType {
    mugradUgradV,               
    alphaDxUDxV,                
    nuDxUV,                     
    nuUdxV,                     
    alphaUV,                    
  };

private:
  OperatorType __operatorType;  
  ReferenceCounting<BoundaryExpression> __border; 
  void __checkNoBoundaryExpression() const {
    if (this->__hasBoundaryExpression()) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "cannot evaluate the expression \""
                         +stringify(*this)+
                         "\" in the volume",
                         ErrorHandler::normal);
    }
  }

protected:
  virtual void __executeRemaining() = 0;
  virtual bool __hasBoundaryExpression() const = 0;

  std::string __propertyBeginWrite(const VariationalOperator::Property& property) const
  {
    switch(property) {
    case VariationalOperator::mean: {
      return "{";
      break;
    }
    case VariationalOperator::jump: {
      return "[";
      break;
    }
    default: {
      return "";
    }
    }
  }

  std::string __propertyEndWrite(const VariationalOperator::Property& property) const
  {
    switch(property) {
    case VariationalOperator::mean: {
      return "}";
      break;
    }
    case VariationalOperator::jump: {
      return "]";
      break;
    }
    default: {
      return "";
    }
    }
  }

  std::string __unknownTypeBeginWrite() const
  {
    return __propertyBeginWrite(__unknownProperty);
  }

  std::string __unknownTypeEndWrite() const
  {
    return __propertyEndWrite(__unknownProperty);
  }

  std::string __testTypeBeginWrite() const
  {
    return __propertyBeginWrite(__testFunctionProperty);
  }

  std::string __testTypeEndWrite() const
  {
    return __propertyEndWrite(__testFunctionProperty);
  }

  char __directionName(const size_t& i) const
  {
    switch(i) {
    case 0: return 'x';
    case 1: return 'y';
    case 2: return 'z';
    default: {
      throw ErrorHandler(__FILE__,__LINE__,": unknown direction",
                         ErrorHandler::unexpected);
      return '0';
    }
    }
  }


  const std::string
  __unknownName;                
  const VariationalOperator::Property
  __unknownProperty;            
  const std::string
  __testFunctionName;           
  const VariationalOperator::Property
  __testFunctionProperty;       
public:

  ReferenceCounting<BoundaryExpression> border() const
  {
    return __border;
  }

  void execute()
  {
    if(__border != 0) {
      (*__border).execute();
    }
    __executeRemaining();
    if(__border == 0) {
      __checkNoBoundaryExpression();
    }
  }
  OperatorType operatorType()
  {
    return __operatorType;
  }

  const std::string& unknownName() const
  {
    return __unknownName;
  }

  const std::string& testFunctionName() const
  {
    return __testFunctionName;
  }

  const VariationalOperator::Property& unknownProperty() const
  {
    return __unknownProperty;
  }

  const VariationalOperator::Property& testFunctionProperty() const
  {
    return __testFunctionProperty;
  }

  VariationalBilinearOperatorExpression(const VariationalBilinearOperatorExpression& V)
    : Expression(V),
      __operatorType(V.__operatorType),
      __border(V.__border),
      __unknownName(V.__unknownName),
      __unknownProperty(V.__unknownProperty),
      __testFunctionName(V.__testFunctionName),
      __testFunctionProperty(V.__testFunctionProperty)
  {
    ;
  }

  VariationalBilinearOperatorExpression(VariationalBilinearOperatorExpression::OperatorType type,
                                        ReferenceCounting<BoundaryExpression> border,
                                        const std::string& unknownName,
                                        const VariationalOperator::Property& unknownProperty,
                                        const std::string& testFunctionName,
                                        const VariationalOperator::Property& testFunctionProperty)
    : Expression(Expression::variationalBilinearOperator),
      __operatorType(type),
      __border(border),
      __unknownName(unknownName),
      __unknownProperty(unknownProperty),
      __testFunctionName(testFunctionName),
      __testFunctionProperty(testFunctionProperty)
  {
    ;
  }

  virtual ~VariationalBilinearOperatorExpression()
  {
    ;
  }
};

class VariationalLinearOperatorExpression
  : public Expression
{
public:
  enum OperatorType {
    FV,                         
    FdxGV,                      
    FdxV,                       
    FgradGgradV                 
  };

private:
  const OperatorType
  __operatorType;               
  ReferenceCounting<BoundaryExpression> __border; 
  virtual void __executeRemaining() = 0;
  void __checkNoBoundaryExpression() const {
    if (this->__hasBoundaryExpression()) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "cannot evaluate the expression \""
                         +stringify(*this)+
                         "\" in the volume",
                         ErrorHandler::normal);
    }
  }

protected:

  std::string __propertyBeginWrite(const VariationalOperator::Property& property) const
  {
    switch(property) {
    case VariationalOperator::mean: {
      return "{";
      break;
    }
    case VariationalOperator::jump: {
      return "[";
      break;
    }
    default: {
      return "";
    }
    }
  }

  std::string __propertyEndWrite(const VariationalOperator::Property& property) const
  {
    switch(property) {
    case VariationalOperator::mean: {
      return "}";
      break;
    }
    case VariationalOperator::jump: {
      return "]";
      break;
    }
    default: {
      return "";
    }
    }
  }

  std::string __testTypeBeginWrite() const
  {
    return __propertyBeginWrite(__testFunctionProperty);
  }

  std::string __testTypeEndWrite() const
  {
    return __propertyEndWrite(__testFunctionProperty);
  }

  virtual bool __hasBoundaryExpression() const = 0;

  char __directionName(const size_t& i) const
  {
    switch(i) {
    case 0: return 'x';
    case 1: return 'y';
    case 2: return 'z';
    default: {
      throw ErrorHandler(__FILE__,__LINE__,": unknown direction",
                         ErrorHandler::unexpected);
      return '0';
    }
    }
  }

  const std::string
  __testFunctionName;           
  const VariationalOperator::Property
  __testFunctionProperty;       
public:
  ReferenceCounting<BoundaryExpression> border() const
  {
    return __border;
  }

  void execute()
  {
    if(__border != 0) {
      (*__border).execute();
    }
    __executeRemaining();
    if(__border == 0) {
      __checkNoBoundaryExpression();
    }

  }

  OperatorType operatorType()
  {
    return __operatorType;
  }

  const std::string& testFunctionName() const
  {
    return __testFunctionName;
  }

  VariationalLinearOperatorExpression(const VariationalLinearOperatorExpression& V)
    : Expression(V),
      __operatorType(V.__operatorType),
      __border(V.__border),
      __testFunctionName(V.__testFunctionName),
      __testFunctionProperty(V.__testFunctionProperty)
  {
    ;
  }

  VariationalLinearOperatorExpression(VariationalLinearOperatorExpression::OperatorType type,
                                      ReferenceCounting<BoundaryExpression> border,
                                      const std::string& testFunctionName,
                                      const VariationalOperator::Property& testFunctionProperty)
    : Expression(Expression::variationalBilinearOperator),
      __operatorType(type),
      __border(border),
      __testFunctionName(testFunctionName),
      __testFunctionProperty(testFunctionProperty)
  {
    ;
  }

  virtual ~VariationalLinearOperatorExpression()
  {
    ;
  }
};

/**********************
 * BILINEAR OPERATORS *
 **********************/

class VariationalMuGradUGradVExpression
  : public VariationalBilinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __mu; 
  bool __hasBoundaryExpression() const
  {
    return (*__mu).hasBoundaryExpression();
  }

public:

  ReferenceCounting<FunctionExpression> mu()
  {
    return __mu;
  }

  void __executeRemaining()
  {
    (*__mu).execute();
  }

  std::ostream& put(std::ostream& os) const
  {
    os << *__mu
       << '*'
       << this->__unknownTypeBeginWrite()
       << "grad(" << __unknownName << ')'
       << this->__unknownTypeEndWrite()
       << '*'
       << this->__testTypeBeginWrite()
       << "grad(" << __testFunctionName << ')'
       << this->__testTypeEndWrite();
    return os;
  }

  VariationalMuGradUGradVExpression(ReferenceCounting<FunctionExpression> mu,
                                    const std::string& unknownName,
                                    const VariationalOperator::Property& unknownProperty,
                                    const std::string& testFunctionName,
                                    const VariationalOperator::Property& testFunctionProperty,
                                    ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalBilinearOperatorExpression(VariationalBilinearOperatorExpression::
                                            mugradUgradV,
                                            border,
                                            unknownName,
                                            unknownProperty,
                                            testFunctionName,
                                            testFunctionProperty),
      __mu(mu)
  {
    ;
  }

  VariationalMuGradUGradVExpression(const VariationalMuGradUGradVExpression& V)
    : VariationalBilinearOperatorExpression(V),
      __mu(V.__mu)
  {
    ;
  }


  ~VariationalMuGradUGradVExpression()
  {
    ;
  }
};


class VariationalAlphaDxUDxVExpression
  : public VariationalBilinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __Alpha; 
  size_t __i;                   
  size_t __j;                   
  std::ostream& put(std::ostream& os) const
  {
    os << *__Alpha
       << '*'
       << this->__unknownTypeBeginWrite()
       << 'd' << __directionName(__j) << '(' << __unknownName << ')'
       << this->__unknownTypeEndWrite()
       << '*'
       << this->__testTypeBeginWrite()
       << 'd' << __directionName(__i) << '(' << __testFunctionName << ')'
       << this->__testTypeEndWrite();
    return os;
  }

  bool __hasBoundaryExpression() const
  {
    return (*__Alpha).hasBoundaryExpression();
  }

public:
  ReferenceCounting<FunctionExpression> alpha()
  {
    return __Alpha;
  }

  const size_t& i() const
  {
    return __i;
  }

  const size_t& j() const
  {
    return __j;
  }

  void __executeRemaining()
  {
    (*__Alpha).execute();
  }

  VariationalAlphaDxUDxVExpression(ReferenceCounting<FunctionExpression> alpha,
                                   const size_t i,
                                   const size_t j,
                                   const std::string& unknownName,
                                   const VariationalOperator::Property& unknownProperty,
                                   const std::string& testFunctionName,
                                   const VariationalOperator::Property& testFunctionProperty,
                                   ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalBilinearOperatorExpression(VariationalBilinearOperatorExpression::
                                            alphaDxUDxV,
                                            border,
                                            unknownName,
                                            unknownProperty,
                                            testFunctionName,
                                            testFunctionProperty),
      __Alpha(alpha),
      __i(i),
      __j(j)
  {
    ;
  }

  VariationalAlphaDxUDxVExpression(const VariationalAlphaDxUDxVExpression& V)
    : VariationalBilinearOperatorExpression(V),
      __Alpha(V.__Alpha),
      __i(V.__i),
      __j(V.__j)
  {
    ;
  }

  ~VariationalAlphaDxUDxVExpression()
  {
    ;
  }
};



class VariationalNuUdxVExpression
  : public VariationalBilinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __nu; 
  size_t __number;              
  std::ostream& put(std::ostream& os) const
  {
    os << *__nu
       << '*'
       << this->__unknownTypeBeginWrite()
       << __unknownName
       << this->__unknownTypeEndWrite()
       << '*'
       << this->__testTypeBeginWrite()
       << 'd' << __directionName(__number) << '(' << __testFunctionName << ')'
       << this->__testTypeEndWrite();

    return os;
  }

  bool __hasBoundaryExpression() const
  {
    return (*__nu).hasBoundaryExpression();
  }

public:
  ReferenceCounting<FunctionExpression> nu()
  {
    return __nu;
  }

  const size_t& number() const
  {
    return __number;
  }

  void __executeRemaining()
  {
    (*__nu).execute();
  }

  VariationalNuUdxVExpression(ReferenceCounting<FunctionExpression> nu,
                              const size_t& number,
                              const std::string& unknownName,
                              const VariationalOperator::Property& unknownProperty,
                              const std::string& testFunctionName,
                              const VariationalOperator::Property& testFunctionProperty,
                              ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalBilinearOperatorExpression(VariationalBilinearOperatorExpression::
                                            nuUdxV,
                                            border,
                                            unknownName,
                                            unknownProperty,
                                            testFunctionName,
                                            testFunctionProperty),
      __nu(nu),
      __number(number)
  {
    ;
  }

  VariationalNuUdxVExpression(const VariationalNuUdxVExpression& V)
    : VariationalBilinearOperatorExpression(V),
      __nu(V.__nu),
      __number(V.__number)
  {
    ;
  }

  ~VariationalNuUdxVExpression()
  {
    ;
  }
};

class VariationalNuDxUVExpression
  : public VariationalBilinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __nu; 
  size_t __number;              
  std::ostream& put(std::ostream& os) const
  {
    os << *__nu
       << '*'
       << this->__unknownTypeBeginWrite()
       << 'd' << __directionName(__number) << '(' << __unknownName << ')'
       << this->__unknownTypeEndWrite()
       << '*'
       << this->__testTypeBeginWrite()
       << __testFunctionName
       << this->__testTypeEndWrite();
    return os;
  }

  bool __hasBoundaryExpression() const
  {
    return (*__nu).hasBoundaryExpression();
  }

public:
  ReferenceCounting<FunctionExpression> nu()
  {
    return __nu;
  }

  const size_t& number() const
  {
    return __number;
  }

  void __executeRemaining()
  {
    (*__nu).execute();
  }

  VariationalNuDxUVExpression(ReferenceCounting<FunctionExpression> nu,
                              const size_t& number,
                              const std::string& unknownName,
                              const VariationalOperator::Property& unknownProperty,
                              const std::string& testFunctionName,
                              const VariationalOperator::Property& testFunctionProperty,
                              ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalBilinearOperatorExpression(VariationalBilinearOperatorExpression::
                                            nuDxUV,
                                            border,
                                            unknownName,
                                            unknownProperty,
                                            testFunctionName,
                                            testFunctionProperty),
      __nu(nu),
      __number(number)
  {
    ;
  }

  VariationalNuDxUVExpression(const VariationalNuDxUVExpression& V)
    : VariationalBilinearOperatorExpression(V),
      __nu(V.__nu),
      __number(V.__number)
  {
    ;
  }

  ~VariationalNuDxUVExpression()
  {
    ;
  }
};


class VariationalAlphaUVExpression
  : public VariationalBilinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __Alpha; 
  bool __hasBoundaryExpression() const
  {
    return (*__Alpha).hasBoundaryExpression();
  }

  void __executeRemaining()
  {
    (*__Alpha).execute();
  }

public:
  ReferenceCounting<FunctionExpression> alpha()
  {
    return __Alpha;
  }

  std::ostream& put(std::ostream& os) const
  {
    os << *__Alpha
       << '*'
       << this->__unknownTypeBeginWrite()
       << __unknownName
       << this->__unknownTypeEndWrite()
       << '*'
       << this->__testTypeBeginWrite()
       << __testFunctionName
       << this->__testTypeEndWrite();
    return os;
  }

  VariationalAlphaUVExpression(ReferenceCounting<FunctionExpression> alpha,
                               const std::string& unknownName,
                               const VariationalOperator::Property& unknownProperty,
                               const std::string& testFunctionName,
                               const VariationalOperator::Property& testFunctionProperty,
                               ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalBilinearOperatorExpression(VariationalBilinearOperatorExpression::alphaUV,
                                            border,
                                            unknownName,
                                            unknownProperty,
                                            testFunctionName,
                                            testFunctionProperty),
      __Alpha(alpha)
  {
    ;
  }

  VariationalAlphaUVExpression(const VariationalAlphaUVExpression& V)
    : VariationalBilinearOperatorExpression(V),
      __Alpha(V.__Alpha)
  {
    ;
  }

  ~VariationalAlphaUVExpression()
  {
    ;
  }
};


/********************
 * LINEAR OPERATORS *
 ********************/

class VariationalFVExpression
  : public VariationalLinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __f; 
  void __executeRemaining()
  {
    (*__f).execute();
  }


  bool __hasBoundaryExpression() const
  {
    return (*__f).hasBoundaryExpression();
  }

  std::ostream& put(std::ostream& os) const
  {
    os << *__f
       << '*'
       << this->__testTypeBeginWrite()
       << __testFunctionName
       << this->__testTypeEndWrite();
    return os;
  }

public:

  ReferenceCounting<FunctionExpression> f()
  {
    return __f;
  }

  VariationalFVExpression(ReferenceCounting<FunctionExpression> f,
                          const std::string& testFunctionName,
                          const VariationalOperator::Property& testFunctionProperty,
                          ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalLinearOperatorExpression(VariationalLinearOperatorExpression::FV,
                                          border, testFunctionName, testFunctionProperty),
      __f(f)
  {
    ;
  }

  VariationalFVExpression(const VariationalFVExpression& V)
    : VariationalLinearOperatorExpression(V),
      __f(V.__f)
  {
    ;
  }

  ~VariationalFVExpression()
  {
    ;
  }
};

class VariationalFdxGVExpression
  : public VariationalLinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __f; 
  ReferenceCounting<FunctionExpression> __g; 
  const size_t __number;        
  bool __hasBoundaryExpression() const
  {
    return ((*__f).hasBoundaryExpression() or
            (*__g).hasBoundaryExpression());
  }

  void __executeRemaining()
  {
    (*__f).execute();
    (*__g).execute();
  }

  std::ostream& put(std::ostream& os) const
  {
    os << *__f << '*'
       << 'd'<< __directionName(__number) << '(' << *__g << ')'
       << this->__testTypeBeginWrite()
       << '*' << __testFunctionName
       << this->__testTypeEndWrite();
    return os;
  }

public:
  const size_t& number() const
  {
    return __number;
  }

  ReferenceCounting<FunctionExpression> f()
  {
    return __f;
  }

  ReferenceCounting<FunctionExpression> g()
  {
    return __g;
  }

  VariationalFdxGVExpression(ReferenceCounting<FunctionExpression> f,
                             ReferenceCounting<FunctionExpression> g,
                             const std::string& testFunctionName,
                             const VariationalOperator::Property& testFunctionProperty,
                             const size_t& n,
                             ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalLinearOperatorExpression(VariationalLinearOperatorExpression::FdxGV,
                                          border, testFunctionName, testFunctionProperty),
      __f(f),
      __g(g),
      __number(n)
  {
    ;
  }

  VariationalFdxGVExpression(const VariationalFdxGVExpression& V)
    : VariationalLinearOperatorExpression(V),
      __f(V.__f),
      __g(V.__g),
      __number(V.__number)
  {
    ;
  }


  ~VariationalFdxGVExpression()
  {
    ;
  }
};

class VariationalFdxVExpression
  : public VariationalLinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __f; 
  const size_t __number;        
  bool __hasBoundaryExpression() const
  {
    return __f->hasBoundaryExpression();
  }

  void __executeRemaining()
  {
    __f->execute();
  }

  std::ostream& put(std::ostream& os) const
  {
    os << *__f << '*'
       << this->__testTypeBeginWrite()
       <<'d'<< __directionName(__number) << '(' <<  __testFunctionName << ')'
       << this->__testTypeEndWrite();
    return os;
  }

public:
  const size_t& number() const
  {
    return __number;
  }

  ReferenceCounting<FunctionExpression> f()
  {
    return __f;
  }

  VariationalFdxVExpression(ReferenceCounting<FunctionExpression> f,
                            const std::string& testFunctionName,
                            const VariationalOperator::Property& testFunctionProperty,
                            const size_t& n,
                            ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalLinearOperatorExpression(VariationalLinearOperatorExpression::FdxV,
                                          border, testFunctionName, testFunctionProperty),
      __f(f),
      __number(n)
  {
    ;
  }

  VariationalFdxVExpression(const VariationalFdxVExpression& V)
    : VariationalLinearOperatorExpression(V),
      __f(V.__f),
      __number(V.__number)
  {
    ;
  }

  ~VariationalFdxVExpression()
  {
    ;
  }
};

class VariationalFgradGgradVExpression
  : public VariationalLinearOperatorExpression
{
private:
  ReferenceCounting<FunctionExpression> __f; 
  ReferenceCounting<FunctionExpression> __g; 
  void __executeRemaining()
  {
    (*__f).execute();
    (*__g).execute();
  }

  bool __hasBoundaryExpression() const
  {
    return ((*__f).hasBoundaryExpression() or
            (*__g).hasBoundaryExpression());
  }

  std::ostream& put(std::ostream& os) const
  {
    os << *__f << "*grad("<< *__g << ')'
       <<'*'
       << this->__testTypeBeginWrite()
       << "grad(" << __testFunctionName << ')'
       << this->__testTypeEndWrite();
    return os;
  }

public:
  ReferenceCounting<FunctionExpression> f()
  {
    return __f;
  }

  ReferenceCounting<FunctionExpression> g()
  {
    return __g;
  }


  VariationalFgradGgradVExpression(ReferenceCounting<FunctionExpression> f,
                                   ReferenceCounting<FunctionExpression> g,
                                   const std::string& testFunctionName,
                                   const VariationalOperator::Property& testFunctionProperty,
                                   ReferenceCounting<BoundaryExpression> border = 0)
    : VariationalLinearOperatorExpression(VariationalLinearOperatorExpression::FgradGgradV,
                                          border, testFunctionName, testFunctionProperty),
      __f(f),
      __g(g)
  {
    ;
  }

  VariationalFgradGgradVExpression(const VariationalFgradGgradVExpression& V)
    : VariationalLinearOperatorExpression(V),
      __f(V.__f),
      __g(V.__g)
  {
    ;
  }


  ~VariationalFgradGgradVExpression()
  {
    ;
  }
};

#endif // VARIATIONAL_OPERATOR_EXPRESSION_HPP

---