Replace assert(false) with throw SimulationStoppingError(To be implemented.)

OndselSolver/ASMTAssembly.cpp

@@ -659,7 +659,7 @@ void MbD::ASMTAssembly::readKinematicIJs(std::vector<std::string>& lines)
 
 void MbD::ASMTAssembly::readKinematicIJ(std::vector<std::string>&)
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTAssembly::readConstraintSets(std::vector<std::string>& lines)
@@ -752,7 +752,7 @@ void MbD::ASMTAssembly::readJoints(std::vector<std::string>& lines)
             joint = CREATE<ASMTPointInPlaneJoint>::With();
         }
         else {
-            assert(false);
+            throw SimulationStoppingError("To be implemented.");
         }
         jointsLines.erase(jointsLines.begin());
         joint->parseASMT(jointsLines);
@@ -787,7 +787,7 @@ void MbD::ASMTAssembly::readMotions(std::vector<std::string>& lines)
             motion = CREATE<ASMTAllowRotation>::With();
         }
         else {
-            assert(false);
+            throw SimulationStoppingError("To be implemented.");
         }
         motionsLines.erase(motionsLines.begin());
         motion->parseASMT(motionsLines);
@@ -816,7 +816,7 @@ void MbD::ASMTAssembly::readLimits(std::vector<std::string>& lines)
             limit = ASMTTranslationLimit::With();
         }
         else {
-            assert(false);
+            throw SimulationStoppingError("To be implemented.");
         }
         limitsLines.erase(limitsLines.begin());
         limit->parseASMT(limitsLines);
@@ -835,7 +835,7 @@ void MbD::ASMTAssembly::readGeneralConstraintSets(std::vector<std::string>& line
     auto it = std::find(lines.begin(), lines.end(), "\tForceTorques");
     std::vector<std::string> generalConstraintSetsLines(lines.begin(), it);
     while (!generalConstraintSetsLines.empty()) {
-        assert(false);
+        throw SimulationStoppingError("To be implemented.");
     }
     lines.erase(lines.begin(), it);
 }
@@ -856,7 +856,7 @@ void MbD::ASMTAssembly::readForcesTorques(std::vector<std::string>& lines)
             forceTorque->owner = this;
         }
         else {
-            assert(false);
+            throw SimulationStoppingError("To be implemented.");
         }
     }
     lines.erase(lines.begin(), it);
@@ -1092,7 +1092,7 @@ void MbD::ASMTAssembly::runDraggingLog(const std::string& fileName)
 
 void MbD::ASMTAssembly::outputFor(AnalysisType)
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTAssembly::preMbDrun(std::shared_ptr<System> mbdSys)
@@ -1112,7 +1112,7 @@ void MbD::ASMTAssembly::preMbDrunDragStep(std::shared_ptr<System> mbdSys, std::s
 
 void MbD::ASMTAssembly::postMbDrun()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTAssembly::calcCharacteristicDimensions()

OndselSolver/ASMTForceTorque.cpp

@@ -12,15 +12,15 @@ using namespace MbD;
 
 void MbD::ASMTForceTorque::updateFromMbD()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTForceTorque::compareResults(AnalysisType)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTForceTorque::outputResults(AnalysisType)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/ASMTItem.cpp

@@ -53,7 +53,7 @@ void MbD::ASMTItem::setName(const std::string& str)
 
 void MbD::ASMTItem::parseASMT(std::vector<std::string>&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 std::string MbD::ASMTItem::popOffTop(std::vector<std::string>& args)
@@ -141,7 +141,7 @@ bool MbD::ASMTItem::readBool(const std::string& line)
 		return false;
 	}
 	else {
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 		return false;
 	}
 }
