// 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()); } }