Iterate.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/utility/IteratorAdapters.h"
#include "quantities/Quantity.h"
#include "quantities/Storage.h"
 
NAMESPACE_SPH_BEGIN
 
template <VisitorEnum TVisitorType>
struct StorageVisitor;
 
template <VisitorEnum TVisitorType>
struct StoragePairVisitor;
 
 
template <>
struct StorageVisitor<VisitorEnum::ALL_VALUES> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q, const QuantityId id, TFunctor&& functor) {
        functor(id, q.getValue<TValue>());
    }
};
template <>
struct StoragePairVisitor<VisitorEnum::ALL_VALUES> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q1, Quantity& q2, TFunctor&& functor) {
        functor(q1.getValue<TValue>(), q2.getValue<TValue>());
    }
};
 
template <>
struct StorageVisitor<VisitorEnum::ALL_BUFFERS> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q, const QuantityId UNUSED(id), TFunctor&& functor) {
        for (auto& i : q.getAll<TValue>()) {
            functor(i);
        }
    }
    template <typename TValue, typename TFunctor>
    void visit(const Quantity& q, const QuantityId UNUSED(id), TFunctor&& functor) {
        for (const auto& i : q.getAll<TValue>()) {
            functor(i);
        }
    }
};
template <>
struct StoragePairVisitor<VisitorEnum::ALL_BUFFERS> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q1, Quantity& q2, const QuantityId UNUSED(id), TFunctor&& functor) {
        auto values1 = q1.template getAll<TValue>();
        auto values2 = q2.template getAll<TValue>();
        SPH_ASSERT(values1.size() == values2.size());
        for (Size j = 0; j < values1.size(); ++j) {
            functor(values1[j], values2[j]);
        }
    }
};
 
 
template <>
struct StorageVisitor<VisitorEnum::ZERO_ORDER> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q, const QuantityId id, TFunctor&& functor) {
        if (q.getOrderEnum() != OrderEnum::ZERO) {
            return;
        }
        functor(id, q.getValue<TValue>());
    }
    template <typename TValue, typename TFunctor>
    void visit(const Quantity& q, const QuantityId id, TFunctor&& functor) {
        if (q.getOrderEnum() != OrderEnum::ZERO) {
            return;
        }
        functor(id, q.getValue<TValue>());
    }
};
template <>
struct StoragePairVisitor<VisitorEnum::ZERO_ORDER> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q1, Quantity& q2, const QuantityId id, TFunctor&& functor) {
        if (q1.getOrderEnum() != OrderEnum::ZERO) {
            return;
        }
        SPH_ASSERT(q2.getOrderEnum() == OrderEnum::ZERO);
        functor(id, q1.getValue<TValue>(), q2.getValue<TValue>());
    }
 
    template <typename TValue, typename TFunctor>
    void visit(const Quantity& q1, const Quantity& q2, const QuantityId id, TFunctor&& functor) {
        if (q1.getOrderEnum() != OrderEnum::ZERO) {
            return;
        }
        SPH_ASSERT(q2.getOrderEnum() == OrderEnum::ZERO);
        functor(id, q1.getValue<TValue>(), q2.getValue<TValue>());
    }
};
 
 
template <>
struct StorageVisitor<VisitorEnum::FIRST_ORDER> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q, const QuantityId id, TFunctor&& functor) {
        if (q.getOrderEnum() != OrderEnum::FIRST) {
            return;
        }
        functor(id, q.getValue<TValue>(), q.getDt<TValue>());
    }
    template <typename TValue, typename TFunctor>
    void visit(const Quantity& q, const QuantityId id, TFunctor&& functor) {
        if (q.getOrderEnum() != OrderEnum::FIRST) {
            return;
        }
        functor(id, q.getValue<TValue>(), q.getDt<TValue>());
    }
};
template <>
struct StoragePairVisitor<VisitorEnum::FIRST_ORDER> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q1, Quantity& q2, const QuantityId id, TFunctor&& functor) {
        if (q1.getOrderEnum() != OrderEnum::FIRST) {
            return;
        }
        SPH_ASSERT(q2.getOrderEnum() == OrderEnum::FIRST);
        functor(id, q1.getValue<TValue>(), q1.getDt<TValue>(), q2.getValue<TValue>(), q2.getDt<TValue>());
    }
 
    template <typename TValue, typename TFunctor>
    void visit(const Quantity& q1, const Quantity& q2, const QuantityId id, TFunctor&& functor) {
        if (q1.getOrderEnum() != OrderEnum::FIRST) {
            return;
        }
        SPH_ASSERT(q2.getOrderEnum() == OrderEnum::FIRST);
        functor(id, q1.getValue<TValue>(), q1.getDt<TValue>(), q2.getValue<TValue>(), q2.getDt<TValue>());
    }
};
 
template <>
struct StorageVisitor<VisitorEnum::SECOND_ORDER> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q, const QuantityId id, TFunctor&& functor) {
        if (q.getOrderEnum() != OrderEnum::SECOND) {
            return;
        }
        functor(id, q.getValue<TValue>(), q.getDt<TValue>(), q.getD2t<TValue>());
    }
    template <typename TValue, typename TFunctor>
    void visit(const Quantity& q, const QuantityId id, TFunctor&& functor) {
        if (q.getOrderEnum() != OrderEnum::SECOND) {
            return;
        }
        functor(id, q.getValue<TValue>(), q.getDt<TValue>(), q.getD2t<TValue>());
    }
};
template <>
struct StoragePairVisitor<VisitorEnum::SECOND_ORDER> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q1, Quantity& q2, const QuantityId id, TFunctor&& functor) {
        if (q1.getOrderEnum() != OrderEnum::SECOND) {
            return;
        }
        SPH_ASSERT(q2.getOrderEnum() == OrderEnum::SECOND);
        functor(id,
            q1.getValue<TValue>(),
            q1.getDt<TValue>(),
            q1.getD2t<TValue>(),
            q2.getValue<TValue>(),
            q2.getDt<TValue>(),
            q2.getD2t<TValue>());
    }
 
    template <typename TValue, typename TFunctor>
    void visit(const Quantity& q1, const Quantity& q2, const QuantityId id, TFunctor&& functor) {
        if (q1.getOrderEnum() != OrderEnum::SECOND) {
            return;
        }
        SPH_ASSERT(q2.getOrderEnum() == OrderEnum::SECOND);
        functor(id,
            q1.getValue<TValue>(),
            q1.getDt<TValue>(),
            q1.getD2t<TValue>(),
            q2.getValue<TValue>(),
            q2.getDt<TValue>(),
            q2.getD2t<TValue>());
    }
};
 
 
template <>
struct StorageVisitor<VisitorEnum::HIGHEST_DERIVATIVES> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q, const QuantityId id, TFunctor&& functor) {
        const OrderEnum order = q.getOrderEnum();
        if (order == OrderEnum::FIRST) {
            functor(id, q.getDt<TValue>());
        } else if (order == OrderEnum::SECOND) {
            functor(id, q.getD2t<TValue>());
        }
    }
    template <typename TValue, typename TFunctor>
    void visit(const Quantity& q, const QuantityId id, TFunctor&& functor) {
        const OrderEnum order = q.getOrderEnum();
        if (order == OrderEnum::FIRST) {
            functor(id, q.getDt<TValue>());
        } else if (order == OrderEnum::SECOND) {
            functor(id, q.getD2t<TValue>());
        }
    }
};
template <>
struct StoragePairVisitor<VisitorEnum::HIGHEST_DERIVATIVES> {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q1, Quantity& q2, TFunctor&& functor) {
        const OrderEnum order1 = q1.getOrderEnum();
        SPH_ASSERT(order1 == q2.getOrderEnum());
        if (order1 == OrderEnum::FIRST) {
            functor(q1.getDt<TValue>(), q2.getDt<TValue>());
        } else if (order1 == OrderEnum::SECOND) {
            functor(q1.getD2t<TValue>(), q2.getD2t<TValue>());
        }
    }
};
 
 
template <VisitorEnum Type, typename TFunctor>
void iterate(Storage& storage, TFunctor&& functor) {
    StorageVisitor<Type> visitor;
    for (auto q : storage.getQuantities()) {
        dispatch(q.quantity.getValueEnum(), visitor, q.quantity, q.id, std::forward<TFunctor>(functor));
    }
}
 
