parent.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 PARENT_H_INCLUDED
#define PARENT_H_INCLUDED

#include "abstract.h"

namespace csl {
class Space;
class Permutation;
class Symmetry;
class ContractionChain;
}

namespace cslParent{

    enum PrimaryType{

        Literal,
        Indicial, 
        Field, 
    };

    enum Type{

        Constant,
        Variable,
        GenericIndicial, 
        Metric, 
        Delta, 
        Epsilon,
        ScalarField, 
        TensorFieldElement, 
    };
}

namespace csl {

class AbstractParent: public std::enable_shared_from_this<AbstractParent>{

    protected:

    std::string name;

    std::string latexName;

    bool commutable;

    csl::ComplexProperty complexProp = csl::ComplexProperty::Real;

    std::vector<Equation*> props;

    public:

    AbstractParent();

    explicit AbstractParent(const std::string& t_name);

    AbstractParent(const AbstractParent& abstract) = default;

    virtual ~AbstractParent(){};

    Parent self();

    virtual bool isAnAbbreviation() const { return false; }

    std::string const &getName() const;

    std::string const &getLatexName() const;

    virtual std::string const &getBaseName() const;

    bool getCommutable() const;

    csl::ComplexProperty getComplexProp() const;

    virtual void setName(std::string t_name);

    virtual void setLatexName(const std::string& t_name);

    void setCommutable(bool t_commutable);

    virtual
    void setComplexProperty(csl::ComplexProperty t_prop);

    void addProperty(Equation* prop);

    void removeProperty(Equation* prop);

    virtual cslParent::PrimaryType getPrimaryType() const = 0;

    virtual cslParent::Type getType() const = 0;

    virtual int getDim() const;

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

    void printPropDefinition(
            std::ostream &out,
            int           indentSize,
            bool          header
            ) const;

    virtual
    void enableEvaluation();

    virtual
    void disableEvaluation();

    virtual
    void toggleEvaluation();

    virtual
    std::optional<Expr> evaluate(
            Expr_info self,
            csl::eval::mode user_mode = csl::eval::base) const;

    virtual
    Expr const &getEncapsulated() const;

    virtual
    Expr getExactEncapsulated(Expr_info self) const;

    virtual
    void setEncapsulated(Expr const &);

    virtual int getDim(const Space* t_space) const;

    virtual std::vector<const Space*> getSpace() const;

    virtual const Space* getFieldSpace() const;

    virtual void setFieldSpace(const Space* t_space);

    virtual bool getFullySymmetric() const;

    virtual bool getFullyAntiSymmetric() const;
    
    virtual std::vector<Permutation> getPermutation() const;

    virtual bool isValued() const;

    virtual Expr getTensor() const;

    virtual Expr getTensor(Expr_info expr) const;

    virtual Expr getTrace() const;

    virtual  bool dependsOn(Expr_info expr) const;

    virtual bool dependsExplicitlyOn(Expr_info expr) const;

    virtual const std::vector<Equation*>& getProperties() const;

    virtual void addSpace(const Space* t_space);

    virtual void setFullySymmetric();

    virtual void setFullyAntiSymmetric();

    virtual bool isTraceLessIn(csl::Space const* space) const;
    virtual void addTraceLessNess(csl::Space const* space);
    virtual void removeTraceLessNess(csl::Space const* space);

    virtual void addSymmetry(int i1, int i2);

    virtual void addAntiSymmetry(int i1, int i2);

    virtual void setSymmetry(const Symmetry& t_symmetry);

    virtual void setTensor(const Expr& t_tensor);

    virtual void setTrace(const Expr& t_trace);

    virtual bool hasContractionProperty(const Abstract* self,
                                        Expr_info B) const;

    virtual Expr contraction(const Abstract* self, Expr_info B) const;

    virtual bool hasChainContractionProperty() const;

    virtual std::vector<ContractionChain>
        getContractionProperties() const;

    virtual void addContractionProperty(
            csl::vector_expr const& leftHandSide,
            const Expr&              rightHandSide);

    virtual void removeContractionProperty(
            csl::vector_expr const& leftHandSide,
            const Expr&              rightHandSide);

    virtual void addSelfContraction(
            const Expr& A,
            const Expr& B,
            const Expr& res,
            std::optional<std::function<bool(Expr_info, Expr_info)>>
                condition = std::nullopt);

    virtual void removeSelfContraction(
            const Expr& A,
            const Expr& B
            );

    virtual std::optional<Expr> getComplexProperty(
            Expr_info self
            ) const;

    virtual std::optional<Expr> getHermitianProperty(
            Expr_info  self,
            const Space* space
            ) const;

    virtual std::optional<Expr> getTransposedProperty(
            Expr_info self,
            const Space* space
            ) const;

    virtual void addComplexProperty(const Expr& init,
                                    const Expr& res);

    virtual void addHermitianProperty(const Space* space,
                                      const Expr& init,
                                      const Expr&  res);

    virtual void addTransposedProperty(const Space* space,
                                       const Expr& init,
                                       const Expr&  res);

    virtual
    std::vector<Parent> getBrokenParts(const Space* broken) const;
    
    virtual
    std::vector<Parent> breakSpace(
            const Space*                     broken,
            const std::vector<const Space*>& newSpace,
            const std::vector<size_t>&       pieces
            ) const;

    virtual Expr operator()(Index index);

    virtual Expr operator()(const Tensor& point);

    virtual Expr operator()(std::vector<Index> indices);

    virtual Expr operator()(const std::vector<int>& indices);

    virtual Expr operator()(Index          index,
                            const Tensor& point);

    virtual Expr operator()(std::vector<Index> indices,
                            const Tensor&     point);

    virtual Expr operator()(const std::vector<int>& indices,
                            const Tensor&          point);

    friend std::ostream& operator<<(std::ostream& fout, const AbstractParent&);
};

class Parent: public std::shared_ptr<AbstractParent> {

    public:

    INHERIT_SHARED_PTR_CONSTRUCTOR(Parent, AbstractParent)

    template<class ...Args>
        inline
        Expr operator()(Args&& ...args)
        {
            return (**this)(args...);
        }

    template<class ...Args>
        inline
        Expr operator()(std::vector<Index> indices, Args&& ...args)
        {
            return (**this)(indices, args...);
        }

};


} // End of namespace csl

#endif