mirror of
https://github.com/paboyle/Grid.git
synced 2024-11-10 15:55:37 +00:00
231 lines
8.1 KiB
C++
231 lines
8.1 KiB
C++
/*************************************************************************************
|
|
|
|
Grid physics library, www.github.com/paboyle/Grid
|
|
|
|
Source file: ./lib/qcd/action/gauge/GaugeImpl.h
|
|
|
|
Copyright (C) 2015
|
|
|
|
Author: paboyle <paboyle@ph.ed.ac.uk>
|
|
|
|
This program 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 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
See the full license in the file "LICENSE" in the top level distribution
|
|
directory
|
|
*************************************************************************************/
|
|
/* END LEGAL */
|
|
#ifndef GRID_QCD_GAUGE_IMPL_H
|
|
#define GRID_QCD_GAUGE_IMPL_H
|
|
|
|
namespace Grid {
|
|
namespace QCD {
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Implementation dependent gauge types
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class Gimpl> class WilsonLoops;
|
|
|
|
//
|
|
#define INHERIT_GIMPL_TYPES(GImpl) \
|
|
typedef typename GImpl::Simd Simd; \
|
|
typedef typename GImpl::LinkField GaugeLinkField; \
|
|
typedef typename GImpl::Field GaugeField; \
|
|
typedef typename GImpl::SiteField SiteGaugeField; \
|
|
typedef typename GImpl::SiteLink SiteGaugeLink;
|
|
|
|
#define INHERIT_FIELD_TYPES(Impl) \
|
|
typedef typename Impl::Field Field;
|
|
|
|
// hard codes the exponential approximation in the template
|
|
template <class S, int Nrepresentation = Nc, int Nexp = 12 > class GaugeImplTypes {
|
|
public:
|
|
typedef S Simd;
|
|
|
|
template <typename vtype>
|
|
using iImplGaugeLink = iScalar<iScalar<iMatrix<vtype, Nrepresentation>>>;
|
|
template <typename vtype>
|
|
using iImplGaugeField = iVector<iScalar<iMatrix<vtype, Nrepresentation>>, Nd>;
|
|
|
|
typedef iImplGaugeLink<Simd> SiteLink;
|
|
typedef iImplGaugeField<Simd> SiteField;
|
|
|
|
typedef Lattice<SiteLink> LinkField;
|
|
typedef Lattice<SiteField> Field;
|
|
|
|
// Move this elsewhere? FIXME
|
|
static inline void AddLink(Field &U, LinkField &W,
|
|
int mu) { // U[mu] += W
|
|
PARALLEL_FOR_LOOP
|
|
for (auto ss = 0; ss < U._grid->oSites(); ss++) {
|
|
U._odata[ss]._internal[mu] =
|
|
U._odata[ss]._internal[mu] + W._odata[ss]._internal;
|
|
}
|
|
}
|
|
|
|
// HMC auxiliary functions
|
|
static inline void generate_momenta(Field& P, GridParallelRNG& pRNG){
|
|
// specific for SU gauge fields
|
|
LinkField Pmu(P._grid);
|
|
Pmu = zero;
|
|
for (int mu = 0; mu < Nd; mu++) {
|
|
SU<Nrepresentation>::GaussianFundamentalLieAlgebraMatrix(pRNG, Pmu);
|
|
PokeIndex<LorentzIndex>(P, Pmu, mu);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static inline void update_field(Field& P, Field& U, double ep){
|
|
for (int mu = 0; mu < Nd; mu++) {
|
|
auto Umu = PeekIndex<LorentzIndex>(U, mu);
|
|
auto Pmu = PeekIndex<LorentzIndex>(P, mu);
|
|
Umu = expMat(Pmu, ep, Nexp) * Umu;
|
|
PokeIndex<LorentzIndex>(U, ProjectOnGroup(Umu), mu);
|
|
}
|
|
}
|
|
|
|
static inline RealD FieldSquareNorm(Field& U){
|
|
LatticeComplex Hloc(U._grid);
|
|
Hloc = zero;
|
|
for (int mu = 0; mu < Nd; mu++) {
|
|
auto Umu = PeekIndex<LorentzIndex>(U, mu);
|
|
Hloc += trace(Umu * Umu);
|
|
}
|
|
Complex Hsum = sum(Hloc);
|
|
return Hsum.real();
|
|
}
|
|
|
|
};
|
|
|
|
// Composition with smeared link, bc's etc.. probably need multiple inheritance
|
|
// Variable precision "S" and variable Nc
|
|
template <class GimplTypes> class PeriodicGaugeImpl : public GimplTypes {
|
|
public:
|
|
INHERIT_GIMPL_TYPES(GimplTypes);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Support needed for the assembly of loops including all boundary condition
|
|
// effects such as conjugate bcs
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class covariant>
|
|
static inline Lattice<covariant>
|
|
CovShiftForward(const GaugeLinkField &Link, int mu,
|
|
const Lattice<covariant> &field) {
|
|
return PeriodicBC::CovShiftForward(Link, mu, field);
|
|
}
|
|
|
|
template <class covariant>
|
|
static inline Lattice<covariant>
|
|
CovShiftBackward(const GaugeLinkField &Link, int mu,
|
|
const Lattice<covariant> &field) {
|
|
return PeriodicBC::CovShiftBackward(Link, mu, field);
|
|
}
|
|
static inline GaugeLinkField
|
|
CovShiftIdentityBackward(const GaugeLinkField &Link, int mu) {
|
|
return Cshift(adj(Link), mu, -1);
|
|
}
|
|
static inline GaugeLinkField
|
|
CovShiftIdentityForward(const GaugeLinkField &Link, int mu) {
|
|
return Link;
|
|
}
|
|
static inline GaugeLinkField ShiftStaple(const GaugeLinkField &Link, int mu) {
|
|
return Cshift(Link, mu, 1);
|
|
}
|
|
|
|
static inline bool isPeriodicGaugeField(void) { return true; }
|
|
};
|
|
|
|
// Composition with smeared link, bc's etc.. probably need multiple inheritance
|
|
// Variable precision "S" and variable Nc
|
|
template <class GimplTypes> class ConjugateGaugeImpl : public GimplTypes {
|
|
public:
|
|
INHERIT_GIMPL_TYPES(GimplTypes);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Support needed for the assembly of loops including all boundary condition
|
|
// effects such as Gparity.
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
template <class covariant>
|
|
static Lattice<covariant> CovShiftForward(const GaugeLinkField &Link, int mu,
|
|
const Lattice<covariant> &field) {
|
|
return ConjugateBC::CovShiftForward(Link, mu, field);
|
|
}
|
|
|
|
template <class covariant>
|
|
static Lattice<covariant> CovShiftBackward(const GaugeLinkField &Link, int mu,
|
|
const Lattice<covariant> &field) {
|
|
return ConjugateBC::CovShiftBackward(Link, mu, field);
|
|
}
|
|
|
|
static inline GaugeLinkField
|
|
CovShiftIdentityBackward(const GaugeLinkField &Link, int mu) {
|
|
GridBase *grid = Link._grid;
|
|
int Lmu = grid->GlobalDimensions()[mu] - 1;
|
|
|
|
Lattice<iScalar<vInteger>> coor(grid);
|
|
LatticeCoordinate(coor, mu);
|
|
|
|
GaugeLinkField tmp(grid);
|
|
tmp = adj(Link);
|
|
tmp = where(coor == Lmu, conjugate(tmp), tmp);
|
|
return Cshift(tmp, mu, -1); // moves towards positive mu
|
|
}
|
|
static inline GaugeLinkField
|
|
CovShiftIdentityForward(const GaugeLinkField &Link, int mu) {
|
|
return Link;
|
|
}
|
|
|
|
static inline GaugeLinkField ShiftStaple(const GaugeLinkField &Link, int mu) {
|
|
GridBase *grid = Link._grid;
|
|
int Lmu = grid->GlobalDimensions()[mu] - 1;
|
|
|
|
Lattice<iScalar<vInteger>> coor(grid);
|
|
LatticeCoordinate(coor, mu);
|
|
|
|
GaugeLinkField tmp(grid);
|
|
tmp = Cshift(Link, mu, 1);
|
|
tmp = where(coor == Lmu, conjugate(tmp), tmp);
|
|
return tmp;
|
|
}
|
|
|
|
static inline bool isPeriodicGaugeField(void) { return false; }
|
|
};
|
|
|
|
typedef GaugeImplTypes<vComplex, Nc> GimplTypesR;
|
|
typedef GaugeImplTypes<vComplexF, Nc> GimplTypesF;
|
|
typedef GaugeImplTypes<vComplexD, Nc> GimplTypesD;
|
|
|
|
typedef GaugeImplTypes<vComplex, SU<Nc>::AdjointDimension> GimplAdjointTypesR;
|
|
typedef GaugeImplTypes<vComplexF, SU<Nc>::AdjointDimension> GimplAdjointTypesF;
|
|
typedef GaugeImplTypes<vComplexD, SU<Nc>::AdjointDimension> GimplAdjointTypesD;
|
|
|
|
typedef PeriodicGaugeImpl<GimplTypesR> PeriodicGimplR; // Real.. whichever prec
|
|
typedef PeriodicGaugeImpl<GimplTypesF> PeriodicGimplF; // Float
|
|
typedef PeriodicGaugeImpl<GimplTypesD> PeriodicGimplD; // Double
|
|
|
|
typedef PeriodicGaugeImpl<GimplAdjointTypesR> PeriodicGimplAdjR; // Real.. whichever prec
|
|
typedef PeriodicGaugeImpl<GimplAdjointTypesF> PeriodicGimplAdjF; // Float
|
|
typedef PeriodicGaugeImpl<GimplAdjointTypesD> PeriodicGimplAdjD; // Double
|
|
|
|
typedef ConjugateGaugeImpl<GimplTypesR> ConjugateGimplR; // Real.. whichever prec
|
|
typedef ConjugateGaugeImpl<GimplTypesF> ConjugateGimplF; // Float
|
|
typedef ConjugateGaugeImpl<GimplTypesD> ConjugateGimplD; // Double
|
|
}
|
|
}
|
|
|
|
#endif
|