SMESHDS_Mesh* theMeshDS = theHelper->GetMeshDS();
const bool hasGeom = ( theHelper->GetMesh()->HasShapeToMesh() );
- int nbInitialNodes = theNodeByGhs3dId.size();
+ int nbInitialNodes = (int) theNodeByGhs3dId.size();
#ifdef _MY_DEBUG_
const bool isQuadMesh =
SMESHUtils::Deleter< SMESH_ElementSearcher > pntCls
( SMESH_MeshAlgos::GetElementSearcher(*theMesh->GetMeshDS()));
- int nbEnforcedVertices = theEnforcedVertices.size();
+ int nbEnforcedVertices = (int) theEnforcedVertices.size();
theInvalidEnforcedFlags = 0;
// count faces
- int nbFaces = theProxyMesh.NbFaces();
+ smIdType nbFaces = theProxyMesh.NbFaces();
int nbNodes;
theFaceByGhs3dId.reserve( nbFaces );
{
// find MG-Tetra ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
- int newId = aNodeToGhs3dIdMap.size() + 1; // MG-Tetra ids count from 1
+ int newId = (int) aNodeToGhs3dIdMap.size() + 1; // MG-Tetra ids count from 1
aNodeToGhs3dIdMap.insert( make_pair( node, newId ));
}
}
#endif
if (nbFoundElems ==0) {
if ((*aNodeToTopAbs_StateMap.find(node)).second == TopAbs_IN) {
- newId = aNodeToGhs3dIdMap.size() + anEnforcedNodeToGhs3dIdMap.size() + 1; // MG-Tetra ids count from 1
+ newId = int( aNodeToGhs3dIdMap.size() + anEnforcedNodeToGhs3dIdMap.size() + 1 ); // MG-Tetra ids count from 1
anEnforcedNodeToGhs3dIdMap.insert( make_pair( node, newId ));
}
}
#endif
if (nbFoundElems ==0) {
if ((*aNodeToTopAbs_StateMap.find(node)).second == TopAbs_IN) {
- newId = aNodeToGhs3dIdMap.size() + anEnforcedNodeToGhs3dIdMap.size() + 1; // MG-Tetra ids count from 1
+ newId = int( aNodeToGhs3dIdMap.size() + anEnforcedNodeToGhs3dIdMap.size() + 1 ); // MG-Tetra ids count from 1
anEnforcedNodeToGhs3dIdMap.insert( make_pair( node, newId ));
}
}
// theOrderedNodes.push_back(node);
theRequiredNodes.push_back(node);
}
- int requiredNodes = theRequiredNodes.size();
+ int requiredNodes = (int) theRequiredNodes.size();
int solSize = 0;
std::vector<std::vector<double> > ReqVerTab;
// GmfVertices
std::cout << "Begin writting required nodes in GmfVertices" << std::endl;
std::cout << "Nb vertices: " << theOrderedNodes.size() << std::endl;
- MGInput->GmfSetKwd( idx, GmfVertices, theOrderedNodes.size()/*+solSize*/);
+ MGInput->GmfSetKwd( idx, GmfVertices, int( theOrderedNodes.size()/*+solSize*/));
for (ghs3dNodeIt = theOrderedNodes.begin();ghs3dNodeIt != theOrderedNodes.end();++ghs3dNodeIt) {
MGInput->GmfSetLin( idx, GmfVertices, (*ghs3dNodeIt)->X(), (*ghs3dNodeIt)->Y(), (*ghs3dNodeIt)->Z(), dummyint);
}
// idxRequired = MGInput->GmfOpenMesh( theRequiredFileName, GmfWrite, GMFVERSION, GMFDIMENSION);
// if (!idxRequired)
// return false;
- MGInput->GmfSetKwd( idx, GmfEdges, theKeptEnforcedEdges.size());
+ MGInput->GmfSetKwd( idx, GmfEdges, (int) theKeptEnforcedEdges.size());
// MGInput->GmfSetKwd( idxRequired, GmfEdges, theKeptEnforcedEdges.size());
for(elemSetIt = theKeptEnforcedEdges.begin() ; elemSetIt != theKeptEnforcedEdges.end() ; ++elemSetIt) {
elem = (*elemSetIt);
int usedEnforcedTriangles = 0;
if (anElemSet.size()+theKeptEnforcedTriangles.size()) {
aFaceGroupByGhs3dId.resize( anElemSet.size()+theKeptEnforcedTriangles.size() );
- MGInput->GmfSetKwd( idx, GmfTriangles, anElemSet.size()+theKeptEnforcedTriangles.size());
+ MGInput->GmfSetKwd( idx, GmfTriangles, int( anElemSet.size()+theKeptEnforcedTriangles.size() ));
int k=0;
for(elemSetIt = anElemSet.begin() ; elemSetIt != anElemSet.end() ; ++elemSetIt,++k) {
elem = (*elemSetIt);
if (usedEnforcedTriangles) {
MGInput->GmfSetKwd( idx, GmfRequiredTriangles, usedEnforcedTriangles);
for (int enfID=1;enfID<=usedEnforcedTriangles;enfID++)
- MGInput->GmfSetLin( idx, GmfRequiredTriangles, anElemSet.size()+enfID);
+ MGInput->GmfSetLin( idx, GmfRequiredTriangles, int( anElemSet.size()+enfID ));
}
MGInput->GmfCloseMesh(idx);
}
}
}
- int nbEnforcedVertices = coordsSizeMap.size();
- int nbEnforcedNodes = enforcedNodes.size();
+ size_t nbEnforcedVertices = coordsSizeMap.size();
+ size_t nbEnforcedNodes = enforcedNodes.size();
std::string tmpStr;
(nbEnforcedNodes <= 1) ? tmpStr = "node" : "nodes";
std::string tmpStr;
- int nbEnforcedVertices = coordsSizeMap.size();
- int nbEnforcedNodes = enforcedNodes.size();
+ size_t nbEnforcedVertices = coordsSizeMap.size();
+ size_t nbEnforcedNodes = enforcedNodes.size();
(nbEnforcedNodes <= 1) ? tmpStr = "node" : tmpStr = "nodes";
std::cout << nbEnforcedNodes << " enforced " << tmpStr << " from hypo" << std::endl;
(nbEnforcedVertices <= 1) ? tmpStr = "vertex" : tmpStr = "vertices";
{
while ( !isdigit( *ptr )) ++ptr;
if ( ptr[-1] == '-' ) --ptr;
- ids.push_back( strtol( ptr, &ptr, 10 ));
+ ids.push_back((int) strtol( ptr, &ptr, 10 ));
--nbIds;
}
return ptr;
ptr += 4;
char* errBeg = ptr;
- int errNum = strtol(ptr, &ptr, 10) + versionAddition;
+ int errNum = int( strtol(ptr, &ptr, 10) + versionAddition );
// we treat errors enumerated in [SALOME platform 0019316] issue
// and all errors from a new (Release 1.1) MeshGems User Manual
switch ( errNum ) {
const TopoDS_Shape& aShape,
MapShapeNbElems& aResMap)
{
- int nbtri = 0, nbqua = 0;
+ smIdType nbtri = 0, nbqua = 0;
double fullArea = 0.0;
for (TopExp_Explorer exp(aShape, TopAbs_FACE); exp.More(); exp.Next()) {
TopoDS_Face F = TopoDS::Face( exp.Current() );
"Submesh can not be evaluated",this));
return false;
}
- std::vector<int> aVec = (*anIt).second;
- nbtri += Max(aVec[SMDSEntity_Triangle],aVec[SMDSEntity_Quad_Triangle]);
- nbqua += Max(aVec[SMDSEntity_Quadrangle],aVec[SMDSEntity_Quad_Quadrangle]);
+ std::vector<smIdType> aVec = (*anIt).second;
+ nbtri += std::max(aVec[SMDSEntity_Triangle],aVec[SMDSEntity_Quad_Triangle]);
+ nbqua += std::max(aVec[SMDSEntity_Quadrangle],aVec[SMDSEntity_Quad_Quadrangle]);
GProp_GProps G;
BRepGProp::SurfaceProperties(F,G);
double anArea = G.Mass();
}
// collect info from edges
- int nb0d_e = 0, nb1d_e = 0;
+ smIdType nb0d_e = 0, nb1d_e = 0;
bool IsQuadratic = false;
bool IsFirst = true;
TopTools_MapOfShape tmpMap;
tmpMap.Add(E);
SMESH_subMesh *aSubMesh = aMesh.GetSubMesh(exp.Current());
MapShapeNbElemsItr anIt = aResMap.find(aSubMesh);
- std::vector<int> aVec = (*anIt).second;
+ std::vector<smIdType> aVec = (*anIt).second;
nb0d_e += aVec[SMDSEntity_Node];
- nb1d_e += Max(aVec[SMDSEntity_Edge],aVec[SMDSEntity_Quad_Edge]);
+ nb1d_e += std::max(aVec[SMDSEntity_Edge],aVec[SMDSEntity_Quad_Edge]);
if(IsFirst) {
IsQuadratic = (aVec[SMDSEntity_Quad_Edge] > aVec[SMDSEntity_Edge]);
IsFirst = false;
}
tmpMap.Clear();
- double ELen = sqrt(2.* ( fullArea/(nbtri+nbqua*2) ) / sqrt(3.0) );
+ double ELen = sqrt(2.* ( fullArea/double(nbtri+nbqua*2) ) / sqrt(3.0) );
GProp_GProps G;
BRepGProp::VolumeProperties(aShape,G);
double aVolume = G.Mass();
double tetrVol = 0.1179*ELen*ELen*ELen;
double CoeffQuality = 0.9;
- int nbVols = int(aVolume/tetrVol/CoeffQuality);
- int nb1d_f = (nbtri*3 + nbqua*4 - nb1d_e) / 2;
- int nb1d_in = (int) ( nbVols*6 - nb1d_e - nb1d_f ) / 5;
- std::vector<int> aVec(SMDSEntity_Last);
- for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aVec[i]=0;
+ smIdType nbVols = smIdType(aVolume/tetrVol/CoeffQuality);
+ smIdType nb1d_f = (nbtri*3 + nbqua*4 - nb1d_e) / 2;
+ smIdType nb1d_in = (smIdType) ( nbVols*6 - nb1d_e - nb1d_f ) / 5;
+ std::vector<smIdType> aVec(SMDSEntity_Last);
+ for(smIdType i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aVec[i]=0;
if( IsQuadratic ) {
aVec[SMDSEntity_Node] = nb1d_in/6 + 1 + nb1d_in;
aVec[SMDSEntity_Quad_Tetra] = nbVols - nbqua*2;
//=======================================================================
//function : SetEnforcedGroup
//=======================================================================
-bool GHS3DPlugin_Hypothesis::SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SMESH::long_array_var theIDs, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName)
+bool GHS3DPlugin_Hypothesis::SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SMESH::smIdType_array_var theIDs, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName)
{
MESSAGE("GHS3DPlugin_Hypothesis::SetEnforcedGroup");
TIDSortedElemSet theElemSet;
if ( theIDs->length() == 0 ){MESSAGE("The source group is empty");}
- for ( CORBA::ULong i=0; i < theIDs->length(); i++) {
- CORBA::Long ind = theIDs[i];
+ for ( CORBA::ULong i = 0; i < theIDs->length(); i++) {
+ SMESH::smIdType ind = theIDs[i];
if (elementType == SMESH::NODE)
{
const SMDS_MeshNode * node = theMeshDS->FindNode(ind);
statex.dwLength = sizeof (statex);
long err = GlobalMemoryStatusEx (&statex);
if (err != 0) {
- double totMB = (double)statex.ullAvailPhys / 1024. / 1024.;
- return (float)( 0.7 * totMB );
+ double totMB = double( statex.ullAvailPhys ) / 1024. / 1024.;
+ return float( 0.7 * totMB );
}
#elif !defined(__APPLE__)
struct sysinfo si;
long err = sysinfo( &si );
if ( err == 0 ) {
- long ramMB = si.totalram * si.mem_unit / 1024 / 1024;
- return ( 0.7 * ramMB );
+ double ramMB = double( si.totalram * si.mem_unit / 1024 / 1024 );
+ return float( 0.7 * ramMB );
}
#endif
return 1024;
isOK = static_cast<bool>(load >> d);
if (isOK)
- myMaximumMemory = d;
+ myMaximumMemory = float( d );
else
load.clear(ios::badbit | load.rdstate());
isOK = static_cast<bool>(load >> d);
if (isOK)
- myInitialMemory = d;
+ myInitialMemory = float( d );
else
load.clear(ios::badbit | load.rdstate());
isOK = static_cast<bool>(load >> i);
if (isOK)
- myOptimizationLevel = i;
+ myOptimizationLevel = (short int) i;
else
load.clear(ios::badbit | load.rdstate());
// strip white spaces
while (ptr[0] == ' ')
ptr++;
- int i = strlen(ptr);
+ size_t i = strlen(ptr);
while (i != 0 && ptr[i - 1] == ' ')
i--;
// check value type
if ( isOk ) *isOk = true;
for ( size_t i = 0; i <= s.size(); ++i )
- s[i] = tolower( s[i] );
+ s[i] = (char) tolower( s[i] );
if ( s == "1" || s == "true" || s == "active" || s == "yes" )
return true;
* To set enforced elements
*/
bool SetEnforcedMesh(SMESH_Mesh& theMesh, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName = "");
- bool SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SMESH::long_array_var theIDs, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName = "");
+ bool SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SMESH::smIdType_array_var theIDs, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName = "");
bool SetEnforcedElements(TIDSortedElemSet theElemSet, SMESH::ElementType elementType, std::string groupName = "");
const TGHS3DEnforcedMeshList _GetEnforcedMeshes() const { return _enfMeshList; }
const TEntryGHS3DEnforcedMeshListMap _GetEnforcedMeshesByEntry() const { return _entryEnfMeshMap; }
CORBA::Short GHS3DPlugin_Hypothesis_i::GetNbVolumeProximityLayers()
{
- return this->GetImpl()->GetNbVolumeProximityLayers();
+ return (CORBA::Short) this->GetImpl()->GetNbVolumeProximityLayers();
}
//=======================================================================
// basic options (visible in Advanced table)
else if ( name == "verbose" )
- SetVerboseLevel( GetImpl()->ToInt( optionValue ));
+ SetVerboseLevel((CORBA::Short) GetImpl()->ToInt( optionValue ));
else if ( name == "max_memory" )
- SetMaximumMemory( GetImpl()->ToInt( optionValue ));
+ SetMaximumMemory((CORBA::Short) GetImpl()->ToInt( optionValue ));
else if ( name == "automatic_memory" )
- SetInitialMemory( GetImpl()->ToInt( optionValue ));
+ SetInitialMemory((CORBA::Short) GetImpl()->ToInt( optionValue ));
else if ( name == "no_initial_central_point" && // optimizer
strcmp( GetImpl()->GetName(), ::GHS3DPlugin_Hypothesis::GetHypType() ) != 0 )
SetGradation( GetImpl()->ToDbl( optionValue ));
else if ( name == "volume_proximity_layers" )
- SetNbVolumeProximityLayers( GetImpl()->ToInt( optionValue ));
+ SetNbVolumeProximityLayers((CORBA::Short) GetImpl()->ToInt( optionValue ));
else if ( name == "components" )
SetToMeshHoles( strncmp( "all", optionValue, 3 ) == 0 );
GHS3DPlugin::string_array_var result = new GHS3DPlugin::string_array();
const ::GHS3DPlugin_Hypothesis::TOptionValues & opts = this->GetImpl()->GetOptionValues();
- result->length(opts.size());
+ result->length((CORBA::ULong) opts.size());
int i=0;
bool isDefault;
GHS3DPlugin::string_array_var result = new GHS3DPlugin::string_array();
const ::GHS3DPlugin_Hypothesis::TOptionValues & custom_opts = this->GetImpl()->GetCustomOptionValues();
- result->length(custom_opts.size());
+ result->length((CORBA::ULong) custom_opts.size());
int i=0;
::GHS3DPlugin_Hypothesis::TOptionValues::const_iterator opIt = custom_opts.begin();
GHS3DPlugin::GHS3DEnforcedVertexList_var result = new GHS3DPlugin::GHS3DEnforcedVertexList();
const ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList enfVertexList = this->GetImpl()->_GetEnforcedVertices();
- result->length( enfVertexList.size() );
+ result->length((CORBA::ULong) enfVertexList.size() );
::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList::const_iterator it = enfVertexList.begin();
enfVertex->geomEntry = CORBA::string_dup(currentVertex->geomEntry.c_str());
// Coords
GHS3DPlugin::TCoords_var coords = new GHS3DPlugin::TCoords();
- coords->length(currentVertex->coords.size());
- for ( size_t ind = 0; ind < currentVertex->coords.size(); ind++)
+ coords->length((CORBA::ULong) currentVertex->coords.size());
+ for ( CORBA::ULong ind = 0; ind < currentVertex->coords.size(); ind++)
coords[ind] = currentVertex->coords[ind];
enfVertex->coords = coords;
// Group Name
GHS3DPlugin::GHS3DEnforcedMeshList_var result = new GHS3DPlugin::GHS3DEnforcedMeshList();
const ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedMeshList enfMeshList = this->GetImpl()->_GetEnforcedMeshes();
- result->length( enfMeshList.size() );
+ result->length((CORBA::ULong) enfMeshList.size() );
::GHS3DPlugin_Hypothesis::TGHS3DEnforcedMeshList::const_iterator it = enfMeshList.begin();
if ( meshDS->NbNodes() != meshDS->MaxNodeID() )
meshDS->CompactMesh();
- theMGInput->GmfSetKwd( mfile, GmfVertices, meshDS->NbNodes() );
+ theMGInput->GmfSetKwd( mfile, GmfVertices, (int) meshDS->NbNodes() );
int TypTab[] = { GmfSca };
- theMGInput->GmfSetKwd( sfile, GmfSolAtVertices, meshDS->NbNodes(), 1, TypTab);
+ theMGInput->GmfSetKwd( sfile, GmfSolAtVertices, (int) meshDS->NbNodes(), 1, TypTab);
SMDS_NodeIteratorPtr nodeIt = theHelper->GetMeshDS()->nodesIterator();
while ( nodeIt->more() )
// write all triangles
- theMGInput->GmfSetKwd( mfile, GmfTriangles, meshDS->GetMeshInfo().NbTriangles() );
+ theMGInput->GmfSetKwd( mfile, GmfTriangles, (int) meshDS->GetMeshInfo().NbTriangles() );
SMDS_ElemIteratorPtr triaIt = meshDS->elementGeomIterator( SMDSGeom_TRIANGLE );
while ( triaIt->more() )
{
const SMDS_MeshElement* tria = triaIt->next();
theMGInput->GmfSetLin( mfile, GmfTriangles,
- tria->GetNode(0)->GetID(),
- tria->GetNode(1)->GetID(),
- tria->GetNode(2)->GetID(),
+ static_cast<int>(tria->GetNode(0)->GetID()),
+ static_cast<int>(tria->GetNode(1)->GetID()),
+ static_cast<int>(tria->GetNode(2)->GetID()),
tag );
}
// write all tetra
- theMGInput->GmfSetKwd( mfile, GmfTetrahedra, meshDS->GetMeshInfo().NbTetras() );
+ theMGInput->GmfSetKwd( mfile, GmfTetrahedra, (int) meshDS->GetMeshInfo().NbTetras() );
SMDS_ElemIteratorPtr tetIt = meshDS->elementGeomIterator( SMDSGeom_TETRA );
while ( tetIt->more() )
{
const SMDS_MeshElement* tet = tetIt->next();
theMGInput->GmfSetLin( mfile, GmfTetrahedra,
- tet->GetNode(0)->GetID(),
- tet->GetNode(2)->GetID(),
- tet->GetNode(1)->GetID(),
- tet->GetNode(3)->GetID(),
+ static_cast<int>(tet->GetNode(0)->GetID()),
+ static_cast<int>(tet->GetNode(2)->GetID()),
+ static_cast<int>(tet->GetNode(1)->GetID()),
+ static_cast<int>(tet->GetNode(3)->GetID()),
tag );
}
int nbNodes = theMGOutput->GmfStatKwd( inFile, GmfVertices );
int nbTet = theMGOutput->GmfStatKwd( inFile, GmfTetrahedra );
- int nbNodesOld = meshDS->NbNodes();
- int nbTetOld = meshDS->GetMeshInfo().NbTetras();
+ smIdType nbNodesOld = meshDS->NbNodes();
+ smIdType nbTetOld = meshDS->GetMeshInfo().NbTetras();
std::cout << "Optimization input: "
<< nbNodesOld << " nodes, \t" << nbTetOld << " tetra" << std::endl;
std::cout << "Optimization output: "
void getNodeByGhsId( SMESH_Mesh& mesh, std::vector <const SMDS_MeshNode*> & nodeByGhsId )
{
SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
- const int nbNodes = meshDS->NbNodes();
+ const smIdType nbNodes = meshDS->NbNodes();
nodeByGhsId.resize( nbNodes + 1 );
SMDS_NodeIteratorPtr nodeIt = meshDS->nodesIterator();
while ( nodeIt->more() )
void GHS3DPluginGUI_HypothesisCreator::onSelectEnforcedVertex()
{
- int nbSelEnfVertex = myEnfVertexWdg->NbObjects();
+ size_t nbSelEnfVertex = myEnfVertexWdg->NbObjects();
clearEnforcedVertexWidgets();
if (nbSelEnfVertex == 1)
{
myEnforcedMeshTableWidget->resizeColumnToContents(column);
// Vertex selection
- int selEnfMeshes = myEnfMeshWdg->NbObjects();
+ size_t selEnfMeshes = myEnfMeshWdg->NbObjects();
if (selEnfMeshes == 0)
return;
myEnforcedTableWidget->resizeColumnToContents(column);
// Vertex selection
- int selEnfVertex = myEnfVertexWdg->NbObjects();
+ size_t selEnfVertex = myEnfVertexWdg->NbObjects();
bool coordsEmpty = (myXCoord->text().isEmpty()) || (myYCoord->text().isEmpty()) || (myZCoord->text().isEmpty());
if ((selEnfVertex == 0) && coordsEmpty)
return;
return;
CORBA::Double x = 0, y = 0,z = 0;
- for (int j = 0 ; j < selEnfVertex ; j++)
+ for ( size_t j = 0 ; j < selEnfVertex ; j++)
{
myEnfVertex = myEnfVertexWdg->GetObject< GEOM::GEOM_Object >(j);
if (myEnfVertex == GEOM::GEOM_Object::_nil())
if( isCreation() )
SMESH::SetName( SMESH::FindSObject( h ), h_data.myName.toLatin1().constData() );
- h->SetOptimizationLevel ( h_data.myOptimizationLevel );
+ h->SetOptimizationLevel ((CORBA::Short) h_data.myOptimizationLevel );
h->SetMinSize ( h_data.myUseMinSize ? h_data.myMinSize : 0 );
h->SetMaxSize ( h_data.myUseMaxSize ? h_data.myMaxSize : 0 );
h->SetMinMaxSizeDefault ( this->myMinSizeDefault, this->myMaxSizeDefault );
h->SetGradation ( h_data.myGradation );
h->SetVolumeProximity ( h_data.myUseProximity );
- h->SetNbVolumeProximityLayers ( h_data.myNbProximityLayers );
+ h->SetNbVolumeProximityLayers ((CORBA::Short) h_data.myNbProximityLayers );
h->SetToMeshHoles ( h_data.myToMeshHoles );
h->SetToMakeGroupsOfDomains ( h_data.myToMakeGroupsOfDomains );
opt->SetSplitOverConstrained ( (GHS3DPlugin::Mode) h_data.mySplitOverConstrained );
opt->SetPThreadsMode ( (GHS3DPlugin::PThreadsMode) h_data.myPThreadsMode );
opt->SetSmoothOffSlivers ( h_data.mySmoothOffSlivers );
- opt->SetMaximalNumberOfThreads( h_data.myNumberOfThreads );
+ opt->SetMaximalNumberOfThreads((CORBA::Short) h_data.myNumberOfThreads );
}
// Enforced vertices
h_data.myToMeshHoles = myToMeshHolesCheck->isChecked();
h_data.myToMakeGroupsOfDomains = myToMakeGroupsOfDomains->isChecked();
}
- h_data.myMaximumMemory = myAdvWidget->maxMemoryCheck->isChecked() ? myAdvWidget->maxMemorySpin->value() : -1;
- h_data.myInitialMemory = myAdvWidget->initialMemoryCheck->isChecked() ? myAdvWidget->initialMemorySpin->value() : -1;
+ h_data.myMaximumMemory = float( myAdvWidget->maxMemoryCheck->isChecked() ? myAdvWidget->maxMemorySpin->value() : -1 );
+ h_data.myInitialMemory = float( myAdvWidget->initialMemoryCheck->isChecked() ? myAdvWidget->initialMemorySpin->value() : -1 );
h_data.myKeepFiles = myAdvWidget->keepWorkingFilesCheck->isChecked();
h_data.myWorkingDir = myAdvWidget->workingDirectoryLineEdit->text().trimmed();
- h_data.myVerboseLevel = myAdvWidget->verboseLevelSpin->value();
+ h_data.myVerboseLevel = short( myAdvWidget->verboseLevelSpin->value() );
h_data.myLogInStandardOutput = !myAdvWidget->logInFileCheck->isChecked();
h_data.myRemoveLogOnSuccess = myAdvWidget->removeLogOnSuccessCheck->isChecked();
