MercuryDPM  Trunk
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
MindlinRollingTorsionSpecies.cc
Go to the documentation of this file.
1 //Copyright (c) 2013-2020, The MercuryDPM Developers Team. All rights reserved.
2 //For the list of developers, see <http://www.MercuryDPM.org/Team>.
3 //
4 //Redistribution and use in source and binary forms, with or without
5 //modification, are permitted provided that the following conditions are met:
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above copyright
9 // notice, this list of conditions and the following disclaimer in the
10 // documentation and/or other materials provided with the distribution.
11 // * Neither the name MercuryDPM nor the
12 // names of its contributors may be used to endorse or promote products
13 // derived from this software without specific prior written permission.
14 //
15 //THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
16 //ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 //WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 //DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
19 //DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 //(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 //LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22 //ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 //(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 //SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 
27 #include<cmath>
28 #include "Species/BaseSpecies.h"
29 
30 class BaseParticle;
31 
32 class BaseInteractable;
33 
35  : MindlinSpecies()
36 {
37  rollingStiffness_ = 0.0;
38  rollingDissipation_ = 0.0;
41  torsionStiffness_ = 0.0;
42  torsionDissipation_ = 0.0;
45 #ifdef DEBUG_CONSTRUCTOR
46  std::cout<<"MindlinRollingTorsionSpecies::MindlinRollingTorsionSpecies() finished"<<std::endl;
47 #endif
48 }
49 
54  : MindlinSpecies(s)
55 {
64 #ifdef DEBUG_CONSTRUCTOR
65  std::cout<<"MindlinRollingTorsionSpecies::MindlinRollingTorsionSpecies(const MindlinRollingTorsionSpecies &p) finished"<<std::endl;
66 #endif
67 }
68 
70 {
71 #ifdef DEBUG_DESTRUCTOR
72  std::cout<<"MindlinRollingTorsionSpecies::~MindlinRollingTorsionSpecies() finished"<<std::endl;
73 #endif
74 }
75 
79 void MindlinRollingTorsionSpecies::write(std::ostream& os) const
80 {
82  os << " rollingStiffness " << rollingStiffness_;
83  os << " rollingDissipation " << rollingDissipation_;
84  os << " rollingFrictionCoefficient " << rollingFrictionCoefficient_;
85  os << " rollingFrictionCoefficientStatic " << rollingFrictionCoefficientStatic_;
86  os << " torsionStiffness " << torsionStiffness_;
87  os << " torsionDissipation " << torsionDissipation_;
88  os << " torsionFrictionCoefficient " << torsionFrictionCoefficient_;
89  os << " torsionFrictionCoefficientStatic " << torsionFrictionCoefficientStatic_;
90 }
91 
95 void MindlinRollingTorsionSpecies::read(std::istream& is)
96 {
98  std::string dummy;
99  is >> dummy >> rollingStiffness_;
100  is >> dummy >> rollingDissipation_;
101  is >> dummy >> rollingFrictionCoefficient_;
102  is >> dummy >> rollingFrictionCoefficientStatic_;
103  is >> dummy >> torsionStiffness_;
104  is >> dummy >> torsionDissipation_;
105  is >> dummy >> torsionFrictionCoefficient_;
106  is >> dummy >> torsionFrictionCoefficientStatic_;
107 }
108 
113 {
114  return "MindlinRollingTorsion";
115 }
116 
124 {
125  return true;
126 }
127 
134 {
135  //rollingStiffness_= BaseSpecies::average(S->getRollingStiffness(), T->getRollingStiffness());
140  //torsionStiffness_= BaseSpecies::average(S->getTorsionStiffness(), T->getTorsionStiffness());
145 }
146 
148 //void MindlinRollingTorsionSpecies::setRollingStiffness(Mdouble new_kt)
149 //{
150 // if (new_kt >= 0)
151 // {
152 // rollingStiffness_ = new_kt;
153 // }
154 // else
155 // {
156 // std::cerr << "Error in setRollingStiffness" << std::endl;
157 // exit(-1);
158 // }
159 //}
160 //
162 //Mdouble MindlinRollingTorsionSpecies::getRollingStiffness() const
163 //{
164 // return rollingStiffness_;
165 //}
166 
169 {
170  if (new_dispt >= 0)
171  rollingDissipation_ = new_dispt;
172  else
173  {
174  std::cerr << "Error in setRollingDissipation" << std::endl;
175  exit(-1);
176  }
177 }
178 
181 {
182  return rollingDissipation_;
183 }
184 
186 //mu has to be set to allow tangential forces (sets dispt=disp as default)
188 {
189  if (new_mu >= 0)
190  {
193  }
194  else
195  {
196  std::cerr << "Error in setSlidingFrictionCoefficient" << std::endl;
197  exit(-1);
198  }
199 }
200 
203 {
205 }
206 
209 {
210  if (new_mu >= 0)
211  {
213  }
214  else
215  {
216  std::cerr << "Error in setSlidingFrictionCoefficientStatic" << std::endl;
217  exit(-1);
218  }
219 }
220 
223 {
225 }
226 
227 
229 //void MindlinRollingTorsionSpecies::setTorsionStiffness(Mdouble new_kt)
230 //{
231 // if (new_kt >= 0)
232 // {
233 // torsionStiffness_ = new_kt;
234 // }
235 // else
236 // {
237 // std::cerr << "Error in setTorsionStiffness" << std::endl;
238 // exit(-1);
239 // }
240 //}
241 
243 //Mdouble MindlinRollingTorsionSpecies::getTorsionStiffness() const
244 //{
245 // return torsionStiffness_;
246 //}
247 
250 {
251  if (new_dispt >= 0)
252  torsionDissipation_ = new_dispt;
253  else
254  {
255  std::cerr << "Error in setTorsionDissipation" << std::endl;
256  exit(-1);
257  }
258 }
259 
262 {
263  return torsionDissipation_;
264 }
265 
267 //mu has to be set to allow tangential forces (sets dispt=disp as default)
269 {
270  if (new_mu >= 0)
271  {
274  }
275  else
276  {
277  std::cerr << "Error in setSlidingFrictionCoefficient" << std::endl;
278  exit(-1);
279  }
280 }
281 
284 {
286 }
287 
290 {
291  if (new_mu >= 0)
292  {
294  }
295  else
296  {
297  std::cerr << "Error in setSlidingFrictionCoefficientStatic" << std::endl;
298  exit(-1);
299  }
300 }
301 
304 {
306 }
void write(std::ostream &os) const
Writes the species properties to an output stream.
void write(std::ostream &os) const
Writes the species properties to an output stream.
void setTorsionFrictionCoefficient(Mdouble new_mu)
Allows the (dynamic) Coulomb torsion friction coefficient to be changed; also sets mu_s by default...
double Mdouble
Definition: GeneralDefine.h:34
void setRollingDissipation(Mdouble new_dispt)
Allows the spring constant to be changed.
Mdouble rollingDissipation_
rolling dissipation coefficient.
void read(std::istream &is)
Reads the species properties from an input stream.
Mdouble getTorsionFrictionCoefficient() const
Allows the (dynamic) Coulomb torsion friction coefficient to be accessed.
void read(std::istream &is)
Reads the species properties from an input stream.
MindlinRollingTorsionSpecies()
The default constructor.
Mdouble getRollingFrictionCoefficient() const
Allows the (dynamic) Coulomb friction coefficient to be accessed.
Mdouble getRollingDissipation() const
Allows the tangential viscosity to be accessed.
MindlinSpecies contains the parameters used to describe sliding friction.
void mix(MindlinRollingTorsionSpecies *S, MindlinRollingTorsionSpecies *T)
creates default values for mixed species
Mdouble torsionFrictionCoefficientStatic_
static Coulomb torsion friction coefficient (by default set equal to the dynamic one).
void setRollingFrictionCoefficient(Mdouble new_mu)
Allows the (dynamic) Coulomb friction coefficient to be changed; also sets mu_s by default...
~MindlinRollingTorsionSpecies()
The default destructor.
Mdouble torsionFrictionCoefficient_
(dynamic) Coulomb torsion friction coefficient.
void setTorsionFrictionCoefficientStatic(Mdouble new_mu)
Allows the static Coulomb torsion friction coefficient to be accessed.
static Mdouble average(Mdouble a, Mdouble b)
Returns the harmonic mean of two variables.
Definition: BaseSpecies.cc:110
Mdouble getTorsionFrictionCoefficientStatic() const
Allows the static Coulomb torsion friction coefficient to be accessed.
Mdouble torsionDissipation_
rolling dissipation coefficient.
Mdouble torsionStiffness_
rolling stiffness.
bool getUseAngularDOFs() const override
Returns true if torques have to be calculated.
Mdouble getTorsionDissipation() const
Allows the torsion viscosity to be accessed.
Mdouble getRollingFrictionCoefficientStatic() const
Allows the static Coulomb rolling friction coefficient to be accessed.
Mdouble rollingFrictionCoefficient_
(dynamic) Coulomb rolling friction coefficient.
void setTorsionDissipation(Mdouble new_dispt)
Allows the torsion viscosity to be changed.
Defines the basic properties that a interactable object can have.
std::string getBaseName() const override
Used in Species::getName to obtain a unique name for each Species.
void setRollingFrictionCoefficientStatic(Mdouble new_mu)
Allows the static Coulomb rolling friction coefficient to be changed.
MindlinRollingTorsionSpecies contains the parameters used to describe sliding, rolling and torsional ...
Mdouble rollingFrictionCoefficientStatic_
static Coulomb rolling friction coefficient (by default set equal to the dynamic one).
Mdouble rollingStiffness_
rolling stiffness.