@@ -188,37 +188,37 @@ void MbD::ASMTItem::deleteMbD()
 void MbD::ASMTItem::createMbD(std::shared_ptr<System>, std::shared_ptr<Units>)
 {
 	noop();
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTItem::updateForFrame([[maybe_unused]] size_t index)
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTItem::updateFromInitiallyAssembledState()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTItem::updateFromInputState()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTItem::updateFromMbD()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTItem::compareResults(AnalysisType)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTItem::outputResults(AnalysisType)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 std::shared_ptr<Units> MbD::ASMTItem::mbdUnits()
@@ -301,7 +301,7 @@ void MbD::ASMTItem::storeOnLevelName(std::ofstream& os, size_t level)
 
 void MbD::ASMTItem::storeOnTimeSeries(std::ofstream&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTItem::logString(const std::string& str)

OndselSolver/ASMTItemIJ.cpp

@@ -175,6 +175,6 @@ void MbD::ASMTItemIJ::createMbD(std::shared_ptr<System> mbdSys, std::shared_ptr<
 
 std::shared_ptr<ItemIJ> MbD::ASMTItemIJ::mbdClassNew()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return std::shared_ptr<ItemIJ>();
 }

OndselSolver/ASMTMotion.cpp

@@ -36,12 +36,12 @@ void ASMTMotion::initMarkers()
 
 void ASMTMotion::storeOnLevel(std::ofstream&, size_t)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void ASMTMotion::storeOnTimeSeries(std::ofstream&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTMotion::createMbD(std::shared_ptr<System> mbdSys, std::shared_ptr<Units> mbdUnits)

OndselSolver/ASMTPart.cpp

@@ -55,7 +55,7 @@ void MbD::ASMTPart::readFeatureOrder(std::vector<std::string>& lines)
 	//		extrusion->owner = this;
 	//	}
 	//	else {
-	//		assert(false);
+	//		throw SimulationStoppingError("To be implemented.");
 	//	}
 	//}
 	lines.erase(lines.begin(), it);

OndselSolver/ASMTRefCurve.cpp

@@ -13,10 +13,10 @@ using namespace MbD;
 
 void MbD::ASMTRefCurve::parseASMT(std::vector<std::string>&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTRefCurve::storeOnLevel(std::ofstream&, size_t)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/ASMTRefSurface.cpp

@@ -13,10 +13,10 @@ using namespace MbD;
 
 void MbD::ASMTRefSurface::parseASMT(std::vector<std::string>&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTRefSurface::storeOnLevel(std::ofstream&, size_t)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/ASMTSpatialContainer.cpp

@@ -119,7 +119,7 @@ void MbD::ASMTSpatialContainer::readRefCurves(std::vector<std::string>& lines)
 
 void MbD::ASMTSpatialContainer::readRefCurve(std::vector<std::string>&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTSpatialContainer::readRefSurfaces(std::vector<std::string>& lines)
@@ -139,7 +139,7 @@ void MbD::ASMTSpatialContainer::readRefSurfaces(std::vector<std::string>& lines)
 
 void MbD::ASMTSpatialContainer::readRefSurface(std::vector<std::string>&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ASMTSpatialContainer::readXs(std::vector<std::string>& lines)
@@ -345,13 +345,13 @@ std::shared_ptr<EulerParameters<double>> MbD::ASMTSpatialContainer::qEp()
 
 FColDsptr MbD::ASMTSpatialContainer::vOcmO()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 
 FColDsptr MbD::ASMTSpatialContainer::omeOpO()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 

OndselSolver/AccNewtonRaphson.cpp

@@ -136,7 +136,7 @@ void MbD::AccNewtonRaphson::handleSingularMatrix()
 			this->logSingularMatrixMessage();
 			matrixSolver->throwSingularMatrixError("AccAccNewtonRaphson");
 		} else {
-			assert(false);
+			throw SimulationStoppingError("To be implemented.");
 		}
 	}
 }

OndselSolver/AllowZRotationConstraintIqctJqc.cpp

@@ -50,7 +50,7 @@ void MbD::AllowZRotationConstraintIqctJqc::postInput()
 void MbD::AllowZRotationConstraintIqctJqc::postPosIC()
 {
 	//self becomeRedundantConstraint
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 std::string MbD::AllowZRotationConstraintIqctJqc::constraintSpec()

OndselSolver/AngleZConstraintIJ.cpp

@@ -33,7 +33,7 @@ void MbD::AngleZConstraintIJ::calcPostDynCorrectorIteration()
 
 void MbD::AngleZConstraintIJ::initthezIeJe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::AngleZConstraintIJ::initialize()

OndselSolver/BasicIntegrator.cpp

@@ -76,7 +76,7 @@ void BasicIntegrator::incrementTime()
 
 void BasicIntegrator::incrementTry()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void BasicIntegrator::initialize()

OndselSolver/ConstVelConstraintIJ.cpp

@@ -34,12 +34,12 @@ void ConstVelConstraintIJ::calcPostDynCorrectorIteration()
 
 void MbD::ConstVelConstraintIJ::initA01IeJe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ConstVelConstraintIJ::initA10IeJe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void ConstVelConstraintIJ::initialize()

OndselSolver/Constraint.cpp

@@ -112,7 +112,7 @@ void Constraint::fillPosICError(FColDsptr col)
 void Constraint::removeRedundantConstraints(std::shared_ptr<std::vector<size_t>>)
 {
 	//My owner should handle this.
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Constraint::setConstant(double value)
@@ -123,7 +123,7 @@ void MbD::Constraint::setConstant(double value)
 void Constraint::reactivateRedundantConstraints()
 {
 	//My owner should handle this.
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 bool Constraint::isRedundant()

OndselSolver/DiagonalMatrix.h

@@ -68,7 +68,7 @@ namespace MbD {
 	template<typename T>
 	inline DiagMatsptr<T> DiagonalMatrix<T>::times(T)
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	template<typename T>
 	inline FColsptr<T> DiagonalMatrix<T>::timesFullColumn(FColsptr<T> fullCol)
@@ -133,7 +133,7 @@ namespace MbD {
 	template<typename T>
 	inline double DiagonalMatrix<T>::maxMagnitude()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 		return 0.0;
 	}
 	template<typename T>

OndselSolver/DifferenceOperator.cpp

@@ -47,7 +47,7 @@ void DifferenceOperator::initialize()
 
 void MbD::DifferenceOperator::initializeLocally()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void DifferenceOperator::setiStep(size_t i)

OndselSolver/DistanceConstraintIJ.cpp

@@ -32,7 +32,7 @@ aG = distIeJe->value() - aConstant;
 
 void MbD::DistanceConstraintIJ::init_distIeJe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::DistanceConstraintIJ::initialize()

OndselSolver/DistanceConstraintIqctJqc.cpp

@@ -12,7 +12,7 @@ using namespace MbD;
 
 MbD::DistanceConstraintIqctJqc::DistanceConstraintIqctJqc(EndFrmsptr frmi, EndFrmsptr frmj) : DistanceConstraintIqcJqc(frmi, frmj)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 ConstraintType MbD::DistanceConstraintIqctJqc::type()

OndselSolver/DistancexyConstraintIJ.cpp

@@ -34,7 +34,7 @@ void MbD::DistancexyConstraintIJ::calcPostDynCorrectorIteration()
 
 void MbD::DistancexyConstraintIJ::init_xyIeJeIe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::DistancexyConstraintIJ::initialize()

OndselSolver/DistxyIecJec.cpp

@@ -45,7 +45,7 @@ void MbD::DistxyIecJec::initializeLocally()
 
 void MbD::DistxyIecJec::init_xyIeJeIe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::DistxyIecJec::postInput()

OndselSolver/EndFramec.cpp

@@ -52,12 +52,12 @@ void EndFramec::initializeLocally()
 
 void EndFramec::initEndFrameqct()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::EndFramec::initEndFrameqct2()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void EndFramec::calcPostDynCorrectorIteration()

OndselSolver/EulerAngles.h

@@ -40,7 +40,7 @@ namespace MbD {
 	template<typename T>
 	inline void EulerAngles<T>::initialize()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	template<>
 	inline void EulerAngles<Symsptr>::calc()
@@ -91,7 +91,7 @@ namespace MbD {
 	template<typename T>
 	inline void EulerAngles<T>::calc()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	template<typename T>
 	inline std::shared_ptr<EulerAnglesDot<T>> EulerAngles<T>::differentiateWRT(T var)

OndselSolver/EulerParameters.h

@@ -383,7 +383,7 @@ inline std::shared_ptr<EulerParameters<double>> EulerParameters<double>::times(d
 template<typename T>
 inline std::shared_ptr<EulerParameters<T>> EulerParameters<T>::times(T)
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 template<typename T>
 inline std::shared_ptr<EulerParameters<T>>

OndselSolver/ExternalSystem.cpp

@@ -27,7 +27,7 @@ void MbD::ExternalSystem::preMbDrun(std::shared_ptr<System> mbdSys)
         //freecadAssemblyObject->preMbDrun();
     }
     else {
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 }
 
@@ -48,7 +48,7 @@ void MbD::ExternalSystem::updateFromMbD()
         //freecadAssemblyObject->updateFromMbD();
     }
     else {
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 }
 
@@ -67,7 +67,7 @@ void MbD::ExternalSystem::outputFor(AnalysisType type)
         //freecadAssemblyObject->outputResults(type);
     }
     else {
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 }
 
@@ -78,17 +78,17 @@ void MbD::ExternalSystem::logString(const std::string& str)
 
 void MbD::ExternalSystem::logString(double)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ExternalSystem::runOndselPiston()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ExternalSystem::runPiston()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ExternalSystem::postMbDrun()

OndselSolver/FullColumn.h

@@ -89,7 +89,7 @@ namespace MbD {
 	template<typename T>
 	inline FColsptr<T> FullColumn<T>::times(T)
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	template<typename T>
 	inline FColsptr<T> FullColumn<T>::negated()
@@ -204,7 +204,7 @@ namespace MbD {
 	template<typename T>
 	inline FColsptr<T> FullColumn<T>::simplified()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 		return FColsptr<T>();
 	}
 	template<typename T>

OndselSolver/FullMatrix.h

@@ -15,6 +15,7 @@
 #include "RowTypeMatrix.h"
 #include "FullColumn.h"
 #include "FullRow.h"
+#include "SimulationStoppingError.h"
 
 namespace MbD {
 	template<typename T>
@@ -395,7 +396,7 @@ namespace MbD {
 	template<typename T>
 	inline FMatsptr<T> FullMatrix<T>::times(T)
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	template<typename T>
 	inline FMatsptr<T> FullMatrix<T>::transposeTimesFullMatrix(FMatsptr<T> fullMat)
@@ -499,13 +500,13 @@ namespace MbD {
 	template<typename T>
 	inline double FullMatrix<T>::sumOfSquares()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 		return 0.0;
 	}
 	template<typename T>
 	inline void FullMatrix<T>::zeroSelf()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	template<typename T>
 	inline FMatsptr<T> FullMatrix<T>::copy()

OndselSolver/FullRow.h

@@ -71,7 +71,7 @@ namespace MbD {
 	template<typename T>
 	inline FRowsptr<T> FullRow<T>::times(T)
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	template<typename T>
 	inline FRowsptr<T> FullRow<T>::negated()

OndselSolver/FullVector.h

@@ -11,6 +11,7 @@
 #include <ostream>
 
 #include "Array.h"
+#include "SimulationStoppingError.h"
 
 namespace MbD {
 	template<typename T>
@@ -80,7 +81,7 @@ namespace MbD {
 	template<typename T>
 	inline double FullVector<T>::sumOfSquares()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 		return 0.0;
 	}
 	template<typename T>
@@ -98,7 +99,7 @@ namespace MbD {
 	template<typename T>
 	inline void FullVector<T>::zeroSelf()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	template<typename T>
 	inline void FullVector<T>::atiplusFullVector(size_t i1, std::shared_ptr<FullVector<T>> fullVec)
@@ -141,7 +142,7 @@ namespace MbD {
 	template<typename T>
 	inline double FullVector<T>::maxMagnitude()
 	{
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 		return 0.0;
 	}
 	template<>
@@ -190,7 +191,7 @@ namespace MbD {
 	inline std::shared_ptr<FullVector<T>> FullVector<T>::clonesptr()
 	{
 		//Return shallow copy of *this wrapped in shared_ptr
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 		return std::make_shared<FullVector<T>>(*this);
 	}
 	template<typename T>

OndselSolver/FunctionWithManyArgs.cpp

@@ -49,7 +49,7 @@ void MbD::FunctionWithManyArgs::createMbD(std::shared_ptr<System> mbdSys, std::s
 
 void MbD::FunctionWithManyArgs::arguments(Symsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 bool MbD::FunctionWithManyArgs::isConstant()

OndselSolver/FunctionX.cpp

@@ -33,7 +33,7 @@ void MbD::FunctionX::arguments(Symsptr args)
 
 Symsptr MbD::FunctionX::copyWith(Symsptr arg)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return Symsptr();
 }
 
@@ -75,7 +75,7 @@ Symsptr MbD::FunctionX::differentiateWRT(Symsptr var)
 
 Symsptr MbD::FunctionX::differentiateWRTx()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return Symsptr();
 }
 
@@ -86,7 +86,7 @@ void MbD::FunctionX::createMbD(std::shared_ptr<System> mbdSys, std::shared_ptr<U
 
 double MbD::FunctionX::getValue()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return 0.0;
 }
 
@@ -100,7 +100,7 @@ double MbD::FunctionX::getValue(double arg)
 		xx->setValue(oldVal);
 	}
 	else {
-		assert(false);
+		throw SimulationStoppingError("To be implemented.");
 	}
 	return answer;
 }

OndselSolver/GEFullMat.cpp

@@ -14,7 +14,7 @@ using namespace MbD;
 
 void GEFullMat::forwardEliminateWithPivot(size_t)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void GEFullMat::backSubstituteIntoDU()
@@ -35,17 +35,17 @@ void GEFullMat::backSubstituteIntoDU()
 
 void GEFullMat::postSolve()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void GEFullMat::preSolvewithsaveOriginal(FMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void GEFullMat::preSolvewithsaveOriginal(SpMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 double GEFullMat::getmatrixArowimaxMagnitude(size_t i)
@@ -68,6 +68,6 @@ FColDsptr GEFullMat::basicSolvewithsaveOriginal(FMatDsptr fullMat, FColDsptr ful
 
 FColDsptr GEFullMat::basicSolvewithsaveOriginal(SpMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }

OndselSolver/GEFullMatFullPv.cpp

@@ -55,5 +55,5 @@ void GEFullMatFullPv::doPivoting(size_t p)
 
 void GEFullMatFullPv::postSolve()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/GEFullMatParPv.cpp

@@ -46,10 +46,10 @@ void GEFullMatParPv::doPivoting(size_t p)
 
 void GEFullMatParPv::postSolve()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void GEFullMatParPv::preSolvewithsaveOriginal(FMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/GESpMat.cpp

@@ -33,18 +33,18 @@ FColDsptr GESpMat::basicSolvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullCo
 
 FColDsptr GESpMat::basicSolvewithsaveOriginal(FMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 
 void GESpMat::preSolvewithsaveOriginal(FMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void GESpMat::preSolvewithsaveOriginal(SpMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 double GESpMat::getmatrixArowimaxMagnitude(size_t i)

OndselSolver/GESpMatFullPv.cpp

@@ -140,7 +140,7 @@ void GESpMatFullPv::backSubstituteIntoDU()
 
 void GESpMatFullPv::postSolve()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void GESpMatFullPv::preSolvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullCol, bool saveOriginal)

OndselSolver/GESpMatParPvMarkoFast.cpp

@@ -16,7 +16,7 @@ using namespace MbD;
 
 void GESpMatParPvMarkoFast::preSolvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullCol, bool saveOriginal)
 {
-	//assert(false);
+	//throw SimulationStoppingError("To be implemented.");
 	//"Optimized for speed."
 	if (m != spMat->nrow() || n != spMat->ncol()) {
 		m = spMat->nrow();

OndselSolver/GESpMatParPvPrecise.cpp

@@ -78,7 +78,7 @@ void GESpMatParPvPrecise::doPivoting(size_t p)
 
 void GESpMatParPvPrecise::preSolvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullCol, bool saveOriginal)
 {
-	//assert(false);
+	//throw SimulationStoppingError("To be implemented.");
 	//"A conditioned copy of aMatrix is solved."
 	if (m != spMat->nrow() || n != spMat->ncol()) {
 		m = spMat->nrow();

OndselSolver/GearConstraintIJ.cpp

@@ -50,7 +50,7 @@ void MbD::GearConstraintIJ::initializeLocally()
 
 void MbD::GearConstraintIJ::initorbitsIJ()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::GearConstraintIJ::postInput()

OndselSolver/ICKineIntegrator.cpp

@@ -20,12 +20,12 @@ void ICKineIntegrator::runInitialConditionTypeSolution()
 
 void ICKineIntegrator::iStep(size_t)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void ICKineIntegrator::selectOrder()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void ICKineIntegrator::preRun()
@@ -36,15 +36,15 @@ void ICKineIntegrator::preRun()
 
 void ICKineIntegrator::firstStep()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void ICKineIntegrator::subsequentSteps()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ICKineIntegrator::nextStep()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/Integral.cpp

@@ -8,7 +8,7 @@ MbD::Integral::Integral(Symsptr arg) : ExpressionX(arg)
 
 MbD::Integral::Integral(Symsptr, Symsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Integral::arguments(Symsptr args)

OndselSolver/IntegratorInterface.cpp

@@ -11,6 +11,7 @@
 #include "IntegratorInterface.h"
 #include "SystemSolver.h"
 #include "BasicQuasiIntegrator.h"
+#include "SimulationStoppingError.h"
 
 using namespace MbD;
 
@@ -60,7 +61,7 @@ void IntegratorInterface::incrementTime(double tnew)
 
 void IntegratorInterface::postFirstStep()
 {
-	assert(false);	//Not used.
+	throw SimulationStoppingError("To be implemented.");	//Not used.
 	//system->postFirstStep();
 	//if (integrator->istep > 0) {
 	//	//"Noise make checking at the start unreliable."
@@ -72,7 +73,7 @@ void IntegratorInterface::postFirstStep()
 void IntegratorInterface::interpolateAt(double)
 {
 	//"Interpolate for system state at tArg and leave system in that state."
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	//auto yout = integrator->yDerivat(0, tArg);
 	//auto ydotout = integrator->yDerivat(1, tArg);
 	//auto yddotout = integrator->yDerivat(2, tArg);

OndselSolver/Item.cpp

@@ -56,25 +56,25 @@ void Item::initializeLocally()
 
 bool MbD::Item::isJointForce()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return false;
 }
 
 bool MbD::Item::isJointTorque()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return false;
 }
 
 bool MbD::Item::isKinedotIJ()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return false;
 }
 
 bool MbD::Item::isKineIJ()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return false;
 }
 
@@ -94,7 +94,7 @@ void Item::calcPostDynCorrectorIteration()
 
 void MbD::Item::checkForCollisionDiscontinuityBetweenand(double, double)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::removeRedundantConstraints(std::shared_ptr<std::vector<size_t>>)
@@ -103,17 +103,17 @@ void Item::removeRedundantConstraints(std::shared_ptr<std::vector<size_t>>)
 
 void MbD::Item::setpqsumu(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::setpqsumuddot(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::setpqsumudot(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::reactivateRedundantConstraints()
@@ -122,7 +122,7 @@ void Item::reactivateRedundantConstraints()
 
 void MbD::Item::registerName()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::fillPosKineError(FColDsptr)
@@ -135,32 +135,32 @@ void Item::fillPosKineJacob(SpMatDsptr)
 
 void MbD::Item::fillpqsumu(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillpqsumudot(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::fillEssenConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillPerpenConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillpFpy(SpMatDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillpFpydot(SpMatDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::fillRedundantConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>>)
@@ -169,27 +169,27 @@ void Item::fillRedundantConstraints(std::shared_ptr<std::vector<std::shared_ptr<
 
 void MbD::Item::fillStaticError(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillStaticJacob(FMatDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::fillConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillDispConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillDynError(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::fillqsu(FColDsptr)
@@ -210,7 +210,7 @@ void Item::setqsulam(FColDsptr)
 
 void MbD::Item::simUpdateAll()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::preDyn()
@@ -225,12 +225,12 @@ void Item::preDyn()
 
 void MbD::Item::preDynCorrector()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::preDynCorrectorIteration()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::postDyn()
@@ -245,12 +245,12 @@ void Item::postDyn()
 
 void MbD::Item::postDynCorrector()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::postDynCorrectorIteration()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 std::string Item::classname()
@@ -268,12 +268,12 @@ void Item::preDynFirstStep()
 
 void MbD::Item::preDynOutput()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::preDynPredictor()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::postDynFirstStep()
@@ -283,12 +283,12 @@ void Item::postDynFirstStep()
 
 void MbD::Item::postDynOutput()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::postDynPredictor()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::preDynStep()
@@ -297,7 +297,7 @@ void Item::preDynStep()
 
 void MbD::Item::preICRestart()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::postDynStep()
@@ -313,13 +313,13 @@ void Item::storeDynState()
 
 double MbD::Item::suggestSmallerOrAcceptCollisionFirstStepSize(double)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return 0.0;
 }
 
 double MbD::Item::suggestSmallerOrAcceptCollisionStepSize(double)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return 0.0;
 }
 
@@ -357,12 +357,12 @@ void Item::fillqsudot(FColDsptr)
 
 void MbD::Item::fillqsudotPlam(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillqsudotPlamDeriv(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::fillqsudotWeights(DiagMatDsptr)
@@ -383,12 +383,12 @@ void Item::setqsudotlam(FColDsptr)
 
 void MbD::Item::setqsudotPlam(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::setqsudotPlamDeriv(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::preAccIC()
@@ -398,32 +398,32 @@ void Item::preAccIC()
 
 void MbD::Item::preCollision()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::preCollisionCorrector()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::preCollisionCorrectorIteration()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::preCollisionDerivativeIC()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::preCollisionPredictor()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::preCollisionStep()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::postAccIC()
@@ -436,27 +436,27 @@ void Item::postAccICIteration()
 
 void MbD::Item::postCollisionCorrector()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::postCollisionCorrectorIteration()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::postCollisionDerivativeIC()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::postCollisionPredictor()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::postCollisionStep()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::fillqsuddotlam(FColDsptr)
@@ -473,27 +473,27 @@ void Item::fillAccICIterJacob(SpMatDsptr)
 
 void MbD::Item::fillCollisionDerivativeICError(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillCollisionDerivativeICJacob(SpMatDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillCollisionError(FColDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillCollisionpFpy(SpMatDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::fillCollisionpFpydot(SpMatDsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::setqsudot(FColDsptr)
@@ -506,13 +506,13 @@ void Item::setqsuddotlam(FColDsptr)
 
 std::shared_ptr<StateData> Item::stateData()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return std::shared_ptr<StateData>();
 }
 
 void MbD::Item::storeCollisionState()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::discontinuityAtaddTypeTo(double, std::shared_ptr<std::vector<DiscontinuityType>>)
@@ -521,7 +521,7 @@ void Item::discontinuityAtaddTypeTo(double, std::shared_ptr<std::vector<Disconti
 
 void MbD::Item::discontinuityAtICAddTo(std::shared_ptr<std::vector<DiscontinuityType>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 double Item::checkForDynDiscontinuityBetweenand(double, double t)
@@ -551,17 +551,17 @@ void Item::logString(const std::string& str)
 
 void MbD::Item::logStringwithArgument(const std::string&, const std::string&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::logStringwithArguments(const std::string&, std::shared_ptr<std::vector<std::string>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::normalImpulse(double)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::prePosIC()
@@ -580,7 +580,7 @@ void Item::prePosKine()
 
 void MbD::Item::preStatic()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::postPosIC()
@@ -594,12 +594,12 @@ void Item::postPosICIteration()
 
 void MbD::Item::postStatic()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Item::postStaticIteration()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Item::fillPosICError(FColDsptr)

OndselSolver/KineIntegrator.cpp

@@ -22,17 +22,17 @@ void KineIntegrator::preRun()
 
 void KineIntegrator::firstStep()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void KineIntegrator::subsequentSteps()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void KineIntegrator::nextStep()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void KineIntegrator::runInitialConditionTypeSolution()
@@ -44,10 +44,10 @@ void KineIntegrator::runInitialConditionTypeSolution()
 
 void KineIntegrator::iStep(size_t)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void KineIntegrator::selectOrder()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/KinematicIeJe.cpp

@@ -26,330 +26,330 @@ bool MbD::KinematicIeJe::isKineIJ()
 
 void MbD::KinematicIeJe::calc_pvaluepXI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_pvaluepEI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXIpXI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXIpEI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEIpEI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_pvaluepXJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_pvaluepEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXIpXJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXIpEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEIpXJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEIpEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXJpXJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXJpEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEJpEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_pvaluepXK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_pvaluepEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXIpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEIpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXJpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEJpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEKpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_pvaluept()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvalueptpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_value()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXIpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEIpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXJpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEJpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepXKpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::KinematicIeJe::calc_ppvaluepEKpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
 }
 
 FRowDsptr MbD::KinematicIeJe::pvaluepXI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::pvaluepEI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepXIpXI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepXIpEI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepEIpEI()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::pvaluepXJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::pvaluepEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepXIpXJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepXIpEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepEIpXJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepEIpEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepXJpXJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepXJpEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepEJpEJ()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::pvaluepXK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::pvaluepEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepXIpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepEIpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepXJpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepEJpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 FMatDsptr MbD::KinematicIeJe::ppvaluepEKpEK()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FMatDsptr();
 }
 
 double MbD::KinematicIeJe::pvaluept()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return 0.0;
 }
 
 double MbD::KinematicIeJe::ppvalueptpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return 0.0;
 }
 
 FRowDsptr MbD::KinematicIeJe::ppvaluepXIpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::ppvaluepEIpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::ppvaluepXJpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::ppvaluepEJpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::ppvaluepXKpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 FRowDsptr MbD::KinematicIeJe::ppvaluepEKpt()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return FRowDsptr();
 }
 
 double MbD::KinematicIeJe::value()
 {
-    assert(false);
+    throw SimulationStoppingError("To be implemented.");
     return 0.0;
 }

OndselSolver/LDUFullMat.cpp

@@ -19,18 +19,18 @@ FColDsptr LDUFullMat::basicSolvewithsaveOriginal(FMatDsptr fullMat, FColDsptr fu
 
 FColDsptr LDUFullMat::basicSolvewithsaveOriginal(SpMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 
 void LDUFullMat::preSolvewithsaveOriginal(FMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void LDUFullMat::preSolvewithsaveOriginal(SpMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void LDUFullMat::forwardEliminateWithPivot(size_t p)
@@ -57,7 +57,7 @@ void LDUFullMat::forwardEliminateWithPivot(size_t p)
 
 void LDUFullMat::postSolve()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void LDUFullMat::preSolvesaveOriginal(FMatDsptr fullMat, bool saveOriginal)
@@ -107,7 +107,7 @@ void LDUFullMat::decomposesaveOriginal(FMatDsptr fullMat, bool saveOriginal)
 
 void LDUFullMat::decomposesaveOriginal(SpMatDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 FMatDsptr LDUFullMat::inversesaveOriginal(FMatDsptr fullMat, bool saveOriginal)

OndselSolver/LDUSpMat.cpp

@@ -20,17 +20,17 @@ FColDsptr LDUSpMat::basicSolvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullC
 
 void LDUSpMat::decomposesaveOriginal(FMatDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void LDUSpMat::decomposesaveOriginal(SpMatDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 FColDsptr LDUSpMat::forAndBackSubsaveOriginal(FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 

OndselSolver/LimitIJ.cpp

@@ -12,7 +12,7 @@ bool MbD::LimitIJ::satisfied() const
 	else if (type == "=>") {
 		return constraint->aG > -tol;
 	}
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return true;
 }
 

OndselSolver/LinearMultiStepMethod.cpp

@@ -32,13 +32,13 @@ FColDsptr MbD::LinearMultiStepMethod::derivativeatpresentpast(size_t n, double t
 
 FColDsptr MbD::LinearMultiStepMethod::derivativepresentpast(size_t, FColDsptr, std::shared_ptr<std::vector<FColDsptr>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 
 double MbD::LinearMultiStepMethod::pvdotpv()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return 0.0;
 }
 
@@ -51,6 +51,6 @@ FColDsptr MbD::LinearMultiStepMethod::derivativepresentpastpresentDerivativepast
 	FColDsptr, std::shared_ptr<std::vector<FColDsptr>>,
 	FColDsptr, std::shared_ptr<std::vector<FColDsptr>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }

OndselSolver/MatrixDecomposition.cpp

@@ -12,7 +12,7 @@ using namespace MbD;
 
 FColDsptr MbD::MatrixDecomposition::forAndBackSubsaveOriginal(FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 
@@ -28,31 +28,31 @@ void MatrixDecomposition::applyRowOrderOnRightHandSideB()
 
 FColDsptr MbD::MatrixDecomposition::basicSolvewithsaveOriginal(FMatDsptr, FColDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 
 void MbD::MatrixDecomposition::forwardSubstituteIntoL()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::MatrixDecomposition::backSubstituteIntoU()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::MatrixDecomposition::forwardSubstituteIntoLD()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::MatrixDecomposition::postSolve()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::MatrixDecomposition::preSolvesaveOriginal(FMatDsptr, bool)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/NewtonRaphson.cpp

@@ -39,7 +39,7 @@ void NewtonRaphson::initializeLocally()
 
 void NewtonRaphson::run()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	//self preRun.
 	//self initializeLocally.
 	//self initializeGlobally.
@@ -98,7 +98,7 @@ bool NewtonRaphson::isConverged()
 
 void NewtonRaphson::askSystemToUpdate()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 bool NewtonRaphson::isConvergedToNumericalLimit()

OndselSolver/PosICDragLimitNewtonRaphson.cpp

@@ -32,7 +32,7 @@ void MbD::PosICDragLimitNewtonRaphson::initializeGlobally()
 void MbD::PosICDragLimitNewtonRaphson::setdragParts(std::shared_ptr<std::vector<std::shared_ptr<Part>>> dragParts)
 {
     (void) dragParts;
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::PosICDragLimitNewtonRaphson::run()

OndselSolver/PosICNewtonRaphson.cpp

@@ -121,7 +121,7 @@ void PosICNewtonRaphson::handleSingularMatrix()
 				this->lookForRedundantConstraints();
 				matrixSolver = this->matrixSolverClassNew();
 			} else {
-				assert(false);
+				throw SimulationStoppingError("To be implemented.");
 			}
 		}
 	}

OndselSolver/RackPinConstraintIJ.cpp

@@ -35,17 +35,17 @@ void MbD::RackPinConstraintIJ::calcPostDynCorrectorIteration()
 
 void MbD::RackPinConstraintIJ::init_xthez()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::RackPinConstraintIJ::initxIeJeIe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::RackPinConstraintIJ::initthezIeJe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::RackPinConstraintIJ::initialize()

OndselSolver/RedundantConstraint.cpp

@@ -106,7 +106,7 @@ void RedundantConstraint::setqsuddotlam(FColDsptr)
 void RedundantConstraint::discontinuityAtaddTypeTo(double, std::shared_ptr<std::vector<DiscontinuityType>>)
 {
 	//"Reactivate all constraints."
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	//| newSelf |
 	//newSelf : = self constraint.
 	//newSelf discontinuityAt : tstartNew addTypeTo : collection.

OndselSolver/ScalarNewtonRaphson.cpp

@@ -13,7 +13,7 @@ using namespace MbD;
 
 void ScalarNewtonRaphson::initializeGlobally()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	//x = system->x;
 }
 

OndselSolver/ScrewConstraintIJ.cpp

@@ -37,17 +37,17 @@ void MbD::ScrewConstraintIJ::calcPostDynCorrectorIteration()
 
 void MbD::ScrewConstraintIJ::init_zthez()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ScrewConstraintIJ::initzIeJeIe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ScrewConstraintIJ::initthezIeJe()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::ScrewConstraintIJ::initialize()

OndselSolver/Solver.cpp

@@ -10,6 +10,7 @@
 
 #include "Solver.h"
 #include <string>
+#include "SimulationStoppingError.h"
 
 using namespace MbD;
 
@@ -28,22 +29,22 @@ void Solver::initializeLocally()
 
 void Solver::initializeGlobally()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Solver::assignEquationNumbers()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Solver::run()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Solver::preRun()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Solver::finalize()
@@ -56,15 +57,15 @@ void Solver::reportStats()
 
 void Solver::postRun()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void Solver::logString(const std::string&)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Solver::handleSingularMatrix()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/StableBackwardDifference.cpp

@@ -43,7 +43,7 @@ FColDsptr MbD::StableBackwardDifference::derivativepresentpastpresentDerivativep
         size_t, FColDsptr, std::shared_ptr<std::vector<FColDsptr>>, FColDsptr,
         std::shared_ptr<std::vector<FColDsptr>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return FColDsptr();
 }
 

OndselSolver/Symbolic.cpp

@@ -82,13 +82,13 @@ void Symbolic::initialize()
 
 Symsptr MbD::Symbolic::differentiateWRT(Symsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return Symsptr();
 }
 
 Symsptr MbD::Symbolic::integrateWRT(Symsptr)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return Symsptr();
 }
 
@@ -123,13 +123,13 @@ Symsptr MbD::Symbolic::expandUntil(std::shared_ptr<std::unordered_set<Symsptr>>
 
 Symsptr Symbolic::expandUntil(Symsptr sptr, std::shared_ptr<std::unordered_set<Symsptr>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return sptr;
 }
 
 Symsptr Symbolic::simplifyUntil(Symsptr sptr, std::shared_ptr<std::unordered_set<Symsptr>>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return sptr;
 }
 
@@ -168,7 +168,7 @@ std::ostream& Symbolic::printOn(std::ostream& s) const
 
 std::shared_ptr<std::vector<Symsptr>> Symbolic::getTerms()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return std::make_shared<std::vector<Symsptr>>();
 }
 
@@ -179,31 +179,31 @@ void MbD::Symbolic::addTerm(Symsptr trm)
 
 double Symbolic::getValue()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return 0.0;
 }
 
 double MbD::Symbolic::getValue(double)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return 0.0;
 }
 
 void MbD::Symbolic::setValue(double)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void MbD::Symbolic::createMbD(std::shared_ptr<System>, std::shared_ptr<Units>)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return;
 }
 
 Symsptr MbD::Symbolic::clonesptr()
 {
 	//Return shallow copy of *this wrapped in shared_ptr
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	return std::make_shared<Symbolic>(*this);
 }
 
@@ -219,7 +219,7 @@ bool MbD::Symbolic::isVariable()
 
 void MbD::Symbolic::setIntegrationConstant(double)
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 Symsptr MbD::Symbolic::raisedTo(Symsptr x, Symsptr y)

OndselSolver/SymbolicParser.cpp

@@ -492,7 +492,7 @@ void MbD::SymbolicParser::notifyat(const std::string&, int) const
 	source->seekg(0);
 	auto contents = source->str();
 	source->seekg(p);
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	//SyntaxErrorException new
 	//targetClass : class;
 	//messageText: aString;

OndselSolver/SystemNewtonRaphson.cpp

@@ -29,7 +29,7 @@ void SystemNewtonRaphson::initializeGlobally()
 
 void MbD::SystemNewtonRaphson::assignEquationNumbers()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void SystemNewtonRaphson::createVectorsAndMatrices()
@@ -79,7 +79,7 @@ void SystemNewtonRaphson::handleSingularMatrix()
             matrixSolver->throwSingularMatrixError("SystemNewtonRaphson");
 		}
 		else {
-			assert(false);
+			throw SimulationStoppingError("To be implemented.");
 		}
 	}
 }

OndselSolver/SystemSolver.cpp

@@ -38,7 +38,7 @@ using namespace MbD;
 void SystemSolver::setSystem(Solver*)
 {
 	//Do not use
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void SystemSolver::initialize()
@@ -297,7 +297,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Constraint>>> SystemSolver::allConst
 
 void SystemSolver::postNewtonRaphson()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void SystemSolver::partsJointsMotionsForcesTorquesDo(const std::function<void(std::shared_ptr<Item>)>& f)
@@ -317,7 +317,7 @@ void MbD::SystemSolver::partsJointsMotionsLimitsForcesTorquesDo(const std::funct
 
 void SystemSolver::discontinuityBlock()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 double SystemSolver::startTime()

OndselSolver/VectorNewtonRaphson.cpp

@@ -20,7 +20,7 @@ using namespace MbD;
 
 void VectorNewtonRaphson::initializeGlobally()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 	//system->fillVarVector(x);
 }
 
@@ -40,7 +40,7 @@ std::shared_ptr<MatrixSolver> VectorNewtonRaphson::matrixSolverClassNew()
 
 void VectorNewtonRaphson::fillY()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }
 
 void VectorNewtonRaphson::calcyNorm()
@@ -80,5 +80,5 @@ void VectorNewtonRaphson::xEqualxoldPlusdx()
 
 void VectorNewtonRaphson::handleSingularMatrix()
 {
-	assert(false);
+	throw SimulationStoppingError("To be implemented.");
 }

OndselSolver/VelSolver.cpp

@@ -37,7 +37,7 @@ void VelSolver::handleSingularMatrix()
             matrixSolver->throwSingularMatrixError("VelSolver");
         }
 		else {
-			assert(false);
+			throw SimulationStoppingError("To be implemented.");
 		}
 	}
 }