Source code for Muscat.FE.KR.KRBase

# -*- coding: utf-8 -*-
#
# This file is subject to the terms and conditions defined in
# file 'LICENSE.txt', which is part of this source code package.
#

import numpy as np


from Muscat.LinAlg.ConstraintsHolder import ConstraintsHolder
from Muscat.LinAlg.Transform import Transform


class KRBase:
    def __init__(self):
        super().__init__()
        self.args = []
        self.on = []

    def AddArg(self, name):
        self.args.append(name)
        return self

    def On(self, zone):
        if type(zone) is list:
            self.on.extend(zone)
        else:
            self.on.append(zone)
        self.on = list(set(self.on))
        return self

    def _GetConstraintHolder(self, CH):
        if CH is None:
            return ConstraintsHolder()
        return CH

    def _ComputeOffsets(self, fields):

        totalNumberOfDofsI = 0
        offsets = []
        fieldOffsets = {}

        for field in fields:
            offsets.append(totalNumberOfDofsI)
            fieldOffsets[field.name] = totalNumberOfDofsI
            totalNumberOfDofsI += field.numbering["size"]

        return offsets, fieldOffsets, totalNumberOfDofsI


class KRBaseScalar(KRBase):
    def __init__(self):
        super().__init__()
        self.value = lambda x: 0.0

    def SetFunction(self, func):
        self.value = func
        return self

    def SetValue(self, val):
        self.SetFunction(lambda x: val)
        return self


class KRBaseVector(KRBase):
    def __init__(self):
        super().__init__()
        self.blockDirections = [False, False, False]
        self.constraintDirections = "Target"  # ["Global","Local","Origin","Target"]

        self.originSystem = Transform()
        self.targetSystem = Transform()

    def Block(self, directions, val=True):
        self.blockDirections[directions] = val
        return self

    def BlockDirection0(self, val=True):
        self.blockDirections[0] = val
        return self

    def BlockDirection1(self, val=True):
        self.blockDirections[1] = val
        return self

    def BlockDirection2(self, val=True):
        self.blockDirections[2] = val
        return self

    def Fix(self, directions, val=True):
        """This function will be deprecated please use Block"""
        return self.Block(directions, val=val)

    def Fix0(self, val=True):
        """This function will be deprecated please use BlockDirection0"""
        return self.BlockDirection0(val=val)

    def Fix1(self, val=True):
        """This function will be deprecated please use BlockDirection1"""
        return self.BlockDirection1(val=val)

    def Fix2(self, val=True):
        """This function will be deprecated please use BlockDirection2"""
        return self.BlockDirection2(val=val)

    def GetConstrainedDirections(self, pos=None, direction=None):
        res = []

        for x, y in zip([0, 1, 2], self.blockDirections):
            if y:
                res.append(self.GetDirections(x, pos, direction))
        return res

    def GetDirections(self, i, pos=None, direction=None):
        if self.constraintDirections == "Global":
            res = np.zeros(3)
            res[i] = 1
            return res
        elif self.constraintDirections == "Origin":
            return self.originSystem.GetOrthoNormalBase().GetDirection(i, pos, direction)
        elif self.constraintDirections == "Target":
            return self.targetSystem.GetOrthoNormalBase().GetDirection(i, pos, direction)
        elif self.constraintDirections == "Local":
            if i == 0:
                return direction / np.linalg.norm(direction)
            # Create a local base based on the direction vector
            # need a second vector to generate a consistent base(???)

            raise ValueError("Error! 'Local' constraintDirections not well formed ")  # pragma: no cover
        else:
            raise ValueError(f"Error! constraintDirections {self.constraintDirections} not well formed ")  # pragma: no cover


def CheckIntegrity(GUI: bool = False):

    obj = KRBaseScalar()
    obj.AddArg("u").On(["Z0", "Z1"])
    obj.SetValue(1.0)

    obj = KRBaseVector()
    obj.AddArg("u").On("Z0").Fix0().Fix1(False).Fix2(True).Block(0, True)
    for corrdSys in ["Global", "Origin", "Target"]:
        obj.constraintDirections = corrdSys
        obj.GetConstrainedDirections()

    return "ok"


if __name__ == "__main__":
    print(CheckIntegrity(GUI=True))  # pragma: no cover