// Resets the attributes of this field if param disagrees (and is defined)
void ColorSpinorField::reset(const ColorSpinorParam ¶m) {
if (param.nColor != 0) nColor = param.nColor;
if (param.nSpin != 0) nSpin = param.nSpin;
if (param.twistFlavor != QUDA_TWIST_INVALID) twistFlavor = param.twistFlavor;
if (param.precision != QUDA_INVALID_PRECISION) precision = param.precision;
if (param.nDim != 0) nDim = param.nDim;
volume = 1;
for (int d=0; d<nDim; d++) {
if (param.x[0] != 0) x[d] = param.x[d];
volume *= x[d];
}
volumeCB = siteSubset == QUDA_PARITY_SITE_SUBSET ? volume : volume/2;
if((twistFlavor == QUDA_TWIST_NONDEG_DOUBLET || twistFlavor == QUDA_TWIST_DEG_DOUBLET) && x[4] != 2) errorQuda("Must be two flavors for non-degenerate twisted mass spinor (provided with %d)\n", x[4]);
if (param.pad != 0) pad = param.pad;
if (param.siteSubset == QUDA_FULL_SITE_SUBSET){
stride = volume/2 + pad;
length = 2*stride*nColor*nSpin*2;
} else if (param.siteSubset == QUDA_PARITY_SITE_SUBSET){
stride = volume + pad;
length = stride*nColor*nSpin*2;
} else {
//errorQuda("SiteSubset not defined %d", param.siteSubset);
//do nothing, not an error (can't remember why - need to document this sometime! )
}
if (param.siteSubset != QUDA_INVALID_SITE_SUBSET) siteSubset = param.siteSubset;
if (param.siteOrder != QUDA_INVALID_SITE_ORDER) siteOrder = param.siteOrder;
if (param.fieldOrder != QUDA_INVALID_FIELD_ORDER) fieldOrder = param.fieldOrder;
if (param.gammaBasis != QUDA_INVALID_GAMMA_BASIS) gammaBasis = param.gammaBasis;
createGhostZone();
real_length = volume*nColor*nSpin*2;
bytes = total_length * precision; // includes pads and ghost zones
bytes = (siteSubset == QUDA_FULL_SITE_SUBSET) ? 2*ALIGNMENT_ADJUST(bytes/2) : ALIGNMENT_ADJUST(bytes);
if (precision == QUDA_HALF_PRECISION) {
norm_bytes = total_norm_length * sizeof(float);
norm_bytes = (siteSubset == QUDA_FULL_SITE_SUBSET) ? 2*ALIGNMENT_ADJUST(norm_bytes/2) : ALIGNMENT_ADJUST(norm_bytes);
} else {
norm_bytes = 0;
}
if (!init) errorQuda("Shouldn't be resetting a non-inited field\n");
if (getVerbosity() >= QUDA_DEBUG_VERBOSE) {
printfQuda("\nPrinting out reset field\n");
std::cout << *this << std::endl;
printfQuda("\n");
}
}
void ColorSpinorField::create(int Ndim, const int *X, int Nc, int Ns, QudaTwistFlavorType Twistflavor,
QudaPrecision Prec, int Pad, QudaSiteSubset siteSubset,
QudaSiteOrder siteOrder, QudaFieldOrder fieldOrder,
QudaGammaBasis gammaBasis) {
this->siteSubset = siteSubset;
this->siteOrder = siteOrder;
this->fieldOrder = fieldOrder;
this->gammaBasis = gammaBasis;
if (Ndim > QUDA_MAX_DIM){
errorQuda("Number of dimensions nDim = %d too great", Ndim);
}
nDim = Ndim;
nColor = Nc;
nSpin = Ns;
twistFlavor = Twistflavor;
precision = Prec;
volume = 1;
for (int d=0; d<nDim; d++) {
x[d] = X[d];
volume *= x[d];
}
volumeCB = siteSubset == QUDA_PARITY_SITE_SUBSET ? volume : volume/2;
if((twistFlavor == QUDA_TWIST_NONDEG_DOUBLET || twistFlavor == QUDA_TWIST_DEG_DOUBLET) && x[4] != 2) errorQuda("Must be two flavors for non-degenerate twisted mass spinor (while provided with %d number of components)\n", x[4]);//two flavors
pad = Pad;
if (siteSubset == QUDA_FULL_SITE_SUBSET) {
stride = volume/2 + pad; // padding is based on half volume
length = 2*stride*nColor*nSpin*2;
} else {
stride = volume + pad;
length = stride*nColor*nSpin*2;
}
real_length = volume*nColor*nSpin*2; // physical length
createGhostZone();
bytes = total_length * precision; // includes pads and ghost zones
bytes = (siteSubset == QUDA_FULL_SITE_SUBSET) ? 2*ALIGNMENT_ADJUST(bytes/2) : ALIGNMENT_ADJUST(bytes);
norm_bytes = total_norm_length * sizeof(float);
norm_bytes = (siteSubset == QUDA_FULL_SITE_SUBSET) ? 2*ALIGNMENT_ADJUST(norm_bytes/2) : ALIGNMENT_ADJUST(norm_bytes);
init = true;
clearGhostPointers();
}
// Resets the attributes of this field if param disagrees (and is defined)
void ColorSpinorField::reset(const ColorSpinorParam ¶m) {
if (param.nColor != 0) nColor = param.nColor;
if (param.nSpin != 0) nSpin = param.nSpin;
if (param.twistFlavor != QUDA_TWIST_INVALID) twistFlavor = param.twistFlavor;
if (param.precision != QUDA_INVALID_PRECISION) precision = param.precision;
if (param.nDim != 0) nDim = param.nDim;
volume = 1;
for (int d=0; d<nDim; d++) {
if (param.x[0] != 0) x[d] = param.x[d];
volume *= x[d];
}
if (param.pad != 0) pad = param.pad;
if (param.siteSubset == QUDA_FULL_SITE_SUBSET){
stride = volume/2 + pad;
length = 2*stride*nColor*nSpin*2;
} else if (param.siteSubset == QUDA_PARITY_SITE_SUBSET){
stride = volume + pad;
length = stride*nColor*nSpin*2;
} else {
//errorQuda("SiteSubset not defined %d", param.siteSubset);
//do nothing, not an error (can't remember why - need to document this sometime! )
}
if (param.siteSubset != QUDA_INVALID_SITE_SUBSET) siteSubset = param.siteSubset;
if (param.siteOrder != QUDA_INVALID_SITE_ORDER) siteOrder = param.siteOrder;
if (param.fieldOrder != QUDA_INVALID_FIELD_ORDER) fieldOrder = param.fieldOrder;
if (param.gammaBasis != QUDA_INVALID_GAMMA_BASIS) gammaBasis = param.gammaBasis;
createGhostZone();
real_length = volume*nColor*nSpin*2;
bytes = total_length * precision;
bytes = ALIGNMENT_ADJUST(bytes);
norm_bytes = total_norm_length * sizeof(float);
norm_bytes = ALIGNMENT_ADJUST(norm_bytes);
if (!init) errorQuda("Shouldn't be resetting a non-inited field\n");
if (verbose >= QUDA_DEBUG_VERBOSE) {
printfQuda("\nPrinting out reset field\n");
std::cout << *this << std::endl;
printfQuda("\n");
}
}
GaugeField::GaugeField(const GaugeFieldParam ¶m) :
LatticeField(param), bytes(0), nColor(param.nColor), nFace(param.nFace),
geometry(param.geometry), reconstruct(param.reconstruct), order(param.order),
fixed(param.fixed), link_type(param.link_type), t_boundary(param.t_boundary),
anisotropy(param.anisotropy), tadpole(param.tadpole), create(param.create)
{
if (nColor != 3) errorQuda("nColor must be 3, not %d\n", nColor);
if (nDim != 4) errorQuda("Number of dimensions must be 4 not %d", nDim);
if (link_type != QUDA_WILSON_LINKS && anisotropy != 1.0) errorQuda("Anisotropy only supported for Wilson links");
if (link_type != QUDA_WILSON_LINKS && fixed == QUDA_GAUGE_FIXED_YES)
errorQuda("Temporal gauge fixing only supported for Wilson links");
if(geometry == QUDA_SCALAR_GEOMETRY) {
real_length = volume*reconstruct;
length = 2*stride*reconstruct; // two comes from being full lattice
} else if (geometry == QUDA_VECTOR_GEOMETRY) {
real_length = nDim*volume*reconstruct;
length = 2*nDim*stride*reconstruct; // two comes from being full lattice
} else if(geometry == QUDA_TENSOR_GEOMETRY){
real_length = (nDim*(nDim-1)/2)*volume*reconstruct;
length = 2*(nDim*(nDim-1)/2)*stride*reconstruct; // two comes from being full lattice
}
bytes = length*precision;
bytes = ALIGNMENT_ADJUST(bytes);
total_bytes = bytes;
}
CloverField::CloverField(const CloverFieldParam ¶m) :
LatticeField(param), bytes(0), norm_bytes(0), nColor(3), nSpin(4)
{
if (nDim != 4) errorQuda("Number of dimensions must be 4, not %d", nDim);
real_length = 2*volumeCB*nColor*nColor*nSpin*nSpin/2; // block-diagonal Hermitian (72 reals)
length = 2*stride*nColor*nColor*nSpin*nSpin/2;
bytes = length*precision;
bytes = ALIGNMENT_ADJUST(bytes);
if (precision == QUDA_HALF_PRECISION) {
norm_bytes = sizeof(float)*2*stride*2; // 2 chirality
norm_bytes = ALIGNMENT_ADJUST(norm_bytes);
}
total_bytes = bytes + norm_bytes;
}
void ColorSpinorField::create(int Ndim, const int *X, int Nc, int Ns, QudaTwistFlavorType Twistflavor,
QudaPrecision Prec, int Pad, QudaSiteSubset siteSubset,
QudaSiteOrder siteOrder, QudaFieldOrder fieldOrder,
QudaGammaBasis gammaBasis) {
this->siteSubset = siteSubset;
this->siteOrder = siteOrder;
this->fieldOrder = fieldOrder;
this->gammaBasis = gammaBasis;
if (Ndim > QUDA_MAX_DIM){
errorQuda("Number of dimensions nDim = %d too great", Ndim);
}
nDim = Ndim;
nColor = Nc;
nSpin = Ns;
twistFlavor = Twistflavor;
precision = Prec;
volume = 1;
for (int d=0; d<nDim; d++) {
x[d] = X[d];
volume *= x[d];
}
pad = Pad;
if (siteSubset == QUDA_FULL_SITE_SUBSET) {
stride = volume/2 + pad; // padding is based on half volume
length = 2*stride*nColor*nSpin*2;
} else {
stride = volume + pad;
length = stride*nColor*nSpin*2;
}
real_length = volume*nColor*nSpin*2; // physical length
createGhostZone();
bytes = total_length * precision; // includes pads and ghost zones
bytes = ALIGNMENT_ADJUST(bytes);
norm_bytes = total_norm_length * sizeof(float);
norm_bytes = ALIGNMENT_ADJUST(norm_bytes);
init = true;
}
CloverField::CloverField(const CloverFieldParam ¶m) :
LatticeField(param), bytes(0), norm_bytes(0), nColor(3), nSpin(4),
clover(0), norm(0), cloverInv(0), invNorm(0), order(param.order), create(param.create),
trlog(static_cast<double*>(pinned_malloc(2*sizeof(double))))
{
if (nDim != 4) errorQuda("Number of dimensions must be 4, not %d", nDim);
if (order == QUDA_QDPJIT_CLOVER_ORDER && create != QUDA_REFERENCE_FIELD_CREATE)
errorQuda("QDPJIT ordered clover fields only supported for reference fields");
real_length = 2*volumeCB*nColor*nColor*nSpin*nSpin/2; // block-diagonal Hermitian (72 reals)
length = 2*stride*nColor*nColor*nSpin*nSpin/2;
bytes = length*precision;
bytes = ALIGNMENT_ADJUST(bytes);
if (precision == QUDA_HALF_PRECISION) {
norm_bytes = sizeof(float)*2*stride*2; // 2 chirality
norm_bytes = ALIGNMENT_ADJUST(norm_bytes);
}
//for twisted mass only:
twisted = false;//param.twisted;
mu2 = 0.0; //param.mu2;
}
GaugeField::GaugeField(const GaugeFieldParam ¶m) :
LatticeField(param), bytes(0), phase_offset(0), phase_bytes(0), nColor(param.nColor), nFace(param.nFace),
geometry(param.geometry), reconstruct(param.reconstruct), order(param.order),
fixed(param.fixed), link_type(param.link_type), t_boundary(param.t_boundary),
anisotropy(param.anisotropy), tadpole(param.tadpole), fat_link_max(0.0), scale(param.scale),
create(param.create), ghostExchange(param.ghostExchange),
staggeredPhaseType(param.staggeredPhaseType), staggeredPhaseApplied(param.staggeredPhaseApplied)
{
if (nColor != 3) errorQuda("nColor must be 3, not %d\n", nColor);
if (nDim != 4) errorQuda("Number of dimensions must be 4 not %d", nDim);
if (link_type != QUDA_WILSON_LINKS && anisotropy != 1.0) errorQuda("Anisotropy only supported for Wilson links");
if (link_type != QUDA_WILSON_LINKS && fixed == QUDA_GAUGE_FIXED_YES)
errorQuda("Temporal gauge fixing only supported for Wilson links");
if(link_type != QUDA_ASQTAD_LONG_LINKS && (reconstruct == QUDA_RECONSTRUCT_13 || reconstruct == QUDA_RECONSTRUCT_9))
errorQuda("reconstruct %d only supported for staggered long links\n", reconstruct);
if (link_type == QUDA_ASQTAD_MOM_LINKS) scale = 1.0;
if(geometry == QUDA_SCALAR_GEOMETRY) {
real_length = volume*reconstruct;
length = 2*stride*reconstruct; // two comes from being full lattice
} else if (geometry == QUDA_VECTOR_GEOMETRY) {
real_length = nDim*volume*reconstruct;
length = 2*nDim*stride*reconstruct; // two comes from being full lattice
} else if(geometry == QUDA_TENSOR_GEOMETRY){
real_length = (nDim*(nDim-1)/2)*volume*reconstruct;
length = 2*(nDim*(nDim-1)/2)*stride*reconstruct; // two comes from being full lattice
}
if(reconstruct == QUDA_RECONSTRUCT_9 || reconstruct == QUDA_RECONSTRUCT_13)
{
// Need to adjust the phase alignment as well.
int half_phase_bytes = (length/(2*reconstruct))*precision; // number of bytes needed to store phases for a single parity
int half_gauge_bytes = (length/2)*precision - half_phase_bytes; // number of bytes needed to store the gauge field for a single parity excluding the phases
// Adjust the alignments for the gauge and phase separately
half_phase_bytes = ((half_phase_bytes + (512-1))/512)*512;
half_gauge_bytes = ((half_gauge_bytes + (512-1))/512)*512;
phase_offset = half_gauge_bytes;
phase_bytes = half_phase_bytes*2;
bytes = (half_gauge_bytes + half_phase_bytes)*2;
}else{
bytes = length*precision;
bytes = 2*ALIGNMENT_ADJUST(bytes/2);
}
total_bytes = bytes;
}
GaugeField::GaugeField(const GaugeFieldParam ¶m, const QudaFieldLocation &location) :
LatticeField(param, location), bytes(0), nColor(param.nColor), nFace(param.nFace),
reconstruct(param.reconstruct), order(param.order), fixed(param.fixed),
link_type(param.link_type), t_boundary(param.t_boundary), anisotropy(param.anisotropy),
tadpole(param.tadpole), create(param.create), is_staple(param.is_staple)
{
if (nColor != 3) errorQuda("nColor must be 3, not %d\n", nColor);
if (nDim != 4 && nDim != 1) errorQuda("Number of dimensions must be 4 or 1, not %d", nDim);
if (link_type != QUDA_WILSON_LINKS && anisotropy != 1.0) errorQuda("Anisotropy only supported for Wilson links");
if (link_type != QUDA_WILSON_LINKS && fixed == QUDA_GAUGE_FIXED_YES)
errorQuda("Temporal gauge fixing only supported for Wilson links");
if(is_staple){
real_length = volume*reconstruct;
length = 2*stride*reconstruct; // two comes from being full lattice
}else{
real_length = 4*volume*reconstruct;
length = 2*4*stride*reconstruct; // two comes from being full lattice
}
bytes = length*precision;
bytes = ALIGNMENT_ADJUST(bytes);
total_bytes = bytes;
}
void cpuColorSpinorField::create(const QudaFieldCreate create) {
// these need to be reset to ensure no ghost zones for the cpu
// fields since we can't determine during the parent's constructor
// whether the field is a cpu or cuda field
// set this again here. this is a hack since we can determine we
// have a cpu or cuda field in ColorSpinorField::create(), which
// means a ghost zone is set. So we unset it here. This will be
// fixed when clean up the ghost code with the peer-2-peer branch
bytes = length * precision;
if (isNative()) bytes = (siteSubset == QUDA_FULL_SITE_SUBSET && fieldOrder != QUDA_QDPJIT_FIELD_ORDER) ? 2*ALIGNMENT_ADJUST(bytes/2) : ALIGNMENT_ADJUST(bytes);
if (pad != 0) errorQuda("Non-zero pad not supported");
if (precision == QUDA_HALF_PRECISION) errorQuda("Half precision not supported");
if (fieldOrder != QUDA_SPACE_COLOR_SPIN_FIELD_ORDER &&
fieldOrder != QUDA_SPACE_SPIN_COLOR_FIELD_ORDER &&
fieldOrder != QUDA_QOP_DOMAIN_WALL_FIELD_ORDER &&
fieldOrder != QUDA_QDPJIT_FIELD_ORDER &&
fieldOrder != QUDA_PADDED_SPACE_SPIN_COLOR_FIELD_ORDER) {
errorQuda("Field order %d not supported", fieldOrder);
}
if (create != QUDA_REFERENCE_FIELD_CREATE) {
// array of 4-d fields
if (fieldOrder == QUDA_QOP_DOMAIN_WALL_FIELD_ORDER) {
int Ls = x[nDim-1];
v = (void**)safe_malloc(Ls * sizeof(void*));
for (int i=0; i<Ls; i++) ((void**)v)[i] = safe_malloc(bytes / Ls);
} else {
v = safe_malloc(bytes);
}
init = true;
}
if (siteSubset == QUDA_FULL_SITE_SUBSET && fieldOrder != QUDA_QDPJIT_FIELD_ORDER) {
ColorSpinorParam param(*this);
param.siteSubset = QUDA_PARITY_SITE_SUBSET;
param.nDim = nDim;
memcpy(param.x, x, nDim*sizeof(int));
param.x[0] /= 2;
param.create = QUDA_REFERENCE_FIELD_CREATE;
param.v = v;
param.norm = norm;
param.is_composite = false;
param.composite_dim = 0;
param.is_component = composite_descr.is_component;
param.component_id = composite_descr.id;
even = new cpuColorSpinorField(*this, param);
odd = new cpuColorSpinorField(*this, param);
// need this hackery for the moment (need to locate the odd pointers half way into the full field)
(dynamic_cast<cpuColorSpinorField*>(odd))->v = (void*)((char*)v + bytes/2);
if (precision == QUDA_HALF_PRECISION)
(dynamic_cast<cpuColorSpinorField*>(odd))->norm = (void*)((char*)norm + norm_bytes/2);
if (bytes != 2*even->Bytes() || bytes != 2*odd->Bytes())
errorQuda("dual-parity fields should have double the size of a single-parity field (%lu,%lu,%lu)\n",
bytes, even->Bytes(), odd->Bytes());
}
}
