int main (int argc, char** argv)
{
int verbose;
QMP_status_t status;
QMP_thread_level_t req, prv;
verbose = 0;
if (argc > 1 && strcmp (argv[1], "-v") == 0)
verbose = 1;
QMP_verbose (verbose);
req = QMP_THREAD_SINGLE;
status = QMP_init_msg_passing (&argc, &argv, req, &prv);
if (status != QMP_SUCCESS) {
QMP_fprintf(stderr, "QMP_init failed\n");
return -1;
}
{
char p[288];
int i;
for(i=0; i < 288;++i)
p[i] = 0;
if (QMP_is_primary_node())
for(i=0; i < 288;++i)
p[i] = 65;
#if 1
for(i=0; i < 10; ++i)
QMP_broadcast(p, 288);
#else
for(i=0; i < 10; ++i)
stupid_broadcast(p, 288);
#endif
QMP_info("result = %c",p[0]);
}
QMP_finalize_msg_passing ();
return 0;
}
void
stupid_broadcast(void *send_buf, int count)
{
int node;
int num_nodes = QMP_get_number_of_nodes();
QMP_msgmem_t request_msg = QMP_declare_msgmem(send_buf, count);
QMP_msghandle_t request_mh;
// Send to each node
for(node=1; node < num_nodes; ++node)
{
if (QMP_get_node_number() == node)
{
request_mh = QMP_declare_receive_from(request_msg, 0, 0);
if (QMP_start(request_mh) != QMP_SUCCESS)
QMP_abort_string(1, "recvFromWait failed\n");
QMP_wait(request_mh);
QMP_free_msghandle(request_mh);
}
if (QMP_is_primary_node())
{
request_mh = QMP_declare_send_to(request_msg, node, 0);
if (QMP_start(request_mh) != QMP_SUCCESS)
QMP_abort_string(1, "sendToWait failed\n");
QMP_wait(request_mh);
QMP_free_msghandle(request_mh);
}
}
QMP_free_msgmem(request_msg);
}
int
main(int argc, char *argv[])
{
const char *msg;
int status = 1;
int mu, i;
struct QOP_CLOVER_State *clover_state;
QDP_Int *I_seed;
int i_seed;
QDP_RandomState *state;
QLA_Real plaq;
QLA_Real n[NELEMS(F)];
struct QOP_CLOVER_Gauge *c_g;
struct QOP_CLOVER_Fermion *c_f[NELEMS(F)];
double kappa;
double c_sw;
double in_eps;
int in_iter;
int log_flag;
double out_eps;
int out_iter;
int cg_status;
double run_time;
long long flops, sent, received;
/* start QDP */
QDP_initialize(&argc, &argv);
if (argc != 1 + NDIM + 6) {
printf0("ERROR: usage: %s Lx ... seed kappa c_sw iter eps log?\n",
argv[0]);
goto end;
}
for (mu = 0; mu < NDIM; mu++) {
lattice[mu] = atoi(argv[1 + mu]);
}
i_seed = atoi(argv[1 + NDIM]);
kappa = atof(argv[2 + NDIM]);
c_sw = atof(argv[3 + NDIM]);
in_iter = atoi(argv[4 + NDIM]);
in_eps = atof(argv[5 + NDIM]);
log_flag = atoi(argv[6 + NDIM]) == 0? 0: QOP_CLOVER_LOG_EVERYTHING;
/* set lattice size and create layout */
QDP_set_latsize(NDIM, lattice);
QDP_create_layout();
primary = QMP_is_primary_node();
self = QMP_get_node_number();
get_vector(network, 1, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_dimensions());
get_vector(node, 0, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_coordinates());
printf0("network: ");
for (i = 0; i < NDIM; i++)
printf0(" %d", network[i]);
printf0("\n");
printf0("node: ");
for (i = 0; i < NDIM; i++)
printf0(" %d", node[i]);
printf0("\n");
printf0("kappa: %20.15f\n", kappa);
printf0("c_sw: %20.15f\n", c_sw);
printf0("in_iter: %d\n", in_iter);
printf0("in_eps: %15.2e\n", in_eps);
/* allocate the gauge field */
create_Mvector(U, NELEMS(U));
create_Mvector(C, NELEMS(C));
create_Dvector(F, NELEMS(F));
I_seed = QDP_create_I();
QDP_I_eq_funci(I_seed, icoord, QDP_all);
state = QDP_create_S();
QDP_S_eq_seed_i_I(state, i_seed, I_seed, QDP_all);
for (mu = 0; mu < NELEMS(U); mu++) {
QDP_M_eq_gaussian_S(U[mu], state, QDP_all);
}
for (i = 0; i < NELEMS(F); i++) {
QDP_D_eq_gaussian_S(F[i], state, QDP_all);
}
/* build the clovers */
clover(C, U);
/* initialize CLOVER */
if (QOP_CLOVER_init(&clover_state, lattice, network, node, primary,
sublattice, NULL)) {
printf0("CLOVER_init() failed\n");
goto end;
}
if (QOP_CLOVER_import_fermion(&c_f[0], clover_state, f_reader, F[0])) {
printf0("CLOVER_import_fermion(0) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[1], clover_state)) {
printf0("CLOVER_allocate_fermion(1) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[2], clover_state)) {
printf0("CLOVER_allocate_fermion(2) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[3], clover_state)) {
printf0("CLOVER_allocate_fermion(3) failed\n");
goto end;
}
if (QOP_CLOVER_import_gauge(&c_g, clover_state, kappa, c_sw,
u_reader, c_reader, NULL)) {
printf("CLOVER_import_gauge() failed\n");
goto end;
}
QOP_CLOVER_D_operator(c_f[2], c_g, c_f[0]);
cg_status = QOP_CLOVER_D_CG(c_f[3], &out_iter, &out_eps,
c_f[2], c_g, c_f[2], in_iter, in_eps,
log_flag);
msg = QOP_CLOVER_error(clover_state);
QOP_CLOVER_performance(&run_time, &flops, &sent, &received, clover_state);
QOP_CLOVER_export_fermion(f_writer, F[3], c_f[3]);
printf0("CG status: %d\n", cg_status);
printf0("CG error message: %s\n", msg? msg: "<NONE>");
printf0("CG iter: %d\n", out_iter);
printf0("CG eps: %20.10e\n", out_eps);
printf0("CG performance: runtime %e sec\n", run_time);
printf0("CG performance: flops %.3e MFlop/s (%lld)\n",
flops * 1e-6 / run_time, flops);
printf0("CG performance: snd %.3e MB/s (%lld)\n",
sent * 1e-6 / run_time, sent);
printf0("CG performance: rcv %.3e MB (%lld)/s\n",
received * 1e-6 / run_time, received);
/* free CLOVER */
QOP_CLOVER_free_gauge(&c_g);
for (i = 0; i < NELEMS(c_f); i++)
QOP_CLOVER_free_fermion(&c_f[i]);
QOP_CLOVER_fini(&clover_state);
/* Compute plaquette */
plaq = plaquette(U);
/* field norms */
for (i = 0; i < NELEMS(F); i++)
QDP_r_eq_norm2_D(&n[i], F[i], QDP_all);
/* Display the values */
printf0("plaquette = %g\n",
plaq / (QDP_volume() * QDP_Nc * NDIM * (NDIM - 1) / 2 ));
for (i = 0; i < NELEMS(F); i++)
printf0(" |f|^2 [%d] = %20.10e\n", i, (double)(n[i]));
/* Compute and display <f[1] f[0]> */
show_dot("1|orig", F[1], F[0]);
/* Compute and display <f[1] f[3]> */
show_dot("1|solv", F[1], F[3]);
QDP_destroy_S(state);
QDP_destroy_I(I_seed);
destroy_Mvector(U, NELEMS(U));
destroy_Mvector(C, NELEMS(C));
destroy_Dvector(F, NELEMS(F));
status = 0;
end:
/* shutdown QDP */
printf0("end\n");
QDP_finalize();
return status;
}
/*
* qcd.Clover(U, -- 1, {U0,U1,U2,U3}, a table of color matrices
* kappa, -- 2, double, the hopping parameter
* c_sw, -- 3, double, the clover term
* boundary) -- 4, {r/c, ...}, a table of boundary phases
*/
static int
q_clover(lua_State *L)
{
int i;
luaL_checktype(L, 1, LUA_TTABLE);
lua_pushnumber(L, 1);
lua_gettable(L, 1);
qlua_checkLatColMat3(L, -1, NULL, 3);
mLattice *S = qlua_ObjLattice(L, -1);
int Sidx = lua_gettop(L);
mClover *c = qlua_newClover(L, Sidx);
if (S->rank != QOP_CLOVER_DIM)
return luaL_error(L, "clover is not implemented for #L=%d", S->rank);
if (QDP_Ns != QOP_CLOVER_FERMION_DIM)
return luaL_error(L, "clover does not support Ns=%d", QDP_Ns);
QCArgs args;
luaL_checktype(L, 4, LUA_TTABLE);
for (i = 0; i < QOP_CLOVER_DIM; i++) {
lua_pushnumber(L, i + 1);
lua_gettable(L, 4);
switch (qlua_qtype(L, -1)) {
case qReal:
QLA_c_eq_r_plus_ir(args.bf[i], lua_tonumber(L, -1), 0);
break;
case qComplex:
QLA_c_eq_c(args.bf[i], *qlua_checkComplex(L, -1));
break;
default:
luaL_error(L, "bad clover boundary condition type");
}
lua_pop(L, 1);
}
double kappa = luaL_checknumber(L, 2);
double c_sw = luaL_checknumber(L, 3);
c->kappa = kappa;
c->c_sw = c_sw;
QDP_D3_ColorMatrix *UF[Nz];
luaL_checktype(L, 1, LUA_TTABLE);
CALL_QDP(L);
/* create a temporary F, and temp M */
for (i = QOP_CLOVER_DIM; i < Nz; i++)
UF[i] = QDP_D3_create_M_L(S->lat);
/* extract U from the arguments */
for (i = 0; i < QOP_CLOVER_DIM; i++) {
lua_pushnumber(L, i + 1); /* [sic] lua indexing */
lua_gettable(L, 1);
UF[i] = qlua_checkLatColMat3(L, -1, S, 3)->ptr;
lua_pop(L, 1);
}
int mu, nu;
QDP_Shift *neighbor = QDP_neighbor_L(S->lat);
CALL_QDP(L); /* just in case, because we touched LUA state above */
/* compute 8i*F[mu,nu] in UF[Nf...] */
for (i = 0, mu = 0; mu < QOP_CLOVER_DIM; mu++) {
for (nu = mu + 1; nu < QOP_CLOVER_DIM; nu++, i++) {
/* clover in [mu, nu] --> UF[Nu + i] */
QDP_D3_M_eq_sM(UF[Nt], UF[nu], neighbor[mu], QDP_forward,
S->all);
QDP_D3_M_eq_Ma_times_M(UF[Nt+1], UF[nu], UF[mu], S->all);
QDP_D3_M_eq_M_times_M(UF[Nt+2], UF[Nt+1], UF[Nt], S->all);
QDP_D3_M_eq_sM(UF[Nt+3], UF[Nt+2], neighbor[nu], QDP_backward,
S->all);
QDP_D3_M_eq_M_times_Ma(UF[Nt+4], UF[Nt+3], UF[mu], S->all);
QDP_D3_M_eq_sM(UF[Nt+1], UF[mu], neighbor[nu], QDP_forward,
S->all);
QDP_D3_M_eq_Ma_times_M(UF[Nt+5], UF[mu], UF[Nt+3], S->all);
QDP_D3_M_eq_M_times_Ma(UF[Nt+2], UF[Nt], UF[Nt+1], S->all);
QDP_D3_M_eq_M_times_Ma(UF[Nt+3], UF[Nt+2], UF[nu], S->all);
QDP_D3_M_peq_M_times_M(UF[Nt+4], UF[mu], UF[Nt+3], S->all);
QDP_D3_M_peq_M_times_M(UF[Nt+5], UF[Nt+3], UF[mu], S->all);
QDP_D3_M_eq_sM(UF[Nt+2], UF[Nt+5], neighbor[mu], QDP_backward,
S->all);
QDP_D3_M_peq_M(UF[Nt+4], UF[Nt+2], S->all);
QDP_D3_M_eq_M(UF[Nu+i], UF[Nt+4], S->all);
QDP_D3_M_meq_Ma(UF[Nu+i], UF[Nt+4], S->all);
}
}
args.lat = S->lat;
/* create the clover state */
QDP_latsize_L(S->lat, args.lattice);
struct QOP_CLOVER_Config cc;
cc.self = S->node;
cc.master_p = QMP_is_primary_node();
cc.rank = S->rank;
cc.lat = S->dim;
cc.net = S->net;
cc.neighbor_up = S->neighbor_up;
cc.neighbor_down = S->neighbor_down;
cc.sublattice = qlua_sublattice;
cc.env = S;
if (QOP_CLOVER_init(&c->state, &cc))
return luaL_error(L, "CLOVER_init() failed");
/* import the gauge field */
for (i = 0; i < Nt; i++) {
args.uf[i] = QDP_D3_expose_M(UF[i]);
}
if (QOP_CLOVER_import_gauge(&c->gauge, c->state, kappa, c_sw,
q_CL_u_reader, q_CL_f_reader, &args)) {
return luaL_error(L, "CLOVER_import_gauge() failed");
}
for (i = 0; i < Nt; i++)
QDP_D3_reset_M(UF[i]);
/* clean up temporaries */
for (i = QOP_CLOVER_DIM; i < Nz; i++)
QDP_D3_destroy_M(UF[i]);
return 1;
}
int
main(int argc, char *argv[])
{
struct QOP_MDWF_State *mdwf_state = NULL;
QMP_thread_level_t qt = QMP_THREAD_SINGLE;
int status = 1;
int vx[4];
int i;
if (QMP_init_msg_passing(&argc, &argv, qt, &qt) != QMP_SUCCESS) {
fprintf(stderr, "QMP_init() failed\n");
return 1;
}
for (i = 0; i < NELEM(b5); i++) {
b5[i] = 0.1 * i * (NELEM(b5) - i);
c5[i] = 0.1 * i * i * (NELEM(b5) - i);
}
self = QMP_get_node_number();
primary = QMP_is_primary_node();
for (i = 0; i < argc; i++)
zprint("arg[%d]=%s", i, argv[i]);
if (argc != 14) {
zprint("14 arguments expected, found %d", argc);
QMP_finalize_msg_passing();
return 1;
}
for (i = 0; i < 4; i++) {
mynetwork[i] = atoi(argv[i+1]);
mylocal[i] = atoi(argv[i+5]);
vx[i] = atoi(argv[i+10]);
mylattice[i] = mylocal[i] * mynetwork[i];
}
mylocal[4] = mylattice[4] = atoi(argv[9]);
zshowv4("network", mynetwork);
zshowv5("local lattice", mylocal);
zshowv5("lattice", mylattice);
getv(mynode, 0, 4, vx);
xshowv("node", mynode);
if (QOP_MDWF_init(&mdwf_state,
mylattice, mynetwork, mynode, primary,
getsub, NULL)) {
zprint("MDWF_init() failed");
goto end;
}
zprint("MDWF_init() done");
dump_state(mdwf_state);
QOP_MDWF_fini(&mdwf_state);
status = 0;
end:
QMP_finalize_msg_passing();
return status;
}
int
main(int argc, char *argv[])
{
int status = 1;
int mu, i;
struct QOP_CLOVER_State *clover_state;
QDP_Int *I_seed;
int i_seed;
QDP_RandomState *state;
QLA_Real plaq;
QLA_Real n[NELEMS(F)];
struct QOP_CLOVER_Gauge *c_g;
struct QOP_CLOVER_Fermion *c_f[NELEMS(F)];
double kappa;
double c_sw;
/* start QDP */
QDP_initialize(&argc, &argv);
if (argc != 1 + NDIM + 3) {
printf0("ERROR: usage: %s Lx ... seed kappa c_sw\n", argv[0]);
goto end;
}
for (mu = 0; mu < NDIM; mu++) {
lattice[mu] = atoi(argv[1 + mu]);
}
i_seed = atoi(argv[1 + NDIM]);
kappa = atof(argv[2 + NDIM]);
c_sw = atof(argv[3 + NDIM]);
/* set lattice size and create layout */
QDP_set_latsize(NDIM, lattice);
QDP_create_layout();
primary = QMP_is_primary_node();
self = QMP_get_node_number();
get_vector(network, 1, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_dimensions());
get_vector(node, 0, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_coordinates());
printf0("network: ");
for (i = 0; i < NDIM; i++)
printf0(" %d", network[i]);
printf0("\n");
printf0("node: ");
for (i = 0; i < NDIM; i++)
printf0(" %d", node[i]);
printf0("\n");
printf0("kappa: %20.15f\n", kappa);
printf0("c_sw: %20.15f\n", c_sw);
/* allocate the gauge field */
create_Mvector(U, NELEMS(U));
create_Mvector(C, NELEMS(C));
create_Dvector(F, NELEMS(F));
I_seed = QDP_create_I();
QDP_I_eq_funci(I_seed, icoord, QDP_all);
state = QDP_create_S();
QDP_S_eq_seed_i_I(state, i_seed, I_seed, QDP_all);
for (mu = 0; mu < NELEMS(U); mu++) {
QDP_M_eq_gaussian_S(U[mu], state, QDP_all);
}
for (i = 0; i < NELEMS(F); i++) {
QDP_D_eq_gaussian_S(F[i], state, QDP_all);
}
/* build the clovers */
clover(C, U);
/* initialize CLOVER */
if (QOP_CLOVER_init(&clover_state, lattice, network, node, primary,
sublattice, NULL)) {
printf0("CLOVER_init() failed\n");
goto end;
}
if (QOP_CLOVER_import_fermion(&c_f[0], clover_state, f_reader, F[0])) {
printf0("CLOVER_import_fermion(0) failed\n");
goto end;
}
if (QOP_CLOVER_import_fermion(&c_f[1], clover_state, f_reader, F[1])) {
printf0("CLOVER_import_fermion(1) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[2], clover_state)) {
printf0("CLOVER_allocate_fermion(2) failed\n");
goto end;
}
if (QOP_CLOVER_allocate_fermion(&c_f[3], clover_state)) {
printf0("CLOVER_allocate_fermion(3) failed\n");
goto end;
}
if (QOP_CLOVER_import_gauge(&c_g, clover_state, kappa, c_sw,
u_reader, c_reader, NULL)) {
printf("CLOVER_import_gauge() failed\n");
goto end;
}
QOP_CLOVER_D_operator(c_f[2], c_g, c_f[0]);
QOP_CLOVER_export_fermion(f_writer, F[2], c_f[2]);
QOP_CLOVER_D_operator_conjugated(c_f[3], c_g, c_f[1]);
QOP_CLOVER_export_fermion(f_writer, F[3], c_f[3]);
/* free CLOVER */
QOP_CLOVER_free_gauge(&c_g);
for (i = 0; i < NELEMS(c_f); i++)
QOP_CLOVER_free_fermion(&c_f[i]);
QOP_CLOVER_fini(&clover_state);
/* Compute plaquette */
plaq = plaquette(U);
/* field norms */
for (i = 0; i < NELEMS(F); i++)
QDP_r_eq_norm2_D(&n[i], F[i], QDP_all);
/* Display the values */
printf0("plaquette = %g\n",
plaq / (QDP_volume() * QDP_Nc * NDIM * (NDIM - 1) / 2 ));
for (i = 0; i < NELEMS(F); i++)
printf0(" |f|^2 [%d] = %20.10e\n", i, (double)(n[i]));
/* Compute and display <f[1] f[2]> */
show_dot("1|D0", F[1], F[2]);
/* Compute and display <f[3] f[0]> */
show_dot("X1|0", F[3], F[0]);
QDP_destroy_S(state);
QDP_destroy_I(I_seed);
destroy_Mvector(U, NELEMS(U));
destroy_Mvector(C, NELEMS(C));
destroy_Dvector(F, NELEMS(F));
status = 0;
end:
/* shutdown QDP */
printf0("end\n");
QDP_finalize();
return status;
}
void test_solver(BfmSolver solver)
{
g5dParams parms;
int Ls=16;
double M5=1.8;
double mq=0.0001;
double wilson_lo = 0.05;
double wilson_hi = 6.8;
double shamir_lo = 0.025;
double shamir_hi = 1.7;
double ht_scale=1.7;
double hw_scale=1.0;
if ( solver != DWF ) {
exit(0);
Printf("Should be testing HtCayleyTanh aka DWF\n");
}
parms.pDWF(mq,M5,Ls);
multi1d<LatticeColorMatrix> u(4);
HotSt(u);
// ArchivGauge_t Header ; readArchiv(Header,u,"ckpoint_lat.3000");
multi1d<LatticeFermion> src(Ls);
/* Rudy calculate some eigenvectors */
BfmWrapperParams BWP;
BWP.BfmInverter = BfmInv_CG;
BWP.BfmMatrix = BfmMat_M;
BWP.BfmPrecision= Bfm64bit;
BWP.MaxIter = 10000;
BWP.RsdTarget.resize(1);
BWP.RsdTarget[0]= 1.0e-9;
BWP.Delta = 1.0e-4;
BWP.BAP = parms;
BfmWrapper bfm(BWP);
bfmarg bfma;
#if defined(QDP_USE_OMP_THREADS)
bfma.Threads(omp_get_max_threads());
#else
bfma.Threads(16);
#endif
bfma.Verbose(0);
//Physics parameters
bfmActionParams *bfmap = (bfmActionParams *) &bfma;
*bfmap = bfm.invParam.BAP;
// Algorithm & code control
bfma.time_report_iter=-100;
bfma.max_iter = bfm.invParam.MaxIter;
bfma.residual = toDouble(bfm.invParam.RsdTarget[0]);
int lx = QDP::Layout::subgridLattSize()[0];
int ly = QDP::Layout::subgridLattSize()[1];
int lz = QDP::Layout::subgridLattSize()[2];
int lt = QDP::Layout::subgridLattSize()[3];
//Geometry
bfma.node_latt[0] = lx;
bfma.node_latt[1] = ly;
bfma.node_latt[2] = lz;
bfma.node_latt[3] = lt;
multi1d<int> procs = QDP::Layout::logicalSize();
for(int mu=0;mu<4;mu++){
if (procs[mu]>1) bfma.local_comm[mu] = 0;
else bfma.local_comm[mu] = 1;
}
// Bfm object
bfm_qdp<double> bfm_eig;
bfm_eig.init(bfma);
//Gauge field import
bfm_eig.importGauge(u);
//Subspace
#define NumberGaussian (1)
Fermion_t subspace[NumberGaussian];
Fermion_t check;
Fermion_t mp;
Fermion_t mmp;
Fermion_t tmp_t;
check = bfm_eig.allocFermion();
mp = bfm_eig.allocFermion();
mmp = bfm_eig.allocFermion();
tmp_t = bfm_eig.allocFermion();
bfm_eig.importFermion(src,check,1);
QDPIO::cout << "Ls = "<<Ls<<endl;
for(int g=0;g<NumberGaussian;g++){
for(int s=0;s<Ls;s++){
gaussian(src[s]);
}
subspace[g]=bfm_eig.allocFermion();
bfm_eig.importFermion(src,subspace[g],1); // Half parity gaussian
if ( g==0) {
bfm_eig.importFermion(src,check,1);
}
for(int s=0;s<Ls;s++){
src[s]=zero;
}
bfm_eig.exportFermion(src,subspace[g],1);
QDPIO::cout << "Subspace norm " << norm2(src)<<endl;
}
for(int s=0;s<Ls;s++){
gaussian(src[s]);
}
QDPIO::cout << "Got here " << endl;
// Handle< LinearOperatorArray<T> > linop =GetLinOp(u, parms);
int block[5];
for(int i=0;i<5;i++) block[i]=4;
QDPIO::cout << "Initialised dirac op"<<endl;
BfmLittleDiracOperator ldop(Ls,NumberGaussian,block,subspace,&bfm_eig);
int ns = ldop.SubspaceDimension();
QDPIO::cout << "subspace dimension is "<< ns<<endl;
ns = ldop.SubspaceLocalDimension();
QDPIO::cout << "subspace dimension per node is "<< ns<<endl;
std::vector<std::complex<double> > decomp(ns);
ldop.ProjectToSubspace(check,decomp);
if (QMP_is_primary_node()){
FILE * fp = fopen("coeff.dat","w");
for(int s=0;s<ns;s++){
fprintf(fp,"coeff %d %le %le\n",s,real(decomp[s]),imag(decomp[s]));
}
fclose(fp);
}
for(int s=0;s<ns;s++){
QDPIO::cout << "coeff "<<s<<" " << real(decomp[s]) << " " << imag(decomp[s])<<endl;
}
ldop.PromoteFromSubspace(decomp,mp);
double n;
#pragma omp parallel
{
omp_set_num_threads(bfm_eig.nthread);
#pragma omp for
for(int t=0;t<bfm_eig.nthread;t++) {
bfm_eig.axpy(check,mp,check,-1);
n = bfm_eig.norm(check);
}
}
QDPIO::cout << "project/promote n2diff "<< n<<endl;
QMP_barrier();
QDPIO::cout << "Computing little dirac matrix"<<endl;
ldop.ComputeLittleMatrixColored();
QDPIO::cout << "Done"<<endl;
std::vector<std::complex<double> > Aphi(ns);
// phi^dag DdagD phi = |Dphi|^2 with phi a subspace vector
// should be equal to Project/Apply/Promote + inner product
#pragma omp parallel
{
#pragma omp for
for(int t=0;t<bfm_eig.nthread;t++) {
bfm_eig.Mprec(subspace[0],mp,tmp_t,0);
}
}
QDPIO::cout << "Applied BFM matrix "<<endl;
double n2;
#pragma omp parallel
{
omp_set_num_threads(bfm_eig.nthread);
#pragma omp for
for(int t=0;t<bfm_eig.nthread;t++) {
n2 = bfm_eig.norm(mp);
}
}
QDPIO::cout << "Applied BFM matrix "<<n2<<endl;
ldop.ProjectToSubspace(subspace[0],decomp);
QDPIO::cout << "Projected to subspace "<<endl;
ldop.Apply(decomp,Aphi);
QDPIO::cout << "Applied A "<<endl;
ldop.PromoteFromSubspace(Aphi,check);
QDPIO::cout << "Promoted "<<endl;
complex<double> inn;
#pragma omp parallel
{
#pragma omp for
for(int t=0;t<bfm_eig.nthread;t++) {
inn = bfm_eig.inner(subspace[0],check);
}
}
QDPIO::cout << "phi^dag Ddag D phi check " << n2 << " " <<real(inn) << imag(inn) <<endl;
std::vector<std::complex<double> > AinvAphi(ns);
ldop.ProjectToSubspace(subspace[0],decomp);
ldop.Apply(decomp,Aphi);
for(int s=0;s<ns;s++){
QDPIO::cout << "Aphi "<<s<<" " << real(Aphi[s]) <<" " << imag(Aphi[s])<<endl;
}
ldop.PromoteFromSubspace(Aphi,check);
#pragma omp parallel
{
#pragma omp for
for(int t=0;t<bfm_eig.nthread;t++) {
bfm_eig.Mprec(subspace[0],mp,tmp_t,0);
bfm_eig.Mprec(mp,mmp,tmp_t,1);
}
}
ldop.ProjectToSubspace(mmp,decomp);
ldop.PromoteFromSubspace(decomp,mmp);
#pragma omp parallel
{
#pragma omp for
for(int t=0;t<bfm_eig.nthread;t++) {
bfm_eig.axpy(check,mmp,check,-1.0);
n2 = bfm_eig.norm(check);
}
}
QDPIO::cout << "PMdagMP check n2diff "<< n2<<endl;
QMP_barrier();
QDPIO::cout << "Applying inverse"<<endl;
ldop.ApplyInverse(Aphi,AinvAphi);
QMP_barrier();
for(int s=0;s<ns;s++){
QDPIO::cout << "AinvAphi "<<s<<" " << real(AinvAphi[s]) << " " << imag(AinvAphi[s])<<endl;
}
ldop.PromoteFromSubspace(AinvAphi,check);
#pragma omp parallel
{
#pragma omp for
for(int t=0;t<bfm_eig.nthread;t++) {
bfm_eig.axpy(check,subspace[0],check,-1.0);
n2 = bfm_eig.norm(check);
}
}
QDPIO::cout << "AinvA check n2diff "<< n2<<endl;
}
int
main(int argc, char *argv[])
{
struct QOP_MDWF_State *mdwf_state = NULL;
struct QOP_MDWF_Parameters *mdwf_params = NULL;
QMP_thread_level_t qt = QMP_THREAD_SINGLE;
int status = 1;
int i;
if (QMP_init_msg_passing(&argc, &argv, qt, &qt) != QMP_SUCCESS) {
fprintf(stderr, "QMP_init() failed\n");
return 1;
}
for (i = 0; i < NELEM(b5); i++) {
b5[i] = 0.1 * i * (NELEM(b5) - i);
c5[i] = 0.1 * i * i * (NELEM(b5) - i);
}
self = QMP_get_node_number();
primary = QMP_is_primary_node();
if (argc != 7) {
zprint("7 arguments expected, found %d", argc);
zprint("usage: localheat Lx Ly Lz Lt Ls time");
QMP_finalize_msg_passing();
return 1;
}
for (i = 0; i < 4; i++) {
mynetwork[i] = 1;
mylocal[i] = atoi(argv[i+1]);
mylattice[i] = mylocal[i] * mynetwork[i];
}
mylocal[4] = mylattice[4] = atoi(argv[5]);
total_sec = atoi(argv[6]);
zshowv4("network", mynetwork);
zshowv5("local lattice", mylocal);
zshowv5("lattice", mylattice);
zprint("total requested runtime %.0f sec", total_sec);
#if 0
if (QMP_declare_logical_topology(mynetwork, 4) != QMP_SUCCESS) {
zprint("declare_logical_top failed");
goto end;
}
getv(mynode, 0, QMP_get_logical_number_of_dimensions(),
QMP_get_logical_coordinates());
#else
{ int i;
for (i = 0; i < 4; i++)
mynode[i] = 0;
}
#endif
if (QOP_MDWF_init(&mdwf_state,
mylattice, mynetwork, mynode, primary,
getsub, NULL)) {
zprint("MDWF_init() failed");
goto end;
}
zprint("MDWF_init() done");
if (QOP_MDWF_set_generic(&mdwf_params, mdwf_state, b5, c5, 0.123, 0.05)) {
zprint("MDW_set_generic() failed");
goto end;
}
zprint("MDWF_set_generic() done");
if (do_run(mdwf_state, mdwf_params)) {
zprint("float test failed");
goto end;
}
QOP_MDWF_fini(&mdwf_state);
zprint("Heater test finished");
status = 0;
end:
QMP_finalize_msg_passing();
return status;
}