An Object Finite Element Library

SideVect.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 class 'SideVect' for SideWise Vectors

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


#ifndef __SIDE_VECT_H
#define __SIDE_VECT_H


#include "AbsVect.h"


namespace OFELI {

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

//-----------------------------------------------------------------------------
// Class ErrorInSideVect
//-----------------------------------------------------------------------------

#ifndef DOXYGEN_SHOULD_SKIP_THIS
template<class T_>
struct ErrorInSideVect {
   void Message(const char *file, size_t line, int code, int p1=0) {
     cerr << "\n*** Fatal Error in OFELI ***\n";
     cerr << "File : " << file << ", line : " << line << "\nIn SideVect<>::";
     switch (code) {

        case 21: 
           cerr << "SideVect(mesh,nb_dof) : Illegal value of nb_dof : " << p1 << endl;
           break;

        case 31: 
           cerr << "SideVect(mesh,nb_dof,name,time) : Illegal value of nb_dof : " << p1 << endl;
           break;
     }
     cerr << "Program stops" << endl;
     exit(1);
   }
};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */



template <class T_>
class SideVect : virtual public AbsVect<T_>
{

 public:

   using AbsVect<T_>::Init;
   using AbsVect<T_>::setName;

    SideVect();

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

    SideVect(const class Mesh &mesh, size_t nb_dof, const char *name, double time=0);

    SideVect(const SideVect<T_> &v);

    ~SideVect();

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

    size_t getNbSides() const;

    SideVect<T_> & operator=(T_ a);

    SideVect<T_> & operator+=(const SideVect<T_> &x);

    SideVect<T_> & operator+=(const T_ &a);

    SideVect<T_> & operator-=(const SideVect<T_> &x);

    SideVect<T_> & operator-=(const T_ &a);

    SideVect<T_> &operator*=(const T_ &a);

    SideVect<T_> &operator/=(const T_ &a);

private:

   ErrorInSideVect<T_> _e;
   size_t              _nb_sides;
   using AbsVect<T_>::_nbn;
   using AbsVect<T_>::_nb;
   using AbsVect<T_>::_nb_dof;
   using AbsVect<T_>::_first_dof;
   using AbsVect<T_>::_length;
   using AbsVect<T_>::_time;
   using AbsVect<T_>::_name;
   using AbsVect<T_>::_theMesh;
   using AbsVect<T_>::_v;
};



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


template<class T_>
SideVect<T_>::SideVect()
{
#ifdef _OFELI_DEBUG
   std::clog << "An instance of class SideVect is constructed.\n";
   std::clog << "File : " << __FILE__ << ", Line: " << __LINE__ << endl;
#endif
}


template<class T_>
SideVect<T_>::SideVect(const class Mesh &mesh, size_t nb_dof) : AbsVect<T_>(mesh,nb_dof)
{
   _nb = _nb_sides = mesh.getNbSides();
   _nbn = 1;
   _nb_dof = nb_dof;
   _length = _nb_dof * _nb;
   Init();
#ifdef _OFELI_DEBUG
   std::clog << "An instance of class SideVect is constructed.\n";
   std::clog << "File : " << __FILE__ << ", Line : " << __LINE__ << endl;
#endif
}


template<class T_>
SideVect<T_>::SideVect(const class Mesh &mesh, size_t nb_dof, const char *name, double time)
             : AbsVect<T_>(mesh,nb_dof,name,time)
{
   if (nb_dof <= 0)
      _e.Message(__FILE__,__LINE__,31,nb_dof);
   _nb_dof = nb_dof;
   _nb = _nb_sides = mesh.getNbSides();
   _length = _nb_dof * _nb_sides;
   Init();
#ifdef _OFELI_DEBUG
   std::clog << "An instance of class SideVect is constructed.\n";
   std::clog << "File : " << __FILE__ << ", Line : " << __LINE__ << endl;
#endif
}


template<class T_>
SideVect<T_>::SideVect(const SideVect<T_> &v)
{
   _time = v._time;
   _name = v._name;
   _length = v.getLength();
   _nb = _nb_sides = v.getNbSides();
   _nbn = 1;
   _theMesh = v._theMesh;
   _first_dof = 1;
   _nb_dof = v._nb_dof;
   Init();
   _v = v._v;
#ifdef _OFELI_DEBUG
   std::clog << "An instance of class SideVect is constructed.\n";
   std::clog << "File : " << __FILE__ << ", Line : " << __LINE__ << endl;
#endif
}


template<class T_>
SideVect<T_>::~SideVect()
{
#ifdef _OFELI_DEBUG
   std::clog << "An instance of class SideVect is destructed.\n";
   std::clog << "File : " << __FILE__ << ", Line : " << __LINE__ << endl;
#endif
}


template<class T_>
void SideVect<T_>::setMesh(const class Mesh &ms, size_t nb_dof)
{
   _theMesh = &ms; 
   _first_dof = 1;
   _nbn = 1;
   _nb_dof = nb_dof;
   if (_nb_dof==0)
      _nb_dof = ms.getPtrSide(1)->getNbDOF();
   _nb = _nb_sides = ms.getNbSides();
   _length = _nb_dof * _nb_sides;
   Init();
}


template<class T_>
size_t SideVect<T_>::getNbSides() const
{
   return _nb_sides;
}


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


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


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


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


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


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


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


//                             Associated Functions                          //


template <class T_>
istream& operator>>(istream& s, SideVect<T_> &v)
{
   size_t j, n;
   double time;
   static char name[40];
   s >> name;
   v.setName(name);
   s >> n >> time;
   v.setTime(time);

   for (size_t i=1; i<=n; i++) {
      s >> j;
      for (size_t k=1; k<=v.NbDOF(); k++)
         s >> v(i,j) >> "    ";
   }
   return s;
}


template <class T_>
ostream& operator<<(ostream &s, const SideVect<T_> &v)
{
   const Side *sd;
   s << v.getName() << " at";
   s << " time = " << v.getTime() << endl << endl;
   s.setf(ios::scientific);
   for (v.getMesh().topSide(); (sd=v.getMesh().getSide());) {
      size_t i = sd->getLabel();
      s << setw(6) << i << "   ";
      for (size_t j=1; j<=v.getNbDOF(); j++)
         s << setprecision(8) << setw(18) << v(i,j);
      s << endl;
   }
   s << endl;
   return s;
}

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani