An Object Finite Element Library

Partition.h

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

                                    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 Partition

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

#ifndef __PARTITION_H
#define __PARTITION_H

#include <stdlib.h>
#include <math.h>
#include <string>

#include <iostream>
using std::cout;
using std::ostream;
using std::endl;

#include <iomanip>
using std::setw;

#include "OFELI_Config.h"
#include "Mesh.h"
#include "output.h"

#define WITH_METIS

#ifdef WITH_METIS
#ifdef __cplusplus
extern "C"
{
#include "metis.h"
}
#endif
#endif


namespace OFELI {

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

class Partition
{

#ifndef DOXYGEN_SHOULD_SKIP_THIS
 typedef struct { size_t side1, sd, side; } Interface;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

 public:

//----------------------------   BASIC OPERATIONS   -----------------------------

    Partition(Mesh &mesh, char *file);

    Partition(Mesh &mesh, size_t n);

    ~Partition();

//-----------------------------   INSPECTORS  -----------------------------------

    size_t getNbSubMeshes() const { return _nb_submesh; }

    size_t getNbNodes(size_t i) const { return _theSubMesh[i]->getNbNodes(); }

    size_t getNbElements(size_t i) const { return _theSubMesh[i]->getNbElements(); }

    Mesh &getMesh(size_t i) const { return *_theSubMesh[i]; }

    size_t getNodeLabelInSubMesh(size_t sm, size_t label) const { return _m2sm_node[sm][label-1]; }

    size_t getElementLabelInSubMesh(size_t sm, size_t label) const { return _m2sm_element[sm][label-1]; }

    size_t getNodeLabelInMesh(size_t sm, size_t label) const { return _sm2m_node[sm][label-1]; }

    size_t getElementLabelInMesh(size_t sm, size_t label) const { return _sm2m_element[sm][label-1]; }

    size_t getNbInterfaceSides(size_t sm) const { return _nb_interface_sides[sm]; }

    size_t getFirstSideLabel(size_t sm, size_t i) const { return _interface_side[sm][i-1].side1; }

    size_t getSubMesh(size_t sm, size_t i) const { return _interface_side[sm][i-1].sd; }

    size_t getSecondSideLabel(size_t sm, size_t i) const { return _interface_side[sm][i-1].side; }

    void setVerbose(size_t verb) { _verbose = verb; }

    void Put(size_t n, char *file) const { _theSubMesh[n]->Put(file); }

    void BPut(size_t n, char *file) const { _theSubMesh[n]->BPut(file); }

//-----------------------------   MODIFIERS  -----------------------------------

    void Init(int *epart);

//------------------------   ASSOCIATED OPERATORS  -----------------------------

    friend ostream & operator<<(ostream& s, const Partition &p);

 protected:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    int  _nb_submesh, _verbose;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

 private:
   Mesh           *_theMesh, *_theSubMesh[MAX_NB_SUBMESHES];
   vector<size_t> _nb_interface_sides;
   size_t         _max_nb_meshes;
   size_t         **_sm2m_node, **_m2sm_node, **_sm2m_element, **_m2sm_element;
   Interface      **_interface_side;
   bool EqualSides(size_t sm1, const Side *sd1, size_t sm2, const Side *sd2);
   ErrorInPartition _e;
};

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani