static void massRescaleCoeff(QudaDslashType dslash_type, double &kappa, QudaSolutionType solution_type,
QudaMassNormalization mass_normalization, double &coeff)
{
if (dslash_type == QUDA_ASQTAD_DSLASH) {
if (mass_normalization != QUDA_MASS_NORMALIZATION) {
errorQuda("Staggered code only supports QUDA_MASS_NORMALIZATION");
}
return;
}
// multiply the source to compensate for normalization of the Dirac operator, if necessary
switch (solution_type) {
case QUDA_MAT_SOLUTION:
if (mass_normalization == QUDA_MASS_NORMALIZATION ||
mass_normalization == QUDA_ASYMMETRIC_MASS_NORMALIZATION) {
coeff *= 2.0*kappa;
}
break;
case QUDA_MATDAG_MAT_SOLUTION:
if (mass_normalization == QUDA_MASS_NORMALIZATION ||
mass_normalization == QUDA_ASYMMETRIC_MASS_NORMALIZATION) {
coeff *= 4.0*kappa*kappa;
}
break;
case QUDA_MATPC_SOLUTION:
if (mass_normalization == QUDA_MASS_NORMALIZATION) {
coeff *= 4.0*kappa*kappa;
} else if (mass_normalization == QUDA_ASYMMETRIC_MASS_NORMALIZATION) {
coeff *= 2.0*kappa;
}
break;
case QUDA_MATPCDAG_MATPC_SOLUTION:
if (mass_normalization == QUDA_MASS_NORMALIZATION) {
coeff*=16.0*pow(kappa,4);
} else if (mass_normalization == QUDA_ASYMMETRIC_MASS_NORMALIZATION) {
coeff*=4.0*kappa*kappa;
}
break;
default:
errorQuda("Solution type %d not supported", solution_type);
}
if (verbosity >= QUDA_DEBUG_VERBOSE) printfQuda("Mass rescale done\n");
}
void GaugeField::checkField(const GaugeField &a) {
LatticeField::checkField(a);
if (a.link_type != link_type) errorQuda("link_type does not match %d %d", link_type, a.link_type);
if (a.nColor != nColor) errorQuda("nColor does not match %d %d", nColor, a.nColor);
if (a.nFace != nFace) errorQuda("nFace does not match %d %d", nFace, a.nFace);
if (a.fixed != fixed) errorQuda("fixed does not match %d %d", fixed, a.fixed);
if (a.t_boundary != t_boundary) errorQuda("t_boundary does not match %d %d", t_boundary, a.t_boundary);
if (a.anisotropy != anisotropy) errorQuda("anisotropy does not match %e %e", anisotropy, a.anisotropy);
if (a.tadpole != tadpole) errorQuda("tadpole does not match %e %e", tadpole, a.tadpole);
if (a.scale != scale) errorQuda("scale does not match %e %e", scale, a.scale);
}
const char*
get_solver_str(QudaInverterType type)
{
const char* ret;
switch(type){
case QUDA_CG_INVERTER:
ret = "cg";
break;
case QUDA_BICGSTAB_INVERTER:
ret = "bicgstab";
break;
case QUDA_GCR_INVERTER:
ret = "gcr";
break;
case QUDA_PCG_INVERTER:
ret = "pcg";
break;
case QUDA_MPCG_INVERTER:
ret = "mpcg";
break;
case QUDA_MPBICGSTAB_INVERTER:
ret = "mpbicgstab";
break;
case QUDA_MR_INVERTER:
ret = "mr";
break;
case QUDA_SD_INVERTER:
ret = "sd";
break;
case QUDA_EIGCG_INVERTER:
ret = "eigcg";
break;
case QUDA_INC_EIGCG_INVERTER:
ret = "inc-eigcg";
break;
case QUDA_GMRESDR_INVERTER:
ret = "gmresdr";
break;
case QUDA_GMRESDR_PROJ_INVERTER:
ret = "gmresdr-proj";
break;
case QUDA_GMRESDR_SH_INVERTER:
ret = "gmresdr-sh";
break;
case QUDA_FGMRESDR_INVERTER:
ret = "fgmresdr";
break;
default:
ret = "unknown";
errorQuda("Error: invalid solver type %d\n", type);
break;
}
return ret;
}
void DiracClover::checkParitySpinor(const cudaColorSpinorField &out, const cudaColorSpinorField &in,
const cudaCloverField &clover) const
{
Dirac::checkParitySpinor(out, in);
if (out.Volume() != clover.VolumeCB()) {
errorQuda("Parity spinor volume %d doesn't match clover checkboard volume %d",
out.Volume(), clover.VolumeCB());
}
}
cudaGaugeField::cudaGaugeField(const GaugeFieldParam ¶m) :
GaugeField(param, QUDA_CUDA_FIELD_LOCATION), gauge(0), even(0), odd(0)
{
if(create != QUDA_NULL_FIELD_CREATE && create != QUDA_ZERO_FIELD_CREATE){
errorQuda("ERROR: create type(%d) not supported yet\n", create);
}
if (cudaMalloc((void **)&gauge, bytes) == cudaErrorMemoryAllocation) {
errorQuda("Error allocating gauge field");
}
if(create == QUDA_ZERO_FIELD_CREATE){
cudaMemset(gauge, 0, bytes);
}
even = gauge;
odd = (char*)gauge + bytes/2;
}
// Apply the even-odd preconditioned clover-improved Dirac operator
void DiracDomainWallPC::M(ColorSpinorField &out, const ColorSpinorField &in) const
{
if ( in.Ndim() != 5 || out.Ndim() != 5) errorQuda("Wrong number of dimensions\n");
double kappa2 = -kappa5*kappa5;
bool reset = newTmp(&tmp1, in);
if (matpcType == QUDA_MATPC_EVEN_EVEN) {
Dslash(*tmp1, in, QUDA_ODD_PARITY);
DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2);
} else if (matpcType == QUDA_MATPC_ODD_ODD) {
Dslash(*tmp1, in, QUDA_EVEN_PARITY);
DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2);
} else {
errorQuda("MatPCType %d not valid for DiracDomainWallPC", matpcType);
}
deleteTmp(&tmp1, reset);
}
ColorSpinorField& cpuColorSpinorField::operator=(const ColorSpinorField &src) {
if (typeid(src) == typeid(cudaColorSpinorField)) {
*this = (dynamic_cast<const cudaColorSpinorField&>(src));
} else if (typeid(src) == typeid(cpuColorSpinorField)) {
*this = (dynamic_cast<const cpuColorSpinorField&>(src));
} else {
errorQuda("Unknown input ColorSpinorField %s", typeid(src).name());
}
return *this;
}
void DiracDomainWall::Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const
{
if ( in.Ndim() != 5 || out.Ndim() != 5) errorQuda("Wrong number of dimensions\n");
checkParitySpinor(in, out);
checkSpinorAlias(in, out);
if (checkLocation(out, in) == QUDA_CUDA_FIELD_LOCATION) {
domainWallDslashCuda(&static_cast<cudaColorSpinorField&>(out), *gauge,
&static_cast<const cudaColorSpinorField&>(in),
parity, dagger, 0, mass, 0, commDim, profile);
} else {
errorQuda("Not implemented");
}
long long Ls = in.X(4);
long long bulk = (Ls-2)*(in.Volume()/Ls);
long long wall = 2*in.Volume()/Ls;
flops += 1320LL*(long long)in.Volume() + 96LL*bulk + 120LL*wall;
}
cpuCloverField::cpuCloverField(const CloverFieldParam ¶m) : CloverField(param) {
if (create != QUDA_REFERENCE_FIELD_CREATE) errorQuda("Create type %d not supported", create);
if (create == QUDA_REFERENCE_FIELD_CREATE) {
clover = param.clover;
norm = param.norm;
cloverInv = param.cloverInv;
invNorm = param.invNorm;
}
}
int
main(int argc, char **argv)
{
#ifdef MULTI_GPU
int test = 1;
#else
int test = 0;
#endif
//default to 18 reconstruct, 8^3 x 8
link_recon = QUDA_RECONSTRUCT_NO;
xdim=ydim=zdim=tdim=8;
cpu_prec = prec = QUDA_DOUBLE_PRECISION;
int i;
for (i =1;i < argc; i++){
if(process_command_line_option(argc, argv, &i) == 0){
continue;
}
if( strcmp(argv[i], "--gauge-order") == 0){
if(i+1 >= argc){
usage(argv);
}
if(strcmp(argv[i+1], "milc") == 0){
gauge_order = QUDA_MILC_GAUGE_ORDER;
}else if(strcmp(argv[i+1], "qdp") == 0){
gauge_order = QUDA_QDP_GAUGE_ORDER;
}else{
fprintf(stderr, "Error: unsupported gauge-field order\n");
exit(1);
}
i++;
continue;
}
fprintf(stderr, "ERROR: Invalid option:%s\n", argv[i]);
usage(argv);
}
#ifdef MULTI_GPU
if(gauge_order == QUDA_MILC_GAUGE_ORDER && test == 0){
errorQuda("ERROR: milc format for multi-gpu with test0 is not supported yet!\n");
}
#endif
initComms(argc, argv, gridsize_from_cmdline);
display_test_info(test);
llfat_test(test);
finalizeComms();
}
cpuColorSpinorField::cpuColorSpinorField(const ColorSpinorField &src) :
ColorSpinorField(src), init(false), reference(false) {
create(QUDA_COPY_FIELD_CREATE);
if (typeid(src) == typeid(cpuColorSpinorField)) {
memcpy(v, dynamic_cast<const cpuColorSpinorField&>(src).v, bytes);
} else if (typeid(src) == typeid(cudaColorSpinorField)) {
dynamic_cast<const cudaColorSpinorField&>(src).saveSpinorField(*this);
} else {
errorQuda("Unknown input ColorSpinorField %s", typeid(src).name());
}
}
cpuColorSpinorField::cpuColorSpinorField(const ColorSpinorField &src) :
ColorSpinorField(src), init(false), order_double(NULL), order_single(NULL) {
create(QUDA_COPY_FIELD_CREATE);
if (src.FieldLocation() == QUDA_CPU_FIELD_LOCATION) {
memcpy(v, dynamic_cast<const cpuColorSpinorField&>(src).v, bytes);
} else if (src.FieldLocation() == QUDA_CUDA_FIELD_LOCATION) {
dynamic_cast<const cudaColorSpinorField&>(src).saveCPUSpinorField(*this);
} else {
errorQuda("FieldType not supported");
}
}
void DiracStaggered::checkParitySpinor(const cudaColorSpinorField &in, const cudaColorSpinorField &out) const
{
if (in.Precision() != out.Precision()) {
errorQuda("Input and output spinor precisions don't match in dslash_quda");
}
if (in.Stride() != out.Stride()) {
errorQuda("Input %d and output %d spinor strides don't match in dslash_quda", in.Stride(), out.Stride());
}
if (in.SiteSubset() != QUDA_PARITY_SITE_SUBSET || out.SiteSubset() != QUDA_PARITY_SITE_SUBSET) {
errorQuda("ColorSpinorFields are not single parity, in = %d, out = %d",
in.SiteSubset(), out.SiteSubset());
}
if ((out.Volume() != 2*fatGauge->VolumeCB() && out.SiteSubset() == QUDA_FULL_SITE_SUBSET) ||
(out.Volume() != fatGauge->VolumeCB() && out.SiteSubset() == QUDA_PARITY_SITE_SUBSET) ) {
errorQuda("Spinor volume %d doesn't match gauge volume %d", out.Volume(), fatGauge->VolumeCB());
}
}
cudaGaugeField::cudaGaugeField(const GaugeFieldParam ¶m) :
GaugeField(param, QUDA_CUDA_FIELD_LOCATION), gauge(0), even(0), odd(0)
{
if (cudaMalloc((void **)&gauge, bytes) == cudaErrorMemoryAllocation) {
errorQuda("Error allocating gauge field");
}
even = gauge;
odd = (char*)gauge + bytes/2;
}
void DiracDomainWall::prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType solType) const
{
if (solType == QUDA_MATPC_SOLUTION || solType == QUDA_MATPCDAG_MATPC_SOLUTION) {
errorQuda("Preconditioned solution requires a preconditioned solve_type");
}
src = &b;
sol = &x;
}
// Apply the even-odd preconditioned clover-improved Dirac operator
void DiracCloverPC::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const
{
double kappa2 = -kappa*kappa;
// FIXME: For asymmetric, a "DslashCxpay" kernel would improve performance.
bool reset = newTmp(&tmp1, in);
if (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) {
Dslash(*tmp1, in, QUDA_ODD_PARITY);
Clover(out, in, QUDA_EVEN_PARITY);
DiracWilson::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, out, kappa2); // safe since out is not read after writing
} else if (matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) {
Dslash(*tmp1, in, QUDA_EVEN_PARITY);
Clover(out, in, QUDA_ODD_PARITY);
DiracWilson::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, out, kappa2);
} else if (!dagger) { // symmetric preconditioning
if (matpcType == QUDA_MATPC_EVEN_EVEN) {
Dslash(*tmp1, in, QUDA_ODD_PARITY);
DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2);
} else if (matpcType == QUDA_MATPC_ODD_ODD) {
Dslash(*tmp1, in, QUDA_EVEN_PARITY);
DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2);
} else {
errorQuda("Invalid matpcType");
}
} else { // symmetric preconditioning, dagger
if (matpcType == QUDA_MATPC_EVEN_EVEN) {
CloverInv(out, in, QUDA_EVEN_PARITY);
Dslash(*tmp1, out, QUDA_ODD_PARITY);
DiracWilson::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2);
} else if (matpcType == QUDA_MATPC_ODD_ODD) {
CloverInv(out, in, QUDA_ODD_PARITY);
Dslash(*tmp1, out, QUDA_EVEN_PARITY);
DiracWilson::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2);
} else {
errorQuda("MatPCType %d not valid for DiracCloverPC", matpcType);
}
}
deleteTmp(&tmp1, reset);
}
// Apply the even-odd preconditioned clover-improved Dirac operator
void DiracCloverPC::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const
{
double kappa2 = -kappa*kappa;
bool reset1 = newTmp(&tmp1, in);
if (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) {
// DiracCloverPC::Dslash applies A^{-1}Dslash
Dslash(*tmp1, in, QUDA_ODD_PARITY);
// DiracClover::DslashXpay applies (A - kappa^2 D)
DiracClover::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2);
} else if (matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) {
// DiracCloverPC::Dslash applies A^{-1}Dslash
Dslash(*tmp1, in, QUDA_EVEN_PARITY);
// DiracClover::DslashXpay applies (A - kappa^2 D)
DiracClover::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2);
} else if (!dagger) { // symmetric preconditioning
if (matpcType == QUDA_MATPC_EVEN_EVEN) {
Dslash(*tmp1, in, QUDA_ODD_PARITY);
DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2);
} else if (matpcType == QUDA_MATPC_ODD_ODD) {
Dslash(*tmp1, in, QUDA_EVEN_PARITY);
DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2);
} else {
errorQuda("Invalid matpcType");
}
} else { // symmetric preconditioning, dagger
if (matpcType == QUDA_MATPC_EVEN_EVEN) {
CloverInv(out, in, QUDA_EVEN_PARITY);
Dslash(*tmp1, out, QUDA_ODD_PARITY);
DiracWilson::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2);
} else if (matpcType == QUDA_MATPC_ODD_ODD) {
CloverInv(out, in, QUDA_ODD_PARITY);
Dslash(*tmp1, out, QUDA_EVEN_PARITY);
DiracWilson::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2);
} else {
errorQuda("MatPCType %d not valid for DiracCloverPC", matpcType);
}
}
deleteTmp(&tmp1, reset1);
}
// creates a copy of src, any differences defined in param
cudaColorSpinorField::cudaColorSpinorField(const ColorSpinorField &src, const ColorSpinorParam ¶m) :
ColorSpinorField(src), v(0), norm(0), alloc(false), init(true) {
// can only overide if we are not using a reference or parity special case
if (param.create != QUDA_REFERENCE_FIELD_CREATE ||
(param.create == QUDA_REFERENCE_FIELD_CREATE &&
src.SiteSubset() == QUDA_FULL_SITE_SUBSET &&
param.siteSubset == QUDA_PARITY_SITE_SUBSET &&
src.FieldLocation() == QUDA_CUDA_FIELD_LOCATION) ) {
reset(param);
} else {
errorQuda("Undefined behaviour"); // else silent bug possible?
}
fieldLocation = QUDA_CUDA_FIELD_LOCATION;
create(param.create);
if (param.create == QUDA_NULL_FIELD_CREATE) {
// do nothing
} else if (param.create == QUDA_ZERO_FIELD_CREATE) {
zero();
} else if (param.create == QUDA_COPY_FIELD_CREATE) {
if (src.FieldLocation() == QUDA_CUDA_FIELD_LOCATION) {
copy(dynamic_cast<const cudaColorSpinorField&>(src));
} else if (src.FieldLocation() == QUDA_CPU_FIELD_LOCATION) {
loadCPUSpinorField(dynamic_cast<const cpuColorSpinorField&>(src));
} else {
errorQuda("FieldLocation %d not supported", src.FieldLocation());
}
} else if (param.create == QUDA_REFERENCE_FIELD_CREATE) {
if (src.FieldLocation() == QUDA_CUDA_FIELD_LOCATION) {
v = (dynamic_cast<const cudaColorSpinorField&>(src)).v;
norm = (dynamic_cast<const cudaColorSpinorField&>(src)).norm;
} else {
errorQuda("Cannot reference a non cuda field");
}
} else {
errorQuda("CreateType %d not implemented", param.create);
}
}
void cpuColorSpinorField::createOrder() {
if (precision == QUDA_DOUBLE_PRECISION) {
if (fieldOrder == QUDA_SPACE_SPIN_COLOR_FIELD_ORDER)
order_double = new SpaceSpinColorOrder<double>(*this);
else if (fieldOrder == QUDA_SPACE_COLOR_SPIN_FIELD_ORDER)
order_double = new SpaceColorSpinOrder<double>(*this);
else
errorQuda("Order %d not supported in cpuColorSpinorField", fieldOrder);
} else if (precision == QUDA_SINGLE_PRECISION) {
if (fieldOrder == QUDA_SPACE_SPIN_COLOR_FIELD_ORDER)
order_single = new SpaceSpinColorOrder<float>(*this);
else if (fieldOrder == QUDA_SPACE_COLOR_SPIN_FIELD_ORDER)
order_single = new SpaceColorSpinOrder<float>(*this);
else
errorQuda("Order %d not supported in cpuColorSpinorField", fieldOrder);
} else {
errorQuda("Precision %d not supported", precision);
}
}
void loadLinkToGPU_ex(cudaGaugeField* cudaGauge, cpuGaugeField* cpuGauge)
{
if (cudaGauge->Precision() != cpuGauge->Precision()){
errorQuda("Mismatch between CPU precision and CUDA precision");
}
QudaPrecision prec = cudaGauge->Precision();
const int *E = cudaGauge->X();
int pad = cudaGauge->Pad();
do_loadLinkToGPU_ex(E, cudaGauge->Even_p(), cudaGauge->Odd_p(), (void**)cpuGauge->Gauge_p(),
cudaGauge->Reconstruct(), cudaGauge->Bytes(), cudaGauge->VolumeCB(), pad,
prec, cpuGauge->Order());
}
void
comm_set_gridsize(const int *X, int nDim)
{
if (nDim != 4) errorQuda("Comms dimensions %d != 4", nDim);
xgridsize = X[0];
ygridsize = X[1];
zgridsize = X[2];
tgridsize = X[3];
int volume = 1;
for (int i=0; i<nDim; i++) volume *= X[i];
int size = -1;
MPI_Comm_size(MPI_COMM_WORLD, &size);
if (volume != size)
errorQuda("Number of processes %d must match requested MPI volume %d",
size, volume);
return;
}
void GaugeField::applyStaggeredPhase() {
if (staggeredPhaseApplied) errorQuda("Staggered phases already applied");
applyGaugePhase(*this);
if (ghostExchange==QUDA_GHOST_EXCHANGE_PAD) {
if (typeid(*this)==typeid(cudaGaugeField)) {
static_cast<cudaGaugeField&>(*this).exchangeGhost();
} else {
static_cast<cpuGaugeField&>(*this).exchangeGhost();
}
}
staggeredPhaseApplied = true;
}
void cpuColorSpinorField::restore() {
if (!backed_up) errorQuda("Cannot restore since not backed up");
memcpy(v, backup_h, bytes);
delete []backup_h;
if (norm_bytes) {
memcpy(norm, backup_norm_h, norm_bytes);
delete []backup_norm_h;
}
backed_up = false;
}
void GaugeField::removeStaggeredPhase() {
if (!staggeredPhaseApplied) errorQuda("No staggered phases to remove");
applyGaugePhase(*this);
if (ghostExchange==QUDA_GHOST_EXCHANGE_PAD) {
if (typeid(*this)==typeid(cudaGaugeField)) {
static_cast<cudaGaugeField&>(*this).exchangeGhost();
} else {
static_cast<cpuGaugeField&>(*this).exchangeGhost();
}
}
staggeredPhaseApplied = false;
}
cudaColorSpinorField::cudaColorSpinorField(const ColorSpinorField &src)
: ColorSpinorField(src), alloc(false), init(true) {
fieldLocation = QUDA_CUDA_FIELD_LOCATION;
create(QUDA_COPY_FIELD_CREATE);
if (src.FieldLocation() == QUDA_CUDA_FIELD_LOCATION) {
copy(dynamic_cast<const cudaColorSpinorField&>(src));
} else if (src.FieldLocation() == QUDA_CPU_FIELD_LOCATION) {
loadCPUSpinorField(src);
} else {
errorQuda("FieldLocation not supported");
}
}
void cpuColorSpinorField::allocateGhostBuffer(void)
{
if(initGhostFaceBuffer){
return;
}
if (this->siteSubset == QUDA_FULL_SITE_SUBSET){
errorQuda("Full spinor is not supported in alllocateGhostBuffer\n");
}
int X1 = this->x[0]*2;
int X2 = this->x[1];
int X3 = this->x[2];
int X4 = this->x[3];
int Vsh[4]={ X2*X3*X4/2,
X1*X3*X4/2,
X1*X2*X4/2,
X1*X2*X3/2};
int num_faces = 1;
if(this->nSpin == 1){ //staggered
num_faces = 3;
}
int spinor_size = 2*this->nSpin*this->nColor*this->precision;
for(int i=0;i < 4; i++){
fwdGhostFaceBuffer[i] = malloc(num_faces*Vsh[i]*spinor_size);
backGhostFaceBuffer[i] = malloc(num_faces*Vsh[i]*spinor_size);
fwdGhostFaceSendBuffer[i] = malloc(num_faces*Vsh[i]*spinor_size);
backGhostFaceSendBuffer[i] = malloc(num_faces*Vsh[i]*spinor_size);
if(fwdGhostFaceBuffer[i]== NULL || backGhostFaceBuffer[i] == NULL||
fwdGhostFaceSendBuffer[i]== NULL || backGhostFaceSendBuffer[i]==NULL){
errorQuda("malloc for ghost buf in cpu spinor failed\n");
}
}
initGhostFaceBuffer = 1;
return;
}
void cpuColorSpinorField::Source(const QudaSourceType sourceType, const int st, const int s, const int c) {
switch(sourceType) {
case QUDA_RANDOM_SOURCE:
if (precision == QUDA_DOUBLE_PRECISION) random((double*)v, length);
else if (precision == QUDA_SINGLE_PRECISION) random((float*)v, length);
else errorQuda("Precision not supported");
break;
case QUDA_POINT_SOURCE:
if (precision == QUDA_DOUBLE_PRECISION) point((double*)v, st, s, c, nSpin, nColor, fieldOrder);
else if (precision == QUDA_SINGLE_PRECISION) point((float*)v, st, s, c, nSpin, nColor, fieldOrder);
else errorQuda("Precision not supported");
break;
default:
errorQuda("Source type %d not implemented", sourceType);
}
}
void point(Float *v, const int st, const int s, const int c, const int nSpin,
const int nColor, const QudaFieldOrder fieldOrder) {
switch(fieldOrder) {
case QUDA_SPACE_SPIN_COLOR_FIELD_ORDER:
v[(st*nSpin+s)*nColor+c] = 1.0;
break;
case QUDA_SPACE_COLOR_SPIN_FIELD_ORDER:
v[(st*nColor+c)*nSpin+s] = 1.0;
break;
default:
errorQuda("Field ordering %d not supported", fieldOrder);
}
}
double norm2(const ColorSpinorField &a) {
double rtn = 0.0;
if (typeid(a) == typeid(cudaColorSpinorField)) {
rtn = normCuda(dynamic_cast<const cudaColorSpinorField&>(a));
} else if (typeid(a) == typeid(cpuColorSpinorField)) {
rtn = normCpu(dynamic_cast<const cpuColorSpinorField&>(a));
} else {
errorQuda("Unknown input ColorSpinorField %s", typeid(a).name());
}
return rtn;
}
cpuColorSpinorField::cpuColorSpinorField(const ColorSpinorParam ¶m) :
ColorSpinorField(param), init(false), order_double(NULL), order_single(NULL) {
create(param.create);
if (param.create == QUDA_NULL_FIELD_CREATE) {
// do nothing
} else if (param.create == QUDA_ZERO_FIELD_CREATE) {
zero();
} else if (param.create == QUDA_REFERENCE_FIELD_CREATE) {
v = param.v;
} else {
errorQuda("Creation type %d not supported", param.create);
}
}
