space.h

Go to the documentation of this file.

// This file is part of MARTY.
// 
// MARTY is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// MARTY is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef SPACE_H_INCLUDED
#define SPACE_H_INCLUDED

#include "literal.h"
#include "numerical.h"
#include "indicial.h"
#include "vector.h"

namespace csl {

template<typename T, typename G>
typename std::vector<std::pair<T,G>>::iterator findFirstInPair(
        std::vector<std::pair<T,G>>& v, const T& element)
{
    typename std::vector<std::pair<T,G>>::iterator 
        iter = v.begin();
    while (iter != v.end() and (*iter).first != element)
        ++iter;

    return iter;
}

template<typename T, typename G>
typename std::vector<std::pair<T,G>>::iterator findSecondInPair(
        std::vector<std::pair<T,G>>& v, const G& element)
{
    typename std::vector<std::pair<T,G>>::iterator 
        iter = v.begin();
    while (iter != v.end() and (*iter).second != element)
        ++iter;

    return iter;
}


class Space{

    public:

    mutable bool keepCycles = false;

    static bool applyMetric;

    protected:

    std::string name;

    int dim;

    bool signedIndex;

    protected:

    mutable
    std::map<char, std::string> nameIndices;

    mutable
    std::map<std::string, char> specIndices;

    mutable
    std::vector<std::pair<std::string, Index::ID_type>> availableIndices;

    mutable
    std::vector<std::pair<std::string, unsigned short>> availableVectors;

    mutable
    std::vector<std::string>::const_iterator defaultName;

    std::vector<std::string> defaultIndexNames;

    mutable
    Tensor delta;

    mutable
    Tensor metric;

    mutable
    Tensor inverseMetric;

    mutable
    Tensor epsilon;

    public:

    Space(const std::string& t_name,
          int t_dim,
          std::vector<std::string> const& indexNames
                = {"i", "j", "k", "l"});

    Space(const std::string& t_name,
          int                t_dim,
          const std::string& name_metric,
          const Expr&        t_metric,
          std::vector<std::string> const& indexNames
                = {"i", "j", "k", "l"});

    virtual ~Space();

    virtual
    void printCode(
            std::ostream &out,
            int           indentSize
            ) const;

    virtual
    void printDefinition(
            std::ostream &out,
            int           indentSize,
            bool          header = false
            ) const;

    virtual std::string getName() const;

    inline std::string getNextIndexName() const;

    inline std::string getIndexName(char spec) const;

    inline std::string_view getIndexNameView(char spec) const;

    inline char getSpecFromIndexName(std::string const& t_name) const;

    inline int getDim() const;

    inline bool getSignedIndex() const;

    virtual
    bool hasSpecialTraceProperty(const csl::vector_expr& tensors) const;

    csl::vector_expr getSignature() const;

    Tensor getMetric() const;

    Tensor getInverseMetric() const;

    Tensor getDelta() const;

    Tensor getEpsilon() const;

    Expr applyMetricOnTensor(Expr const&  tensor,
                             size_t       axis,
                             bool         covariant) const;

    inline Index generateIndex(const std::string& name) const;

    inline Index generateIndex() const;

    inline std::vector<Index> generateIndices(size_t N) const;
    inline std::vector<Index> generateIndices(
            size_t             N,
            const std::string& name
            ) const;

    inline Index generateSimilar(const Index& model) const;

    inline void resetIndexNumber() const;

    inline void refreshIndexName(Index& index) const;

    Expr generateVector(const std::string& t_name) const;

    std::string generateVectorName(const std::string& t_name) const;

    void addIndexNames(const std::string& name) const;

    void addVectorNames(const std::string& name) const;

    void addIndexNames(const std::vector<std::string>& names) const;

    void addVectorNames(const std::vector<std::string>& names) const;

    virtual
    Expr calculateTrace(csl::vector_expr tensors) const;

    private:

    void buildEpsilon();

    inline Index::ID_type getID(std::string_view name) const;

    std::string getProperVectorName(const std::string& initialName) const;
};

std::string Space::getIndexName(char spec) const
{
    return nameIndices[spec];
}

std::string_view Space::getIndexNameView(char spec) const
{
    return nameIndices[spec];
}

char Space::getSpecFromIndexName(std::string const& t_name) const
{
    if (specIndices.find(t_name) == specIndices.end()) {
        constexpr char maxChar = std::numeric_limits<char>::max();
        char c = 1;
        while (true) {
            if (nameIndices.find(c) == nameIndices.end()) {
                nameIndices[c] = t_name;
                specIndices[t_name] = c;
                return c;
            }
            if (c == maxChar)
                break;
            ++c;
        }
    }
    return specIndices[t_name];
}

int Space::getDim() const
{
    return dim;
}

bool Space::getSignedIndex() const
{
    return signedIndex;
}

void Space::resetIndexNumber() const
{
    availableIndices.clear();
    defaultName = defaultIndexNames.begin();
}

void Space::refreshIndexName(Index& index) const
{
    index.setID(getID(index.getName()));
}

Index::ID_type Space::getID(std::string_view t_name) const 
{
    for (size_t i = 0; i != availableIndices.size(); ++i)
        if (availableIndices[i].first == t_name) {
            return ++availableIndices[i].second;
        }
    availableIndices.push_back(make_pair(std::string(t_name), 0));
    return 0;
}

Index Space::generateSimilar(const Index& model) const {
    Index newIndex = model;
    refreshIndexName(newIndex);
    return newIndex;
}

Index Space::generateIndex(const std::string& t_name) const {
    return Index(t_name,this,getID(t_name));
}

std::string Space::getNextIndexName() const
{
    auto iter = defaultName;
    ++defaultName;
    if (defaultName == defaultIndexNames.end())
        defaultName = defaultIndexNames.begin();
    return *iter;
}

Index Space::generateIndex() const {
    return generateIndex(getNextIndexName());
}

std::vector<Index> Space::generateIndices(size_t N) const
{
    std::vector<Index> indices(N);
    for (size_t i = 0; i != N; ++i) 
        indices[i] = generateIndex();

    return indices;
}

std::vector<Index> Space::generateIndices(
        size_t N,
        const std::string& name
        ) const
{
    std::vector<Index> indices(N);
    for (size_t i = 0; i != N; ++i) 
        indices[i] = generateIndex(name);

    return indices;
}

inline Expr DMinko = csl::constant_s("D", csl::int_s(4));

inline const Space& buildMinkowski()
{
    static const Space Minkowski(
                "Minko",
                4,
                "g",
                matrix_s({{CSL_1,CSL_0,CSL_0,CSL_0},
                          {CSL_0,CSL_M_1,CSL_0,CSL_0},
                          {CSL_0,CSL_0,CSL_M_1,CSL_0},
                          {CSL_0,CSL_0,CSL_0,CSL_M_1}}),
                {"\\mu", "\\nu", "\\rho", "\\sigma", "\\lambda", "\\tau"});
    Minkowski.getDelta()->setTrace(DMinko);
    Minkowski.getMetric()->setTrace(DMinko);
    return Minkowski;
}


void fillEpsilonTensor(Expr& tensor,
                       int   dim);

inline const Space Euclid_R2("R2", 2);

inline const Space Euclid_R3("R3", 3);

inline const Space Euclid_R4("R4", 4);

inline const Space &Minkowski = buildMinkowski();

} // End of namespace csl

#endif