AntisymmetricTensor.h

Go to the documentation of this file.

#pragma once
 
 
 
#include "objects/geometry/SymmetricTensor.h"
#include "objects/containers/StaticArray.h"
 
NAMESPACE_SPH_BEGIN
 
struct PseudoVectorTag {};
 
const PseudoVectorTag PSEUDOVECTOR;
 
class AntisymmetricTensor {
private:
    Vector u;
 
public:
    AntisymmetricTensor() = default;
 
    explicit AntisymmetricTensor(const Vector& v)
        : u(v) {}
 
    explicit AntisymmetricTensor(const PseudoVectorTag, const Vector& v)
        : u(v[Z], -v[Y], v[X]) {}
 
    explicit AntisymmetricTensor(const Float v)
        : u(v) {}
 
    INLINE Vector& components() {
        return u;
    }
 
    INLINE const Vector& components() const {
        return u;
    }
 
    Vector pseudovector() const {
        return Vector(u[Z], -u[Y], u[X]);
    }
 
    INLINE Vector operator[](const Size idx) const {
        switch (idx) {
        case 0:
            return Vector(0._f, u[X], u[Y]);
        case 1:
            return Vector(-u[X], 0._f, u[Z]);
        case 2:
            return Vector(-u[Y], -u[Z], 0._f);
        default:
            STOP;
        }
    }
 
    INLINE Float operator()(const Size i, const Size j) const {
        if (i == j) {
            return 0._f;
        } else if (i < j) {
            return u[i + j - 1];
        } else {
            return -u[i + j - 1];
        }
    }
 
    INLINE static AntisymmetricTensor null() {
        return AntisymmetricTensor(Vector(0._f));
    }
 
    INLINE AntisymmetricTensor operator+=(const AntisymmetricTensor& other) {
        u += other.u;
        return *this;
    }
 
    INLINE AntisymmetricTensor operator-=(const AntisymmetricTensor& other) {
        u -= other.u;
        return *this;
    }
 
    INLINE AntisymmetricTensor operator-() const {
        return AntisymmetricTensor(-u);
    }
 
    friend bool operator==(const AntisymmetricTensor& t1, const AntisymmetricTensor& t2) {
        return t1.u == t2.u;
    }
 
    friend AntisymmetricTensor operator+(const AntisymmetricTensor& t1, const AntisymmetricTensor& t2) {
        return AntisymmetricTensor(t1.u + t2.u);
    }
 
    friend AntisymmetricTensor operator-(const AntisymmetricTensor& t1, const AntisymmetricTensor& t2) {
        return AntisymmetricTensor(t1.u - t2.u);
    }
 
    friend AntisymmetricTensor operator*(const AntisymmetricTensor& t, const Float v) {
        return AntisymmetricTensor(t.u * v);
    }
 
    friend AntisymmetricTensor operator*(const Float v, const AntisymmetricTensor& t) {
        return AntisymmetricTensor(t.u * v);
    }
 
    friend AntisymmetricTensor operator/(const AntisymmetricTensor& t, const Float v) {
        return AntisymmetricTensor(t.u / v);
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const AntisymmetricTensor& t) {
        stream << std::setprecision(6) << std::setw(20) << t.u[X] << std::setw(20) << t.u[Y] << std::setw(20)
               << t.u[Z];
        return stream;
    }
};
 
INLINE AntisymmetricTensor antisymmetricOuter(const Vector& v1, const Vector& v2) {
    return AntisymmetricTensor(
        0.5_f *
        Vector(v1[X] * v2[Y] - v1[Y] * v2[X], v1[X] * v2[Z] - v1[Z] * v2[X], v1[Y] * v2[Z] - v1[Z] * v2[Y]));
}
 
 
INLINE bool almostEqual(const AntisymmetricTensor& t1, const AntisymmetricTensor& t2, const Float eps = EPS) {
    return almostEqual(t1.components(), t2.components(), eps);
}
 
template <>
INLINE Float norm(const AntisymmetricTensor& t) {
    return norm(t.components());
}
 
template <>
INLINE Float normSqr(const AntisymmetricTensor& t) {
    return normSqr(t.components());
}
 
template <>
INLINE auto abs(const AntisymmetricTensor& t) {
    return SymmetricTensor(Vector(0._f), abs(t.components()));
}
 
template <>
INLINE Float minElement(const AntisymmetricTensor& t) {
    return min(minElement(t.components()), minElement(-t.components()));
}
 
template <>
INLINE AntisymmetricTensor min(const AntisymmetricTensor& t1, const AntisymmetricTensor& t2) {
    return AntisymmetricTensor(min(t1.components(), t2.components()));
}
 
template <>
INLINE AntisymmetricTensor max(const AntisymmetricTensor& t1, const AntisymmetricTensor& t2) {
    return AntisymmetricTensor(max(t1.components(), t2.components()));
}
 
template <>
INLINE AntisymmetricTensor clamp(const AntisymmetricTensor& t, const Interval& range) {
    SPH_ASSERT(range.contains(0._f));
    const Float upper = max(-range.lower(), range.upper());
    return AntisymmetricTensor(clamp(t.components(), Interval(-upper, upper)));
}
 
template <>
INLINE bool isReal(const AntisymmetricTensor& t) {
    return isReal(t.components());
}
 
template <>
INLINE auto less(const AntisymmetricTensor& t1, const AntisymmetricTensor& t2) {
    return AntisymmetricTensor(less(t1.components(), t2.components()));
}
 
INLINE Float ddot(const AntisymmetricTensor& t1, const AntisymmetricTensor& t2) {
    return 2._f * dot(t1.components(), t2.components());
}
 
 
NAMESPACE_SPH_END