Softening Law Implementation - Revision history

Nairnj: /* Implementing Required Methods */

2021-09-09T00:56:56Z

Implementing Required Methods

← Older revision		Revision as of 00:56, 9 September 2021
Line 75:		Line 75:

	<math>\Omega(\delta,s) = \int_0^\delta f(u,s) du - \frac{1}{2}\delta f(\delta,s)</math>		<math>\Omega(\delta,s) = \int_0^\delta f(u,s) du - \frac{1}{2}\delta f(\delta,s)</math>
	<br>Note that recent code changes have eliminated this ~~methods~~. New cohesive ~~lows~~ need not implement it.		<br><i>Note</i>: that recent code changes have eliminated this method. New cohesive laws need not implement it.
	</li>		</li>

Line 85:		Line 85:
	Although this result could be found from<br>		Although this result could be found from<br>
	<tt>GetGToDelta(delta,s)/GetGToDelta(GetDeltaMax(s),s)</tt><br>		<tt>GetGToDelta(delta,s)/GetGToDelta(GetDeltaMax(s),s)</tt><br>
	that approach is less efficient (probably for any softening law). As a result, this implementation requires implementation of a separate method to do the calculation. Note ~~that~~ this method is only used or cubic failure surfaces (and then only in 3D for isotropic materials). Cohesive laws that do not override this method are limited to other modes (but cubic failure surface is no longer recommended)		that approach is less efficient (probably for any softening law). As a result, this implementation requires implementation of a separate method to do the calculation.<br>
			<i>Note</i>: this method is only used for cubic failure surfaces (and then only in 3D for isotropic softening materials). Cohesive laws that do not override this method are limited to other modes (but cubic failure surface is no longer recommended).
	</li>		</li>

Nairnj: /* Implementing Required Methods */

2021-09-09T00:55:07Z

Implementing Required Methods

← Older revision		Revision as of 00:55, 9 September 2021
Line 75:		Line 75:

	<math>\Omega(\delta,s) = \int_0^\delta f(u,s) du - \frac{1}{2}\delta f(\delta,s)</math>		<math>\Omega(\delta,s) = \int_0^\delta f(u,s) du - \frac{1}{2}\delta f(\delta,s)</math>
			<br>Note that recent code changes have eliminated this methods. New cohesive lows need not implement it.
	</li>		</li>


	<li><tt>double MySofteningLaw::GetGoverGc(double delta,double gScaling) const</tt><br>		<li><tt>double MySofteningLaw::GetGoverGc(double delta,double gScaling) const</tt><br>
Line 83:		Line 85:
	Although this result could be found from<br>		Although this result could be found from<br>
	<tt>GetGToDelta(delta,s)/GetGToDelta(GetDeltaMax(s),s)</tt><br>		<tt>GetGToDelta(delta,s)/GetGToDelta(GetDeltaMax(s),s)</tt><br>
	that approach is less efficient (probably for any softening law). As a result, this implementation requires implementation of a separate method to do the calculation.		that approach is less efficient (probably for any softening law). As a result, this implementation requires implementation of a separate method to do the calculation. Note that this method is only used or cubic failure surfaces (and then only in 3D for isotropic materials). Cohesive laws that do not override this method are limited to other modes (but cubic failure surface is no longer recommended)
	</li>		</li>

Nairnj: /* Implementing Optional Methods */

2021-07-20T20:23:30Z

Implementing Optional Methods

← Older revision		Revision as of 20:23, 20 July 2021
Line 111:		Line 111:
	=== Implementing Optional Methods ===		=== Implementing Optional Methods ===

	The required methods in the previous section are sufficient to implement a new softening law. The parent class, <tt>SofteningLaw.cpp</tt> implements calculations that work for any softening law that provides these methods. Some of those calculations, however, use numerical solutions to key problems. If any specific law can find closed-form solutions instead, implementing one or more of the following ~~options~~ methods can improve calculation speed for new laws. You can refer to [[Linear Softening]] or [[Exponential Softening]] coding to see examples of overriding these methods.		The required methods in the previous section are sufficient to implement a new softening law. The parent class, <tt>SofteningLaw.cpp</tt> implements calculations that work for any softening law that provides these methods. Some of those calculations, however, use numerical solutions to key problems. If any specific law can find closed-form solutions instead, implementing one or more of the following optional methods can improve calculation speed for new laws. You can refer to [[Linear Softening]] or [[Exponential Softening]] coding to see examples of overriding these methods.

	<ol>		<ol>

Nairnj: /* Editing Core Code */

2021-07-20T20:20:10Z

Editing Core Code

← Older revision		Revision as of 20:20, 20 July 2021
Line 41:		Line 41:
	</pre>		</pre>
	or the appropriate relative path to the new law's header file.		or the appropriate relative path to the new law's header file.
	<li>In <tt>void MaterialBase::SetSofteningLaw(char *lawName,int mode)</tt>, instantiate ~~you~~ new law based on user input of a name or a number. Pick any name and number that does not conflict with currently implemented softening laws. The new code will look like:		<li>In <tt>void MaterialBase::SetSofteningLaw(char *lawName,int mode)</tt>, instantiate your new law based on user input of a name or a number. Pick any name and number that does not conflict with currently implemented softening laws. The new code will look like:
	<pre>		<pre>
	else if(strcmp(lawName,"MyFavoriteLaw")==0 \|\| strcmp(lawName,"9")==0)		else if(strcmp(lawName,"MyFavoriteLaw")==0 \|\| strcmp(lawName,"9")==0)

Nairnj: /* Class Source Code */

2021-07-20T20:19:23Z

Class Source Code

← Older revision		Revision as of 20:19, 20 July 2021
Line 29:		Line 29:
	=== Class Source Code ===		=== Class Source Code ===

	The first step is to create source files for the new softening law class. The parent class for all softening laws are in <tt>SofteningLaw.cpp</tt> and <tt>SofteningLaw.hpp</tt> files. Normally, you will create new files that subclass this class (which can be done by starting with new files or by duplicating files from an existing softening law). You can pick any unique name for the softening law source files.		The first step is to create source files for the new softening law class. The parent class for all softening laws are in <tt>SofteningLaw.cpp</tt> and <tt>SofteningLaw.hpp</tt> files. Normally, you will create new files that subclass this class (which can be done by starting with new files or by duplicating files from an existing softening law). You can pick any unique name for the softening law source files. If beneficial, a new law cal alternative subclass any other existing softening law.

	=== Editing Core Code ===		=== Editing Core Code ===

Nairnj: /* Softening Law Definition */

2021-07-20T20:17:28Z

Softening Law Definition

← Older revision		Revision as of 20:17, 20 July 2021
Line 11:		Line 11:
	<math>F(\delta,s) = \sigma_{init}f(\delta,s)</math>		<math>F(\delta,s) = \sigma_{init}f(\delta,s)</math>

	Because the initiation stress is provided by the choosen [[Damage Initiation Laws\|initiation law]], the softening law depends only on dimensionless <math>f(\delta,s)</math> that is equal to 1 when <math>\delta=0</math> and <math>s</math> is a scaling ~~function~~ to connect total energy released to particle volume and crack orientation <ref name="dmref"/>:		Because the initiation stress is provided by the choosen [[Damage Initiation Laws\|initiation law]], the softening law depends only on dimensionless <math>f(\delta,s)</math> that is equal to 1 when <math>\delta=0</math> and <math>s</math> is a scaling factor to connect total energy released to particle volume and crack orientation <ref name="dmref"/>:

Nairnj: /* Implementing Required Methods */

2021-07-09T00:07:33Z

Implementing Required Methods

← Older revision		Revision as of 00:07, 9 July 2021
Line 80:		Line 80:
	Return ratio of energy released to the total toughness. It is defined by<br>		Return ratio of energy released to the total toughness. It is defined by<br>

	<math>\frac{\Omega(\delta,s)}{\Omega(\delta_{max},s)}</math><br>		<math>\frac{G}{G_c} = \frac{\Omega(\delta,s)}{\Omega(\delta_{max},s)}</math><br>
	Although this result could be found from<br>		Although this result could be found from<br>
	<tt>GetGToDelta(delta,s)/GetGToDelta(GetDeltaMax(s),s)</tt><br>		<tt>GetGToDelta(delta,s)/GetGToDelta(GetDeltaMax(s),s)</tt><br>

Nairnj: /* Implementing Required Methods */

2021-07-08T22:35:07Z

Implementing Required Methods

← Older revision		Revision as of 22:35, 8 July 2021
Line 101:		Line 101:

	<li><tt>double MySofteningLaw::GetRdFxn(double delta,double s,double ei) const</tt><br>		<li><tt>double MySofteningLaw::GetRdFxn(double delta,double s,double ei) const</tt><br>
	Return function that ~~relates evolution~~ of damage variable <math>D</math> to damage variable <math>\delta</math> ~~defined by~~:<br>		Return function that gives ratio of damage variable <math>D</math> evolution to damage variable <math>\delta</math> evolution. It is found from:<br>

	<math>\frac{dD}{d\delta} = \frac{\varepsilon_i\varphi(\delta,s)}{\bigl(\delta + \varepsilon_i f(\delta,s)\bigr)^2}</math><br>		<math>\frac{dD}{d\delta} = \frac{\varepsilon_i\varphi(\delta,s)}{\bigl(\delta + \varepsilon_i f(\delta,s)\bigr)^2}</math><br>

Nairnj: /* Implementing Required Methods */

2021-07-08T22:26:45Z

Implementing Required Methods

← Older revision		Revision as of 22:26, 8 July 2021
Line 86:		Line 86:
	</li>		</li>

	<li><tt>double MySofteningLaw::~~GetMaxSlope~~(~~double gScaling~~) const</tt><br>		<li><tt>double MySofteningLaw::GetEtaStability(void) const</tt><br>
	Return ~~the maximum value for the negative slope or~~<br>		Return dimensionless stability factor, <math>\eta</math> <ref name="dmref"/>. It is given by<br>

	<math>\max\left(-\frac{\partial f(\delta,s)}{\partial\delta}\right)</math><br>		<math>\frac{1}{\eta} = sG_c\max\left(-\frac{\partial f(\delta,s)}{\partial\delta}\right)</math><br>
	~~This calculation is used to verify cell sizes are sufficently small for stable calculations.~~		None of the current laws need <tt>s</tt> to find <math>\eta</math>. If that ever changes for a future softening law, this method will change to include <tt>s</tt> as an argument.
	~~</li>~~

	~~<li><tt>double MySofteningLaw::GetEtaStability(void) const</tt><br>~~
	~~Return dimensionless stability factor, <math>\eta</math> <ref name="dmref"/>. It is given by <tt>sG<sub>c</sub>GetMaxSlope(s)</tt>, but the scaling factor <tt>s</tt> is not provided as a parameter.~~ None of the current laws need <tt>s</tt> to find <math>\eta</math>. If that ever changes for a future softening law, this method will change to include <tt>s</tt> as an argument.
	</li>		</li>

Nairnj: /* Introduction */

2021-07-08T21:59:33Z

Introduction

← Older revision		Revision as of 21:59, 8 July 2021
Line 2:		Line 2:
	== Introduction ==		== Introduction ==

	[[Softening Laws]] are used to implement damage mechanics in [[Material_Models#Softening_Materials\|softening materials]]. This documentation ~~hows~~ to write code for user-defined softening laws.		[[Softening Laws]] are used to implement damage mechanics in [[Material_Models#Softening_Materials\|softening materials]]. This documentation explains how to write code for user-defined softening laws.

	== Softening Law Definition ==		== Softening Law Definition ==