An Object Finite Element Library

EdgeVect.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 'EdgeVect' for EdgeWise Vectors

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


#ifndef __EDGE_VECT_H
#define __EDGE_VECT_H


namespace OFELI {

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

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

        case 31:
           cerr << "EdgeVect(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 EdgeVect : virtual public AbsVect<T_>
{

 public:

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

    EdgeVect();

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

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

    EdgeVect(const EdgeVect<T_> &v);

    ~EdgeVect();

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

    size_t getNbEdges() const;

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

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

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

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

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

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

    EdgeVect<T_> &operator/=(const T_ &a);
 
private:

   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;

   ErrorInEdgeVect<T_> _e;
   size_t              _nb_edges;

};


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


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


template <class T_>
EdgeVect<T_>::EdgeVect(const class Mesh &mesh, size_t nb_dof) : AbsVect<T_>(mesh,_nb_dof)
{
   if (nb_dof <= 0 || nb_dof)
      _e.Message(__FILE__,__LINE__,21,_nb_dof);
   _nb = _nb_edges = mesh.getNbEdges();
   _nb_dof = nb_dof;
   _length = _nb_dof * _nb;
   Init();
#ifdef _OFELI_DEBUG
   std::clog << "An instance of class EdgeVect is constructed.\n";
   std::clog << "File: " << __FILE__ << ", Line: " << __LINE__ << endl;
#endif
}


template <class T_>
EdgeVect<T_>::EdgeVect(const class Mesh &mesh, size_t nb_dof, const string &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_edges = mesh.getNbEdges();
   _length = _nb_dof * _nb;
   Init();
#ifdef _OFELI_DEBUG
   std::clog << "An instance of class EdgeVect is constructed.\n";
   std::clog << "File: " << __FILE__ << ", Line: " << __LINE__ << endl;
#endif
}


template <class T_>
EdgeVect<T_>::EdgeVect(const EdgeVect<T_> &v)
{
   _time = v._time;
   _name = v._name;
   _length = v.getLength();
   _nb = _nb_edges = v.getNbEdges();
   _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 EdgeVect is constructed.\n";
   std::clog << "File: " << __FILE__ << ", Line: " << __LINE__ << endl;
#endif
}


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


template <class T_>
void EdgeVect<T_>::setMesh(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.getPtrEdge(1)->getNbDOF();
   _nb = _nb_edges = ms.getNbEdges();
   _length = _nb_dof * _nb_edges;
   Init();
}


template <class T_>
size_t EdgeVect<T_>::getNbEdges() const
{
   return _nb_edges;
}


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


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


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


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


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


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


template <class T_>
EdgeVect<T_> & EdgeVect<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, EdgeVect<T_> &a)
{
   size_t j, n;
   double time;
   static char name[40];
   s >> name;
   a.setName(name);
   s >> n >> time;
   a.setTime(time);

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


template <class T_>
ostream& operator<<(ostream& s, const EdgeVect<T_> &a)
{
   Edge *ed;
   if (a.getName())
      s << a.getName() << " at";
   s << " time = " << a.Time() << endl << endl;
   s.setf(ios::scientific);
   for (a.getMesh()->topEdge(); (ed=a.getMesh()->getEdge());) {
      size_t i = ed->getLabel();
      s << setw(6) << i << "   ";
      for (size_t j=1; j<=a.getNbDOF(); j++)
         s << setprecision(8) << setw(18) << a(i,j);
      s << endl;
   }
   s << endl;
   return s;
}

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani