field.h

#ifndef FIELD_H
#define FIELD_H

#include "ddf/ddf.h"
#include "interpolator.h"
#include "afltypes.h"
#include "value.h"
#include "boundary.h"
#include "simplex.h"
#include "integrator.h"
#include "afltypes.h"
#include "exc/aflexc.h"

namespace afl
{
    class Iterator;
    class FieldFactory;
    class Derivator;
    class Field
    {
        public:
            typedef Iterator iterator;

        protected:
              Field( const std::string& name, ddf::PropertySet* pset);

        public:
              virtual ~Field(  );

        public:
             virtual void interpolation( Interpolator* interpolator );

             virtual void interpolation( interp_t method ) = 0;

            virtual void interpolation( const std::string& function );

             virtual void boundary( Boundary* boundary ) throw(exc::GeometryException);

             virtual void derivator( Derivator* derivator );

            virtual void integrator( Integrator* integrator );

             virtual void addBoundarySegment( const Point& p1, const Point& p2 );

             virtual void addBoundarySegment( const Field* f );

             virtual void toXML( std::ostream& doc, const std::string& componentsDir, 
                     const std::string& baseURI, bool allInline ) const;

             virtual Value get( const Point& x ) const = 0;

             virtual Derivative jacobian( const Point& x ) const = 0;

             virtual Point gradient( const Point& x ) const = 0;

             virtual data_t divergence( const Point& x ) const = 0;

             virtual data_t  laplacian( const Point& x ) const = 0;

             virtual Point curl( const Point& x ) const;

             virtual Value integral ( const Simplex& s ) const = 0;

             virtual void set( const Point& x, const Value& value ) = 0;

             virtual void set( const Point& x, const Value& value, const Derivative& dvalue ) = 0;
             
             virtual iterator begin() const;
             
             virtual iterator end() const;

             virtual void erase( const iterator& pt );

             virtual bool hasDerivative(  ) const;

             virtual size_t size(  ) const;

             virtual size_t getDimension(  ) const = 0;

             virtual const Boundary* getBoundary(  ) const;

             virtual Point getBoundingBoxMin(  ) const = 0;

             virtual Point getBoundingBoxMax(  ) const = 0;

             virtual void resetBoundary(  );
             virtual const std::string& getName(  ) const { return _name; }

             virtual const ddf::Geometry* getValueGeometry(  ) const;

             virtual std::string getValueTypeStr(  ) const;

            virtual troolean locate( const Point& p ) const;

            virtual Field* clone(  ) const = 0;

             void setDirichletCondition( const Field* value );
             
             void setDirichletCondition( const Value& value );

             bool hasDirichletCondition(  ) const;

             Value getDirichlet( const Point& p ) const;

             void setNeumannCondition( const Field* deriv );

             void setNeumannCondition( const Value& value );

             bool hasNeumannCondition(  ) const;

             Value getNeumann( const Point& p ) const;

             const ddf::PropertySet* getNumericData(  ) const { return _pset; } 

        protected:
            friend class FieldFactory;
            friend class Iterator;

            ddf::PropertySet* _pset;

            std::string _name;

            Interpolator* _interpolator;
            Boundary* _boundary;
            Derivator* _derivator;
            Integrator* _integrator;

            const Field* _dirichlet;

            const Field* _neumann;

    };

};

#endif // FIELD_H

---