/***********************************************************************
*
* 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_model_aux.h
Language: C++
Date: 20.10.98
Version: 1.00
Author(s): Martti Verho
Revisions:
Abstract: Model helper structures
************************************************************************/
#ifndef _ECIF_MODEL_AUX_
#define _ECIF_MODEL_AUX_
#include "ecif_def.h"
#include "ecif_def_stl.h"
class MeshElementTable;
class MeshBulkElementTable;
class MeshFaceElementTable;
class MeshEdgeElementTable;
// This class stores info on mesh element connections to parent
// elements, like edge elements to boundaries, node to edges etc.
// If connections are numerated, each new connection stores also
// numerating number for the connections
//
class MeshConnectionTable {
public:
MeshConnectionTable(int count, int alloc_size, int realloc_size,
bool enumerate_connections = false);
~MeshConnectionTable();
bool addConnection(int index, int parent_id, bool only_unique = false);
bool addConnection(int index, int parent_id, int& connection_nbr, bool only_unique = false);
bool addConnections(int nof_indices, int* indices, int parent_id, bool only_unique = false);
int getConnectionNbr(int index, int parent_index);
const int* getConnectionNbrs(int index);
int getNofConnections(int index);
int getParentId(int index, int parent_index);
const int* getParentIds(int index);
bool getParentIds(int nof_indices, int* indices, int max_buffer_size, int* parent_id_buffer,
int minimum_connection_count, int& nof_ids);
void sortParentIds();
protected:
bool enumerateConnections;
int lastConnectionNbr;
int* nofConnections; // Current nof connections
int* maxNofConnections; // Max nof of connection
int** parentIds; // List of ids to connected parents
int** connectionNbrs; // List of enumerating numbers for the connections
static int allocSize; // Initial connection allocation size
static int reallocSize; // Connection reallocation size
static int totalCount; // Total nof items
};
// This structure is used to store info for mesh elements during
// mesh input file reading
//
struct MeshInputElement {
MeshInputElement();
~MeshInputElement();
char type; // U=bulk, B=bndr, E=edge, V=vertex
meshElementCode elementCode; // Elmer elemen code (MEC_303 etc.)
int elementId; // Internal element id (both types have own numbering!)
int extElementId; // External element id
int extParentTag; // External body/boundary tag (material-id)
int* extNodeIds; // External node ids
int parentTag; // Internal body/boundary tag (counter)
char isAdded; // 0/1
};
// Used to store info on mesh corner elements, ie elements
// whose n-1 faces are at boundary
struct MeshCornerElement {
MeshCornerElement();
~MeshCornerElement();
int elementId; // Original element id
int elementCode; // Original element code
int bodyId; // Element bodyi id
int* nodeIds; // Current node ids
bool hasZeroVelocity; // Zero-velocity bc flag
bool corrected; // True if corrected for zero-velocity
bool splitted; // True if corrected by splitting
int nofSubElements; // Original element nof sub elems
int* subElementIds; // Original element subelem ids
int* boundaryElementIds; // Original element subelem ids in boundarElements table
int* boundaryIds; // Original element subelem bounary ids
int newNodeId; // New (center) node id for splitted elemtent
int nofNewElements; // Nof of new elements for splitted element
int* newElementIds; // New elment ids for splitted element
Point3 centerPoint; // Element center point (location of the new node!)
};
struct MeshData {
MeshData();
~MeshData();
void resizeFlagTable(bool*& id_table, int old_size, int new_size, bool* copy_flags);
void resizeIdTable(int*& id_table, int old_size, int new_size, bool* copy_flags);
void resizeNodeTable(int old_size, int new_size, bool* copy_flags);
MeshElementTable* bulkElements;
MeshElementTable* bulkEdges;
bool* bulkEdgeRendered;
int* bulkRenumbering; // This is needed if splitted ("holes") elements
MeshElementTable* boundaryElements;
MeshElementTable* boundaryEdges;
MeshElementTable* boundaryVertices;
int* boundaryElementBoundaryIds;
int* bulkElementExt2Int;
int* bulkElementInt2Ext;
int* bodyExt2Int;
int* bodyInt2Ext;
int nofAllocNodes;
int nofNodes;
int* nofBoundaryNodeParents; // Nof boundary element parents for each boundary node (NOTE: a sparse table, size is nofNodes)
int** boundaryNodeParentIds; // Boundary element parent ids for each boundary node (NOTE: a sparse table, size is nofNodes)
int lastBulkElementIndex;
int lastBoundaryElementIndex;
Point3* nodes;
int* nodeExt2Int;
int* nodeInt2Ext;
};
struct MeshInfo {
MeshInfo();
~MeshInfo();
int selectedBndrElementId;
int selectedBulkElementId;
int nofCornerElements;
int nofZeroVelocityElements;
int nofSplittedElements;
int nofBulkEdges;
int nofBulkElements;
int nofVertices;
int nofAllocElements;
int maxExternalElementId;
int nofNodes;
int nofAllocNodes;
int maxExternalNodeId;
int nofBodies;
//int nofBoundaries;
int nofBoundaryEdges;
int nofBoundaryElements;
int nofBoundaryVertices;
int nofInputBoundaryElements;
//int nofInnerBoundaries;
int nofInnerBndrElements;
//int nofOuterBoundaries;
int nofOuterBndrElements;
int* nofUsedElementTypes;
double minX, maxX, minY, maxY, minZ, maxZ;
double dimX, dimY, dimZ, dimAvg;
};
// This is used ex. to store vertices to be printed as a vertex table
// in emf-file
//
struct VertexTable {
VertexTable();
~VertexTable();
int dim1;
int dim2;
int* vertexIds;
MatcValueTable matcTable;
};
struct ModelData {
ModelData();
~ModelData();
void purgeBodyElementTable(BodyElementTable*& table);
void purgeMeshCornerElements();
void purgeCreatedElements();
void purgeModelObjects();
void purgeModelPoints();
void purgeParameterTable(ParameterTable*& table);
void purgeRemovedElements();
void setVertexTable(int dim1, int dim2, int* vertex_ids, MatcValueTable& matc_table);
void reset();
AdjacentPairArray* boundaryCandidates;
int lastPointId;
MeshCornerElementList* meshCornerElements;
ModelObjectArray* modelObjects;
VertexTable* vertexTable;
PointHashTable* modelPoints;
Point2VertexTable* modelPoint2Vertices;
BodyPairArray* neighbourCandidates;
BodyElementTable* createdModelElements;
BodyElementTable* removedModelElements;
SplitCombineInfoArray* splitCombineInfos;
int splitCombineInfoIndex;
IdListTable* coveringElementTable;
IdNumberTable* swapElementTable;
ParameterTable* bodyParameters;
ParameterTable* boundaryParameters;
ParameterTable* boundaryConditions;
ParameterTable* bodyForces;
ParameterTable* calculators;
ParameterTable* constants;
ParameterTable* coordinates;
ParameterTable* datafiles;
ParameterTable* equations;
ParameterTable* equationVariables;
ParameterTable* gridParameters;
ParameterTable* gridHs;
ParameterTable* initialConditions;
ParameterTable* materials;
ParameterTable* modelParameters;
ParameterTable* simulationParameters;
ParameterTable* solvers;
ParameterTable* solverControls;
ParameterTable* timesteps;
ParameterTable* userSettings;
};
// A structure to collect general model info
struct ModelInfo {
ModelInfo(char* model_name, ecif_modelSource source, char* in_file_name);
~ModelInfo();
modelGeometryType updateGeometryType();
void updateCoordinateMapping(const char* coordinate_mapping_str);
modelCoordinateType updateCoordinateType(const char* coordinate_system);
ecif_modelDimension updateSimulationDimension(const char* coordinate_system);
// NOTE: We want to track one level back with the input version number!
int frontPreviousInputVersionNbr; // Front previous version number for the input model file (emf-file)
int frontInputVersionNbr; // Front version number for the input model file (emf-file)
int frontVersionNbr; // Front version number for the output model file (emf-file)
ecif_modelStatus modelStatus;
enum ecif_modelSource modelSourceType;
enum ecif_modelDimension dimension;
enum ecif_modelDimension simulationDimension;
enum modelGeometryType geometryType;
enum modelCoordinateType coordinateType;
int coordinateMapping[3];
bool hasGeometry;
int* activeMeshIndices;
char* cadSourceFile;
char* created;
bool hasUserDefinitions;
bool hasMatcDefinitions;
char* includePath;
char* includePath_absolute;
bool includePath_save;
bool keepMatcDefinitions;
char* matcInputFile_emf;
char* matcInputFile_sif;
int currentMeshIndex;
int nofActiveMeshes;
int nofMeshes;
int nofBgMeshFiles;
int* meshBgMeshFileIndices;
char** meshBgMeshFiles;
bool* meshBgMeshActives;
bool* meshBgMeshControls;
char** meshNames;
double* meshFs;
double* meshHs;
char* meshDirectory;
char* meshDirectory_absolute;
char* meshSourceFile;
char* meshResultFile;
char* modelName;
char* modelDescription;
char* modelDirectory;
char* modelDirectory_absolute;
char* modelFileName;
char* modelFileTs;
char* modified;
char* problemDescription;
char* problemName;
char* resultsDirectory;
char* resultsDirectory_absolute;
bool resultsDirectory_save;
char* temporaryFilesDirectory;
char* temporaryFilesDirectory_absolute;
bool temporaryFilesDirectory_save;
int selectedBodyElementId;
int selectedBody1Id;
int selectedBody2Id;
int selectedLayer1Id;
int selectedLayer2Id;
bool editingMeshBoundaries;
int nofEditableMeshBoundaries;
BodyElement** editableMeshBoundaries;
// Model (Cad) dimensions
double minEdgeSize;
double minX, maxX, minY, maxY, minZ, maxZ;
double dimX, dimY, dimZ, dimAvg, dimMin, dimMax;
// Timestamps when stored data was last change in the model file
// Note! These are not (necesarily) times when the target was updated!
// This time is stored in the target iself (Gebhard factors file etc.)
char* databaseTs;
char* frontTs;
char* gebhardtFactorsTs;
char* meshParameterTs;
char* meshTs;
char* solverTs;
char* viewfactorsTs;
// Flags if data was changed during the current session
bool databaseNeedsUpdate;
bool gebhardtFactorsNeedsUpdate;
bool hasDiffuseGrayRadiation;
bool meshNeedsUpdate;
bool solverNeedsUpdate;
bool viewfactorsNeedsUpdate;
// Other flags
bool readingModelFile; // Model is reading ecf-model input file
};
struct ModelStatistics
{
ModelStatistics();
~ModelStatistics();
int nofBodies;
int nofBodiesWithBodyForce;
int nofBodiesWithEquation;
int nofBodiesWithInitialCondition;
int nofBodiesWithMaterial;
int nofBodyForces;
int nofBodyPairs;
int nofBodyParameters;
int nofBoundaryConditions;
int nofBoundaryParameters;
int nofBoundaryPoints;
int nofCalculators;
int nofConstants;
int nofCoordinates;
int nofDatafiles;
int nofEdgesWithCondition;
int nofElements;
int nofElementLoops;
int nofElementGroups;
int nofEquations;
int nofEquationVariables;
int nofGridHs;
int nofGridParameters;
int nofInitialConditions;
int nofInnerBoundaries;
int nofInnerBoundariesWithCondition;
int nofMaterials;
int nofMeshBodies;
int nofMeshBodyElements;
int nofMeshBoundaryVertices;
int nofModelObjects;
int nofModelParameters;
int nofOuterBoundaries;
int nofOuterBoundariesWithCondition;
int nofPatterns;
int nofPoints;
int nofSimulationParameters;
int nofSolvers;
int nofSolverControls;
int nofTimesteps; // NOTE: nof timestepping schemes!
int nofUserSettings;
int nofVertices;
int nofVerticesWithCondition;
int maxLoopSize;
};
struct ParallelInfo {
ParallelInfo();
~ParallelInfo();
int nofProcessors;
};
struct PickInfo {
PickInfo() {
anchorPoint[0] = anchorPoint[1] = anchorPoint[2] = NSVD;
pickPoint[0] = pickPoint[1] = pickPoint[2] = NSVD;
pickDir[0] = pickDir[1] = pickDir[2] = NSVD;
}
~PickInfo() {};
Point3 anchorPoint;
Point3 pickPoint;
Point3 pickDir;
};
#endif
syntax highlighted by Code2HTML, v. 0.9.1