void curses_init()
{
null = g_fopen("/dev/null", "w");
unsetenv("COLUMNS");
unsetenv("LINES");
initscr();
noecho();
nonl();
cbreak();
keypad(stdscr, TRUE);
meta(stdscr, TRUE);
intrflush(stdscr, FALSE);
leaveok(stdscr, TRUE);
if (has_colors())
{
start_color();
use_default_colors();
init_pair(COLORPAIR, conf.fg, conf.bg);
}
else
conf.color = FALSE;
curs_set(false);
ws = newwin(1, COLS, EL, 0);
view.current = 0;
view.top_x = 0;
view.top_y = 0;
prompt.buf = g_string_new("");
prompt.on = false;
prompt.regex = NULL;
grid = g_array_sized_new(FALSE, TRUE, sizeof(grid_line_t*), SL);
for (glong i = 0; i < SL; i++)
{
grid_line_t* grid_line = g_malloc(sizeof(grid_line_t));
g_array_append_val(grid, grid_line);
}
regrid();
}
// Meshes are already committed
int online_regrid(Mesh &srcmesh, Mesh &dstmesh, IWeights &wts,
int *regridConserve, int *regridMethod,
int *regridScheme, int *unmappedaction) {
// Conflict management
int regridPoleType = ESMC_REGRID_POLETYPE_ALL;
int regridPoleNPnts = 0;
// Conservative regridding
switch (*regridConserve) {
case (ESMC_REGRID_CONSERVE_ON): {
// Get the integration weights
MEField<> *src_iwts = srcmesh.GetField("iwts");
if (!src_iwts) Throw() << "Integration weights needed for conservative regridding."
<<std::endl;
MEField<> *dst_iwts = dstmesh.GetField("iwts");
if (!dst_iwts) Throw() << "Integration weights needed for conservative regridding."
<<std::endl;
if (!csrv(srcmesh, dstmesh, wts, src_iwts, dst_iwts, regridMethod, regridScheme,
®ridPoleType, ®ridPoleNPnts, unmappedaction))
Throw() << "Conservative regridding error" << std::endl;
} break;
// NON Conservative regridding
case (ESMC_REGRID_CONSERVE_OFF): {
if (!regrid(srcmesh, dstmesh, wts, regridMethod, regridScheme,
®ridPoleType, ®ridPoleNPnts, unmappedaction))
Throw() << "Regridding error" << std::endl;
// Remove non-locally owned weights (assuming destination mesh decomposition)
wts.Prune(dstmesh, 0);
} break;
default:
Throw() << "Regridding method:" << *regridConserve << " is not implemented";
}
return 1;
}
int main(int argc, char* argv[])
{
int i, ia, na, nx, ns, dim, n[SF_MAX_DIM], m[SF_MAX_DIM];
float a0, *pp, *qq;
bool adj;
sf_filter aa;
char* lagfile;
sf_file in, out, filt, lag;
sf_init (argc,argv);
in = sf_input("in");
filt = sf_input("filt");
out = sf_output("out");
dim = sf_filedims (in,n);
if (!sf_histint(filt,"n1",&na)) sf_error("No n1= in filt");
aa = sf_allocatehelix (na);
if (!sf_histfloat(filt,"a0",&a0)) a0=1.;
sf_floatread (aa->flt,na,filt);
for( ia=0; ia < na; ia++) {
aa->flt[ia] /= a0;
}
if (NULL != (lagfile = sf_getstring("lag")) /* file with filter lags */
||
NULL != (lagfile = sf_histstring(filt,"lag"))) {
lag = sf_input(lagfile);
sf_intread(aa->lag,na,lag);
} else {
lag = NULL;
for( ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
}
sf_fileclose(filt);
if (!sf_getints ("n",m,dim) && (NULL == lag ||
!sf_histints (lag,"n",m,dim))) {
for (i=0; i < dim; i++) {
m[i] = n[i];
}
}
if (NULL != lag) sf_fileclose(lag);
regrid (dim, m, n, aa);
if (!sf_getbool ("adj",&adj)) adj=false;
/* if y, do adjoint operation */
if (!sf_getint ("ns",&ns)) sf_error("Need ns=");
/* scaling */
nx = 1;
for( i=0; i < dim; i++) {
nx *= n[i];
}
pp = sf_floatalloc (nx);
qq = sf_floatalloc (nx);
if (adj) {
sf_floatread (qq,nx,in);
} else {
sf_floatread (pp,nx,in);
}
hshape_init (nx,ns,aa);
hshape_lop (adj,false,nx,nx,pp,qq);
if (adj) {
sf_floatwrite (pp,nx,out);
} else {
sf_floatwrite (qq,nx,out);
}
exit (0);
}
int main(int argc, char* argv[])
{
bool spitz, verb;
int niter, sa, na, j, dim, nx, n[SF_MAX_DIM], m[SF_MAX_DIM];
float *dd, *ss, eps, na0, sa0;
char varname[6], *lagfile;
sf_filter naa, saa;
sf_file spef, npef, dat, signoi, slag, nlag;
sf_init(argc,argv);
dat = sf_input("in");
signoi = sf_output("out");
spef = sf_input("sfilt");
npef = sf_input("nfilt");
dim = sf_filedims(dat,n);
if (!sf_histint(spef,"n1",&sa)) sf_error("No n1= in sfilt");
if (!sf_histint(npef,"n1",&na)) sf_error("No n1= in nfilt");
naa = sf_allocatehelix(na);
saa = sf_allocatehelix(sa);
if (NULL == (lagfile = sf_histstring(spef,"lag")) &&
NULL == (lagfile = sf_getstring("slag")))
sf_error("Need slag=");
slag = sf_input(lagfile);
if (!sf_histints(slag,"n",m,dim)) sf_error("No n= in %s",lagfile);
sf_intread(saa->lag,sa,slag);
regrid(dim,m,n,saa);
sf_fileclose(slag);
if (NULL == (lagfile = sf_histstring(npef,"lag")) &&
NULL == (lagfile = sf_getstring("nlag")))
sf_error("Need nlag=");
nlag = sf_input(lagfile);
if (!sf_histints(nlag,"n",m,dim)) sf_error("No n= in %s",lagfile);
sf_intread(naa->lag,na,nlag);
regrid(dim,m,n,naa);
sf_fileclose(nlag);
if (!sf_histfloat(spef,"a0",&sa0)) sa0=1.;
if (!sf_histfloat(npef,"a0",&na0)) na0=1.;
if (!sf_getfloat("epsilon",&eps)) sf_error("Need eps=");
/* regularization parameter */
if (!sf_getint("niter",&niter)) niter=20;
/* number of iterations */
sprintf(varname,"n%d",dim+1);
sf_putint(signoi,varname,2);
nx=1;
for(j=0; j < dim; j++) {
nx *= n[j];
}
dd = sf_floatalloc(nx);
ss = sf_floatalloc(nx);
sf_floatread(dd,nx,dat);
sf_floatread(saa->flt,sa,spef);
for (j=0; j < sa; j++) {
saa->flt[j] /= sa0;
}
sf_floatread(naa->flt,na,npef);
for (j=0; j < na; j++) {
naa->flt[j] /= na0;
}
if (!sf_getbool("spitz",&spitz)) spitz=false;
/* if use Spitz method */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
signoi_init (naa, saa, niter, nx, eps, verb);
if (spitz) {
signoi2_lop (false,false,nx,nx,dd,ss);
} else {
signoi_lop (false,false,nx,nx,dd,ss);
}
sf_floatwrite(ss,nx,signoi);
for (j=0; j < nx; j++) {
dd[j] -= ss[j];
}
sf_floatwrite(dd,nx,signoi);
exit (0);
}
// Mesh are not committed yet
int offline_regrid(Mesh &srcmesh, Mesh &dstmesh, Mesh &dstmeshcpy,
int *regridConserve, int *regridMethod,
int *regridPoleType, int *regridPoleNPnts,
char *srcGridFile, char *dstGridFile, char *wghtFile) {
// Conflict management
int regridScheme = ESMC_REGRID_SCHEME_FULL3D;
int unmappedaction = ESMC_UNMAPPEDACTION_ERROR;
IWeights wts;
MEField<> *src_iwts, *dst_iwts, *dst_iwtscpy;
switch (*regridConserve) {
// Conservative regridding
case (ESMC_REGRID_CONSERVE_ON): {
// Add fields to mesh
Context ctxt; ctxt.flip();
src_iwts = srcmesh.RegisterField("iwts",
MEFamilyStd::instance(), MeshObj::ELEMENT, ctxt, 1, true);
dst_iwts = dstmesh.RegisterField("iwts",
MEFamilyStd::instance(), MeshObj::ELEMENT, ctxt, 1, true);
// generate integration weights on the copy
// TODO: remove this (and the dstcpy mesh passed in) when the
// write bug with pole assimilation is fixed.
dst_iwtscpy = dstmeshcpy.RegisterField("iwts",
MEFamilyStd::instance(), MeshObj::ELEMENT, ctxt, 1, true);
dstmeshcpy.Commit();
Integrate dig(dstmeshcpy);
dig.clearWeights(dst_iwtscpy);
if (regridScheme == ESMC_REGRID_SCHEME_FULL3D) {
for (UInt i = 1; i <= 7; ++i)
dig.AddPoleWeights(dstmeshcpy,i,dst_iwtscpy);
}
dig.intWeights(dst_iwtscpy);
// Commit the meshes
srcmesh.Commit();
dstmesh.Commit();
if (!csrv(srcmesh, dstmesh, wts, src_iwts, dst_iwts, regridMethod, ®ridScheme,
regridPoleType, regridPoleNPnts, &unmappedaction))
Throw() << "Conservative regridding error" << std::endl;
} break;
// NON Conservative regridding
case (ESMC_REGRID_CONSERVE_OFF): {
// Commit the meshes
srcmesh.Commit();
dstmesh.Commit();
dstmeshcpy.Commit();
if (!regrid(srcmesh, dstmesh, wts, regridMethod, ®ridScheme,
regridPoleType, regridPoleNPnts, &unmappedaction))
Throw() << "Regridding error" << std::endl;
// the mask
MEField<> *mask = dstmesh.GetField("MASK_IO");
ThrowRequire(mask);
wts.Prune(dstmesh, mask);
} break;
default:
Throw() << "Regridding method:" << *regridConserve << " is not implemented";
}
// Redistribute weights in an IO friendly decomposition
if (Par::Rank() == 0) std::cout << "Writing weights to " << wghtFile << std::endl;
GatherForWrite(wts);
// Write the weights
WriteNCMatFilePar(srcGridFile, dstGridFile, wghtFile,
wts, srcmesh, dstmesh, dstmeshcpy,
regridConserve, regridMethod, NCMATPAR_ORDER_SEQ);
return 1;
}
void node_server::start_run(bool scf) {
integer output_cnt;
if (!hydro_on) {
save_to_file("X.chk");
diagnostics();
return;
}
printf("%e %e\n", grid::get_A(), grid::get_B());
if (scf) {
run_scf();
set_pivot();
printf("Adjusting velocities:\n");
auto diag = diagnostics();
space_vector dv;
dv[XDIM] = -diag.grid_sum[sx_i] / diag.grid_sum[rho_i];
dv[YDIM] = -diag.grid_sum[sy_i] / diag.grid_sum[rho_i];
dv[ZDIM] = -diag.grid_sum[sz_i] / diag.grid_sum[rho_i];
this->velocity_inc(dv);
save_to_file("scf.chk");
}
printf("Starting...\n");
solve_gravity(false);
int ngrids = regrid(me.get_gid(), false);
real output_dt = opts.output_dt;
printf("OMEGA = %e, output_dt = %e\n", grid::get_omega(), output_dt);
real& t = current_time;
integer step_num = 0;
auto fut_ptr = me.get_ptr();
node_server* root_ptr = fut_ptr.get();
output_cnt = root_ptr->get_rotation_count() / output_dt;
hpx::future<void> diag_fut = hpx::make_ready_future();
hpx::future<void> step_fut = hpx::make_ready_future();
profiler_output (stdout);
real bench_start, bench_stop;
while (current_time < opts.stop_time) {
auto time_start = std::chrono::high_resolution_clock::now();
if (root_ptr->get_rotation_count() / output_dt >= output_cnt) {
// if (step_num != 0) {
char* fname;
if (asprintf(&fname, "X.%i.chk", int(output_cnt))) {
}
save_to_file(fname);
free(fname);
if (asprintf(&fname, "X.%i.silo", int(output_cnt))) {
}
output(fname, output_cnt, false);
free(fname);
// SYSTEM(std::string("cp *.dat ./dat_back/\n"));
// }
++output_cnt;
}
if (step_num == 0) {
bench_start = MPI_Wtime();
}
// break;
auto ts_fut = hpx::async([=]() {return timestep_driver();});
step();
real dt = ts_fut.get();
real omega_dot = 0.0, omega = 0.0, theta = 0.0, theta_dot = 0.0;
if (opts.problem == DWD) {
auto diags = diagnostics();
const real dx = diags.secondary_com[XDIM] - diags.primary_com[XDIM];
const real dy = diags.secondary_com[YDIM] - diags.primary_com[YDIM];
const real dx_dot = diags.secondary_com_dot[XDIM] - diags.primary_com_dot[XDIM];
const real dy_dot = diags.secondary_com_dot[YDIM] - diags.primary_com_dot[YDIM];
theta = atan2(dy, dx);
omega = grid::get_omega();
theta_dot = (dy_dot * dx - dx_dot * dy) / (dx * dx + dy * dy) - omega;
const real w0 = grid::get_omega() * 100.0;
const real theta_dot_dot = (2.0 * w0 * theta_dot + w0 * w0 * theta);
omega_dot = theta_dot_dot;
omega += omega_dot * dt;
// omega_dot += theta_dot_dot*dt;
grid::set_omega(omega);
}
double time_elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::high_resolution_clock::now() - time_start).count();
step_fut.get();
step_fut =
hpx::async(
[=]() {
FILE* fp = fopen( "step.dat", "at");
fprintf(fp, "%i %e %e %e %e %e %e %e %e %i\n", int(step_num), double(t), double(dt), time_elapsed, rotational_time, theta, theta_dot, omega, omega_dot, int(ngrids));
fclose(fp);
});
printf("%i %e %e %e %e %e %e %e %e\n", int(step_num), double(t), double(dt), time_elapsed, rotational_time, theta, theta_dot, omega, omega_dot);
// t += dt;
++step_num;
if (step_num % refinement_freq() == 0) {
ngrids = regrid(me.get_gid(), false);
FILE* fp = fopen("profile.txt", "wt");
profiler_output(fp);
fclose(fp);
// set_omega_and_pivot();
bench_stop = MPI_Wtime();
if (scf || opts.bench) {
printf("Total time = %e s\n", double(bench_stop - bench_start));
FILE* fp = fopen("bench.dat", "at");
fprintf(fp, "%i %e\n", int(hpx::find_all_localities().size()), double(bench_stop - bench_start));
fclose(fp);
break;
}
}
// set_omega_and_pivot();
if (scf) {
bench_stop = MPI_Wtime();
printf("Total time = %e s\n", double(bench_stop - bench_start));
// FILE* fp = fopen( "bench.dat", "at" );
// fprintf( fp, "%i %e\n", int(hpx::find_all_localities().size()), double(bench_stop - bench_start));
// fclose(fp);
break;
}
}
compare_analytic();
output("final.silo", output_cnt, true);
}
int main(int argc, char* argv[])
{
int n[SF_MAX_DIM], m[SF_MAX_DIM];
int ndim, dim, n123, n123s, i, ia, ns, i1, na, i4, n4;
float *f, *dd;
char *lagfile;
sf_filter aa;
sf_file in, filt, lag, out;
sf_init(argc,argv);
in = sf_input("in");
filt = sf_output("filt");
out = sf_output("out");
if (!sf_histint(filt,"n1",&na)) sf_error("No n1= in filt");
aa = sf_allocatehelix (na);
if (NULL != (lagfile = sf_getstring("lag"))
/*( lag file with filter lags )*/
||
NULL != (lagfile = sf_histstring(filt,"lag"))) {
lag = sf_input(lagfile);
sf_intread(aa->lag,na,lag);
} else {
lag = NULL;
for( ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
}
ndim = sf_filedims(in,n);
if (!sf_getint("dim",&dim)) dim=ndim; /* number of dimensions */
if (!sf_getints ("n",m,dim) && (NULL == lag ||
!sf_histints (lag,"n",m,dim))) {
for (i=0; i < dim; i++) {
m[i] = n[i];
}
}
regrid (dim, m, n, aa);
n4 = sf_leftsize(in,dim);
n123 = 1;
for (i=0; i < dim; i++) {
n123 *= n[i];
}
dd = sf_floatalloc(n123);
n123s = n123*na;
f = sf_floatalloc(n123s);
for (i4=0; i4 < n4; i4++) {
sf_floatread(dd,n123,in);
sf_floatread(f,n123s,in);
/* apply shifts: dd -> d */
for (i=ia=0; ia < na; ia++) {
ns = aa->lag[ia];
for (i1=0; i1 < n123; i1++,i++) {
dd[i1] -= f[i]*dd[i1-ns];
}
}
sf_floatwrite(dd,n123,out);
}
exit(0);
}
