VariationalProblem.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: VariationalProblem.hpp,v 1.8 2007/11/02 20:02:20 delpinux Exp $

#ifndef VARIATIONAL_PROBLEM_HPP
#define VARIATIONAL_PROBLEM_HPP

#include <list>

#include <Problem.hpp>

#include <VariationalBilinearBorderOperator.hpp>
#include <VariationalLinearBorderOperator.hpp>

#include <VariationalBilinearOperator.hpp>
#include <VariationalLinearOperator.hpp>

#include <BoundaryConditionSet.hpp>

class VariationalProblem
  : public Problem
{
private:
  typedef std::list <ConstReferenceCounting<VariationalBilinearOperator> >
  BilinearOperatorListType;

  BilinearOperatorListType
  __bilinearOperatorList;       
  typedef std::list <ConstReferenceCounting<VariationalLinearOperator> >
  LinearOperatorListType;

  LinearOperatorListType
  __linearOperatorList;         
  typedef std::list <ConstReferenceCounting<VariationalBilinearBorderOperator> >
  BilinearBorderOperatorListType;

  BilinearBorderOperatorListType
  __bilinearBorderOperatorList; 
  typedef std::list <ConstReferenceCounting<VariationalLinearBorderOperator> >
  LinearBorderOperatorListType;

  LinearBorderOperatorListType
  __linearBorderOperatorList; 
  std::vector<ConstReferenceCounting<BoundaryConditionSet> >
  __bc;                         
public:
  typedef BilinearOperatorListType::iterator bilinearOperatorIterator;
  typedef BilinearOperatorListType::const_iterator bilinearOperatorConst_iterator;

  typedef LinearOperatorListType::iterator linearOperatorIterator;
  typedef LinearOperatorListType::const_iterator linearOperatorConst_iterator;

  typedef BilinearBorderOperatorListType::iterator bilinearBorderOperatorIterator;
  typedef BilinearBorderOperatorListType::const_iterator bilinearBorderOperatorConst_iterator;

  typedef LinearBorderOperatorListType::iterator linearBorderOperatorIterator;
  typedef LinearBorderOperatorListType::const_iterator linearBorderOperatorConst_iterator;

  bilinearOperatorIterator beginBilinearOperator()
  {
    return __bilinearOperatorList.begin();
  }

  bilinearOperatorConst_iterator beginBilinearOperator() const
  {
    return __bilinearOperatorList.begin();
  }

  bilinearOperatorConst_iterator endBilinearOperator() const
  {
    return __bilinearOperatorList.end();
  }

  linearOperatorIterator beginLinearOperator()
  {
    return __linearOperatorList.begin();
  }

  linearOperatorConst_iterator beginLinearOperator() const
  {
    return __linearOperatorList.begin();
  }

  linearOperatorConst_iterator endLinearOperator() const
  {
    return __linearOperatorList.end();
  }

  bilinearBorderOperatorIterator beginBilinearBorderOperator()
  {
    return __bilinearBorderOperatorList.begin();
  }

  bilinearBorderOperatorConst_iterator beginBilinearBorderOperator() const
  {
    return __bilinearBorderOperatorList.begin();
  }

  bilinearBorderOperatorConst_iterator endBilinearBorderOperator() const
  {
    return __bilinearBorderOperatorList.end();
  }

  linearBorderOperatorIterator beginLinearBorderOperator()
  {
    return __linearBorderOperatorList.begin();
  }

  linearBorderOperatorConst_iterator beginLinearBorderOperator() const
  {
    return __linearBorderOperatorList.begin();
  }

  linearBorderOperatorConst_iterator endLinearBorderOperator() const
  {
    return __linearBorderOperatorList.end();
  }

  ReferenceCounting<Problem>
  operator*(const ConstReferenceCounting<ScalarFunctionBase>& u) const
  {
    VariationalProblem* newVariationalProblem = new VariationalProblem(*this);

    newVariationalProblem->__bilinearOperatorList.clear();
    for (BilinearOperatorListType::const_iterator i = __bilinearOperatorList.begin(); 
         i != __bilinearOperatorList.end(); ++i) {
      newVariationalProblem->__bilinearOperatorList.push_back((**i) * u);
    }

    newVariationalProblem->__linearOperatorList.clear();
    for (LinearOperatorListType::const_iterator i = __linearOperatorList.begin(); 
         i != __linearOperatorList.end(); ++i) {
      newVariationalProblem->__linearOperatorList.push_back((**i) * u);
    }

    return newVariationalProblem;
  }

  void add(ReferenceCounting<VariationalBilinearOperator> v)
  {
    __bilinearOperatorList.push_back(v);
  }


  void add(ReferenceCounting<VariationalBilinearBorderOperator> v)
  {
    __bilinearBorderOperatorList.push_back(v);
  }

  void add(ReferenceCounting<VariationalLinearOperator> v)
  {
    __linearOperatorList.push_back(v);
  }

  void add(ReferenceCounting<VariationalLinearBorderOperator> v)
  {
    __linearBorderOperatorList.push_back(v);
  }

  size_t numberOfUnknown() const
  {
    return __bc.size();
  }

  const BoundaryConditionSet& boundaryConditionSet(const size_t& i) const
  {
    return *(__bc[i]);
  }

  bool hasJumpOrMean() const
  {
    for (BilinearOperatorListType::const_iterator i=__bilinearOperatorList.begin();
         i != __bilinearOperatorList.end(); ++i) {
      if (((*i)->testFunctionProperty() != VariationalOperator::normal) or
          ((*i)->unknownProperty() != VariationalOperator::normal)) {
        return true;
      }
    }

    for (LinearOperatorListType::const_iterator i=__linearOperatorList.begin();
         i != __linearOperatorList.end(); ++i) {
      if ((*i)->testFunctionProperty() != VariationalOperator::normal) {
        return true;
      }
    }

    return false;
  }

  VariationalProblem(std::vector<ConstReferenceCounting<BoundaryConditionSet> > bc)
    : Problem(Problem::variational, 0),
      __bc(bc)
  {
    ;
  }

  VariationalProblem(const VariationalProblem& V,
                     const bool& getOnlyBilinearForms = false)
    : Problem(V),
      __bilinearOperatorList(V.__bilinearOperatorList),
      __linearOperatorList(V.__linearOperatorList),
      __bilinearBorderOperatorList(V.__bilinearBorderOperatorList),
      __linearBorderOperatorList(V.__linearBorderOperatorList),
      __bc(V.__bc)
  {
    if (getOnlyBilinearForms) {
      __linearOperatorList.clear();
      __linearBorderOperatorList.clear();
    }
  }


  ~VariationalProblem()
  {
    ;
  }
};

#endif // VARIATIONAL_PROBLEM_HPP

---