An Object Finite Element Library

AbsVect.h

Go to the documentation of this file.

/*==============================================================================

                                    O  F  E  L  I

                           Object  Finite  Element  Library

  ==============================================================================

   Copyright (C) 1998 - 2008 Rachid Touzani

   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; Version 2 of the License.

   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

  ==============================================================================

             Definition of abstract class 'AbsVect' for field vectors

  ==============================================================================*/


#ifndef __ABS_VECT_H
#define __ABS_VECT_H

#include <iostream>
#include <fstream>
using std::istream;
using std::ostream;
using std::endl;

#include <iomanip>
using std::setw;
using std::ios;
using std::setprecision;

#include <string>
using std::string;

#include <valarray>
using std::valarray;

#include "OFELI_Config.h"
#include "Mesh.h"
#include "Vect.h"
#include "FFI.h"
#include "fparser.h"
#include "util.h"

extern FunctionParser _theParser;

namespace OFELI {

template <class T_> class Vect;
template <class T_> class AbsVect;


//-----------------------------------------------------------------------------
// Class AbsVect
//-----------------------------------------------------------------------------

template <class T_>
class AbsVect
{

 public:

    AbsVect();

    AbsVect(const class Mesh &mesh, size_t nb_dof=1);

    AbsVect(const class Mesh &mesh, size_t nb_dof, const string &name, double time=0);

    AbsVect(const class Mesh &mesh, const string &name=" ", double time=0);

    AbsVect(const class Mesh &mesh, size_t nb_dof, size_t first_dof, const string &name, double time=0);

    AbsVect(Vect<T_> &v);

    virtual ~AbsVect();

    char *getBinary();

    void setBinary(char *s);

    virtual void setMesh(const class Mesh &ms, size_t nb_dof=0)=0;

    void Fill(const valarray<T_> &v, size_t dof=0);

    void Copy(valarray<T_> &v);

    void setName(const string &name);

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void setField(int field);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

    const string &getName() const;

    void setTime(double time);

    double getTime() const;

    const Mesh &getMesh() const;

    size_t getNbX() const;

    double getNorm2() const;

    double getWNorm2() const;

    double getNormMax() const;

    double getNorm2(size_t j) const;

    double getWNorm2(size_t j) const;

    double getNormMax(size_t j) const;

    double getMin(size_t j) const;

    double getMax(size_t j) const;

    T_ & operator()(size_t i, size_t j=1, size_t k=1);

    T_ operator()(size_t i, size_t j=1, size_t k=1) const;

    AbsVect<T_> & operator*=(T_ a);

    AbsVect<T_> & operator/=(T_ a);

    AbsVect<T_> & operator+=(T_ a);

    AbsVect<T_> & operator-=(T_ a);

    AbsVect<T_> & operator=(const AbsVect<T_> &v);

    AbsVect<T_> & operator-=(const AbsVect<T_> &v);

    AbsVect<T_> & operator+=(const AbsVect<T_> &v);

    AbsVect<T_> & operator=(const valarray<T_> &v);

    virtual void insertBC(const Vect<T_> &v, const Vect<T_> &bc);

    void BGet(const string &file);

    void BPut(const string &file);

    size_t getLength() const;

    void setLength(size_t n);

    size_t getNbDOF() const;

    void setNbDOF(int n);

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    size_t getNb() const { return _nb; }
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

    int getField() const;

    Vect<T_> &getVect();

    void selectDOF(size_t dof);

    void unselectDOF();

 protected:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
   Vect<T_>         _v;
   valarray<string> _kw;
   double           _time;
   size_t           _nb_dof, _first_dof, _length, _nb, _nbn, _this_dof;
   int              _field;
   string           _name;
   valarray<T_>     _M, _b;
   const Mesh       *_theMesh;