template <VisitorEnum Type, typename TFunctor>
void iterate(const Storage& storage, TFunctor&& functor) {
    StorageVisitor<Type> visitor;
    for (auto q : storage.getQuantities()) {
        dispatch(q.quantity.getValueEnum(), visitor, q.quantity, q.id, std::forward<TFunctor>(functor));
    }
}
 
struct StorageVisitorWithPositions {
    template <typename TValue, typename TFunctor>
    void visit(Quantity& q, Array<Vector>& r, QuantityId key, TFunctor&& functor) {
        if (key == QuantityId::POSITION) {
            // exclude positions, iterate only derivatives
            auto buffers = q.getAll<TValue>();
            // usually, there are 3 buffers (positions, velocities, accelerations), but we allow any number of
            // buffers to make it more general (and this is actually used in DiehlDistribution, for example).
            for (Size i = 1; i < buffers.size(); ++i) {
                functor(buffers[i], r);
            }
        } else {
            for (auto& i : q.getAll<TValue>()) {
                functor(i, r);
            }
        }
    }
};
 
template <typename TFunctor>
void iterateWithPositions(Storage& storage, TFunctor&& functor) {
    Array<Vector>& r = storage.getValue<Vector>(QuantityId::POSITION);
    StorageVisitorWithPositions visitor;
    for (auto q : storage.getQuantities()) {
        dispatch(q.quantity.getValueEnum(), visitor, q.quantity, r, q.id, functor);
    }
}
 
template <VisitorEnum Type, typename TFunctor>
void iteratePair(Storage& storage1, Storage& storage2, TFunctor&& functor) {
    SPH_ASSERT(storage1.getQuantityCnt() == storage2.getQuantityCnt(),
        storage1.getQuantityCnt(),
        storage2.getQuantityCnt());
    StoragePairVisitor<Type> visitor;
    struct Element {
        StorageElement e1;
        StorageElement e2;
    };
 
    for (auto i : iterateTuple<Element>(storage1.getQuantities(), storage2.getQuantities())) {
        SPH_ASSERT(i.e1.id == i.e2.id);
        Quantity& q1 = i.e1.quantity;
        Quantity& q2 = i.e2.quantity;
        SPH_ASSERT(q1.getValueEnum() == q2.getValueEnum());
        dispatch(q1.getValueEnum(), visitor, q1, q2, i.e1.id, functor);
    }
}
 
template <VisitorEnum Type, typename TFunctor>
void iteratePair(const Storage& storage1, const Storage& storage2, TFunctor&& functor) {
    SPH_ASSERT(storage1.getQuantityCnt() == storage2.getQuantityCnt(),
        storage1.getQuantityCnt(),
        storage2.getQuantityCnt());
    StoragePairVisitor<Type> visitor;
    struct Element {
        ConstStorageElement e1;
        ConstStorageElement e2;
    };
 
    for (auto i : iterateTuple<Element>(storage1.getQuantities(), storage2.getQuantities())) {
        SPH_ASSERT(i.e1.id == i.e2.id);
        const Quantity& q1 = i.e1.quantity;
        const Quantity& q2 = i.e2.quantity;
        SPH_ASSERT(q1.getValueEnum() == q2.getValueEnum());
        dispatch(q1.getValueEnum(), visitor, q1, q2, i.e1.id, functor);
    }
}
 
 
NAMESPACE_SPH_END