/***********************************************************************
*
* ELMER, A Computational Fluid Dynamics Program.
*
* Copyright 1st April 1995 - , Center for Scientific Computing,
* Finland.
*
* All rights reserved. No part of this program may be used,
* reproduced or transmitted in any form or by any means
* without the written permission of CSC.
*
* Address: Center for Scientific Computing
* Tietotie 6, P.O. BOX 405
* 02101 Espoo, Finland
* Tel. +358 0 457 2001
* Telefax: +358 0 457 2302
* EMail: Jari.Jarvinen@csc.fi
************************************************************************/
/***********************************************************************
Program: ELMER Front
Module: ecif_body.h
Language: C++
Date: 01.10.98
Version: 1.00
Author(s): Martti Verho
Revisions:
Abstract: A Base class for model's bodies.
A body is a separable entity in the model geometry.
Body consist of body-elements, which can be edges, surfaces
etc. depending on the topology dimension.
Often also called a part in CAD programs.
************************************************************************/
#ifndef _ECIF_BODY_
#define _ECIF_BODY_
#include "ecif_def.h"
#include "ecif_def_stl.h"
#include "ecif_def_trx.h"
#include "ecif_boundbox.h"
#include "ecif_modelObject.h"
class BodyPair : public ModelObject
{
public:
BodyPair();
BodyPair(const Body* bd1, const Body* bd2);
BodyPair(int tag, const Body* bd1, const Body* bd2);
~BodyPair();
static void initClass(Model* model);
void getBodies(const Body*& bd1, const Body*& bd2) { bd1 = body1; bd2 = body2;}
const char* getName();
int setTag();
int setId();
protected:
void init();
const Body* body1;
const Body* body2;
static int last_tag;
};
class Body : public ModelObject
{
friend class Control;
friend class Model;
public:
Body();
Body(bodyGmtrType type, int ext_tag, char* name, colorIndices color_index = DEFAULT_COLOR_INDEX);
Body(bodyGmtrType type, int int_tag, int ext_tag, char* name, colorIndices color_index = DEFAULT_COLOR_INDEX);
Body(ecif_Body_X& trx_body, bool add_default_layer = false);
virtual ~Body();
virtual bool addAllLoopElements(int layer);
virtual int addAllPendingElements(int layer);
virtual int addAllPendingVertices(int layer) = 0;
bool addElementLoopTags(int layer, int nof_loops, int* loop_tags);
bool addElementGroupTags(int nof_groups, int* group_tags);
bool addElementGroupTag(int group_tag);
int addElement(int layer, BodyElement* be);
int addLayer(ecif_BodyLayer_X& trx_layer);
int addMeshElements(int nof_new_elements, int* new_elment_ids);
int addPendingElement(int layer,int element_tag);
int addPendingVertex(int layer,int vertex_group_id, int vertex_tag);
virtual bool acceptsStructuredMesh(int layer) { return false; }
void calcMeshBox();
bool canHaveZeroVelocityElements();
bool checkElements();
bool checkLayerIndex(int layer);
ecif_modelStatus checkStatus();
virtual bool convertTags2Ids();
void deleteMeshElements();
virtual void draw(Renderer* renderer, flagName geometry_type, objectDrawingMode dmode);
BoundBox* getBoundBox() {return boundbox;}
BoundBox* getBoundBox(int layer);
void getColor(Color4& color);
void getColor(Color4f& color);
colorIndices getColorIndex() { return colorIndex;}
int getBodyForceId();
BodyLayer* getBodyLayer(int layer);
int getBodyParameterId() { return bodyParameterId;}
int getDirectedElementLoopId(int layer, int index);
int getDirectedElementLoopTag(int layer, int index);
enum objectDrawingMode getDrawMode() { return drawMode;}
enum objectDrawingState getDrawState() { return drawState;}
int getElementCount();
int getElementCount(int layer);
BodyElement** getElementArray();
BodyElement** getElementArray(int layer);
BodyElement* getElement(int index);
BodyElement* getElement(int layer, int index);
BodyElement* getElementById(int id);
BodyElement* getElementById(int layer, int id);
int getElementGroupId(int index);
void getElementGroupIds(int& nof_groups, int*& group_ids);
int getElementGroupTag(int index);
void getElementGroupTags(int& nof_groups, int*& group_tags);
BodyElementLoop* getElementLoop(int index);
BodyElementLoop* getElementLoop(int layer, int index);
void getElementIds(int& nof_elements, int*& element_ids);
void getElementIds(int layer, int& nof_elements, int*& element_ids);
void getElementTags(int& nof_elements, int*& element_tags);
void getElementTags(int layer, int& nof_elements, int*& element_tags);
int getElementLoopId(int index);
int getElementLoopTag(int index);
int getElementLoopId(int layer, int index);
int getElementLoopTag(int layer, int index);
int getEquationId();
const int* getExcludedMeshIndices(int layer);
int getExternalTag() {return externalTag;}
const int* getGridParameterMeshIndices(int layer);
const int* getGridParameterIds(int layer);
int getInitialConditionId();
BodyLayer* getLayer(int layer);
int getLayerId(int layer);
int getLayerIndexById(int layer_id);
int getLayerIndexByTag(int layer_tag);
int getLayerTag(int layer);
int getLayerTagById(int layer_id);
int getMaterialId();
int getMeshElementId(int index);
bool getMeshDensityValue(int layer, int mesh_index, char& type, double& value);
int getMeshQuadGridN(int layer, int mesh_index, int element_id);
const char* getName();
const char* getName(int layer);
int getNofBoundaries(int layer, elementType type);
int getNofElementGroups();
int getNofElementLoops(int layer);
int getNofLayers() {return nofLayers;}
int getNofMeshElements() {return nofMeshElements;}
int getNofMifLayers();
void getRangeVector(RangeVector rv) {boundbox->getRangeVector(rv);}
bool getSeparateFlag() { return separateFlag; }
int getGmtrType() { return gmtrType;}
int getTplgType() { return tplgType;}
int getType() { return type;}
bool hasInside(int layer, Body* other_body, int other_body_layer);
void incrBndrCount(int layer, elementType type);
static void initClass(Model* model);
void initName();
virtual bool isClosed() { return tplgType == CLOSED_BODY; }
bool isExcludedFromCurrentMesh();
bool isExcludedFromCurrentMesh(int layer);
bool isExcludedFromMesh(int mesh_index);
bool isExcludedFromMesh(int layer, int mesh_index);
virtual bool isCadBody() { return gmtrType == GEOM_CAD; }
virtual bool isBemBody() { return type == BEM_BODY; }
virtual bool isMeshBody() { return gmtrType == GEOM_MESH; }
virtual bool isOk();
virtual bool isOpen() { return tplgType == OPEN_BODY; }
virtual bool isSeparable(int layer);
virtual bool isVirtual() { return type == VIRTUAL_BODY; }
virtual void markActiveObjects();
virtual void markActiveMeshObjects(int mesh_index, bool*& active_object_flags);
virtual ostream& output_emf(ostream& out, short indent_size, short indent_level);
virtual ostream& output_sif(ostream& out, short indent_size, short indent_level);
virtual ostream& output_mif(ostream& out);
int removeMeshElements(bool* remove_flags);
bool selectLayer(int layer);
virtual void separate(bool* object_duplicate_flags);
void setSeparateFlag(bool value) { separateFlag = value; }
void setBodyForceId(int bf_id) { bodyForceId = bf_id; }
void setBodyParameterId(int pid);
void setColor(Color4& color);
void setColorIndex(colorIndices color_index);
void setDrawMode(enum objectDrawingMode mode) { drawMode = mode; }
void setDrawState(enum objectDrawingState state) { drawState = state; }
void setEquationId(int eq_id) { equationId = eq_id; }
void setElementLoops(int layer, int nof_loops, int* loop_ids, int* loop_tags);
void setExternalTag(int ext_tag) {externalTag = ext_tag;}
void setInitialConditionId(int ic_id) { initialConditionId = ic_id; }
void setLayerTag(int layer, int tag);
void setMaterialId(int mt_id) { materialId = mt_id; }
void setMeshElements(int nof_elements, int* element_ids);
void setGmtrType(bodyGmtrType value) { gmtrType = value; };
void setTplgType(bodyTplgType value) { tplgType = value; };
void setType(bodyType value) { type = value; };
virtual void swapBodyElements(int layer, BodyElement* b1, BodyElement* b2);
int removeElement(int layer, BodyElement* be);
virtual void updateBoundBox();
void updateBoundBox(int layer, RangeVector rv);
void updateMinimumBox(RangeVector rv);
protected:
virtual bool check();
virtual bool checkVirtual();
virtual void drawMesh(Renderer* renderer);
void init(bool add_default_layer = true);
void removeElementLoops(int layer);
void removeElementGroups();
void removeLayers();
void updateBodyElementMeshH(int layer, int updateMode);
// Body level stuff
//
BoundBox* boundboxMesh;
BoundBox* boundbox;
bool checked;
Color4 color;
colorIndices colorIndex;
enum objectDrawingMode drawMode;
enum objectDrawingState drawState;
bool separateFlag;
int* meshElementIds;
int externalTag;
static int last_tag;
int maxNofMeshElements;
int nofMeshElements;
bool status;
enum bodyType type;
enum bodyGmtrType gmtrType;
enum bodyTplgType tplgType;
int bodyParameterId;
int initialConditionId;
int bodyForceId;
int equationId;
int materialId;
// Body Layer level stuff
//
int nofLayers;
int* layerIds;
BodyElementTable** belements;
BoundBox** boundboxes;
IdList** elementLoopIds;
IdList** elementLoopTags;
int* nofElements;
int* nofElementLoops;
IdArray** pendingElementTags;
IdArray** pendingVertexGroups;
IdArray** pendingVertexTags;
int* nofInnerBoundaries;
int* nofOuterBoundaries;
// For virtual bodies
int nofElementGroups;
IdList* elementGroupIds;
IdList* elementGroupTags;
};
#endif
syntax highlighted by Code2HTML, v. 0.9.1