Material law describing a non viscous fluid.

Stresses are computed with

$$ \sigma_{ij} = s_{ij} + p\delta_{ij} $$

with $ s_{ij} = 0 $ in a non viscous fluid.

The equation which associates pressure and volume is

$$ dp = K \frac{dV}{V} $$

where $K$ is the bulk modulus.

Norton-Hoff law describing a viscous fluid.

Stresses are computed with $$ \sigma_{ij} = s_{ij} + p \delta_{ij} $$

where $p$ is the hydrostatic pressure and $ s_{ij} $ the stress deviator tensor.

The stress deviator tensor ($ s_{ij} $) is determined upon the strain rate deviator tensor ($ D_{ij} $) through the following equation

$$ s_{ij} = 2 \mu D_{ij} \left( \sqrt{3} \ \sqrt{\frac{2}{3} D_{wz}.D_{wz}} \right)^{m-1}$$

Hydrostatic pressure is computed upon volume variation through the following eqation

$$ dp = K \frac{dV}{V} $$

where $K$ is the bulk modulus and $V$ the volume.

This law is identical to NortonHoffHypoMaterial but it can account for the variation of the bulk modulus and the viscosity parameter with the hydrostatic pressure $p$.

As mentionned above, the bulk modulus dependance with pressure must be linear.

$$ K(p) = K_0 + \frac{dK}{dp} p $$

Therefore two parameters must be provided by the user: the bulk modulus at atmospheric pressure and the derivative $\frac{dK}{dp}$

The function $K(p)$ is provided by the user through a PythonDirectorOneParameterFunction:

class MyBulkFunction(PythonDirectorOneParameterFunction):
    def __init__(self,_p):
        PythonDirectorOneParameterFunction.__init__(self)
        self.debugRefs()
        self.p      = _p

    def __del__(self):
        print "MyBulkFunction : __del__ begin\n"
        print "callToDestructor of MyBulkFunction not allowed."
        print "Add MyBulkFunction.__disown__()"
        exit(1)

    def evaluate(self, pres):
        if pres>=0.0: # pression positive en traction !
            return self.p['k0']
        else :       # pression négative en compression !
            return self.p['k0']+self.p['dkdp']*pres

    def computeDerivation(self, pres):
        if pres>=0.0:
            return 0.0
        else :
            return self.p['dkdp']

The user has more freedom for the viscosity evolution with pressure. The viscosity variation and its derivative have to be provided trough a class similar to the one below

class MyViscoPFunction(PythonDirectorOneParameterFunction):
    def __init__(self,_p):
        print "MyViscoPFunction : __init__"
        PythonDirectorOneParameterFunction.__init__(self)
        self.debugRefs()
        self.p      = _p
        print "MyViscoPFunction : __init__ finished"
    def __del__(self):
        print "MyViscoPFunction : __del__ \n"
        print "callToDestructor of MyViscoPFunction not allowed. Add MyViscoPFunction.__disown__()"
        exit(1)
    def evaluate(self,pres):
        if pres>0.0: # pression positive en traction !
            return self.p['mu0']
        else :       # pression négative en compression !
            return self.p['mu0']*math.exp(-self.p['alpha']*pres)

    def computeDerivation(self,pres):
        if pres>0.0:
            return 0.0
        else :
            return -self.p['mu0']*self.p['alpha']*math.exp(-self.p['alpha']*pres)

The instances of MyBulkFunction and MyViscoPFunction are passed to the Norton-Hoff material law through the commands below

    bulkLaw  = MyBulkFunction(p)   # <-- p stands 
    viscoLaw = MyViscoPFunction(p) # <-  "     "
    # for parameters dictionnary and not pressure
    
    materset = domain.getMaterialSet()
    materset.define(1,NortonHoffPHypoMaterial)
    materset(1).put   (BULK_MODULUS ,  1.0)
    materset(1).depend(BULK_MODULUS ,  bulkLaw  , Field(IF_P))
    materset(1).put   (NORTON_MU    ,  1.0)
    materset(1).depend(NORTON_MU    ,  viscoLaw , Field(IF_P))
    materset(1).put   (NORTON_M     ,  1.0      )
    materset(1).put   (MASS_DENSITY ,  p['rho'] )    

Norton-Hoff law including thermal aspects.