Functions
ContactLawTestHelpers.h File Reference
#include "DPMBase.h"
#include "Helpers/FileIOHelpers.h"
#include "Logger.h"
#include "Particles/BaseParticle.h"
#include "Species/BaseSpecies.h"
#include "Walls/InfiniteWall.h"

Go to the source code of this file.

Functions

void loadingTest (const ParticleSpecies *species, Mdouble displacement, Mdouble velocity, Mdouble radius, std::string name)
 
void normalAndTangentialLoadingTest (const ParticleSpecies *species, Mdouble displacement, Mdouble tangentialDisplacement, Mdouble velocity, Mdouble radius, std::string name)
 
void objectivenessTest (const ParticleSpecies *species, Mdouble displacement, Mdouble tangentialDisplacement, Mdouble velocity, Mdouble radius, std::string name)
 

Function Documentation

◆ loadingTest()

void loadingTest ( const ParticleSpecies *  species,
Mdouble  displacement,
Mdouble  velocity,
Mdouble  radius,
std::string  name 
)
Note
The file contains the function definitions, so no additional linking is required. Creates a DPMBase with a particles of unit size and a flat wall and loads/unloads the particle-wall contact
Parameters
[in]speciesparticle species specifying the contact law
[in]displacementpeak displacement before unloading
[in]velocityloading/unloading velocity
[in]radius
[in]name
29 {
30  class LoadingTest : public DPMBase
31  {
32  const ParticleSpecies* species;
33  Mdouble displacement;
34  Mdouble velocity;
35  Mdouble radius;
36  public:
37  //public variables
38  LoadingTest(const ParticleSpecies* species, Mdouble displacement, Mdouble velocity, Mdouble radius)
39  : species(species), displacement(displacement), velocity(velocity), radius(radius)
40  {}
41 
42  void setupInitialConditions() override
43  {
44  //setName("LoadingTest"+species->getName());
45  setTimeMax(2.0 * displacement / velocity);
46  setTimeStep(2e-3 * getTimeMax());
47  setSaveCount(1);
48  setFileType(FileType::NO_FILE);
49  fStatFile.setFileType(FileType::ONE_FILE);
50 
51  setMax({radius, radius, radius + radius});
52  setMin({-radius, -radius, 0});
53  setSystemDimensions(3);
54  setParticleDimensions(3);
55 
56  speciesHandler.copyAndAddObject(*species);
57 
58  SphericalParticle p;
59  p.setSpecies(speciesHandler.getObject(0));
60  p.setRadius(radius);
61  p.setPosition({0, 0, radius});
62  particleHandler.copyAndAddObject(p);
63 
64  InfiniteWall w;
65  w.setSpecies(speciesHandler.getObject(0));
66  w.set(Vec3D(0, 0, -1), Vec3D(0.0, 0.0, 0.0));
67  wallHandler.copyAndAddObject(w);
68  }
69 
70  void actionsBeforeTimeStep() override
71  {
72  BaseParticle* p = particleHandler.getLastObject();
73  logger.assert_debug(p,"Empty particle handler");
74  p->setAngularVelocity({0, 0, 0});
75 
76  //Moving particle normally into surface
77  if (getTime() <= displacement / velocity)
78  {
79  p->setVelocity({0, 0, velocity});
80  p->setPosition({0, 0, radius - velocity * getTime()});
81  }
82  else
83  {
84  p->setVelocity({0, 0, -velocity});
85  p->setPosition({0, 0, radius - displacement - displacement + velocity * getTime()});
86  }
87  }
88  } test(species, displacement, velocity, radius);
89  test.setName(name);
90  test.solve();
91  helpers::writeToFile(test.getName() + ".gnu", "plot '" + test.getName() + ".fstat' u 7:9 w lp");
92  logger(INFO, "finished loading test: run 'gnuplot %.gnu' to view output", test.getName());
93 }
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
FileType::NO_FILE
@ NO_FILE
file will not be created/read
FileType::ONE_FILE
@ ONE_FILE
all data will be written into/ read from a single file called name_
logger
Logger< MERCURYDPM_LOGLEVEL > logger("MercuryKernel")
Definition of different loggers with certain modules. A user can define its own custom logger here.
w
RowVector3d w
Definition: Matrix_resize_int.cpp:3
p
float * p
Definition: Tutorial_Map_using.cpp:9
BaseParticle
Definition: BaseParticle.h:33
DPMBase
The DPMBase header includes quite a few header files, defining all the handlers, which are essential....
Definition: DPMBase.h:56
DPMBase::setSaveCount
void setSaveCount(unsigned int saveCount)
Sets File::saveCount_ for all files (ene, data, fstat, restart, stat)
Definition: DPMBase.cc:386
DPMBase::setupInitialConditions
virtual void setupInitialConditions()
This function allows to set the initial conditions for our problem to be solved, by default particle ...
Definition: DPMBase.cc:1987
DPMBase::setParticleDimensions
void setParticleDimensions(unsigned int particleDimensions)
Sets the particle dimensionality.
Definition: DPMBase.cc:1439
DPMBase::actionsBeforeTimeStep
virtual void actionsBeforeTimeStep()
A virtual function which allows to define operations to be executed before the new time step.
Definition: DPMBase.cc:1853
DPMBase::getTime
Mdouble getTime() const
Returns the current simulation time.
Definition: DPMBase.cc:799
DPMBase::setFileType
void setFileType(FileType fileType)
Sets File::fileType_ for all files (ene, data, fstat, restart, stat)
Definition: DPMBase.cc:437
DPMBase::setMin
void setMin(const Vec3D &min)
Sets the minimum coordinates of the problem domain.
Definition: DPMBase.cc:1109
DPMBase::setTimeStep
void setTimeStep(Mdouble newDt)
Sets a new value for the simulation time step.
Definition: DPMBase.cc:1225
DPMBase::setTimeMax
void setTimeMax(Mdouble newTMax)
Sets a new value for the maximum simulation duration.
Definition: DPMBase.cc:864
DPMBase::setSystemDimensions
void setSystemDimensions(unsigned int newDim)
Sets the system dimensionality.
Definition: DPMBase.cc:1408
DPMBase::setMax
void setMax(const Vec3D &max)
Sets the maximum coordinates of the problem domain.
Definition: DPMBase.cc:1073
DPMBase::getTimeMax
Mdouble getTimeMax() const
Returns the maximum simulation duration.
Definition: DPMBase.cc:879
InfiniteWall
A infinite wall fills the half-space {point: (position_-point)*normal_<=0}.
Definition: InfiniteWall.h:27
ParticleSpecies
Definition: ParticleSpecies.h:16
SphericalParticle
A spherical particle is the most simple particle used in MercuryDPM.
Definition: SphericalParticle.h:16
Vec3D
Definition: Kernel/Math/Vector.h:30
INFO
#define INFO(i)
Definition: mumps_solver.h:54
Eigen::test
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil not a number test
Definition: GlobalFunctions.h:109
Jeffery_Solution::velocity
double velocity(const double &t)
Angular velocity as function of time t.
Definition: jeffery_orbit.cc:107
UniformPSDSelfTest.radius
radius
Definition: UniformPSDSelfTest.py:15
helpers::writeToFile
bool writeToFile(const std::string &filename, const std::string &filecontent)
Writes a string to a file.
Definition: FileIOHelpers.cc:29
plotDoE.name
string name
Definition: plotDoE.py:33
test
Definition: indexed_view.cpp:20

References DPMBase::actionsBeforeTimeStep(), e(), DPMBase::getTime(), DPMBase::getTimeMax(), INFO, logger, plotDoE::name, NO_FILE, ONE_FILE, p, UniformPSDSelfTest::radius, DPMBase::setFileType(), DPMBase::setMax(), DPMBase::setMin(), DPMBase::setParticleDimensions(), DPMBase::setSaveCount(), DPMBase::setSystemDimensions(), DPMBase::setTimeMax(), DPMBase::setTimeStep(), DPMBase::setupInitialConditions(), Eigen::test, Jeffery_Solution::velocity(), w, and helpers::writeToFile().

Referenced by main().

◆ normalAndTangentialLoadingTest()

void normalAndTangentialLoadingTest ( const ParticleSpecies *  species,
Mdouble  displacement,
Mdouble  tangentialDisplacement,
Mdouble  velocity,
Mdouble  radius,
std::string  name 
)

Creates a DPMBase with a particles of unit size and a flat wall and loads/unloads/reloads the particle-wall contact in tangential direction

Parameters
[in]speciesparticle species specifying the contact law
[in]displacementpeak displacement before unloading
[in]velocityloading/unloading velocity
[in]tangentialDisplacement
[in]radius
[in]name
107 {
108  class LoadingTest : public DPMBase
109  {
110  const ParticleSpecies* species;
111  Mdouble displacement;
112  Mdouble tangentialDisplacement;
113  Mdouble velocity;
114  Mdouble radius;
115  public:
116  //public variables
117  LoadingTest(const ParticleSpecies* species, Mdouble displacement, Mdouble tangentialDisplacement,
118  Mdouble velocity, Mdouble radius)
119  : species(species), displacement(displacement), tangentialDisplacement(tangentialDisplacement),
120  velocity(velocity), radius(radius)
121  {}
122 
123  void setupInitialConditions() override
124  {
125  //setName("TangentialLoadingTest"+species->getName());
126  setTimeMax(4.0 * tangentialDisplacement / velocity);
127  setTimeStep(4e-4 * getTimeMax());
128  setSaveCount(1);
129  setFileType(FileType::NO_FILE);
130  fStatFile.setFileType(FileType::ONE_FILE);
131 
132  setMax({radius, radius, radius + radius});
133  setMin({-radius, -radius, 0});
134  setSystemDimensions(3);
135  setParticleDimensions(3);
136 
137  speciesHandler.copyAndAddObject(*species);
138 
139  SphericalParticle p;
140  p.setSpecies(speciesHandler.getObject(0));
141  p.setRadius(radius);
142  p.setPosition({0, 0, radius - displacement});
143  particleHandler.copyAndAddObject(p);
144 
145  InfiniteWall w;
146  w.setSpecies(speciesHandler.getObject(0));
147  w.set(Vec3D(0, 0, -1), Vec3D(0.0, 0.0, 0.0));
148  wallHandler.copyAndAddObject(w);
149  }
150 
151  void actionsBeforeTimeStep() override
152  {
153  BaseParticle* p = particleHandler.getLastObject();
154  logger.assert_debug(p,"Empty particle handler");
155  p->setAngularVelocity({0, 0, 0});
156 
157  //Moving particle cyclically right and left between +-tangentialDisplacement
158  bool moveRight = static_cast<int>(getTime() / (2.0*tangentialDisplacement / velocity) +0.5)%2==0;
159  if (moveRight)
160  {
161  p->setVelocity({-velocity, 0, 0});
162  p->setPosition({tangentialDisplacement - velocity * getTime(), 0, radius - displacement});
163  }
164  else
165  {
166  p->setVelocity({velocity, 0, 0});
167  p->setPosition({-2*tangentialDisplacement + velocity * getTime(), 0, radius - displacement});
168  }
169  }
170 
171  } test(species, displacement, tangentialDisplacement, velocity, radius);
172  test.setName(name);
173  test.solve();
174  helpers::writeToFile(test.getName() + ".gnu", "plot '" + test.getName() + ".fstat' u 8:($10*$14) w lp");
175  logger(INFO, "finished tangential loading test: run 'gnuplot %.gnu' to view output", test.getName());
176 }

References DPMBase::actionsBeforeTimeStep(), e(), DPMBase::getTime(), DPMBase::getTimeMax(), INFO, logger, plotDoE::name, NO_FILE, ONE_FILE, p, UniformPSDSelfTest::radius, DPMBase::setFileType(), DPMBase::setMax(), DPMBase::setMin(), DPMBase::setParticleDimensions(), DPMBase::setSaveCount(), DPMBase::setSystemDimensions(), DPMBase::setTimeMax(), DPMBase::setTimeStep(), DPMBase::setupInitialConditions(), Eigen::test, Jeffery_Solution::velocity(), w, and helpers::writeToFile().

Referenced by main().

◆ objectivenessTest()

void objectivenessTest ( const ParticleSpecies *  species,
Mdouble  displacement,
Mdouble  tangentialDisplacement,
Mdouble  velocity,
Mdouble  radius,
std::string  name 
)

Creates a DPMBase with a particles of unit size and a flat wall, loads the particle-wall contact in normal and tangential direction, then rotates.

Parameters
[in]speciesparticle species specifying the contact law
[in]displacementpeak displacement before unloading
[in]velocityloading/unloading velocity
[in]tangentialDisplacement
[in]radius
[in]name
189 {
190  class ObjectivenessTest : public DPMBase
191  {
192  const ParticleSpecies* species;
193  Mdouble displacement;
194  Mdouble tangentialDisplacement;
195  Mdouble velocity;
196  Mdouble radius;
197  public:
198  //public variables
199  ObjectivenessTest(const ParticleSpecies* species, Mdouble displacement, Mdouble tangentialDisplacement,
200  Mdouble velocity, Mdouble radius)
201  : species(species), displacement(displacement), tangentialDisplacement(tangentialDisplacement),
202  velocity(velocity), radius(radius)
203  {}
204 
205  void setupInitialConditions() override
206  {
207  //setName("ObjectivenessTest"+species->getName());
208  setTimeMax((tangentialDisplacement + 0.5 * constants::pi * radius) / velocity);
209  setTimeStep(1e-4 * getTimeMax());
210  setSaveCount(20);
211  setFileType(FileType::NO_FILE);
212  dataFile.setFileType(FileType::ONE_FILE);
213  fStatFile.setFileType(FileType::ONE_FILE);
214 
215  setMax(radius * Vec3D(2, 2, 2));
216  setMin(radius * Vec3D(-2, -2, -2));
217  setSystemDimensions(2);
218  setParticleDimensions(3);
219 
220  speciesHandler.copyAndAddObject(*species);
221 
222  SphericalParticle p;
223  p.setSpecies(speciesHandler.getObject(0));
224  p.setRadius(radius);
225  p.setPosition({0, radius - displacement, 0});
226  particleHandler.copyAndAddObject(p);
227  p.setPosition({0, -radius + displacement, 0});
228  particleHandler.copyAndAddObject(p);
229  }
230 
231  void actionsBeforeTimeStep() override
232  {
233  BaseParticle* p = particleHandler.getObject(0);
234  BaseParticle* q = particleHandler.getLastObject();
235  logger.assert_debug(p,"Empty particle handler");
236  logger.assert_debug(q,"Empty particle handler");
237 
238  //Moving particle normally into surface
239  if (getTime() <= tangentialDisplacement / velocity)
240  {
241  p->setAngularVelocity({0, 0, 0});
242  p->setVelocity({velocity, 0, 0});
243  p->setPosition({-tangentialDisplacement + velocity * getTime(), radius - displacement, 0});
244  q->setAngularVelocity({0, 0, 0});
245  q->setVelocity({-velocity, 0, 0});
246  q->setPosition({tangentialDisplacement - velocity * getTime(), -radius + displacement, 0});
247  }
248  else
249  {
250  Mdouble angle = velocity / (radius - displacement) * (getTime() - tangentialDisplacement / velocity);
251  Mdouble s = sin(angle);
252  Mdouble c = cos(angle);
253  p->setAngularVelocity(velocity / (radius - displacement) * Vec3D(0, 0, -1));
254  //p->setAngularVelocity(Vec3D(0,0,0));
255  p->setOrientation({1, 0, 0, 0});
256  p->setVelocity(velocity * Vec3D(c, -s, 0));
257  //p->setVelocity(Vec3D(0,0,0));
258  p->setPosition((radius - displacement) * Vec3D(s, c, 0));
259  q->setAngularVelocity(-p->getAngularVelocity());
260  q->setOrientation(-p->getOrientation());
261  q->setVelocity(-p->getVelocity());
262  q->setPosition(-p->getPosition());
263  }
264  }
265 
266  } test(species, displacement, tangentialDisplacement, velocity, radius);
267  test.setName(name);
268  test.solve();
269  helpers::writeToFile(test.getName() + ".gnu", "set size ratio -1; plot '" + test.getName() + ".fstat' u 14:15 every 2 w lp");
270  logger(INFO, "finished objectiveness test: run 'gnuplot %.gnu' to view output", test.getName());
271 }
cos
AnnoyingScalar cos(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:136
sin
AnnoyingScalar sin(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:137
s
RealScalar s
Definition: level1_cplx_impl.h:130
Eigen::numext::q
EIGEN_DEVICE_FUNC const Scalar & q
Definition: SpecialFunctionsImpl.h:2019
Jeffery_Solution::angle
double angle(const double &t)
Angular position as a function of time t.
Definition: jeffery_orbit.cc:98
calibrate.dataFile
string dataFile
Definition: calibrate.py:175
calibrate.c
int c
Definition: calibrate.py:100
constants::pi
const Mdouble pi
Definition: ExtendedMath.h:23

References DPMBase::actionsBeforeTimeStep(), Jeffery_Solution::angle(), calibrate::c, cos(), calibrate::dataFile, e(), DPMBase::getTime(), DPMBase::getTimeMax(), INFO, logger, plotDoE::name, NO_FILE, ONE_FILE, p, constants::pi, Eigen::numext::q, UniformPSDSelfTest::radius, s, DPMBase::setFileType(), DPMBase::setMax(), DPMBase::setMin(), DPMBase::setParticleDimensions(), DPMBase::setSaveCount(), DPMBase::setSystemDimensions(), DPMBase::setTimeMax(), DPMBase::setTimeStep(), DPMBase::setupInitialConditions(), sin(), Eigen::test, Jeffery_Solution::velocity(), and helpers::writeToFile().

Referenced by main().