BoundaryCondition.h

#ifndef OERSTED_BOUNDARYCONDITION_H
#define OERSTED_BOUNDARYCONDITION_H

#include <vector>
#include <set>
#include <algorithm>

#include <Eigen/Sparse>

#include "MatrixGroup.h"
#include "QuadratureRule.h"
#include "FiniteElementMesh.h"

// TODO: DiscreteBoundaryCondition versus ContinuousBoundaryCondition? Somehow need to apply to top level model and have that be translated to the discrete model
// TODO: Boundary conditions should represent simple containers that know how to perform actions on matrices, parsing of boundaries to extract nodes should take place at a higher level

class BoundaryCondition {
public:
    virtual ~BoundaryCondition(){};

    virtual void apply(std::vector<Eigen::Triplet<double>> &triplets) const = 0;
    virtual void reduce(std::set<size_t,std::greater<size_t>> &index) const = 0;
};

template<size_t Dimension, size_t ElementOrder, size_t QuadratureOrder>
class ZeroDirichlet : public BoundaryCondition{};

template<size_t ElementOrder, size_t QuadratureOrder>
class ZeroDirichlet<2,ElementOrder,QuadratureOrder> : public BoundaryCondition {
public:
    ZeroDirichlet(std::vector<std::shared_ptr<Boundary<2>>> boundaries) : Boundaries{boundaries} {};

    void apply(std::vector<Eigen::Triplet<double>> &triplets) const override {};

    void reduce(std::set<size_t,std::greater<size_t>> &index) const override {
        for (auto const& b : Boundaries) {
            for (auto const& i : b->nodes()) {
                index.insert(i);
            }
        }
    };

protected:
    std::vector<std::shared_ptr<Boundary<2>>> Boundaries;
};


template<size_t Dimension, size_t ElementOrder, size_t QuadratureOrder>
class PeriodicBoundaryCondition : public BoundaryCondition{};

template<size_t ElementOrder, size_t QuadratureOrder>
class PeriodicBoundaryCondition<2,ElementOrder,QuadratureOrder> : public BoundaryCondition {
public:
    PeriodicBoundaryCondition(std::vector<std::shared_ptr<BoundaryPair<2>>> boundary_pairs, bool antiperiodic) : BoundaryPairs{boundary_pairs}, Antiperiodic{antiperiodic} {};

    void apply(std::vector<Eigen::Triplet<double>> &triplets) const override {
        double sign{1.0 - 2.0 * Antiperiodic};

        // TODO:
        /*
        for(size_t i = 0;i!=FirstNodes.size();++i){
            triplets[FirstNodes[i]].row() = SecondNodes[i];
            triplest[FirstNodes[i]].value() = sign;
         }
         */
    }

    void reduce(std::set<size_t, std::greater<size_t>> &index) const override {
        /*
        for (auto const &bp : BoundaryPairs) {
            for(auto const &ij : bp->nodes()) {
                index.insert(ij.second);
            }
        }
         */
    }

protected:
    std::vector<std::shared_ptr<BoundaryPair<2>>> BoundaryPairs;

    bool Antiperiodic;
};


#endif //OERSTED_BOUNDARYCONDITION_H