Merge pull request #39 from kmokstad/outofcore-settings

Change default out-of-core settings

Author: kmokstad

vpmDB/FmAnalysis.C

@@ -157,11 +157,11 @@ FmAnalysis::FmAnalysis()
   FFA_FIELD_DEFAULT_INIT(solverAddOpts, "SOLVER_ADD_OPTIONS");
   FFA_FIELD_DEFAULT_INIT(stressAddOpts, "STRESS_ADD_OPTIONS");
 
-  FFA_FIELD_INIT(useRamSizeGSF, true,"USE_RAMSIZE_GSF_SOLVER");
+  FFA_FIELD_INIT(useRamSizeGSF,false,"USE_RAMSIZE_GSF_SOLVER");
   FFA_FIELD_INIT(autoRamSizeGSF,true,"AUTO_RAMSIZE_GSF_SOLVER");
   FFA_FIELD_INIT(ramSizeGSF,       0,"RAMSIZE_GSF_SOLVER");
 
-  FFA_FIELD_INIT(useRamSizeBmat, true,"USE_RAMSIZE_RECOVERY_MATRIX");
+  FFA_FIELD_INIT(useRamSizeBmat,false,"USE_RAMSIZE_RECOVERY_MATRIX");
   FFA_FIELD_INIT(autoRamSizeBmat,true,"AUTO_RAMSIZE_RECOVERY_MATRIX");
   FFA_FIELD_INIT(ramSizeBmat,       0,"RAMSIZE_RECOVERY_MATRIX");
 
@@ -252,11 +252,11 @@ bool FmAnalysis::readAndConnect(std::istream& is, std::ostream&)
     else if (shadowPosAlg.getValue() == 0)
     {
       obj->defaultShadowPosAlg.setValue(3);
-      FFaMsg::dialog("This model used the depreciated \"Max triangle, with unit offset\" option in the\n"
-		     "\"Default positioning algorithm for the co-rotated reference coordinate system\"\n"
-		     "menu. This is now changed to \"Max triangle, with scaled offset\" instead.\n\n"
-		     "This change may affect the simulation, if the model contains Parts that\n"
-		     "rely on the default positioning algorithm.",FFaMsg::WARNING);
+      FFaMsg::dialog("This model used the deprecated \"Max triangle, with unit offset\" option in the\n"
+                     "\"Default positioning algorithm for the co-rotated reference coordinate system\"\n"
+                     "menu. This is now changed to \"Max triangle, with scaled offset\" instead.\n\n"
+                     "This change may affect the simulation, if the model contains Parts that\n"
+                     "rely on the default positioning algorithm.", FFaMsg::WARNING);
     }
     else
       obj->defaultShadowPosAlg.setValue(shadowPosAlg.getValue());
@@ -275,12 +275,21 @@ bool FmAnalysis::readAndConnect(std::istream& is, std::ostream&)
   if (old && obj->numEigenmodes.getValue() == 0)
     obj->numEigenmodes.setValue(old->numEigenmodes.getValue());
 
+  if (FmDB::getModelFileVer() < FFaVersionNumber(8,1,2,8))
+  {
+    // The default used to be true for these settings, but they should be false
+    if (obj->useRamSizeGSF.setValue(false))
+      ListUI <<"  -> Resetting the FE model Reducer out-of-core option to OFF.\n";
+    if (obj->useRamSizeBmat.setValue(false))
+      ListUI <<"  -> Resetting the Recovery matrix out-of-core option to OFF.\n";
+  }
+
   return obj->cloneOrConnect();
 }
 
 
 bool FmAnalysis::localParse(const char* keyWord, std::istream& activeStatement,
-			    FmAnalysis* obj)
+                            FmAnalysis* obj)
 {
   enum { MAX_EIGENMODES = 1,
          ABSOLUTE_INTEGRATION_TOLERANCE,
@@ -317,6 +326,7 @@ bool FmAnalysis::localParse(const char* keyWord, std::istream& activeStatement,
 				    "CURR_SCALE",
 				    NULL};
 
+  bool defsonly;
   int tmpInt;
   double tmp;
   switch (FaParse::findIndex(key_words, keyWord))
@@ -353,7 +363,6 @@ bool FmAnalysis::localParse(const char* keyWord, std::istream& activeStatement,
       break;
 
     case STRESS_DEFORMATIONS_ONLY:
-      bool defsonly;
       activeStatement >> defsonly;
       obj->stressDeformation.setValue(true);
       obj->stressStressTensor.setValue(!defsonly);
@@ -419,21 +428,18 @@ void FmAnalysis::initAfterResolve()
 
   if (seaEngine == 0) return;
 
-  FmMathFuncBase* sfunc = NULL;
-  FmBase* found = FmDB::findID(FmEngine::getClassTypeID(),seaEngine);
-  if (found) sfunc = static_cast<FmEngine*>(found)->getFunction();
-  if (sfunc)
-  {
-    sfunc->setUserDescription(found->getUserDescription());
-    sfunc->setFunctionUse(FmMathFuncBase::WAVE_FUNCTION);
-    FmDB::getSeaStateObject()->waveFunction.setRef(sfunc);
-    FmModelMemberBase* user = NULL;
-    if (!found->hasReferringObjs(user))
+  if (FmBase* found = FmDB::findID(FmEngine::getClassTypeID(),seaEngine); found)
+    if (FmMathFuncBase* swf = static_cast<FmEngine*>(found)->getFunction(); swf)
     {
-      static_cast<FmEngine*>(found)->setFunction(NULL);
-      found->erase();
+      swf->setUserDescription(found->getUserDescription());
+      swf->setFunctionUse(FmMathFuncBase::WAVE_FUNCTION);
+      FmDB::getSeaStateObject()->waveFunction.setRef(swf);
+      if (FmModelMemberBase* user; !found->hasReferringObjs(user))
+      {
+        static_cast<FmEngine*>(found)->setFunction(NULL);
+        found->erase();
+      }
     }
-  }
 
   seaEngine = 0;
 }

vpmDB/FmFuncAdmin.C

@@ -67,17 +67,20 @@ namespace
       numClassTypes = FFaTypeCheck::getNewTypeID(NULL);
 
       std::string funcName(64,' ');
-      const char* fName = funcName.c_str()+4;
+      char* fName = const_cast<char*>(funcName.c_str()+4);
+      int funcIdx = USER_HEADING + 1;
       itsFuncInfoTable[USER_HEADING] = "-- User-defined Functions --";
-      for (int i = 1; i <= nUserFuncs; i++)
-        if (FFaUserFuncPlugin::instance()->getFuncName(funcId[i-1],60,const_cast<char*>(fName)) > 0)
-          itsFuncInfoTable[USER_HEADING+i] = FmFuncTypeInfo(funcName.c_str(),numClassTypes+funcId[i-1]);
+      for (int i = 0; i < nUserFuncs; i++, funcIdx++)
+        if (FFaUserFuncPlugin::instance()->getFuncName(funcId[i],60,fName) > 0)
+          itsFuncInfoTable[funcIdx] = FmFuncTypeInfo(funcName.c_str(),
+                                                     numClassTypes + funcId[i]);
     }
 
     for (std::pair<const int,FmFuncTypeInfo>& info : itsFuncInfoTable)
       info.second.funcMenuEnum = info.first;
 
-    itsFuncInfoTable[WAVE_SINUS].funcMenuEnum = INTERNAL; // Should not appear in Function type menu
+    // Should not appear in the Function type menu
+    itsFuncInfoTable[WAVE_SINUS].funcMenuEnum = INTERNAL;
   }
 }
 
@@ -140,36 +143,32 @@ bool FmFuncAdmin::hasSmartPoints(int type)
 }
 
 
-void FmFuncAdmin::getCompatibleFunctionTypes(std::vector<FmFuncTypeInfo>& toFill,
-                                             FmMathFuncBase* compatibleFunc)
+void FmFuncAdmin::getCompatibleFunctionTypes(std::vector<FmFuncTypeInfo>& types,
+                                             FmMathFuncBase* func)
 {
-  toFill.clear();
-  if (!compatibleFunc)
-    return;
-
   if (itsFuncInfoTable.empty())
     initFuncInfoTable();
 
   using FmFuncInfo = std::pair<const int,FmFuncTypeInfo>;
 
-  switch (compatibleFunc->getFunctionUse())
+  switch (func ? func->getFunctionUse() : FmMathFuncBase::GENERAL)
     {
     case FmMathFuncBase::GENERAL:
       // General function, allow all function types,
       // except for internal ones and wave spectrums
-      if (compatibleFunc->getTypeID() == FmfWaveSinus::getClassTypeID())
+      if (func && func->getTypeID() == FmfWaveSinus::getClassTypeID())
         // Internal function with predefined type, don't allow type switching
-        toFill.push_back(itsFuncInfoTable[FmFuncAdmin::WAVE_SINUS]);
+        types.push_back(itsFuncInfoTable[FmFuncAdmin::WAVE_SINUS]);
       else
         for (const FmFuncInfo& info : itsFuncInfoTable)
           if (info.second.funcMenuEnum > FmFuncAdmin::UNDEFINED &&
               info.second.funcMenuEnum != FmFuncAdmin::WAVE_SPECTRUM &&
               info.second.funcMenuEnum != FmFuncAdmin::FILE_SPECTRUM)
-            toFill.push_back(info.second);
+            types.push_back(info.second);
       return;
 
     case FmMathFuncBase::DRIVE_FILE:
-      toFill.push_back(itsFuncInfoTable[FmFuncAdmin::DEVICE]);
+      types.push_back(itsFuncInfoTable[FmFuncAdmin::DEVICE]);
       return;
 
     case FmMathFuncBase::NONE:
@@ -180,20 +179,20 @@ void FmFuncAdmin::getCompatibleFunctionTypes(std::vector<FmFuncTypeInfo>& toFill
             info.second.funcMenuEnum != FmFuncAdmin::WAVE_SPECTRUM &&
             info.second.funcMenuEnum != FmFuncAdmin::FILE_SPECTRUM &&
             info.second.funcMenuEnum != FmFuncAdmin::REFERENCE)
-          toFill.push_back(info.second);
+          types.push_back(info.second);
       return;
 
     case FmMathFuncBase::WAVE_FUNCTION:
-      toFill.push_back(itsFuncInfoTable[FmFuncAdmin::SINUSOIDAL]);
-      toFill.push_back(itsFuncInfoTable[FmFuncAdmin::WAVE_SPECTRUM]);
-      toFill.push_back(itsFuncInfoTable[FmFuncAdmin::FILE_SPECTRUM]);
+      types.push_back(itsFuncInfoTable[FmFuncAdmin::SINUSOIDAL]);
+      types.push_back(itsFuncInfoTable[FmFuncAdmin::WAVE_SPECTRUM]);
+      types.push_back(itsFuncInfoTable[FmFuncAdmin::FILE_SPECTRUM]);
       // Check if we have user-defined wave functions
       for (const FmFuncInfo& info : itsFuncInfoTable)
         if (info.first > FmFuncAdmin::USER_HEADING &&
             info.second.funcType > numClassTypes)
           if (int fId = info.second.funcType - numClassTypes;
               FFaUserFuncPlugin::instance()->getFlag(fId) & 4)
-            toFill.push_back(info.second);
+            types.push_back(info.second);
       return;
 
     default: // Stiffness or Damper function
@@ -204,7 +203,7 @@ void FmFuncAdmin::getCompatibleFunctionTypes(std::vector<FmFuncTypeInfo>& toFill
     for (const FmFuncInfo& info : itsFuncInfoTable)
       if (std::find(ftyp.begin(),ftyp.end(),info.second.funcType) != ftyp.end())
         if (info.first != FmFuncAdmin::FILE_SPECTRUM)
-          toFill.push_back(info.second);
+          types.push_back(info.second);
 }
 
 

vpmDB/FmFuncAdmin.H

@@ -32,8 +32,8 @@ namespace FmFuncAdmin
 
   bool hasSmartPoints(int type);
 
-  void getCompatibleFunctionTypes(std::vector<FmFuncTypeInfo>& toFill,
-                                  FmMathFuncBase* compatibleFunc);
+  void getCompatibleFunctionTypes(std::vector<FmFuncTypeInfo>& types,
+                                  FmMathFuncBase* func);
 
   FmMathFuncBase* createFunction(int type);
 

vpmDB/FmPart.C

@@ -1089,6 +1089,8 @@ void FmPart::updateMassProperties()
     // We have a generic part without a FE data file.
     // Calculate mass properties from the associated CAD data file, if any.
     std::string cadFile = this->getGeometryFile();
+    if (FFaLowerCaseString(FFaFilePath::getExtension(cadFile)) == "obj")
+      myCalculateMass.setValue(EXPLICIT); // not implemented for obj-files
     if (!cadFile.empty() && myCalculateMass.getValue() == FROM_GEOMETRY)
     {
       ListUI <<"  -> Calculating mass properties for "<< this->getIdString(true)

vpmDB/FmSolverInput.C

@@ -261,12 +261,18 @@ std::string Fedem::createReducerInput(FmAnalysis* analysis,
   else if (!analysis->autoRamSizeBmat.getValue())
     fcoArgs.add("-Bramsize",analysis->ramSizeBmat.getValue());
   const std::string& addOptions = analysis->reducerAddOpts.getValue();
-  if (addOptions.find("-gsfSolver") != std::string::npos) {
-    if (!analysis->useRamSizeGSF.getValue())
+  if (analysis->useRamSizeGSF.getValue())
+  {
+    // Use the out-of-core GSF equation solver
+    if (addOptions.find("-gsfSolver") != std::string::npos)
+      fcoArgs.add("-gsfSolver",2);
+    if (analysis->autoRamSizeGSF.getValue())
       fcoArgs.add("-cachesize",0);
-    else if (!analysis->autoRamSizeGSF.getValue())
+    else if (analysis->ramSizeGSF.getValue() > 0)
       fcoArgs.add("-cachesize",analysis->ramSizeGSF.getValue());
+    // else switch off out-of-core for GSF
   }
+  // else use the SPR solver (default)
 
   int ngen = part->nGenModes.getValue();
   fcoArgs.add("-neval",        part->nEigvalsCalc.getValue());
@@ -614,12 +620,12 @@ std::string Fedem::createSolverInput(FmAnalysis* analysis,
   {
     fcoArgs.addComment("Eigenvalue solution parameters");
     if (analysis->dynamicsEnable.getValue())
-      fcoArgs.add("-eiginc",          analysis->eigenSolveTimeInterval.getValue());
-    fcoArgs.add("-numEigModes",       analysis->numEigenmodes.getValue());
-    fcoArgs.add("-damped",            analysis->dampedEigenvalues.getValue());
-    fcoArgs.add("-eigenshift",        analysis->eigenvalueShiftFactor.getValue());
+      fcoArgs.add("-eiginc",       analysis->eigenSolveTimeInterval.getValue());
+    fcoArgs.add("-numEigModes",    analysis->numEigenmodes.getValue());
+    fcoArgs.add("-damped",         analysis->dampedEigenvalues.getValue());
+    fcoArgs.add("-eigenshift",     analysis->eigenvalueShiftFactor.getValue());
     fcoArgs.add("-addBC_eigensolver", analysis->useBCsOnEigenvalues.getValue());
-    fcoArgs.add("-stressStiffEig",    analysis->useEigStressStiffening.getValue());
+    fcoArgs.add("-stressStiffEig", analysis->useEigStressStiffening.getValue());
   }
 
   if (analysis->solveFrequencyDomain.getValue())
@@ -677,7 +683,7 @@ std::string Fedem::createSolverInput(FmAnalysis* analysis,
   const std::string& addOptions = analysis->solverAddOpts.getValue();
 
   // Check if frs-output of recovery results has been enabled
-  // though the additional solver options
+  // through the additional solver options
   size_t iStr = addOptions.rfind("-partDeformation");
   bool saveStr = iStr == std::string::npos; // use "==" here since default value is 1
   if (!saveStr && iStr+17 < addOptions.size())