diff --git a/Base/ForceModel/imstkForceModelConfig.cpp b/Base/ForceModel/imstkForceModelConfig.cpp
index 2593c02520d38ff8a321dff8bb3c9ec7b511d137..14f71142bde2fa860ef8024726a36a609ac7598b 100644
--- a/Base/ForceModel/imstkForceModelConfig.cpp
+++ b/Base/ForceModel/imstkForceModelConfig.cpp
@@ -24,103 +24,77 @@ limitations under the License.
 namespace imstk
 {
 
-ForceModelConfig::ForceModelConfig(const std::string &configurationFile, const bool verbose) : m_loadSuccessful(false)
+ForceModelConfig::ForceModelConfig(const std::string &configFileName) : m_loadSuccessful(false)
 {
-    if (configurationFile.empty())
+    if (configFileName.empty())
     {
         LOG(INFO) << "WARNING: Empty configuration filename." << std::endl;
         return;
     }
+    else
+    {
+        parseConfig(configFileName);
+    }
+};
 
-    this->m_vegaConfigFile = configurationFile;
+void setOptions(vega::ConfigFile& vegaConfigFileOptions)
+{
+
+
+}
 
+bool ForceModelConfig::parseConfig(const std::string &configFileName)
+{
     vega::ConfigFile vegaConfigFileOptions;
+    ForceModelConfig::customOptionsList optList;
+    ForceModelConfig::customOptionsNameList optNameList;
+
+    vegaConfigFileOptions.addOptionOptional(optNameList.femMethodName, optList.femMethod, "StVK");
+    vegaConfigFileOptions.addOptionOptional(optNameList.invertibleMaterialName, optList.invertibleMaterial, "StVK");
+    vegaConfigFileOptions.addOptionOptional(optNameList.fixedDOFFilenameName, optList.fixedDOFFilename, "");
+    vegaConfigFileOptions.addOptionOptional(optNameList.dampingMassCoefficientName, &optList.dampingMassCoefficient, optList.dampingMassCoefficient);
+    vegaConfigFileOptions.addOptionOptional(optNameList.dampingStiffnessCoefficientName, &optList.dampingStiffnessCoefficient, optList.dampingStiffnessCoefficient);
+    vegaConfigFileOptions.addOptionOptional(optNameList.dampingLaplacianCoefficientName, &optList.dampingLaplacianCoefficient, optList.dampingLaplacianCoefficient);
+    vegaConfigFileOptions.addOptionOptional(optNameList.deformationComplianceName, &optList.deformationCompliance, optList.deformationCompliance);
+    vegaConfigFileOptions.addOptionOptional(optNameList.gravityName, &optList.gravity, optList.gravity);
+    vegaConfigFileOptions.addOptionOptional(optNameList.compressionResistanceName, &optList.compressionResistance, optList.compressionResistance);
+    vegaConfigFileOptions.addOptionOptional(optNameList.inversionThresholdName, &optList.inversionThreshold, optList.inversionThreshold);
+    vegaConfigFileOptions.addOptionOptional(optNameList.numberOfThreadsName, &optList.numberOfThreads, optList.numberOfThreads);
 
-    char femMethod[256];
-    vegaConfigFileOptions.addOptionOptional("femMethod",
-        femMethod,
-        "StVK");
-
-    char invertibleMaterial[256];
-    vegaConfigFileOptions.addOptionOptional("invertibleMaterial",
-        invertibleMaterial,
-        "StVK");
-
-    char fixedDOFFilename[256];
-    vegaConfigFileOptions.addOptionOptional("fixedDOFFilename",
-        fixedDOFFilename,
-        "");
-
-    double dampingMassCoefficient = 0.1;
-    vegaConfigFileOptions.addOptionOptional("dampingMassCoefficient",
-        &dampingMassCoefficient,
-        dampingMassCoefficient);
-
-    double dampingStiffnessCoefficient = 0.01;
-    vegaConfigFileOptions.addOptionOptional("dampingStiffnessCoefficient",
-        &dampingStiffnessCoefficient,
-        dampingStiffnessCoefficient);
-
-    double dampingLaplacianCoefficient = 0.0;
-    vegaConfigFileOptions.addOptionOptional("dampingLaplacianCoefficient",
-        &dampingLaplacianCoefficient,
-        dampingLaplacianCoefficient);
-
-    double deformationCompliance = 1.0;
-    vegaConfigFileOptions.addOptionOptional("deformationCompliance",
-        &deformationCompliance,
-        deformationCompliance);
-
-    double gravity = -9.81;
-    vegaConfigFileOptions.addOptionOptional("gravity",
-        &gravity,
-        gravity);
-
-    double compressionResistance = 500.0;
-    vegaConfigFileOptions.addOptionOptional("compressionResistance",
-        &compressionResistance,
-        compressionResistance);
-
-    double inversionThreshold = -std::numeric_limits< double >::max();
-    vegaConfigFileOptions.addOptionOptional("inversionThreshold",
-        &inversionThreshold,
-        inversionThreshold);
-
-    int numberOfThreads = 0;
-    vegaConfigFileOptions.addOptionOptional("numberOfThreads",
-        &numberOfThreads,
-        numberOfThreads);
 
     // Parse the configuration file
-    if (!configurationFile.empty() &&
-        vegaConfigFileOptions.parseOptions(configurationFile.data()) != 0)
+    if (vegaConfigFileOptions.parseOptions(configFileName.data()) != 0)
     {
+        this->m_vegaConfigFileName = configFileName;
         m_loadSuccessful = true;
+
         // Print option variables
-        if (verbose)
-        {
-            vegaConfigFileOptions.printOptions();
-        }
+        vegaConfigFileOptions.printOptions();
+    }
+    else
+    {
+        return false;
     }
 
     // Store parsed string values
-    this->m_stringsOptionMap.emplace("femMethod", femMethod);
-    this->m_stringsOptionMap.emplace("invertibleMaterial", invertibleMaterial);
-    this->m_stringsOptionMap.emplace("fixedDOFFilename", fixedDOFFilename);
+    this->m_stringsOptionMap.emplace(optNameList.femMethodName, optList.femMethod);
+    this->m_stringsOptionMap.emplace(optNameList.invertibleMaterialName, optList.invertibleMaterial);
+    this->m_stringsOptionMap.emplace(optNameList.fixedDOFFilenameName, optList.fixedDOFFilename);
 
     // Store parsed floating point values
-    this->m_floatsOptionMap.emplace("dampingMassCoefficient", dampingMassCoefficient);
-    this->m_floatsOptionMap.emplace("dampingLaplacianCoefficient", dampingLaplacianCoefficient);
-    this->m_floatsOptionMap.emplace("dampingStiffnessCoefficient", dampingStiffnessCoefficient);
-    this->m_floatsOptionMap.emplace("deformationCompliance", deformationCompliance);
-    this->m_floatsOptionMap.emplace("gravity", gravity);
-    this->m_floatsOptionMap.emplace("compressionResistance", compressionResistance);
-    this->m_floatsOptionMap.emplace("inversionThreshold", inversionThreshold);
+    this->m_floatsOptionMap.emplace(optNameList.dampingMassCoefficientName, optList.dampingMassCoefficient);
+    this->m_floatsOptionMap.emplace(optNameList.dampingLaplacianCoefficientName, optList.dampingLaplacianCoefficient);
+    this->m_floatsOptionMap.emplace(optNameList.dampingStiffnessCoefficientName, optList.dampingStiffnessCoefficient);
+    this->m_floatsOptionMap.emplace(optNameList.deformationComplianceName, optList.deformationCompliance);
+    this->m_floatsOptionMap.emplace(optNameList.gravityName, optList.gravity);
+    this->m_floatsOptionMap.emplace(optNameList.compressionResistanceName, optList.compressionResistance);
+    this->m_floatsOptionMap.emplace(optNameList.inversionThresholdName, optList.inversionThreshold);
 
     // Store parsed int values
-    this->m_intsOptionMap.emplace("numberOfThreads", numberOfThreads);
-};
+    this->m_intsOptionMap.emplace(optNameList.numberOfThreadsName, optList.numberOfThreads);
 
+    return true;
+}
 
 ForceModelType ForceModelConfig::getForceModelType()
 {
diff --git a/Base/ForceModel/imstkForceModelConfig.h b/Base/ForceModel/imstkForceModelConfig.h
index 8430de737a3155b30ef6d3167b431e4189934dff..b78f9c5a34f0bd4738ef8b839d4a6f84d70fd52b 100644
--- a/Base/ForceModel/imstkForceModelConfig.h
+++ b/Base/ForceModel/imstkForceModelConfig.h
@@ -94,36 +94,85 @@ namespace imstk
 ///
 class ForceModelConfig
 {
+    // TODO: Do this in a better way
+    struct customOptionsList
+    {
+        char femMethod[256];
+        char invertibleMaterial[256];
+        char fixedDOFFilename[256];
+        double dampingMassCoefficient = 0.1;
+        double dampingStiffnessCoefficient = 0.01;
+        double dampingLaplacianCoefficient = 0.0;
+        double deformationCompliance = 1.0;
+        double gravity = -9.81;
+        double compressionResistance = 500.0;
+        double inversionThreshold = -std::numeric_limits< double >::max();
+        int numberOfThreads = 0;
+    };
+    struct customOptionsNameList
+    {
+        const char femMethodName[256] = "femMethod";
+        const char invertibleMaterialName[256] = "invertibleMaterial";
+        const char fixedDOFFilenameName[256] = "fixedDOFFilename";
+        const char dampingMassCoefficientName[256] = "dampingMassCoefficient";
+        const char dampingLaplacianCoefficientName[256] = "dampingLaplacianCoefficient";
+        const char dampingStiffnessCoefficientName[256] = "dampingStiffnessCoefficient";
+        const char deformationComplianceName[256] = "deformationCompliance";
+        const char compressionResistanceName[256] = "compressionResistance";
+        const char inversionThresholdName[256] = "inversionThreshold";
+        const char numberOfThreadsName[256] = "numberOfThreads";
+        const char gravityName[256] = "gravity";
+    };
 public:
 
     ///
     /// \brief Constructor
     ///
-    ForceModelConfig(const std::string &configurationFile, const bool verbose = false);
+    ForceModelConfig(const std::string &configurationFileName);
 
     ~ForceModelConfig(){};
 
+    ///
+    /// \brief
+    ///
+    bool parseConfig(const std::string &configFileName);
+
+    ///
+    /// \brief
+    ///
     const std::map<std::string, double>& getFloatsOptionsMap()
     {
         return m_floatsOptionMap;
     }
 
+    ///
+    /// \brief
+    ///
     const std::map<std::string, int>& getIntegerOptionsMap()
     {
         return m_intsOptionMap;
     }
 
+    ///
+    /// \brief
+    ///
     const std::map<std::string, std::string>& getStringOptionsMap()
     {
         return m_stringsOptionMap;
     }
 
+    ///
+    /// \brief
+    ///
     ForceModelType getForceModelType();
 
+    ///
+    /// \brief
+    ///
     HyperElasticMaterialType gethyperElasticMaterialType();
 
 protected:
-    std::string m_vegaConfigFile;                          ///> Store configuration file.
+    std::string m_vegaConfigFileName;                      ///> Store configuration file.
     std::map<std::string, double> m_floatsOptionMap;       ///> Map for floating point
     std::map<std::string, int> m_intsOptionMap;            ///> Map for int configuration variables
     std::map<std::string, std::string> m_stringsOptionMap; ///> Map for string