vectorField.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 VECTOR_FIELD_H_INCLUDED
#define VECTOR_FIELD_H_INCLUDED

#include "quantumField.h"

namespace mty {

class FieldStrength;
class Model;

class BaseVectorBoson: public QuantumFieldParent {

    public: 

    BaseVectorBoson() = default;

    BaseVectorBoson(BaseVectorBoson const& other) = default;

    BaseVectorBoson(const std::string& t_name,
                    Gauge*             t_gauge);

    BaseVectorBoson(const std::string& t_name,
                    mty::Model       & model);

    BaseVectorBoson(const std::string& t_name,
                    const GaugeIrrep&  irrep);

    BaseVectorBoson(const std::string& t_name,
                    Gauge*             t_gauge,
                    bool               t_isSelfConjugate);

    BaseVectorBoson(const std::string& t_name,
                    const GaugeIrrep&  irrep,
                    bool               t_isSelfConjugate);

    BaseVectorBoson(const std::string& t_name,
                    const GaugeIrrep&  irrep,
                    const FlavorIrrep& flavorRep);

    BaseVectorBoson(const std::string& t_name,
                    const BaseVectorBoson* other);

    csl::Expr getEnergyDimension() const override;

    int getNDegreesOfFreedom() const override;

    csl::Expr getKineticTerm(csl::Tensor & X) override;
};

class VectorBoson: public BaseVectorBoson {

    protected:

    mty::gauge::Choice choice;

    std::shared_ptr<GoldstoneBoson> goldstone;
    std::shared_ptr<GhostBoson>   ghost;
    std::shared_ptr<GhostBoson>   ghost_c;
    std::shared_ptr<FieldStrength> fieldStrength;

    public:

    template<class ...Args>
    inline VectorBoson(Args&& ...args);

    void setName(std::string t_name) override;

    bool isSameSpecies(QuantumFieldParent const *other) const override;

    bool contains(QuantumFieldParent const *other) const override {
        return isSameSpecies(other);
    }

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

    ParticleType getParticleType() const override {
        return ParticleType::VectorBoson;
    }

    Particle generateSimilar(std::string const& t_name) const override;

    bool hasFieldStrength() const override;

    Particle getFieldStrength() const override;

    csl::Expr getXiGauge() const override;

    mty::gauge::Choice getGaugeChoice() const override;

    Particle getGhostBoson() const override;

    Particle getConjugatedGhostBoson() const override;

    Particle getGoldstone() const override;

    void setGoldstoneBoson(Particle const& goldstone) override;

    void setGhostBoson(Particle const& ghost) override;

    void setConjugatedGhostBoson(Particle const& ghost) override;

    void setGaugeChoice(gauge::Type type) override;

    void setFieldStrength(Particle const& fieldStrength) override;

    void setBrokenParts(
        const csl::Space*            broken,
        const std::vector<Particle>& parts) override;

    csl::Expr operator()(std::vector<csl::Index> indices,
                    const csl::Tensor&     t_point) override;

    void breakParticle(
            mty::Group                     *brokenGroup,
            std::vector<std::string> const &newNames
            ) override;
    void breakParticle(
            mty::FlavorGroup                     *brokenFlavor,
            std::vector<mty::FlavorGroup*> const &subGroups,
            std::vector<std::string>       const &names
            ) override;


    protected:

    void initPropagator() override;

    void updateBrokenFieldStrength(csl::Space const *space);
    void updateBrokenGhost(
            csl::Space const *space, 
            std::shared_ptr<GhostBoson> const &local_ghost
            );
    void updateBrokenGoldstone(csl::Space const *space);
};

class GoldstoneBoson;
class GhostBoson;
class GaugeBoson: public VectorBoson {

    private:

    GaugedGroup* gaugedGroup;

    public:

    GaugeBoson(std::string const& t_name,
               GaugeIrrep  const& irrep,
               GaugedGroup* group);

    GaugeBoson(const std::string& t_name,
               GaugeBoson const* other);

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

    GaugedGroup const* getGaugedGroup() const override;

    GaugedGroup* getGaugedGroup() override;

    Particle generateSimilar(std::string const& t_name) const override;

    bool isGaugeBoson() const override;
};

class FieldStrength: public BaseVectorBoson {

    private:

    VectorBoson* vectorParent;

    public:

    FieldStrength(VectorBoson* t_vectorParent);

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

    bool isSameSpecies(QuantumFieldParent const *other) const override {
        return this == other 
            || vectorParent == other;
    }

    ParticleType getParticleType() const override {
        return ParticleType::FieldStrength;
    }

    VectorBoson* getVectorParent() const;

    Particle generateSimilar(std::string const& t_name) const override;

    csl::Expr getEnergyDimension() const override;
};

template<class ...Args>
inline VectorBoson::VectorBoson(Args&& ...args)
    :BaseVectorBoson(std::forward<Args>(args)...)
{
    choice.setName("xi_" + getName());
    fieldStrength = csl::make_shared<FieldStrength>(this);
    addRelative(fieldStrength);
    initPropagator();
}

template<class ...Args>
inline Particle vectorboson_s(Args&& ...args)
{
    return csl::make_shared<VectorBoson>(std::forward<Args>(args)...);
}

template<class ...Args>
inline Particle gaugeboson_s(Args&& ...args)
{
    return csl::make_shared<GaugeBoson>(std::forward<Args>(args)...);
}

template<class ...Args>
inline Particle fieldstrength_s(Args&& ...args)
{
    return csl::make_shared<FieldStrength>(std::forward<Args>(args)...);
}


}


#endif