An Object Finite Element Library

Field.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

  ==============================================================================
                           Classes for field variables
  ==============================================================================*/

#ifndef __FIELD_H
#define __FIELD_H

#include <math.h>
#include <float.h>
#include <stdlib.h>
#include <assert.h>
#include <iostream>
using std::ostream;

#include "OFELI_Config.h"
#include "Point.h"


namespace OFELI {

#ifndef DOXYGEN_SHOULD_SKIP_THIS
template<class T_>
class Field
{

 public:

    Field()
    {
       x_ = 0;
#ifdef _OFELI_DEBUG
       std::clog << "An instance of class Field is constructed.\n";
       std::clog << "File : " << __FILE__ << ", Line : " << __LINE__ << endl;
#endif
    }

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

    Field(const Field<T_> &x)
    {
       x_ = x.x_;
#ifdef _OFELI_DEBUG
       std::clog << "An instance of class Field is constructed.\n";
       std::clog << "File : " << __FILE__ << ", Line : " << __LINE__ << endl;
#endif
    }

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

    Field<T_> & operator=(const Field<T_> &x) { x_ = x.x_; return *this; }

    Field<T_> & operator+=(const Field<T_> &x) { x_ += x; return *this; }

    Field<T_> & operator+=(T_ x) { x_ += x; return *this; }

    Field<T_> & operator-=(const Field<T_> &x) { x_ -= x; return *this; }

    Field<T_> & operator-=(T_ x) { x_ -= x; return *this; }

    Field & operator*=(T_ x) { x_ *= x; return *this; }

    Field & operator/=(T_ x) { x_ /= x; return *this; }

    operator T_() const { return x_; }

    T_ x_;
};


//template<class T_>
//Field<T_> & operator=(const Field<T_> &x) { x_ = x.x_; return *this; }

class Temperature : public Field<double>
{
 public:

    Temperature() { }

    Temperature(double x) : Field<double>(x) { }
//    Temperature & operator=(const Field<double> &x) { x_ = x.x_; }

    friend ostream& operator<<(ostream& s, const Temperature &v) { s << v.x_; return s; }
};


class Enthalpy : public Field<double>
{
 public:

    Enthalpy() { }

    Enthalpy(double x) : Field<double>(x) { }

    friend ostream& operator<<(ostream& s, const Enthalpy &v) { s << v.x_; return s; }
};

class Pressure : public Field<double>
{
 public:

    Pressure() { x_ = 0; }

    Pressure(const double &x) { x_ = x; }

    friend ostream& operator<<(ostream& s, const Pressure &v) { s << v.x_; return s; }
};


class Displacement : public Field<Point<double> >
{
 public:

    Displacement() { x_ = 0; }

    Displacement(const Point<double> &x) { x_ = x; }

    Displacement(double x, double y=0, double z=0) { x_.x = x; x_.y = y; x_.z = z; }

    friend ostream& operator<<(ostream& s, const Displacement &v) { s << v.x_; return s; }
};


class Velocity : public Field<Point<double> >
{
 public:

    Velocity() { x_ = 0; }

    Velocity(const Point<double> &x) { x_ = x; }

    Velocity(double x, double y=0, double z=0) { x_.x = x; x_.y = y; x_.z = z; }

    friend ostream& operator<<(ostream& s, const Velocity &v) { s << v.x_; return s; }
};


class MagneticField : public Field<Point<double> >
{
 public:

    MagneticField() { x_ = 0; }

    MagneticField(const Point<double> &x) { x_ = x; }

    MagneticField(double x, double y=0, double z=0) { x_.x = x; x_.y = y; x_.z = z; }

    friend ostream& operator<<(ostream& s, const MagneticField &v) { s << v.x_; return s; }
};


class ElectricField : public Field<Point<double> >
{
 public:

    ElectricField() { x_ = 0; }

    ElectricField(const Point<double> &x) { x_ = x; }

    ElectricField(double x, double y=0, double z=0) { x_.x = x; x_.y = y; x_.z = z; }

    friend ostream& operator<<(ostream& s, const ElectricField &v) { s << v.x_; return s; }
};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani