Gradient-enhanced models interface

[srosenbu]

We (or I) need an interface for gradient-enhanced models. I did some calculations, and I think it does not matter so much if we do gradient-plasticity or gradient damage. In the end, we have a local variable $\alpha$ and its nonlocal counterpart $\bar\alpha$ which is the solution of the PDE

$$ l^{2}\nabla^{2}\bar{\alpha}+\alpha-\bar{\alpha}=0. $$

For quasi-static calculations, we then need the tangents

$$ \frac{\partial\sigma}{\partial\varepsilon},\quad \frac{\partial\sigma}{\partial\bar\alpha}, \quad \frac{\partial\alpha}{\partial\varepsilon},\quad \frac{\partial\alpha}{\partial\bar\alpha}. $$

For dynamic simulations, the underlying PDE is

$$ l^{2}\nabla^{2}\bar{\alpha}+\alpha-\bar{\alpha}-\gamma\dot{\bar{\alpha}}=\zeta\ddot{\bar{\alpha}}. $$

for which we do not need any of these tangents if we use an explicit solver.

The proposed interface should therefore have the tangents as optional parameters:

class IncrSmallStrainNonlocalModel(ABC):
    """
    Interface for incremental small strain models.
    """

    @abstractmethod
    def evaluate(
        self,
        t: float,
        del_t: float,
        grad_del_u: np.ndarray,
        nonlocal_quantity: np.ndarray, #NEW parameter
        stress: np.ndarray,
        local_quantity: np.ndarray, #NEW parameter
        dsigma_deps: np.ndarray | None, #NEW parameter
        dsigma_dnonlocal: np.ndarray | None, #NEW parameter
        dlocal_deps: np.ndarray | None, #NEW parameter
        dlocal_dnonlocal: np.ndarray | None, #NEW parameter
        history: dict[str, np.ndarray] | None,
    ) -> None:

Or as a tuple

class IncrSmallStrainNonlocalModel(ABC):
    """
    Interface for incremental small strain models.
    """

    @abstractmethod
    def evaluate(
        self,
        t: float,
        del_t: float,
        grad_del_u: np.ndarray,
        nonlocal_quantity: np.ndarray, #NEW parameter
        stress: np.ndarray,
        local_quantity: np.ndarray, #NEW parameter
        tangents: tuple[np.ndarray] | None, #NEW parameter
        history: dict[str, np.ndarray] | None,
    ) -> None:

The first design could be annoying because we only want to handle the case where all tangents are either something or none. In the second approach, it is not obvious from the interface alone what the input for tangents is, but it should be somewhat easier to handle the two cases.

Another option could be a named tuple or a dataclass as input for the model

@dataclass
class NonlocalTangents:
    dsigma_deps: np.ndarray
    dsigma_dnonlocal: np.ndarray
    dlocal_deps: np.ndarray
    dlocal_dnonlocal: np.ndarray

class IncrSmallStrainNonlocalModel(ABC):
    """
    Interface for incremental small strain models.
    """

    @abstractmethod
    def evaluate(
        self,
        t: float,
        del_t: float,
        grad_del_u: np.ndarray,
        nonlocal_quantity: np.ndarray, #NEW parameter
        stress: np.ndarray,
        local_quantity: np.ndarray, #NEW parameter
        tangents: NonlocalTangents | None, #NEW parameter
        history: dict[str, np.ndarray] | None,
    ) -> None:

[joergfunger]

why do you need the local quantity as additional input? And don't you need not only a stress component with the tangents, but for the second PDE the equivalent to compute the residual in that nonlocal pde? Or is that not to be done on the constitutive level?

[srosenbu]

In some form, the solver will need an array of the local quantity. So this can either be an element of the history, or an additional input which is overwritten. I prefer the first option, because otherwise, the model interface would also need to provide a key under which the local quantity is stored in the history. Also, if it is a parameter that is needed in all nonlocal models, i want to make that explicit in the interface. It is also not my intention to replace the old interface for local models.

I am also not sure that I understand your second question. The derivatives that I listed are derived from the weak form of the quasi-static case when I assume that the local quantity and the stress are functions of the strain increment and of the nonlocal quantity. For Gradient-Damage, the local quantity is only a function of the strain, but for plasticity, the nonlocal quantity also determines the yield stress and therefore the amount of accumulated plastic strain is dependent on it. All the tangents can then be derived from the Newton iteration matrix on the constitutive level. (I can show you the theory document if you want to see for yourself)

[joergfunger]

I think most questions are answered, in IMO I'm fine with any of the options

[srosenbu]

I also did some short calculations yesterday to see, if it is easy to include decreasing interactions as in the Poh paper. If we want to do this, then we need gradients of the function $g(\omega)$ which decreases with damage. This means that we need the damage to be evaluated on the nodes in addition to the quadrature points. We could require an additional method evaluate_damage that takes the nonlocal quantity and evaluates the damage on the nodes. We would probably also need some derivatives of $g$, but I would deal with that when we actually need it. For now, I would only implement the version without decreasing interactions.

[joergfunger]

why would you need damage at the nodes, you have the nonlocal strain that is used to compute damage, so if you provide that, you should be fine?

[srosenbu]

I have $\nabla g(\omega(\bar\alpha))$ in the weak form. I can only evaluate this if the values are on the nodes because I cannot calculate a gradient on a quadrature space.

Edit: Juist to clarify again: I don't have this problem with the normal gradient-enahncement case, therefore, I would focus on that first

[joergfunger]

but if you have the nonlocal alpha on the nodes, you can interpolate the nonlocal alpha and then compute from that the damage and then compute the gradient of that

[srosenbu]

Yes. But then I can't just hide the damage calculation inside the constitutive model which normally takes values on the quadrature points and returns values on the quadrature points. The constitutive model would need to "tell" the solver how to calculate damage in the weak form or alternatively provide a function that does the calculation on the nodes.

If we consider the damage to only be a function of the nonlocal quantity and not depend on any quadrature value, we could however say that damage is never calculated in the evaluate method, but that it is another parameter that is passed to the interface. But maybe we can discuss this sometime in person. I would like to focus on first bringing the normal gradient-enhancement into the package.