    void Init();
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};


//                         I M P L E M E N T A T I O N                       //


template <class T_>
AbsVect<T_>::AbsVect()
{
   _first_dof = 1;
   _this_dof = 0;
   _time = 0.;
   _length = 0;
   _theMesh = NULL;
   _name = "u";
   _kw.resize(7);
   _kw[0] = "EOF$";
   _kw[1] = "Name$";
   _kw[2] = "NbDOF$";
   _kw[3] = "NbNodes$";
   _kw[4] = "Time$";
   _kw[5] = "Data$";
   _kw[6] = "Val$ue";
}


template <class T_>
AbsVect<T_>::AbsVect(const class Mesh &mesh, size_t nb_dof)
{
   _nb_dof = nb_dof;
   _this_dof = 0;
   _nbn = 1;
   _first_dof = 1;
   _time = 0.;
   _theMesh = &mesh;
   _name = "u";
   _kw.resize(7);
   _kw[0] = "EOF$";
   _kw[1] = "Name$";
   _kw[2] = "NbDOF$";
   _kw[3] = "NbNodes$";
   _kw[4] = "Time$";
   _kw[5] = "Data$";
   _kw[6] = "Val$ue";
}


template <class T_>
AbsVect<T_>::AbsVect(const class Mesh &mesh, size_t nb_dof, const string &name, double time)
{
   _nb_dof = nb_dof;
   _this_dof = 0;
   _nbn = 1;
   _first_dof = 1;
   _time = time;
   _theMesh = &mesh;
   _name = name;
   _kw.resize(7);
   _kw[0] = "EOF$";
   _kw[1] = "Name$";
   _kw[2] = "NbDOF$";
   _kw[3] = "NbNodes$";
   _kw[4] = "Time$";
   _kw[5] = "Data$";
   _kw[6] = "Val$ue";
}


template <class T_>
AbsVect<T_>::AbsVect(const class Mesh &mesh, const string &name, double time)
{
   _nbn = 1;
   _first_dof = 1;
   _this_dof = 0;
   _time = time;
   _theMesh = &mesh;
   _name = name;
   _length = mesh.getNbDOF();
   _kw.resize(7);
   _kw[0] = "EOF$";
   _kw[1] = "Name$";
   _kw[2] = "NbDOF$";
   _kw[3] = "NbNodes$";
   _kw[4] = "Time$";
   _kw[5] = "Data$";
   _kw[6] = "Val$ue";
}


template <class T_>
AbsVect<T_>::AbsVect(const class Mesh &mesh, size_t nb_dof, size_t first_dof, const string &name, double time)
{
   _nb_dof = nb_dof;
   _nbn = 1;
   _first_dof = first_dof;
   _this_dof = 0;
   _time = time;
   _theMesh = &mesh;
   _name = name;
   _kw.resize(7);
   _kw[0] = "EOF$";
   _kw[1] = "Name$";
   _kw[2] = "NbDOF$";
   _kw[4] = "Time$";
   _kw[5] = "Data$";
   _kw[6] = "Val$ue";
}


template <class T_>
AbsVect<T_>::AbsVect(Vect<T_> &v)
{
   &_v = &(v._v);
   _name = "u";
   _this_dof = 0;
}


template <class T_>
AbsVect<T_>::~AbsVect() { }


template <class T_>
void AbsVect<T_>::Fill(const valarray<T_> &v, size_t dof)
{
#ifdef _BOUNDS_DEBUG
   assert(v.size() == _length);
#endif
   if (dof==0)
      for (size_t i=0; i<_length; ++i)
         _v[i] = v[i];
   else
      for (size_t i=0; i<_nb*_nbn; ++i)
         _v[_nb_dof*i+dof-1] = v[i];
}


template <class T_>
char *AbsVect<T_>::getBinary()
{
   return reinterpret_cast<char *>(&_v);
}


template <class T_>
void AbsVect<T_>::setBinary(char *s)
{
   _v = *reinterpret_cast<Vect<T_> *>(s);
}


template <class T_>
void AbsVect<T_>::Copy(valarray<T_> &v)
{
   for (size_t i=0; i<_length; ++i)
      v[i] = _v[i];
}


template <class T_>
void AbsVect<T_>::setName(const string &name)
{
   _name = name;
}


#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <class T_>
void AbsVect<T_>::setField(int field)
{
   _field = field;
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


template <class T_>
const string &AbsVect<T_>::getName() const
{
   return _name;
}


template <class T_>
void AbsVect<T_>::setTime(double time)
{
   _time = time;
}


template <class T_>
double AbsVect<T_>::getTime() const
{
   return _time;
}


template <class T_>
const Mesh &AbsVect<T_>::getMesh() const
{
   return *_theMesh;
}


template <class T_>
size_t AbsVect<T_>::getNbX() const
{
   return _nb;
}


template <class T_>
double AbsVect<T_>::getNorm2() const
{
   double s = 0.;
   for (size_t i=0; i<_length; ++i)
      s += _v[i] * _v[i];
   return sqrt(s);
}


template <class T_>
double AbsVect<T_>::getWNorm2() const
{
   return getNorm2()/sqrt(_length);
}


template <class T_>
double AbsVect<T_>::getNormMax() const
{
   double s = 0.;
   for (size_t i=0; i<_length; ++i)
      s = max(abs(_v[i]),s);
   return s;
}


template <class T_>
double AbsVect<T_>::getNorm2(size_t j) const
{
   double s = 0.;
#ifdef _BOUNDS_DEBUG
   assert(j>0 && j<=_nb_dof);
#endif
   for (size_t i=0; i<_nb*_nbn; ++i)
      s += _v[_nb_dof*i+j-1];
   return sqrt(s);
}


template <class T_>
double AbsVect<T_>::getWNorm2(size_t j) const
{
   return getNorm2(j)/sqrt(_nb);
}


template <class T_>
double AbsVect<T_>::getNormMax(size_t j) const
{
   double s = 0.;
   for (size_t i=0; i<_length; ++i)
      s = max(Abs(_v[i]),s);
   return s;
}


template <class T_>
double AbsVect<T_>::getMin(size_t j) const
{
#ifdef _BOUNDS_DEBUG
   assert(j>0 && j<=_nb_dof);
#endif
   double s = _v[j-1];
   for (size_t i=1; i<_nb; ++i)
      s = Min(_v[_nb_dof*i+j-1],s);
   return s;
}


template <class T_>
double AbsVect<T_>::getMax(size_t j) const
{
#ifdef _BOUNDS_DEBUG
   assert(j>0 && j<=_nb_dof);
#endif
   double s = _v[j-1];
   for (size_t i=1; i<_nb*_nbn; ++i)
      s = Max(_v[_nb_dof*i+j-1],s);
   return s;
}


template <class T_>
T_ &AbsVect<T_>::operator()(size_t i, size_t j, size_t k)
{
#ifdef _BOUNDS_DEBUG
   assert(i>0 && i<=_nb);
   assert(j>0 && j<=_nbn);
   assert(k>0 && k<=_nb_dof);
#endif
   return _v[_nb_dof*(i-1)+_nbn*(j-1)+k-1];
}


template <class T_>
T_ AbsVect<T_>::operator()(size_t i, size_t j, size_t k) const
{
#ifdef _BOUNDS_DEBUG
   assert(i>0 && i<=_nb);
   assert(j>0 && j<=_nbn);
   assert(k>0 && k<=_nb_dof);
#endif
   return _v[_nb_dof*(i-1)+_nbn*(j-1)+k-1];
}


template <class T_>
AbsVect<T_> &AbsVect<T_>::operator*=(T_ a)
{
   for (size_t i=0; i<_length; ++i)
      _v[i] *= a;
   return *this;
}


template <class T_>
AbsVect<T_> &AbsVect<T_>::operator/=(T_ a)
{
   for (size_t i=0; i<_length; ++i)
      _v[i] /= a;
   return *this;
}


template <class T_>
AbsVect<T_> &AbsVect<T_>::operator+=(T_ a)
{
   for (size_t i=0; i<_length; ++i)
      _v[i] += a;
   return *this;
}


template <class T_>
AbsVect<T_> &AbsVect<T_>::operator-=(T_ a)
{
   for (size_t i=0; i<_length; ++i)
      _v[i] -= a;
   return *this;
}


template <class T_>
AbsVect<T_> &AbsVect<T_>::operator=(const AbsVect<T_> &v)
{
#ifdef _BOUNDS_DEBUG
   assert(v._nb == _nb);
   assert(v._length == _length);
#endif
   for (size_t i=0; i<_length; ++i)
      _v[i] = v._v[i];
   return *this;
}


template <class T_>
AbsVect<T_> &AbsVect<T_>::operator-=(const AbsVect<T_> &v)
{
#ifdef _BOUNDS_DEBUG
   assert(v._nb == _nb);
   assert(v._nbn == _nbn);
   assert(v._nb_dof == _nb_dof);
#endif
   for (size_t i=0; i<_length; ++i)
      _v[i] -= v._v[i];
   return *this;
}


template <class T_>
AbsVect<T_> &AbsVect<T_>::operator+=(const AbsVect<T_> &v)
{
#ifdef _BOUNDS_DEBUG
   assert(v._nb == _nb);
   assert(v._nbn == _nbn);
   assert(v._nb_dof == _nb_dof);
#endif
   for (size_t i=0; i<_length; ++i)
      _v[i] += v._v[i];
   return *this;
}


template <class T_>
AbsVect<T_> &AbsVect<T_>::operator=(const valarray<T_> &v)
{
#ifdef _BOUNDS_DEBUG
    assert(v._size == _length);
#endif
    for (size_t i=0; i<_length; ++i)
       _v[i] = v[i];
    return *this;
}


template <class T_>
void AbsVect<T_>::insertBC(const Vect<T_> &v, const Vect<T_> &bc)
{
   v.size();
   bc.size();
}


template <class T_>
void AbsVect<T_>::BGet(const string &file)
{
   ifstream ff(file.c_str(),ios::binary);
   ff.read(reinterpret_cast<char *>(this),sizeof(*this));
}


template <class T_>
void AbsVect<T_>::BPut(const string &file)
{
   ofstream ff(file.c_str(),ios::binary);
   ff.write(reinterpret_cast<const char *>(this),sizeof(*this));
}


template <class T_>
size_t AbsVect<T_>::getLength() const
{
   return _length;
}


template <class T_>
void AbsVect<T_>::setLength(size_t n)
{
   _length = n;
}


template <class T_>
size_t AbsVect<T_>::getNbDOF() const
{
   return _nb_dof;
}


template <class T_>
void AbsVect<T_>::setNbDOF(int n)
{
   _nb_dof = n;
}


template <class T_>
int AbsVect<T_>::getField() const
{
   return _field;
}


template <class T_>
Vect<T_> &AbsVect<T_>::getVect()
{
   return _v;
}


template <class T_>
void AbsVect<T_>::selectDOF(size_t dof)
{
   _this_dof = dof;
}


template <class T_>
void AbsVect<T_>::unselectDOF()
{
   _this_dof = 0;
}


#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <class T_>
void AbsVect<T_>::Init()
{
   _v.resize(_length);
   for (size_t i=0; i<_length; ++i)
      _v[i] = 0;
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani