xfygogo
/
phasicFlow
mirror of https://github.com/PhasicFlow/phasicFlow.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

global damping is activated for velocity and rVelocity in both sphere and grain solvers

This commit is contained in:
HRN 2025-02-10 01:10:13 +03:30
parent db9b1e62e4
commit 8466e02d81
10 changed files with 72 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Particles/GrainParticles/grainParticles/grainParticles.cpp
View File

@ -324,10 +324,12 @@ bool pFlow::grainParticles::iterate()
{ {
return false; return false;
} }
real damping = dynPointStruct().dampingFactor(ti);
if(!rVelIntegration_().correct( if(!rVelIntegration_().correct(
ti.dt(), ti.dt(),
rVelocity_, rVelocity_,
rAcceleration_)) rAcceleration_,
damping))
{ {
return false; return false;
} }

2
src/Particles/Insertion/insertionRegion/insertionRegion.hpp
View File

@ -173,7 +173,7 @@ public:
inline bool insertionTime(uint32 iter, real t, real dt) const inline bool insertionTime(uint32 iter, real t, real dt) const
{ {
return tControl_.timeEvent(iter, t, dt); return tControl_.eventTime(iter, t, dt);
} }
uint32 numberToBeInserted(uint32 iter, real t, real dt); uint32 numberToBeInserted(uint32 iter, real t, real dt);

6
src/Particles/SphereParticles/sphereParticles/sphereParticles.cpp
View File

@ -300,10 +300,12 @@ bool pFlow::sphereParticles::iterate()
{ {
return false; return false;
} }
real damping = dynPointStruct().dampingFactor(ti);
if(!rVelIntegration_().correct( if(!rVelIntegration_().correct(
dt(), ti.dt(),
rVelocity_, rVelocity_,
rAcceleration_)) rAcceleration_,
damping))
{ {
return false; return false;
} }

17
src/Particles/dynamicPointStructure/dynamicPointStructure.cpp
View File

@ -89,9 +89,11 @@ pFlow::dynamicPointStructure::dynamicPointStructure
fatalExit; fatalExit;
} }
REPORT(1)<<"Reading globalDamping dictionary ..."<<END_REPORT; if(control.settingsDict().containsDictionay("globalDamping"))
velDamping_ = makeUnique<globalDamping>(control); {
REPORT(1)<<"Reading globalDamping dictionary ..."<<END_REPORT;
velDamping_ = makeUnique<globalDamping>(control);
}
} }
@ -111,10 +113,6 @@ bool pFlow::dynamicPointStructure::iterate()
{ {
return pointStructure::iterate(); return pointStructure::iterate();
/*real dt = this->dt();
auto& acc = time().lookupObject<realx3PointField_D>("acceleration");
return correct(dt, acc);*/
} }
bool pFlow::dynamicPointStructure::afterIteration() bool pFlow::dynamicPointStructure::afterIteration()
@ -122,14 +120,13 @@ bool pFlow::dynamicPointStructure::afterIteration()
//const auto ti = TimeInfo(); //const auto ti = TimeInfo();
auto succs = pointStructure::afterIteration(); auto succs = pointStructure::afterIteration();
//velDamping_().applyDamping(ti, velocity_);
return succs; return succs;
} }
bool pFlow::dynamicPointStructure::predict(real dt) bool pFlow::dynamicPointStructure::predict(real dt)
{ {
if(!integrationPos_().predict(dt, pointPosition(), velocity_ ))return false; if(!integrationPos_().predict(dt, pointPosition(), velocity_ ))return false;
if(!integrationVel_().predict(dt, velocity_, acceleration_))return false; if(!integrationVel_().predict(dt, velocity_, acceleration_))return false;
@ -141,7 +138,7 @@ bool pFlow::dynamicPointStructure::correct(real dt)
const auto& ti = TimeInfo(); const auto& ti = TimeInfo();
if(!integrationPos_().correctPStruct(dt, *this, velocity_) )return false; if(!integrationPos_().correctPStruct(dt, *this, velocity_) )return false;
if(!integrationVel_().correct(dt, velocity_, acceleration_, velDamping_().dampingFactor(ti)))return false; if(!integrationVel_().correct(dt, velocity_, acceleration_, dampingFactor(ti)))return false;
return true; return true;
} }

10
src/Particles/dynamicPointStructure/dynamicPointStructure.hpp
View File

@ -101,6 +101,16 @@ public:
return acceleration_; return acceleration_;
} }
inline
real dampingFactor(const timeInfo& ti)const
{
if(velDamping_)
{
return velDamping_().dampingFactor(ti);
}
return 1.0;
}
/// In the time loop before iterate /// In the time loop before iterate
bool beforeIteration() override; bool beforeIteration() override;

38
src/Particles/globalDamping/globalDamping.cpp
View File

@ -23,13 +23,12 @@ Licence:
pFlow::globalDamping::globalDamping(const systemControl& control) pFlow::globalDamping::globalDamping(const systemControl& control)
{} :
/*:
timeControl_(control.settingsDict().subDict("globalDamping"), control.time().dt(), "damping") timeControl_(control.settingsDict().subDict("globalDamping"), control.time().dt(), "damping")
{ {
const dictionary& dict = control.settingsDict().subDict("globalDamping"); const dictionary& dict = control.settingsDict().subDict("globalDamping");
dampingFactor_ = dict.getValOrSetMin<real>("dampingFactor", static_cast<real>(1.0)); dampingFactor_ = dict.getValMin<real>("dampingFactor", static_cast<real>(1.0));
dampingFactor_ = max( dampingFactor_ , static_cast<real>(0.01)); dampingFactor_ = max( dampingFactor_ , static_cast<real>(0.01));
@ -41,36 +40,11 @@ pFlow::globalDamping::globalDamping(const systemControl& control)
else else
REPORT(2)<<"Global damping "<<Yellow_Text("is not active")<<"."<<END_REPORT; REPORT(2)<<"Global damping "<<Yellow_Text("is not active")<<"."<<END_REPORT;
}*/ }
/*void pFlow::globalDamping::applyDamping
(
const timeInfo& ti,
realx3PointField_D& velocity
)
{
if(!performDamping_) return;
if(!timeControl_.timeEvent(ti.iter(), ti.t(), ti.dt()) )return;
auto d_v = velocity.deviceView();
auto activeRng = velocity.activeRange();
auto dmpng = dampingFactor_;
Kokkos::parallel_for(
"globalDamping::applyDamping",
deviceRPolicyStatic(activeRng.start(), activeRng.end()),
LAMBDA_HD(uint32 i){
d_v[i] *= dmpng;
});
Kokkos::fence();
//REPORT(1)<<"Applied global damping "<<END_REPORT;
}*/
pFlow::real pFlow::globalDamping::dampingFactor(const timeInfo& ti)const pFlow::real pFlow::globalDamping::dampingFactor(const timeInfo& ti)const
{ {
return 1; if(!performDamping_) return 1.0;
/*if(!performDamping_) return 1.0; if(!timeControl_.eventTime(ti ))return 1.0;
if(!timeControl_.timeEvent(ti.iter(), ti.t(), ti.dt()) )return 1.0; return dampingFactor_;
return dampingFactor_;*/
} }

7
src/Particles/globalDamping/globalDamping.hpp
View File

@ -37,8 +37,7 @@ private:
real dampingFactor_; real dampingFactor_;
// baseTimeControl timeControl_; baseTimeControl timeControl_;
public: public:
@ -47,9 +46,7 @@ public:
~globalDamping()=default; ~globalDamping()=default;
//void applyDamping( const timeInfo& ti, realx3PointField_D& velocity); bool dampingActive()const
bool performDamping()const
{ {
return performDamping_; return performDamping_;
} }

41
src/phasicFlow/repository/Time/baseTimeControl.cpp
View File

@ -19,13 +19,13 @@ Licence:
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/
#include "baseTimeControl.hpp" #include "baseTimeControl.hpp"
#include "timeInfo.hpp"
pFlow::baseTimeControl::baseTimeControl pFlow::baseTimeControl::baseTimeControl
( (
const dictionary &dict, const dictionary &dict,
const word& intervalPrefix, const word& intervalPrefix,
real defStartTime timeValue defStartTime
) )
: :
intervalPrefix_(intervalPrefix) intervalPrefix_(intervalPrefix)
@ -49,10 +49,10 @@ pFlow::baseTimeControl::baseTimeControl
if(!isTimeStep_) if(!isTimeStep_)
{ {
auto startTime = (dict.getValOrSet<real>("startTime", defStartTime)); auto startTime = (dict.getValOrSet<timeValue>("startTime", defStartTime));
auto endTime = (dict.getValOrSet<real>("endTime", largeValue)); auto endTime = (dict.getValOrSet<timeValue>("endTime", largeValue));
auto interval = dict.getVal<real>(intervalWord); auto interval = dict.getVal<timeValue>(intervalWord);
rRange_ = realStridedRange(startTime, endTime, interval); rRange_ = stridedRange<timeValue>(startTime, endTime, interval);
} }
else else
@ -68,9 +68,9 @@ pFlow::baseTimeControl::baseTimeControl
pFlow::baseTimeControl::baseTimeControl pFlow::baseTimeControl::baseTimeControl
( (
const dictionary& dict, const dictionary& dict,
const real defInterval, const timeValue defInterval,
const word& intervalPrefix, const word& intervalPrefix,
const real defStartTime const timeValue defStartTime
) )
: :
intervalPrefix_(intervalPrefix) intervalPrefix_(intervalPrefix)
@ -94,10 +94,10 @@ pFlow::baseTimeControl::baseTimeControl
if(!isTimeStep_) if(!isTimeStep_)
{ {
auto startTime = (dict.getValOrSet<real>("startTime", defStartTime)); auto startTime = (dict.getValOrSet<timeValue>("startTime", defStartTime));
auto endTime = (dict.getValOrSet<real>("endTime", largeValue)); auto endTime = (dict.getValOrSet<timeValue>("endTime", largeValue));
auto interval = dict.getValOrSet<real>(intervalWord, defInterval); auto interval = dict.getValOrSet<timeValue>(intervalWord, defInterval);
rRange_ = realStridedRange(startTime, endTime, interval); rRange_ = stridedRange<timeValue>(startTime, endTime, interval);
} }
else else
@ -119,7 +119,7 @@ pFlow::baseTimeControl::baseTimeControl(int32 start, int32 end, int32 stride, co
{ {
} }
bool pFlow::baseTimeControl::timeEvent(uint32 iter, real t, real dt) const bool pFlow::baseTimeControl::eventTime(uint32 iter, timeValue t, timeValue dt) const
{ {
if(isTimeStep_) if(isTimeStep_)
{ {
@ -132,8 +132,13 @@ bool pFlow::baseTimeControl::timeEvent(uint32 iter, real t, real dt) const
return false; return false;
} }
bool pFlow::baseTimeControl::eventTime(const timeInfo &ti) const
{
return eventTime(ti.iter(), ti.t(), ti.dt());
}
bool bool
pFlow::baseTimeControl::isInRange(uint32 iter, real t, real dt) const pFlow::baseTimeControl::isInRange(uint32 iter, timeValue t, timeValue dt) const
{ {
if(isTimeStep_) if(isTimeStep_)
{ {
@ -145,7 +150,7 @@ pFlow::baseTimeControl::isInRange(uint32 iter, real t, real dt) const
} }
} }
pFlow::real pFlow::timeValue
pFlow::baseTimeControl::startTime() const pFlow::baseTimeControl::startTime() const
{ {
if(!isTimeStep_) if(!isTimeStep_)
@ -158,7 +163,7 @@ pFlow::baseTimeControl::startTime() const
return 0; return 0;
} }
pFlow::real pFlow::timeValue
pFlow::baseTimeControl::endTime() const pFlow::baseTimeControl::endTime() const
{ {
if(!isTimeStep_) if(!isTimeStep_)
@ -171,7 +176,7 @@ pFlow::baseTimeControl::endTime() const
return 0; return 0;
} }
pFlow::real pFlow::timeValue
pFlow::baseTimeControl::rInterval() const pFlow::baseTimeControl::rInterval() const
{ {
if(!isTimeStep_) if(!isTimeStep_)

26
src/phasicFlow/repository/Time/baseTimeControl.hpp
View File

@ -26,6 +26,8 @@ under the terms of GNU General Public License v3 or any other later versions.
namespace pFlow namespace pFlow
{ {
class timeInfo;
class baseTimeControl class baseTimeControl
{ {
private: private:
@ -34,7 +36,7 @@ private:
int32StridedRagne iRange_; int32StridedRagne iRange_;
realStridedRange rRange_; stridedRange<timeValue> rRange_;
const word intervalPrefix_; const word intervalPrefix_;
@ -43,14 +45,14 @@ public:
baseTimeControl( baseTimeControl(
const dictionary& dict, const dictionary& dict,
const word& intervalPrefix = "", const word& intervalPrefix = "",
real defStartTime = 0.0 timeValue defStartTime = 0.0
); );
baseTimeControl( baseTimeControl(
const dictionary& dict, const dictionary& dict,
const real defInterval, const timeValue defInterval,
const word& intervalPrefix="", const word& intervalPrefix="",
const real defStartTime=0.0); const timeValue defStartTime=0.0);
baseTimeControl( baseTimeControl(
int32 start, int32 start,
@ -64,15 +66,17 @@ public:
return isTimeStep_; return isTimeStep_;
} }
bool timeEvent(uint32 iter, real t, real dt) const; bool eventTime(uint32 iter, timeValue t, timeValue dt) const;
bool isInRange(uint32 iter, real t, real dt) const; bool eventTime(const timeInfo& ti)const;
real startTime() const; bool isInRange(uint32 iter, timeValue t, timeValue dt) const;
real endTime() const; timeValue startTime() const;
real rInterval() const; timeValue endTime() const;
timeValue rInterval() const;
int32 startIter() const; int32 startIter() const;

2
src/phasicFlow/structuredData/pointStructure/pointStructure/pointSorting/pointSorting.hpp
View File

@ -52,7 +52,7 @@ public:
bool sortTime(uint32 iter, real t, real dt)const bool sortTime(uint32 iter, real t, real dt)const
{ {
return performSorting_() && timeControl_.timeEvent(iter, t, dt); return performSorting_() && timeControl_.eventTime(iter, t, dt);
} }
uint32IndexContainer getSortedIndices( uint32IndexContainer getSortedIndices(