An Object Finite Element Library

Domain.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 Domain for domain definition

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

#ifndef __DOMAIN_H
#define __DOMAIN_H

#include <stdlib.h>
#include <math.h>
#include <string>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <valarray>
#include <vector>

using namespace std;


#include "OFELI_Config.h"
#include "util.h"
#include "fparser.h"
#include "FFI.h"
#include "getMesh.h"
#include "saveMesh.h"
#include "misc/Mesh2.h"
#include "misc/io.h"
#include "misc/QuadTree.h"
#include "misc/R2.h"
#include "Point.h"

extern FunctionParser _theParser;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
int bamg(const string &emfile, const string &outfile);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

namespace OFELI {

#ifndef DOXYGEN_SHOULD_SKIP_THIS
struct ErrorInDomain {
   void Message(const char *file, size_t line, int code, int p1=0, int p2=0);
};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

class Domain
{

struct Vertex : public Point<double> {
   double h;
   size_t label;
   int code;
};

struct Ln {
   Ln() { s.resize(MAX_NB_LINE_NODES); node.resize(MAX_NB_LINE_NODES); }
   size_t nb, n1, n2;
   int Dcode, Ncode; 
   valarray<double> s;
   valarray<Point<double> > node;
};

typedef struct {
   size_t nb, first_line;
   int orientation[MAX_NB_CONT_LINES];
   size_t line[MAX_NB_CONT_LINES];
} Cont;

typedef struct { int code, contour; } Sd;
typedef struct { size_t i, j; int dc, nc; } LP;
typedef struct { size_t n1, n2, n3, n4; int code; } El;

public:

//----------------------  CONSTRUCTORS AND DESTRUCTOR  -------------------------

    Domain();

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

    size_t getDim() const { return _dim; }

    size_t getNbDOF() const { return _nb_dof; }

    size_t getNbVertices() const { return _nb_vertices; }

    size_t getNbLines() const { return _nb_lines; }

    size_t getNbContours() const { return _nb_contours; }

    size_t getNbHoles() const { return _nb_holes; }

    size_t getNbSubDomains() const { return _nb_sub_domains; }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void Get() { get(); }
    void Get(const string &file) { get(file); }
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

    void get();

    void get(const string &file);

    int generateMesh(const string &file);

    void insertVertex(double x, double y, double h, int code);

    void insertLine(size_t n1, size_t n2, int dc, int nc);

    void insertCircle(size_t n1, size_t n2, double cx, double cy, double r, 
                      double orient, size_t nb, int dc, int nc);

    void insertContour(const vector<size_t> &c);

    void insertHole(const vector<size_t> &c);

    void insertSubDomain(size_t n, int code);

    friend class XMLParser;

private:

   FFI *_ff;
   ofstream *_jf;
   valarray<string> _kw;
   valarray<Vertex> _v, _V, _nd, _bnd;
   valarray<El> _el;
   valarray<Ln> _l;
   vector<Cont> _h;
   valarray<Sd> _sd;
   vector<Cont> _c;
   valarray<LP> _ln;
   size_t _v_label[MAX_NB_VERTICES], _l_label[MAX_NB_LINES], _h_label[MAX_NB_HOLES];
   size_t _dim, _nb_vertices, _nb_lines, _nb_contours, _nb_holes, _sub_domain, _nb_sub_domains;
   size_t _nb_dof;
   size_t _ret_cont, _ret_line, _ret_save, _ret_sd;
   bool _file;
   FILE *_mdf;
   ErrorInDomain _e;

   void getVertex();
   int getLine();
   int getCurve();
   void getCircle();
   int getContour();
   int getHole();
   int getSubDomain();
   int Rectangle();
   int Disk();
   void deleteVertex();
   void deleteLine();
   void list();
   int saveAsEasymesh();
   int saveAsBamg();
   int saveAsTriangle();
   int Position(double s, double *data);
   int gm();
   int gm1(const string &file);
   int gm2(const string &file);
   int gm3(const string &file);
   int insert(size_t item, size_t &length, size_t *set);
   int remove(size_t item, size_t &length, size_t *set);
   void dof_code(int mark, valarray<int> &code);
   void dof_code(int mark, int *code);
   int zero_code(const valarray<int> &code);
   void init_kw();
   int setCode(size_t ne1, size_t ne2, size_t i, size_t j, size_t nb_dof,
               int c1, int c2, int  c3, int c4);
};

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani