ScalarFunctionBase.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: ScalarFunctionBase.hpp,v 1.11 2008/01/31 21:38:15 delpinux Exp $

#ifndef SCALAR_FUNCTION_BASE_HPP
#define SCALAR_FUNCTION_BASE_HPP

#include <Types.hpp>
#include <TinyVector.hpp>

#include <iostream>
#include <ErrorHandler.hpp>

class ScalarFunctionBase
{
public:
  enum Type {
    cfunction,
    constant,
    convection,
    dgfunction,
    femfunction,
    linearBasis,
    spectral,
    unaryMinus,

    modulo,
    sum,
    difference,
    product,
    division,
    power,

    min,
    max,

    gt,
    ge,
    lt,
    le,
    ne,
    eq,
    and_,
    or_,
    xor_,

    not_,

    derivate,
    integrate,

    normal,

    domainCharacteristic,
    meshCharacteristic,
    objectCharacteristic,

    composed,
    references,

    FEM0,

    undefined
  };

protected:
  const Type __type;            
  std::string __name;           
  virtual std::ostream& __put(std::ostream& os) const = 0;

public:
  void setName(const std::string& name)
  {
    __name = name;
  }

  const std::string& name() const
  {
    return __name;
  }

  inline const Type& type() const
  {
    return __type;
  }

  friend std::ostream& operator<<(std::ostream& os,
                                  const ScalarFunctionBase& scalarFunction)
  {
    if (scalarFunction.__name.size()>0) {
      os << scalarFunction.__name;
      return os;
    } else {
      return scalarFunction.__put(os);
    }
  }

  inline real_t operator()(const real_t& x,
                           const real_t& y,
                           const real_t& z) const
  {
    return this->operator()(TinyVector<3, real_t>(x,y,z));    
  }

  virtual real_t operator()(const TinyVector<3, real_t>& X) const = 0;

  virtual real_t dx(const TinyVector<3, real_t>& x) const
  {
    std::stringstream errorMsg;

    errorMsg << "cannot compute derivative of non discrete functions :-(\n";
    errorMsg << "the function " << (*this) << " is not of that kind"
             << std::ends;

    throw ErrorHandler(__FILE__,__LINE__,
                       errorMsg.str(),
                       ErrorHandler::normal);
    return 0;
  }

  virtual real_t dy(const TinyVector<3, real_t>& x) const
  {
    std::stringstream errorMsg;

    errorMsg << "cannot compute derivative of non discrete functions :-(\n";
    errorMsg << "the function " << (*this) << " is not of that kind"
             << std::ends;

    throw ErrorHandler(__FILE__,__LINE__,
                       errorMsg.str(),
                       ErrorHandler::normal);
    return 0;
  }

  virtual real_t dz(const TinyVector<3, real_t>& x) const
  {
    std::stringstream errorMsg;

    errorMsg << "cannot compute derivative of non discrete functions :-(\n";
    errorMsg << "the function " << (*this) << " is not of that kind"
             << std::ends;

    throw ErrorHandler(__FILE__,__LINE__,
                       errorMsg.str(),
                       ErrorHandler::normal);
    return 0;
  }

  virtual bool canBeSimplified() const = 0;

  ScalarFunctionBase(const ScalarFunctionBase& f)
    : __type(f.__type),
      __name(f.__name)
  {
    ;
  }

  ScalarFunctionBase(const Type& type)
    : __type(type),
      __name("")
  {
    ;
  }

  virtual ~ScalarFunctionBase()
  {
    ;
  }
};

#endif // SCALAR_FUNCTION_BASE_HPP

---