/***********************************************************************
*
* 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_control.cpp
Language: C++
Date: 13.11.98
Version: 1.00
Author(s): Martti Verho
Revisions:
Abstract: Implementation
************************************************************************/
#include "ecif_body.h"
#include "ecif_bodyElement.h"
#include "ecif_control.h"
#include "ecif_input.h"
#include "ecif_inputAbaqus.h"
#include "ecif_inputEmf.h"
#include "ecif_inputEgf.h"
#include "ecif_inputElmer.h"
#include "ecif_inputFidap.h"
#include "ecif_inputIges.h"
#include "ecif_inputIdeas.h"
#include "ecif_inputThetis.h"
#include "ecif_mesh.h"
#include "ecif_model.h"
#include "ecif_modelMeshManager.h"
// #include "ecif_modelOutputManager.h"
#include "ecif_process.h"
#include "ecif_renderer_OGL.h"
#include "ecif_userinterface.h"
#include "ecif_timer.h"
void read_Model_File(char*, Model*);
// ***** Constants used within main-function *****
const char* STD_IN = "stdin";
const char* STD_OUT = "stdout";
Control::Control(Hinst app_name, UserInterface* ui)
{
appInstance = app_name;
breakEgfInput = false;
breakEgfOutput = false;
breakEmfInput = false;
breakEmfOutput = false;
breakMeshInput = false;
breakMeshOutput = false;
theModel = NULL;
theRenderer = NULL;
theUI = ui;
Input::theControlCenter = this;
Model::theControlCenter = this;
ModelMeshManager::theControlCenter = this;
ModelOutputManager::theControlCenter = this;
UserInterface::theControlCenter = this;
Renderer::theControlCenter = this;
processTable = new ProcessTable;
}
void
Control::copyParameters(char* emf_filename)
{
char fname[1 + 1024];
FILE* emf_file = NULL;
//---Test if file exists.
if ( (emf_file = fopen(emf_filename, "r")) == NULL ) {
theUI->errMsg(0, "Error! Can't open the file: ", emf_filename);
return;
}
//---Read parameters from the emf-file
ifstream in_file(emf_filename);
InputEmf* in = new InputEmf(ECIF_ND, in_file, emf_filename);
in->copyEmfParameters();
}
void
Control::Exit()
{
delete theRenderer; theRenderer = NULL;
exit(1);
}
bool
Control::getBreakValue(enum frontProcessType process)
{
switch (process) {
case EGF_INPUT: return breakEgfInput;
case EGF_OUTPUT: return breakEgfOutput;
case EMF_INPUT: return breakEmfInput;
case EMF_OUTPUT: return breakEmfOutput;
case MESH_INPUT: return breakMeshInput;
case MESH_OUTPUT: return breakMeshOutput;
}
return false;
}
void
Control::activateUI()
{
if (theUI == NULL)
return;
enum ecif_modelDimension dim = theModel->getDimension();
theUI->configureButtons("moveButtons", 1);
theUI->configureButtons("displayButtons", 1);
theUI->configureButtons("draw_target_bodies", 1);
theUI->configureButtons("draw_target_edges", 1);
if (dim == ECIF_2D) {
theUI->configureButtons("draw_target_surfaces", 0);
theUI->configureButtons("rotateButtons2D", 1);
} else {
theUI->configureButtons("draw_target_surfaces", 1);
theUI->configureButtons("rotateButtons", 1);
}
if ( theModel->getFlagValue(GEOMETRY_TYPE_CAD) ) {
theUI->configureButtons("draw_source_cad", 1);
} else {
theUI->configureButtons("draw_source_cad", 0);
}
if ( theModel->getFlagValue(GEOMETRY_TYPE_MESH) ) {
theUI->configureMenuButtons("File", "Mesh", 1);
theUI->configureButtons("draw_source_mesh", 1);
}
else {
theUI->configureMenuButtons("File", "Mesh", 0);
theUI->configureButtons("draw_source_mesh", 0);
}
theUI->configureButtons("saveModel", 1);
theUI->configureButtons("mesh", 1);
theUI->configureButtons("solve", 1);
theUI->configureButtons("results", 1);
theUI->configureButtons("break", 0);
theUI->configureButtons("clearMessageArea", 1);
theUI->configureButtons("info_", 1);
theUI->configureButtons("process", 1);
theUI->configureMenuButtons("File", "Save", 1);
theUI->configureMenuButtons("File", "Browsers", 1);
theUI->configureMenuButtons("Edit", "All", 1);
theUI->configureMenuButtons("Edit", "Editors", 1);
theUI->configureMenuButtons("Display", "All", 1);
theUI->configureMenuButtons("Problem", "All", 1);
theUI->configureMenuButtons("Model", "All", 1);
theUI->configureMenuButtons("Mesh", "All", 1);
theUI->configureMenuButtons("Solver", "All", 1);
theUI->configureMenuButtons("Run", "All", 1);
theUI->setInitialState();
}
void
Control::deactivateUI()
{
if (theUI == NULL)
return;
theUI->configureMenuButtons("File", "Save", 0);
theUI->configureMenuButtons("File" ,"Browsers", 0);
theUI->configureMenuButtons("File" , "LoadMesh", 0);
theUI->configureMenuButtons("File", "Mesh", 0);
theUI->configureMenuButtons("Edit", "All", 0);
theUI->configureMenuButtons("Edit" ,"Editors", 0);
theUI->configureMenuButtons("Edit", "MatcGmtr", 0);
theUI->configureMenuButtons("Display", "All", 0);
//theUI->configureMenuButtons("Problem", "All", 0);
theUI->configureMenuButtons("Problem", "Model", 0);
//theUI->configureMenuButtons("Model", "All", 0);
theUI->configureMenuButtons("Model", "Model", 0);
theUI->configureMenuButtons("Mesh", "All", 0);
//theUI->configureMenuButtons("Solver", "All", 0);
theUI->configureMenuButtons("Solver", "Model", 0);
theUI->configureMenuButtons("Run", "NearlyAll", 0);
theUI->configureButtons("break", 1);
}
Input*
Control::create_mesh_input(enum ecif_modelDimension m_dim, ifstream& in_file, char* mesh_filename)
{
Input* in = NULL;
// *** CHECK INPUT FILE ******
bool is_abaqus = checkFname(mesh_filename, ".inp");
bool is_elmer = checkFname(mesh_filename, ".header");
bool is_ideas = checkFname(mesh_filename, ".unv");
bool is_thetis = checkFname(mesh_filename, ".tmf");
//****** KNOWN FILE FORMAT ******
// Read mesh file and select renderer-type based on the model type.
if (is_abaqus || is_elmer || is_ideas || is_thetis) {
//---Select input-type and create model object
if (is_abaqus) {
in = new InputAbaqus(m_dim, in_file, mesh_filename);
} else if (is_elmer) {
in = new InputElmer(m_dim, in_file, mesh_filename);
} else if (is_ideas) {
in = new InputIdeas(m_dim, in_file, mesh_filename);
} else if (is_thetis) {
in = new InputThetis(m_dim, in_file, mesh_filename);
}
}
return in;
}
//Method creates a renderer based on model dimension
void
Control::createRenderer(enum ecif_modelDimension m_dim, bool display_gmtr)
{
// A renderer already exists
if (theRenderer != NULL) {
theRenderer->setDimension(m_dim);
theRenderer->resetData();
// Create a new renderer
} else {
theRenderer = new Renderer_OGL(appInstance, m_dim);
}
if ( display_gmtr ) {
theRenderer->refresh();
}
// Renderer has to know about cylindric symmetry axis
if ( theModel != NULL ) {
theRenderer->setSimulationDimension(theModel->getSimulationDimension());
}
}
// Draw the whole model in the Renderer window
void
Control::displayModel()
{
if (theModel == NULL) {
return;
}
if (theRenderer == NULL) {
createRenderer(theModel->getDimension());
}
theModel->setWindowTitles();
theRenderer->displayRenderer();
}
void
Control::getCurrentTimestamp(char* buffer)
{
theUI->getCurrentTimestamp(buffer);
}
Process*
Control::getProcess(int process_nbr)
{
ProcessTable::iterator itr = processTable->find(process_nbr);
if ( itr != processTable->end() )
return (*itr).second;
else
return NULL;
}
void
Control::handleKeyAction(enum keyAction action)
{
switch (action) {
case KEY_CTRL_B: theUI->sendCommandToGui("SELECT_BODIES"); break;
case KEY_CTRL_H: theUI->sendCommandToGui("SELECT_BOUNDARIES"); break;
case KEY_CTRL_L: theUI->sendCommandToGui("SELECT_LABELS"); break;
case KEY_CTRL_R: theUI->sendCommandToGui("RESET_RENDERER"); break;
case KEY_CTRL_X: theUI->sendCommandToGui("SET_ROTATE_PRIORITY_X"); break;
case KEY_CTRL_Y: theUI->sendCommandToGui("SET_ROTATE_PRIORITY_Y"); break;
case KEY_CTRL_Z: theUI->sendCommandToGui("SET_ROTATE_PRIORITY_Z"); break;
}
}
// Print %-progress info for "nbr" (eg. element_id)
// when total number is "total_nbr" (eg. nofElements)
// MVe 8/97
iostream&
Control::print_progress_info(iostream& strm, int nbr, int total_nbr, char* text)
{
double done = (int(1000.0* nbr/total_nbr))/10.0;
strm << "(";
strm << setiosflags(ios::right | ios::fixed);
strm << setw(4) << setprecision(1);
strm << done << "%)";
if (text != NULL)
strm << text;
return strm;
}
bool
Control::processExists(int process_nbr)
{
strstream strm;
Process* process = getProcess(process_nbr);
if (process == NULL || !process->exists() ) {
return false;
}
return true;
}
bool
Control::processResume(int process_nbr)
{
strstream strm;
Process* process = getProcess(process_nbr);
if (process == NULL || !process->exists() ) {
strm << "Process: " << process_nbr << " not reachable!" << ends;
theUI->showMsg(strm.str());
return false;
}
ProcessId pid = process->getProcessId();
strm << "Process: " << process_nbr << " (PID " << pid << ") being resumed" << ends;
theUI->showMsg(strm.str());
return process->resume();
}
bool
Control::processSetPriorityLevel(int process_nbr, priorityLevel priority)
{
strstream strm;
Process* process = getProcess(process_nbr);
if (process == NULL) {
strm << "Process: " << process_nbr << " not reachable!" << ends;
theUI->showMsg(strm.str());
return false;
}
ProcessId pid = process->getProcessId();
strm << "Process: " << process_nbr << " (PID " << pid << ") priority being set to " << priority << ends;
theUI->showMsg(strm.str());
process->setPriorityLevel(priority);
return true;
}
bool
Control::processStart(Process* process)
{
strstream strm;
int process_nbr = process->ID();
(*processTable)[process_nbr] = process;
if ( NULL == getProcess(process_nbr) ) {
strm << "Process: " << process_nbr << " NOT started!" << ends;
theUI->showMsg(strm.str());
return false;
}
bool success = process->start();
ProcessId pid = process->getProcessId();
if (success) {
//strm << "Process: " << process_nbr << " (PID " << pid << ") started!" << ends;
//theUI->showMsg(strm.str());
return true;
} else {
processTable->erase(process_nbr);
strm << "Process: " << process_nbr << " (PID " << pid << ") NOT started and is removed!" << ends;
theUI->showMsg(strm.str());
return false;
}
return false;
}
bool
Control::processStop(int process_nbr)
{
strstream strm;
Process* process = getProcess(process_nbr);
if (process == NULL) {
strm << "Process: " << process_nbr << " not reachable!" << ends;
theUI->showMsg(strm.str());
return false;
}
ProcessId pid = process->getProcessId();
const char* nm = process->getName();
if ( nm == NULL || nm[0] == '\0' ) {
strm << "Process: " << process_nbr << " (PID " << pid << ") being stopped!" << ends;
} else {
strm << "Process: " << process_nbr << " (" << nm << ") being stopped!" << ends;
}
theUI->showMsg(strm.str());
bool stopped = process->stop();
if (stopped) {
processTable->erase(process_nbr);
return true;
}
return false;
}
bool
Control::processSuspend(int process_nbr)
{
strstream strm;
Process* process = getProcess(process_nbr);
if (process == NULL) {
strm << "Process: " << process_nbr << " not reachable!" << ends;
theUI->showMsg(strm.str());
return false;
}
ProcessId pid = process->getProcessId();
strm << "Process: " << process_nbr << " (PID " << pid << ") being suspended" << ends;
theUI->showMsg(strm.str());
return process->suspend();
}
// Reads in CAD model data file.
//
bool
Control::readCADFile(char* CAD_filename,
char* CAD_type,
enum ecif_modelDimension m_dim)
{
char fname[1 + 1024];
FILE* CAD_file = NULL;
// *** Check that input-file exists.
if ( (CAD_file = fopen(CAD_filename, "r")) == NULL ) {
theUI->errMsg(0, "Error! Can't open the file: ", CAD_filename);
return false;
}
fclose(CAD_file);
// *** Ok, continue
// Deactivate first menus
deactivateUI();
strncpy(fname, CAD_filename, 1024);
LibFront::toLower(fname);
// *** CHECK INPUT FILE ******
bool is_egf = false;
bool is_ideas = false;
bool is_iges = false;
// Quess fron the file extension
if ( CAD_type == NULL ||
CAD_type[0] == '\0' ||
LibFront::in(CAD_type, "default")
) {
is_egf = checkFname(fname, ".egf");
is_ideas = checkFname(fname, ".unv");
is_iges = checkFname(fname, ".igs");
// User has specified the type
} else {
if ( LibFront::in(CAD_type, "elmer") ) is_egf = true;
else if ( LibFront::in(CAD_type, "iges") ) is_iges = true;
else if ( LibFront::in(CAD_type, "ideas") ) is_ideas = true;
}
//****** UNKNOWN FILE FORMAT ******
if ( !(is_egf || is_ideas || is_iges) ) {
theUI->errMsg(0, "Error! Unknown CAD-file format: ", CAD_filename);
return false;
}
//****** KNOWN FILE FORMAT ******
// Read CAD file and select renderer-type based on the model type.
// Clear renderer window
if ( theRenderer != NULL ) {
theRenderer->clear();
}
// First delete possible old model
if (theModel != NULL) {
delete theModel; theModel = NULL;
}
Input* in = NULL;
//ifstream in_file(CAD_filename, ios::nocreate);
ifstream in_file(CAD_filename);
theModel = new Model("", ECIF_CAD_FILE, CAD_filename);
//---Select input-type and create model object
if (is_egf) {
// NOTE: Egf-file errors are handled by the input routine, so
// we can give the dimension already here --> Dimension
// keyword is not necessary in the egf-file
// MVe, 12.01.03
m_dim = ECIF_2D;
in = new InputEgf(m_dim, in_file, CAD_filename);
}
else if (is_ideas) {
in = new InputIdeas(m_dim, in_file, CAD_filename);
}
else if (is_iges) {
in = new InputIges(m_dim, in_file, CAD_filename);
}
//---Read CAD-file, update model-type and create suitable renderer
enum ecif_modelDimension m_out_dim;
#if defined(FRONT_DEBUG)
m_out_dim = in->readCadFile();
#else
// Try to read cad-geometry file
// -----------------------------
try {
m_out_dim = in->readCadFile();
}
// If error
// --------
catch (...) {
m_out_dim = ECIF_ND;
}
#endif
in_file.close();
//---Check that dat was ok.
if ( m_out_dim == ECIF_ND ) {
theUI->errMsg(0, "Error! Incorrect data in CAD-inputfile: ", CAD_filename);
delete in;
return false;
}
//---Ok, process Cad data and create suitable renderer
bool rc = theModel->processCadFileData();
if (rc == false) {
theUI->errMsg(0, "Error! Cad file data not correct!");
return false;
}
//---Ok. Create renderer
createRenderer(m_out_dim);
//---Update data and activate GUI menus.
updateUI();
delete in;
return true;
}
// Reads in mesh data file.
//
bool
Control::readMeshFile(char* mesh_filename,
char* mesh_type,
bool create_new_model,
enum ecif_modelDimension m_dim)
{
char fname[1 + 1024];
FILE* mesh_file = NULL;
// *** Check that input-file exists.
if ( (mesh_file = fopen(mesh_filename, "r")) == NULL ) {
theUI->errMsg(0, "Error! Can't open the file: ", mesh_filename);
return false;
}
fclose(mesh_file);
deactivateUI();
strncpy(fname, mesh_filename, 1024);
LibFront::toLower(fname);
//*** CHECK INPUT FILE TYPE ***
bool is_abaqus = false;
bool is_elmer = false;
bool is_fidap = false;
bool is_ideas = false;
bool is_thetis = false;
if ( LibFront::in(mesh_type, "abaqus2d") ) {
is_abaqus = true;
m_dim = ECIF_2D;
} else if ( LibFront::in(mesh_type, "abaqus3d") ) {
is_abaqus = true;
m_dim = ECIF_3D;
} else if ( LibFront::in(mesh_type, "elmer2d") ) {
is_elmer = true;
m_dim = ECIF_2D;
} else if ( LibFront::in(mesh_type, "elmer3d") ) {
is_elmer = true;
m_dim = ECIF_3D;
} else if ( LibFront::in(mesh_type, "fidap2d") ) {
is_fidap = true;
m_dim = ECIF_2D;
} else if ( LibFront::in(mesh_type, "fidap3d") ) {
is_fidap = true;
m_dim = ECIF_3D;
} else if ( LibFront::in(mesh_type, "ideas2d") ) {
is_ideas = true;
m_dim = ECIF_2D;
} else if ( LibFront::in(mesh_type, "ideas3d") ) {
is_ideas = true;
m_dim = ECIF_3D;
} else if ( LibFront::in(mesh_type, "thetis2d") ) {
is_thetis = true;
m_dim = ECIF_2D;
} else if ( LibFront::in(mesh_type, "thetis3d") ) {
is_thetis = true;
m_dim = ECIF_3D;
}
//****** UNKNOWN FILE FORMAT ******
if ( !(is_abaqus || is_elmer || is_fidap || is_ideas || is_thetis) ) {
theUI->errMsg(0, "Error! Unknown mesh-file format: ", mesh_filename);
return false;
}
//*** KNOWN FILE FORMAT ***
// Read mesh file and select renderer-type based on the model type.
Input* in = NULL;
//ifstream in_file(mesh_filename, ios::nocreate);
ifstream in_file(mesh_filename);
//---Select input-type and create model object
if (is_abaqus) {
in = new InputAbaqus(m_dim, in_file, mesh_filename);
} else if (is_elmer) {
in = new InputElmer(m_dim, in_file, mesh_filename);
} else if (is_fidap) {
in = new InputFidap(m_dim, in_file, mesh_filename);
} else if (is_ideas) {
in = new InputIdeas(m_dim, in_file, mesh_filename);
} else if (is_thetis) {
in = new InputThetis(m_dim, in_file, mesh_filename);
}
// Clear renderer window
if ( theRenderer != NULL ) {
theRenderer->clear();
}
// Delete current model and cretate a new model
if ( create_new_model || theModel == NULL ) {
// First delete possible old model and create new model
if (theModel != NULL) {
delete theModel; theModel = NULL;
}
// Create new model
theModel = new Model("", ECIF_MESH_FILE, mesh_filename);
// Delete only current mesh data, but use bodies etc.
// NOTE: Used when remeshing an external mesh!!!
} else if ( theModel != NULL ) {
theModel->resetModelData();
theModel->resetMeshData();
}
// Elmer mesh specific
if (is_elmer) {
theModel->updateModelNameInfo();
theModel->updateModelDirectoryInfo();
theModel->updateMeshDirectoryInfo();
}
//---Read meshfile, update model-type and create suitable renderer
ecif_modelDimension m_out_dim = ECIF_ND;
bool mesh_ok = true;
#if defined(FRONT_DEBUG)
m_out_dim = in->readMeshFile();
#else
// Try to read mesh-geomtry file
// -----------------------------
//
try {
m_out_dim = in->readMeshFile();
}
// If error
//
catch (...) {
m_out_dim = ECIF_ND;
}
#endif
in_file.close();
if ( m_out_dim == ECIF_ND ) {
mesh_ok = false;
if ( !breakMeshInput ) {
theUI->errMsg(0, "Error! Incorrect data in the mesh inputfile: ", mesh_filename);
}
}
//---If ok so far, process mesh data and create suitable renderer
if (mesh_ok) {
mesh_ok = theModel->processMeshFileData(in);
if (!mesh_ok) {
theUI->errMsg(0, "Error! Mesh file data not correct, mesh not read!");
}
}
delete in;
breakMeshInput = false;
//---If not ok
if (!mesh_ok) {
theModel->resetMeshData();
theUI->configureButtons("break", 0);
return false;
}
//---Ok. Create renderer
createRenderer(m_out_dim);
//---Update data and activate GUI menus
updateUI();
// NOTE: We reset always the mesh unit factor after a succesful read!!!
//
Model::setMeshInputUnit(1.0);
return true;
}
// Read model (emf) file
//
bool
Control::readModelFile(char* model_filename, bool load_mesh, bool is_batch)
{
char fname[1 + 1024];
FILE* model_file = NULL;
//---Test if file exists.
if ( model_filename == NULL || model_filename[0] == '\0' ) {
theUI->errMsg(0, "***ERROR No model file given!");
return false;
}
//---Test if file exists.
if ( (model_file = fopen(model_filename, "r")) == NULL ) {
theUI->errMsg(0, "***ERROR Can't open the file: ", model_filename);
return false;
}
fclose(model_file);
//---Test if we can write to the file
if ( !fopen(model_filename, "r+") ) {
theUI->errMsg(0, "***ERROR Could not get write access to the model file:", model_filename, " , file opened in read only mode!");
fclose(model_file);
}
strncpy(fname, model_filename, 1024);
LibFront::toLower(fname);
// Check file type
//bool is_emf = checkFname(fname, ".emf");
bool is_emf = true;
if (is_emf) {
// First deactivate menus
deactivateUI();
// Clear renderer window
if ( theRenderer != NULL ) {
theRenderer->clear();
}
// Delete possible old model
if (theModel != NULL) {
delete theModel; theModel = NULL;
}
//---Create model object
theModel = new Model();
//---Update model directory info
theModel->updateModelDirectoryInfo();
//---Read model file
//ifstream in_file(model_filename, ios::nocreate);
ifstream in_file(model_filename);
InputEmf* in = new InputEmf(ECIF_ND, in_file, model_filename);
enum ecif_modelDimension m_out_dim;
theModel->setReadingModelFile(true);
// To be sure (for model mesh!)
Model::setMeshInputUnit(1.0);
#if defined(FRONT_DEBUG)
m_out_dim = in->readCadFile();
#else
// Try to read model emf-file
// --------------------------
try {
m_out_dim = in->readCadFile();
}
// If error
// --------
catch (...) {
m_out_dim = ECIF_ND;
}
#endif
theModel->setReadingModelFile(false);
in_file.close();
fclose(model_file);
//---Check that data was ok.
if ( m_out_dim == ECIF_ND ) {
theUI->errMsg(0, "***ERROR Incorrect data in Model-inputfile: ", model_filename);
return false;
}
//---Ok, process model file data and create suitable renderer
bool rc = theModel->processModelFileData();
if (rc == false) {
theUI->errMsg(0, "***ERROR Model file data not correct!");
return false;
}
if (!is_batch) updatePreUI();
//---Update mesh directory info
theModel->updateMeshDirectoryInfo();
//---Mesh loading turned off, make load-button active
if ( !load_mesh && !is_batch ) {
theUI->configureMenuButtons("File", "LoadMesh", 1);
}
//---Load Elmer mesh
else {
theModel->loadMesh();
}
theModel->markActiveObjects();
if (!is_batch) updatePostUI();
//---Create renderer
bool display_gmtr = theModel->modelHasCadGeometry() ||
(theModel->modelHasMeshGeometry() && load_mesh);
if (!is_batch) createRenderer(m_out_dim, display_gmtr);
return true;
}
//****** UNKNOWN FILE FORMAT ******
else {
theUI->errMsg(0, "***ERROR Unknown Model file format: ", model_filename);
return false;
}
}
void
Control::rendererIsClosed()
{
delete theRenderer;
theRenderer = NULL;
}
void
Control::setModelDimension(enum ecif_modelDimension model_dim)
{
theModel->setModelDimension(model_dim);
}
// Saves mesh file in Elmer format
void
Control::saveElmerMeshFile(char* mesh_dir)
{
theModel->saveElmerMesh(mesh_dir);
}
// Saves mesh result file in ElmerPost format
void
Control::saveElmerPostMeshFile(char* out_filename)
{
theModel->saveElmerPostMesh(out_filename);
}
// Saves mesh result file in Thetis format
void
Control::saveThetisMeshFile(char* out_filename)
{
theModel->saveThetisMesh(out_filename);
}
// Saves user settings into a (default) file
void
Control::saveUserSettingsFile(char* out_filename)
{
theModel->saveUserSettingsFile(out_filename);
}
// Saves model file (.emf)
void
Control::saveFrontModelFile(char* out_filename)
{
ofstream out_file(out_filename, ios::out);
if ( !write_ok(out_file, out_filename, "(Writing ELMER Front model file)") )
return;
#if defined(FRONT_DEBUG)
theModel->saveFrontModelFile(out_file, out_filename);
#else
try
{
theModel->saveFrontModelFile(out_file, out_filename);
}
catch (...)
{
theUI->showMsg("ERROR: Unable to save model file (emf-file)!");
}
#endif
out_file.close();
}
// Saves Mesh input (.mif) file.
void
Control::saveMeshInputFile(char* out_filename)
{
ofstream out_file(out_filename, ios::out);
if ( !write_ok(out_file, out_filename, "(Writing ELMER Mesh input file)") )
return;
#if defined(FRONT_DEBUG)
theModel->saveMeshInputFile(out_file, out_filename);
#else
try
{
theModel->saveMeshInputFile(out_file, out_filename);
}
catch (...)
{
theUI->showMsg("ERROR: Unable to save Mesh2D input file (mif-file)!");
}
#endif
out_file.close();
}
// Saves Solver input (.sif) file.
void
Control::saveSolverInputFile(char* out_filename)
{
ofstream out_file(out_filename, ios::out);
if ( !write_ok(out_file, out_filename, "(Writing ELMER Solver input file)") )
return;
#if defined(FRONT_DEBUG)
theModel->saveSolverInputFile(out_file, out_filename);
#else
try
{
theModel->saveSolverInputFile(out_file, out_filename);
}
catch (...)
{
theUI->showMsg("ERROR: Unable to save Solver input file (sif-file)!");
}
#endif
out_file.close();
}
// Sets drawing mode for a body
void
Control::selectBody(int bd_id, int lr_id, bool update_gui)
{
return;
Body* body = theModel->getBodyById(bd_id);
objectDrawingMode dmode = body->getDrawMode();
if ( dmode == DM_NORMAL ) {
body->setDrawMode(DM_HIDDEN);
} else {
body->setDrawMode(DM_NORMAL);
}
if (theRenderer != NULL) {
//theRenderer->setParameters();
theRenderer->drawAllBodies();
}
}
void
Control::selectBoundary(int elem_id, int body1_id, int layer1_id,
int body2_id, int layer2_id,
bool accept_body_change, bool update_gui)
{
if (theRenderer == NULL) {
createRenderer(theModel->getDimension());
}
theRenderer->selectBoundary(elem_id,
body1_id, layer1_id,
body2_id, layer2_id,
accept_body_change, update_gui);
}
void
Control::setBreakValue(enum frontProcessType process, bool value)
{
switch (process) {
case EGF_INPUT: breakEgfInput = value;
case EGF_OUTPUT: breakEgfOutput = value;
case EMF_INPUT: breakEmfInput = value;
case EMF_OUTPUT: breakEmfOutput = value;
case MESH_INPUT: breakMeshInput = value;
case MESH_OUTPUT: breakMeshOutput = value;
}
}
void
Control::selectBoundaries(int nof_elems, int* elem_ids,
int* body1_ids, int* layer1_ids,
int* body2_ids, int* layer2_ids,
bool accept_body_change, bool update_gui)
{
if (theRenderer == NULL) {
createRenderer(theModel->getDimension());
}
theRenderer->selectBoundaries(nof_elems, elem_ids,
body1_ids, layer1_ids,
body2_ids, layer2_ids,
accept_body_change, update_gui);
}
void
Control::setGuiWindowTitle(char* case_name)
{
if ( theUI == NULL ) {
return;
}
theUI->setWindowTitle(case_name);
}
void
Control::setWindowTitles(char* case_name)
{
setRendererWindowTitle(case_name);
setGuiWindowTitle(case_name);
}
void
Control::setRendererWindowTitle(char* case_name)
{
if ( theModel == NULL || theRenderer == NULL ) {
return;
}
double x1, x2, y1, y2, z1, z2;
strstream strm;
theModel->getBoundingBox(x1, x2, y1, y2, z1, z2);
strm << case_name;
strm << " (" << x2 - x1 << " x " << y2 - y1;
if (theModel->getDimension() == ECIF_3D) {
strm << " x " << z2 - z1;
}
strm << ")";
const char* mesh_name = theModel->getCurrentMeshName();
bool drawing_mesh = theModel->getFlagValue(DRAW_SOURCE_MESH);
if (drawing_mesh && mesh_name != NULL && mesh_name[0] != '\0' ) {
strm << " " << mesh_name;
}
strm << ends;
theRenderer->setWindowTitle(strm.str());
}
int
Control::unknownFieldMsg(emf_ObjectData_X* object_data, bool is_fatal)
{
const int isOK = 0;
UserInterface* gui = getGui();
strstream strm;
strm << "WARNING: Unknown field name ("
<< object_data->field_name
<< ") when reading object: "
<< object_data->object_name
<< ends;
gui->showMsg(strm.str());
if (is_fatal)
return !isOK;
else
return isOK;
}
int
Control::unknownObjectMsg(emf_ObjectData_X* object_data, bool is_fatal)
{
const int isOK = 0;
UserInterface* gui = getGui();
strstream strm;
strm << "WARNING: Unknown object name: "
<< object_data->object_name
<< ends;
gui->showMsg(strm.str());
if (is_fatal)
return !isOK;
else
return isOK;
}
void
Control::update(int counter, int update_interval)
{
theUI->update(counter, update_interval);
}
void
Control::updateUI()
{
updatePreUI();
updatePostUI();
}
void
Control::updatePreUI()
{
//theUI->showMsg("---1. Updating model objects...");
// Update general model level data in Gui
theModel->initModelFlags();
theUI->updateModelFlags(theModel);
theUI->updateModelStatus(theModel);
theUI->updateModelData(theModel);
theUI->updateObjectData(theModel);
theUI->updateParameterDataPre(theModel);
}
void
Control::updatePostUI()
{
// Why this was called again here (also in updateObjectData) ???!!!???
//
// Update boundary level data
//theUI->updateBoundaryData(theModel);
theUI->showMsg("Checking model data...");
// Set mask related stuff (when all boundaries are now set!)
theUI->updateParameterDataPost(theModel);
// Activate menus
activateUI();
theModel->setWindowTitles();
theUI->showMsg("All done");
}
bool
Control::write_ok(ofstream& out_file, char* out_filename, char* msg)
{
int state = out_file.rdstate();
if ( state & (ios::failbit | ios::badbit) ) {
strstream strm;
strm << "Error! Cannot write data to the file:" << endl;
strm << out_filename;
if ( msg != NULL ) {
strm << endl << msg;
}
strm << ends;
theUI->errMsg(0, strm.str());
return false;
}
return true;
}
syntax highlighted by Code2HTML, v. 0.9.1