Todo List

Member AdaptiveSmoothingLength::finalize (IScheduler &scheduler, Storage &storage, const Float t) override

generalize for grad v

Class AffineMatrix

somewhat duplicate of Tensor, but many function differ slightly due to translation, different asserts, etc. Probably not worth having common parent.

Member AffineMatrix2::transpose () const

test

Member AffineMatrix::operator*= (const Float value)

test

Class Aggregate

Not owning the particles, bound to a Storage object. Not compatible with mergers.

Member AggregateHolder::separate (Aggregate &ag, const Size idx)

?? how to do this

Member AggregateOverlapHandler::handle (const Size i, const Size j, FlatSet< Size > &toRemove) override

precompute

Class AlignedStorage< Type >

It's weird that GCC issues this warning as we are using may_alias attribute. Perhaps a bug?

Class AllTrue< Values >

Can be replaced by C++17 fold expressions

Member AnimationJob::evaluate (const RunSettings &global, IRunCallbacks &UNUSED(callbacks)) override

maybe also work with a copy of Gui ?

how to report this? (don't do modal dialog)

Member AnimationJob::getColorizer (const RunSettings &global) const

Class AntiAliasedRenderContext

do not derive from PreviewRenderContext, rather some RenderContextBase; AA context is NOT a preview render context!

Member antisymmetricOuter (const Vector &v1, const Vector &v2)

optimize

Member areFilesApproxEqual (const Path &path1, const Path &path2)

also materials

Member ArgParser::printHelp (ILogger &logger)

make padding adaptive

Member ArrayStats< Type >::ArrayStats (ArrayView< const Type > values)

flags for each stat

Member BarnesHut::build (IScheduler &pool, const Storage &storage) override

sequential needed because TBB cannot wait on child tasks yet

Member BarnesHut::evalNode (IScheduler &scheduler, ArrayView< Vector > dv, const Size nodeIdx, TreeWalkState data, TreeWalkResult &result) const

try different containers; we need fast inserting & deletion

ASSERT FIRED !

Member BarnesHut::gravityConstant

generalize

Member BarnesHutNode::r_open

can be stored as 4th component of com.

Class BatchJob

refactor, derive from INode instead

Class BatchValueVisitor

could be deduplicated (e.g. ConfigValue)

Class BinaryOutput

Possible todos & fixes:

• arbitrary precision: store doubles as floats or halfs and size_t as uint32 or uint16, based on data in header
• deserialized materials are created using Factory::getMaterial from loaded settings. This won't be correct if the material was created differently, i.e. if the material doesn't match the information in the settings it holds. This should be enforced somehow.

Class BlockDomain

create extra ghosts in the corners?

Member BooleanDomain::addGhosts (ArrayView< const Vector > vs, Array< Ghost > &ghosts, const Float eta, const Float eps) const override

this is not correct, do properly

Member BooleanDomain::project (ArrayView< Vector > vs, Optional< ArrayView< Size >> indices) const override

this is not correct, do properly

Member clampWithDerivative (const TracelessTensor &v, const TracelessTensor &dv, const Interval &range)

optimize

Member clampWithDerivative (const T &, const T &, const Interval &)

clamp derivatives for all types? So far we don't clamp non-scalar quantities anyway ...

Member CliffCollapse::setUp (SharedPtr< Storage > storage) override

change to logfile

Member CohesionDerivative::additionalInitialize (const Storage &input, Accumulated &UNUSED(results))

needs to be generalized for heterogeneous fluids

Member CohesionDerivative::eval (const Size i, const Size j, const Vector &UNUSED(grad))

heating?

Member Collision::setUp (SharedPtr< Storage > storage) override

change to logfile

Member CollisionMC::operator() (const Float QoverQ_D, const Float M_tot, const Float m_min)

fix

Member CompressedOutput::dump (const Storage &storage, const Statistics &stats) override

runType as string

Class ConcurrentQueue< Type >

can be implemented as lock-free queue, see boost::lockfree::queue

Member ContourRenderer::render (const RenderParams &params, Statistics &stats, IRenderOutput &output) const override

deduplicate

Member Controller::getIntersectedParticle (const Pixel position, const float toleranceEps)

This is really weird, we are duplicating code of ParticleRenderer in a function that really makes only sense with ParticleRenderer. Needs refactoring.

this radius computation is actually renderer-specific ...

wait, -INFTY != -inf ?? // (first.t == -INFTY) {

Member Controller::getStorage () const

synchronize

Member Controller::quit (const bool waitForFinish=false)

is this necessary? why not just use status?

Member Controller::refresh (AutoPtr< ICamera > &&camera)

generalize

Member Controller::setSelectedParticle (const Optional< Size > &particleIdx)

if the colorizer is not initialized, we should selected the particle after the next timestep

Member convertSphToSpheres (const Storage &sph, const RunSettings &settings, const HandoffParams &params)

when to remove? to avoid shifting indices

Member copyable (const Array< T, TAllocator, TCounter > &array)

test

Member cos (const Vector &v)

return _mm_cos_ps(v.sse());

Member cross (const BasicVector< double > &v1, const BasicVector< double > &v2)

optimize

Member DamageActivationColorizer::initialize (const Storage &storage, const RefEnum ref) override

parallelize

taken from ScalarGradyKippDamage, could be deduplicated

Member DensityIndependentPressureForce::initialize (IScheduler &UNUSED(scheduler), Storage &storage, const Float UNUSED(t)) override

generalize the min value

Class DensityIndependentPressureGradient

change to simpe IDerivative ? (no need for symmetrization)

Member DensityIndependentSolver::integrate (Storage &storage, Statistics &stats) override

do correctly

Class DerivativeCriterion

currently only used on first-order quantities.

Namespace Detail

Types Scalar -> scalar Vector -> size, x, y, z Tensor -> trace, 2nd inv, xx, yy, zz, xy, xz, yz, largest eigen, smallest eigen

Member Detail::expandPack (TArgs &&...)

can be replaced with fold expressions

Member Detail::TupleValue< TIndex, TValue >::get () const

Does this make any sense? What's the point of const r-value reference?

Member DisplacementGradient::additionalInitialize (const Storage &input, Accumulated &results)

generalize for heterogeneous body

Member DisplacementGradient::eval (const Size i, const Size j, const Vector &grad)

determine actual discretization of this equation

Member dot (const BasicVector< double > &v1, const BasicVector< double > &v2)

optimize

Member drawPalette (IRenderContext &context, const Pixel origin, const Pixel size, const Rgba &lineColor, const Palette &palette)

exposed for PaletteDialog, should be possibly generalized, used by other renderers, etc.

Member DruckerPragerRheology::create (Storage &storage, IMaterial &material, const MaterialInitialContext &context) const override

user defined max value

Member ElasticBands::setUp (SharedPtr< Storage > storage) override

change to logfile

Class ElasticBounceHandler

if restitution.t < 1, we should spin up the particles to conserve the angular momentum!!

Member ElasticDeformationSolver::integrate (Storage &storage, Statistics &stats) override

needs to be generalized if particles with different materials interact

Member EllipsoidalDomain::getDistanceToBoundary (ArrayView< const Vector > vs, Array< Float > &distances) const override

test

Member EllipsoidalDomain::project (ArrayView< Vector > vs, Optional< ArrayView< Size >> indices=NOTHING) const override

test

Class EnergyLogWriter

generailize, add generic triggers to UI

Member EosMaterial::initialize (IScheduler &scheduler, Storage &storage, const IndexSequence sequence) override

now we can easily pass sequence into the EoS and iterate inside, to avoid calling virtual function (and we could also optimize with SSE)

Member evalBenzAsphaugScalingLaw (const Float D, const Float rho)

replace D with units, do not enforce SI

Member ExternalForce< TFunctor >::finalize (IScheduler &UNUSED(scheduler), Storage &storage, const Float t) override

parallelize

Member Factory::getDistribution (const BodySettings &settings, Function< bool(Float)> progressCallback=nullptr)

user-selected seed?

Member Factory::getDomain (const RunSettings &settings)

split IDomain into IComputationalDomain and IShape (or IBodyShape)

Member Factory::getGravityKernel (const RunSettings &settings)

use analytical functions instead of getAssociatedGravityKernel

Member FILE

print using callback to gui application

Class FileSystem::FileLock

UNFINISHED

Member FileSystem::pathType (const Path &path)

possibly get the actual error, like in other functions

Member findPairByComparator (ArrayView< T > container, TFunctor &&functor, const U defaultValue, TComparator &&comparator)

ignore same iterator (inner = outer?) flag?

Member FixedParticles::FixedParticles (const RunSettings &settings, Params &&params)

generalize, we assume that kernel radius = 2 and don't take eta into account

Member FlatMap< TKey, TValue, TLess >::Element::key

we definitely don't want to expose mutable key when iterating. Possibly create two structs – PrivateElement and Element – and just reinterpret_cast ? (kinda crazy)

Member FragmentationHandler::collide (const Size i, const Size j, FlatSet< Size > &UNUSED(toRemove)) override

Member GalaxyIc::evaluate (const RunSettings &global, IRunCallbacks &UNUSED(callbacks)) override

generalize units

Member GalaxyRun::setUp (SharedPtr< Storage > storage) override

change to logfile

Member GaussianRandomSphere::getBoundingBox () const override

Member GENERALIZED_PRESSURE

Member getFileSequence (const Path &firstFile)

deduplicate with timeline

Member getIdentifier (const std::string &name)

deduplicate

Member getMaxEmissionWavelength (const float temperature)

maybe move to Constants.h

Member getPlotList (const GuiSettings &gui)

could be deduplicated a bit

Member getStandardEquations (const RunSettings &settings, const EquationHolder &other={})

this term (and also AV) do not depend on particular equation set, so it could be moved outside to reduce code duplication, but this also provides a way to get all necessary terms by calling a single function ...

add test checking that with ConstSmoothingLength the h will indeed be const

test that all possible combination (pressure, stress, AV, ...) work and dont assert

Member getSurfaceMesh (IScheduler &scheduler, const Storage &storage, const McConfig &config)

point cloud denoising?

Member GravitySolver< TSphSolver >::sanityCheck (const Storage &storage) const override

generalize for ALL solvers of gravity (some categories?)

Class HandoffParams

partially duplicates the PkdgravOutput

Member HandoffParams::largestRemnant

Separates the largest remnant. Other SPH particles are converted into N-body particles using 1-1 correspondence, regenerated inside remnant with optionally lower particles density.

Member HandoffParams::LargestRemnant::distribution

should this be optional? We need particles in close packing (no voids, no overlaps).

Member HardSphereSolver::collide (Storage &storage, Statistics &stats, const Float dt) override

We have to process the all collision in order, sorted according to collision time, but this is hardly parallelized. We can however process collisions concurrently, as long as the collided particles don't intersect the spheres with radius equal to the search radius. Note that this works as long as the search radius does not increase during collision handling.

Class HeatDiffusionEquation

this

Class HexagonalDomain

could be easily generalized to any polygon, currently not needed though

Member HexagonalDomain::addGhosts (ArrayView< const Vector > vs, Array< Ghost > &ghosts, const Float eta, const Float eps) const override

almost identical to cylinder domain, remove duplication

Member IAsymmetricSolver::beforeLoop (Storage &storage, Statistics &stats)=0

this structure is probably not needed, we only use it by EnergyConservingSolver anyway

Class IAsymmetricTerm

Member ICamera::clone () const =0

revert to ClonePtr!

Member ICollisionHandler::collide (const Size i, const Size j, FlatSet< Size > &toRemove)=0

Needs to be generatelized for fragmentation handlers. Currently the function CANNOT change the number of particles as it would invalidate arrayviews and we would lost the track of i-th and j-th particle (which we need for decreasing movement time).

Member IDomain::getDistanceToBoundary (ArrayView< const Vector > vs, Array< Float > &distances) const =0

unify the (non)clearing of output arrays

Member IExtraEntry::clone () const =0

use ClonePtr instead

Class IIntegral< Type >

automatically exclude ghost particles?

Member ILogger::writeString (const std::string &s)=0

different types (log, warning, error, ...) and levels of verbosity

Member ImpactCone::getFragments (const Float m_tot, const Size N, Array< Vector > &r, Array< Vector > &v, Array< Float > &m)

sample velocity from power law

Member Indices::Indices (const BasicVector< double > &v)

optimize

Member Indices::operator BasicVector< double > () const

optimize

Member InertialForce::finalize (IScheduler &UNUSED(scheduler), Storage &storage, const Float UNUSED(t)) override

parallelize

Member InitialConditions::addMonolithicBody (Storage &storage, const IDomain &domain, SharedPtr< IMaterial > material, const IDistribution &distribution)

refactor

Member InitialConditions::addRubblePileBody (Storage &storage, const IDomain &domain, const PowerLawSfd &sfd, const BodySettings &bodySettings)

potentially move to other object / create an abstract interface for addBody ?

Member InteractiveRenderer::camera

changed need to be protected by a mutex

Member IRaytracer::getEnviroColor (const CameraRay &ray) const

deduplicate with setupUvws

Class IRenderOutput::Label

would be nice to make it more general, cleaner

Member isMeshClosed (const Mesh &mesh)

or invalid (edge shared by >2 faces)

Member isReal (const BasicVector< double > &v)

optimize using SSE intrinsics

Member isReal (const BasicVector< float > &v)

optimize using SSE intrinsics

Class IsShareFromThis< T, TEnabler >

this is a weird solution, it must be doable with more standard approach

Class ITextColumn

There should also be a conversion from code units to user-selected output units

Member KdTree< TNode, TMetric >::find (const Vector &pos, const Size index, const Float radius, Array< NeighbourRecord > &neighs) const

order part

Member Kernel< TDerived, D >::value (const Vector &r, const Float h) const noexcept

Potentially precompute the 3rd power ...

Member LeapFrog::stepImpl (IScheduler &scheduler, ISolver &solver, Statistics &stats) override

this is not LeapFrog !

Member less (const Vector &v1, const Vector &v2)

optimize

Member List< T, TAllocator >::begin () const

is this ok? better solution?

Class LoadProc

deduplicate

Member LoadProc::onEntry (const std::string &name, IVirtualEntry &entry) const override

better logging

currently used only by curves, can be generalized if needed

currently used only by curves, can be generalized if needed

Class Locking< T, TMutex >

Member Lut< TValue, TScalar >::operator() (const TScalar x) const

possibly make linear interpolation rather than just const value

Member LutKernel< D >::LutKernel (TKernel &&source)

re-normalize?

Member MainWindow::MainWindow (const Path &openPath=Path())

generalize

Member makeSubsetIterator (const TIterator &iterator, const TIterator &end, TCondition &&condition)

test

Class MaterialInitialContext

possibly generalize, allowing to create generic context as needed by components of the run

Member maxElement (const TracelessTensor &t)

optimize

Member MergeBoundHandler::overlaps (const Size i, const Size j) const override

shouldn't we check velocities AFTER the bounce?

Member MergingCollisionHandler::collide (const Size i, const Size j, FlatSet< Size > &toRemove) override

remove, we have unit tests for this

Member MeshRenderer::initialize (const Storage &storage, const IColorizer &colorizer, const ICamera &camera) override

fix, the weight here should be consistent with MC

Member MieGruneisenEos::evaluate (const Float rho, const Float u) const override

derive the sound speed

Member minElement (const Vector &v)

possibly optimize with SSE? Only 3 components though ...

Member minElement (const TracelessTensor &t)

optimize

Class MissingQuantityException

move directly to Storage?

Member MonolithicBodyIc::evaluate (const RunSettings &global, IRunCallbacks &UNUSED(callbacks)) override

less retarded way – particle count has no place in material settings

Class NavierStokesForce

Member NavierStokesForce::finalize (IScheduler &scheduler, Storage &storage, const Float t) override

rotation rate tensor?

Member NBODY_MAX_ROTATION_ANGLE

Member NodeManager::cloneHierarchy (JobNode &node)

deduplicate

Member NodeWindow::NodeWindow (wxWindow *parent, SharedPtr< INodeManagerCallbacks > callbacks)

generalize, using some kind of validator

alternatively the entry could return the list of properties to update ...

Member norm (const TracelessTensor &t)

Use some well-defined norm instead? (spectral norm, L1 or L2 norm, ...)

optimize

Member norm (const AntisymmetricTensor &t)

Use some well-defined norm instead? (spectral norm, L1 or L2 norm, ...)

Member norm (const SymmetricTensor &t)

Use some well-defined norm instead? (spectral norm, L1 or L2 norm, ...)

Member norm (const Tensor &t)

Use some well-defined norm instead? (spectral norm, L1 or L2 norm, ...)

Member OperatorTemplate< TDerived >::operator* (const Float value) const

gcc is happy even if the operators arent defined (as long as they are not called), is this correct according to standard?

Member OutputFile::getMaskFromPath (const Path &path, const Size firstDumpIdx=0)

could be deduplicated a bit

Member OutputFile::getNextPath (const Statistics &stats) const

replace decimal dot as docs say

Member Palette::loadFromStream (std::istream &ifs)

improve

Member PaletteDialog::PaletteDialog (wxWindow *parent, wxSize size, const Palette palette, Function< void(Palette)> setPalette)

deduplicate

Member ParticlePairingDiagnostic::check (const Storage &storage, const Statistics &stats) const override

some message? compare it to the limit?

Member ParticlePairingDiagnostic::getPairs (const Storage &storage) const

symmetrized h

Member ParticleRenderer::initialize (const Storage &storage, const IColorizer &colorizer, const ICamera &camera) override

could be changed to AOS to sort only once

Member Path::isAbsolute () const

generalize, currently only checks for path starting with '/'

Member Path::native () const

change for windows

Class PerElementWrapper< TContainer >

move to some more reasonable location

Member PerspectiveCamera::unproject (const Coords &coords) const override

implement far clipping plane (max ray param)

Member PkdgravInput::load (const Path &path, Storage &storage, Statistics &stats) override

too high, fix

here we actually store radius in rho ...

Member pkdgravToMoons (const Path &filePath, const Float limit)

use correct radius here, we assume that very close ecounters will eventually collide

Class PlotPoint

deduplicate with Gui Point class

Member PlyFile::load (const Path &path) override

can be read directly from ifs, no need to go through stringstream

Member Quantity::clamp (const TIndexSequence &sequence, const Interval range)

clamp derivatives as well

Class Register

param, warning for too fast/too slow units

add comparing benchmarks, running two functions and comparing, instead of comparing against baseline

Member root< 4 > (const Float f)

is this faster than pow(f, 0.25)?

Member SECOND

can be improved after units are introduced into the code

Member subset (TContainer &&container, TCondition &&condition)

test

Member SubsetType

rename

Member symmetricOuter (const Vector &v1, const Vector &v2)

optimize

Member TextInput::load (const Path &path, Storage &storage, Statistics &stats) override

de-duplicate the loading (used in Settings)

Member TOTAL_ENERGY

Currently does not contain potential energy!

Class TotalEnergy

this has to be generalized if some external potential is used.

Member transform (const SymmetricTensor &t, const AffineMatrix &transform)

optimize

Class Unit

better name

Class XSph

This implementation is currently not consistent ContinuitySolver; different velocities should also affect the continuity equations (density derivative). For self-consistent solutions, use XSPH corrected velocities in continuity equation or use direct summation of density.

Member Post::ROTATIONAL_PERIOD

it should be in code units and then converted to hours on output!

Member PredictorCorrector::makePredictions (IScheduler &scheduler)

this is currently incompatible with NBodySolver, because we advance positions by 0.5 adt^2 ...

Member Presets::makeFragmentationAndReaccumulation (UniqueNameManager &nameMgr, const Size particleCnt=10000)

needed to include geometry in the list, how??

Member Process::Process (const Path &path, Array< std::string > &&args)

hopefully c_str doesn't return pointer to some temporary stuff ...

Member Project::getGuiSettings ()

synchronize

Member QuantityMetadata::expectedType

Units & dimensional analysis !

Class RandomPathManager

TESTS!

Member RotatingRod::setUp (SharedPtr< Storage > storage) override

change to logfile

Member RungeKutta::stepImpl (IScheduler &scheduler, ISolver &solver, Statistics &stats) override

at this point, I no longer need k1, we just need 2 auxiliary buffers

derivatives of storage (original, not k1, ..., k4) are never used

Member RunPage::onTimeStep (const Storage &storage, const Statistics &stats)

we should only touch colorizer from main thread!

Member RunPage::setProgress (const Statistics &stats)

check if IsShown works if hidden by AUI

Member ScalarGradyKippModel::setFlaws (Storage &storage, IMaterial &material, const MaterialInitialContext &context) const override

needs to be generalized for setting up initial conditions with heterogeneous material.

Member SessionDialog::SessionDialog (wxWindow *parent, UniqueNameManager &nameMgr)

these presets should also setup GUI parameters (palettes, particle radii, ...) !!

Member SimplifiedTillotsonEos::evaluate (const Float rho, const Float u) const override

Correctly, has to depend on u!

Member SingleParticleIc::evaluate (const RunSettings &global, IRunCallbacks &UNUSED(callbacks)) override

only to allow pressure, should be done better

Member SolidSphereKernel::valueImpl (const Float UNUSED(qSqr)) const

Member SolidStressForce::create (Storage &storage, IMaterial &material) const override

make sure that there is only a single derivative writing to VELOCITY_GRADIENT!!

Member SolidStressForce::setDerivatives (DerivativeHolder &derivatives, const RunSettings &settings) override

Correction tensor should be added automatically; same as above

Member SolidStressForce::SolidStressForce (const RunSettings &settings)

correction tensor is now generalized, it is easily accessible to ALL derivatives deriving from DerivativeTemplate. We should create this quantity somehow automatically, without relying on SolidStressForce to add it.

Class SpatialPlot< TDerived >

Needs to limit the number of drawn points - we definitely dont want to draw 10^5 points.

Member SphDomain::SphDomain (const Storage &storage, ArrayView< const Size > idxs, const RunSettings &settings)

generalize

Member Sphere::intersectsBox (const Box &box) const

not all branches are actually needed by TreeWalk, possibly optimize by some constexpr flag

Member Stellar::generateIc (const IDistribution &distribution, const Size particleCnt, const Float radius, const Float mass, const Float n)

add to params

Member Storage::setMaterial (const Size matIdx, const SharedPtr< IMaterial > &material)

merge material ranes if they have the same material

Member StressAV::setDerivatives (DerivativeHolder &derivatives, const RunSettings &settings) override

partially duplicates stuff from EquationTerm.cpp

Member SymmetricSolver< Dim >::beforeLoop (Storage &storage, Statistics &stats)

there functions HAVE to be called, so it doesn't make sense to have them virtual - instead split it into a mandatory function and another one (empty by default) than can be overriden

Member SymmetricSolver< Dim >::getFinder (ArrayView< const Vector > r)

same thing as in AsymmetricSolver -> move to shared parent?

Member SymmetricSolver< Dim >::SymmetricSolver (IScheduler &scheduler, const RunSettings &settings, const EquationHolder &eqs, AutoPtr< IBoundaryCondition > &&bc)

we have to somehow enforce either conservation of smoothing length or some EquationTerm that will evolve it. Or maybe just move smoothing length to separate quantity to get rid of these issues?

Member SymmetricTensor::invariant () const

optimize with shuffle

Member SymmetricTensor::inverse () const

optimize using SSE

Member SymmetricTensor::operator* (const Vector &v) const

optimize using _mm_shuffle_ps

Member Tensor::operator*= (const Float value)

test

Member TillotsonEos::evaluate (const Float rho, const Float u) const override

interpolate squared values or after sqrt?

Member TillotsonEos::getDensity (const Float p, const Float u) const override

this is currently fine tuned for getting density in stationary (initial) state

Member TillotsonEos::getInternalEnergy (const Float rho, const Float p) const override

optimize, find proper upper bound

Member TotalAngularMomentum::evaluate (const Storage &storage) const override

consolidate the angular momentum here - always in local frame? introduce physical quantity?

Class TransformedDomain

TESTS

Member Tuple< TArgs >::operator== (const Tuple &other) const

Generalize operator to allow comparing tuples of different types.

Member UniformGridFinder::iterate (const TFunctor &functor)

refactor, finder shouldn't know anything about gravity

Member UniqueNameManager::getName (const std::string &name)

increase the number if there is already a (x) at the end

what to return?

Member ValueColumn< TValue >::accumulate (Storage &storage, const Dynamic value, const Size particleIdx) const override

must also resize derivaties, or avoid resizing

Member VanDerWaalsEos::evaluate (const Float rho, const Float u) const override

correct sound speed

Class VectorPdfRng< TScalarRng >

make jacobian work, create few basic coordinate systems

Member VectorPdfRng< TScalarRng >::VectorPdfRng (const Box &box, const Function< Float(const Vector &)> &pdf=[](const Vector &) { return 1._f;}, const Function< Float(const Vector &)> &jacobian=[](const Vector &) { return 1._f;}, const Float maximalPdf=0._f)

should depend on jacobian

jacobian

Member WxRenderContext::setThickness (const float UNUSED(newThickness)) override

Member XSph::initialize (IScheduler &UNUSED(scheduler), Storage &storage, const Float UNUSED(t)) override

this is not very good solution as it depends on ordering of equation term in the array; some may already get corrected velocities. This should be really done by deriving the solver and correcting velocities manually.