vertices.hpp

Go to the documentation of this file.

// ====================================================================
// This file is part of FlexibleSUSY.
//
// FlexibleSUSY 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.
//
// FlexibleSUSY 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 FlexibleSUSY.  If not, see
// <http://www.gnu.org/licenses/>.
// ====================================================================
 
 
#ifndef CXXQFT_VERTICES_H
#define CXXQFT_VERTICES_H
 
#include "multiindex.hpp"
#include "numerics2.hpp"
 
#include "fields.hpp"
 
#include <array>
#include <algorithm>
 
#include <boost/mpl/erase.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/joint_view.hpp>
#include <boost/mpl/vector.hpp>
 
namespace flexiblesusy {
namespace cxx_diagrams {
 
   struct context_base;
 
   class ScalarVertex
   {
   private:
      std::complex<double> val;
 
   public:
      ScalarVertex(std::complex<double> v) : val(v) {}
 
      std::complex<double> value() const { return val; }
 
      bool isZero() const
      {
         return (is_zero(val.real()) && is_zero(val.imag()));
      }
   };
 
   class ChiralVertex
   {
   private:
      std::pair<std::complex<double>, std::complex<double>> value;
 
   public:
      ChiralVertex(const std::complex<double>& left,
                   const std::complex<double>& right)
         : value(left, right)
      {
      }
 
      std::complex<double> left() const { return value.first; }
      std::complex<double> right() const { return value.second; }
 
      bool isZero() const
      {
         return (is_zero(value.first.real()) && is_zero(value.first.imag()) &&
                 is_zero(value.second.real()) && is_zero(value.second.imag()));
      }
   };
 
class MomentumVertex {
  std::complex<double> val;
   int ind;
public:
   MomentumVertex(const std::complex<double>& v, int i)
      : val(v), ind(i)
   {}
 
   int index() const { return ind; }
 
   std::complex<double> value(int i) const
   {
      if (i != ind)
         throw std::invalid_argument(
            "MomentumVertex: Wrong index specified");
 
      return val;
   }
 
   bool isZero() const
   {
      return (is_zero(val.real()) && is_zero(val.imag()));
   }
};
 
class TripleVectorVertex {
public:
   struct even_permutation {};
   struct odd_permutation {};
private:
   std::complex<double> val;
   bool even;
public:
   TripleVectorVertex(const std::complex<double>& v,
                      even_permutation)
      : val(v), even(true)
   {}
 
   TripleVectorVertex(const std::complex<double>& v,
                      odd_permutation)
      : val(v), even(false)
   {}
 
   bool is_even() const { return even; }
 
   std::complex<double> value(even_permutation) const
   { return even ? val : - val; }
 
   std::complex<double> value(odd_permutation) const
   { return even ? - val : val; }
 
   bool isZero() const
   {
      return (is_zero(val.real()) && is_zero(val.imag()));
   }
};
 
class QuadrupleVectorVertex {
   std::complex<double> part1, part2, part3;
 
public:
   QuadrupleVectorVertex(const std::complex<double>& p1,
                         const std::complex<double>& p2,
                         const std::complex<double>& p3)
      : part1(p1), part2(p2), part3(p3)
   {}
 
   std::complex<double> value1() const { return part1; }
 
   std::complex<double> value2() const { return part2; }
 
   std::complex<double> value3() const { return part3; }
 
   bool isZero() const
   {
      return (is_zero(part1.real()) && is_zero(part1.imag()) &&
              is_zero(part2.real()) && is_zero(part2.imag()) &&
              is_zero(part3.real()) && is_zero(part3.imag()));
   }
};
 
class MomentumDifferenceVertex {
   std::complex<double> val;
   int minuendIndex;
   int subtrahendIndex;
public:
   MomentumDifferenceVertex(std::complex<double> v, int mi, int si)
      : val(v), minuendIndex(mi), subtrahendIndex(si) {}
 
   std::complex<double> value(int mi, int si) const
   {
      if (mi == minuendIndex && si == subtrahendIndex)
         return val;
      if (mi == subtrahendIndex && si == minuendIndex)
         return -val;
 
      throw std::invalid_argument(
         "MomentumDifferenceVertex: Wrong index combination");
      return 0.0;
   }
 
   int incoming_index() const { return minuendIndex; }
   int outgoing_index() const { return subtrahendIndex; }
 
   bool isZero() const
   {
      return (is_zero(val.real()) && is_zero(val.imag()));
   }
};
 
class InverseMetricVertex {
   std::complex<double> val;
public:
   InverseMetricVertex(std::complex<double> v) : val(v) {}
 
   std::complex<double> value() const { return val; }
 
   bool isZero() const
   {
      return (is_zero(val.real()) && is_zero(val.imag()));
   }
};
 
} // namespace cxx_diagrams
} // namespace flexiblesusy
 
#endif