void validateArgs(ARGS * args) {
if(args->n == SET){
if(sscanf(args->nproc, "%d", &args->n_proc) <= 0 ) {
fprintf(stderr, "Argument prepinaca -n nie je cislo!\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
if(args->n_proc < 4){
fprintf(stderr, "Argument prepinaca -n musi byt vacsi ako 4\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
}
}
void parseArgs(int argc, char * argv[], ARGS * args) {
int opt;
args->h = UNSET;
args->n = UNSET;
args->nproc = NULL;
args->n_proc = 4;
args->f = UNSET;
args->file_name = NULL;
static struct option long_options[] = {
{"help", 0, NULL, 'h'},
{"n_proc", 1, NULL, 'n'},
{"file", 1, NULL, 'f'},
{0, 0, 0, 0}
};
int option_index = 0;
do {
opt = getopt_long(argc, argv, ":hn:f:", long_options, &option_index);
switch (opt) {
case 'h':
args->h = SET;
printHelpAndExit(stderr, EXIT_SUCCESS);
break;
case 'n':
args->n = SET;
args->nproc = optarg;
break;
case 'f':
args->f = SET;
args->file_name = optarg;
break;
case '?':
fprintf(stderr,"Neznama volba -%c\n", optopt);
printHelpAndExit(stderr, EXIT_FAILURE);
case ':':
fprintf(stderr, "Nebol zadany argument prepinaca '-%c'\n", optopt);
printHelpAndExit(stderr, EXIT_FAILURE);
default:
break;
}
} while(opt != -1);
while(optind < argc ) {
printf("Debug: non-option ARGV-element: %s\n", argv[optind++]);
printHelpAndExit(stderr, EXIT_FAILURE);
}
}
void parseArguments(int argc,char *argv[], ARGS *args) {
initArguments(args);
struct option long_opts[] = {
{"help",0,NULL,'h'},
{NULL,0,NULL,0}
};
int opt;
int opt_index = 0;
char *arg;
do {
opt = getopt_long(argc,argv,":c:h",long_opts, &opt_index);
switch(opt) {
case 'c':
args->c = SET;
args->lineCount = atoi(optarg);
break;
case 'h':
args->h = SET;
break;
case ':':
fprintf(stderr, "Heej chyba ti parameter\n");
printHelpAndExit(stderr, EXIT_FAILURE);
case '?':
fprintf(stderr,"Neznama volba -%c\n",optopt);
printHelpAndExit(stderr, EXIT_FAILURE);
default:
break;
}
} while(opt != -1);
// nacitaj ostatne prepinace
while (optind < argc) {
arg = argv[optind];
if (args->startDir == NULL && arg != NULL) {
args->startDir = arg;
} else {
printf("Ignorovany argument bez prepicana: %s\n", arg);
}
optind++;
}
}
int main(int argc, char *argv[]) {
ARGS args;
parseArguments(argc,argv,&args);
validateARGS(&args);
if( args.h ) {
printHelpAndExit(stderr, EXIT_SUCCESS);
}
executeChoice(&args);
return 0;
}
void validateArgs(ARGS * args) {
if(args->n == SET){
if(sscanf(args->nproc, "%d", &args->n_proc) <= 0 ) {
fprintf(stderr, "Argument prepinaca -n nie je cislo!\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
if(args->n_proc < 4){
fprintf(stderr, "Argument prepinaca -n musi byt vacsi ako 4\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
}
if(args->f != SET){
fprintf(stderr, "Prepinac -f je povinny\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
if(args->f == SET && args->file_name == NULL){
fprintf(stderr, "Argument prepinaca -f nebol zadany\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
}
//parsovanie vstupnych argumentov programu
void parseArguments(int argc, char*argv[], SETTINGS * settings) {
int opt;
//inicializacia nastaveni na defaultne hodnoty
settings->help = UNSET;
settings->symbolicLink = NULL;
//parsovanie argumentov zacinajucich pomlckov
do {
opt = getopt(argc, argv, ":h");
switch(opt) {
case 'h':
settings->help = SET;
break;
case ':':
fprintf(stderr, "CHYBA: nezadany argument volby '%c'\n", optopt);
printHelpAndExit(stderr, EXIT_FAILURE);
break;
case '?':
fprintf(stderr, "CHYBA: neznama volba '%c'\n", optopt);
printHelpAndExit(stderr, EXIT_FAILURE);
break;
}
}while(opt != -1);
//parsovanie argumentov bez pomlcky
if( settings->help == UNSET ) {
if( argv[optind] == NULL ) {
fprintf(stderr, "CHYBA: nezadana vstupna linka\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
if( argv[optind+1] != NULL ) {
fprintf(stderr, "CHYBA: prilis vela parametrov\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
settings->symbolicLink = argv[optind];
}
}
void parseArgs(int argc, char * argv[]) {
int opt;
static struct option long_options[] = { {"help", 0, NULL, 'h'},
{"exist", 0, NULL, 'e'},
{"not_exist", 0, NULL, 'n'},
{0, 0, 0, 0}
};
int option_index = 0;
do {
opt = getopt_long(argc, argv, "hen", long_options, &option_index);
switch (opt) {
case 'h':
printHelpAndExit(stderr, EXIT_SUCCESS);
break;
case 'e':
exist_ = 1;
break;
case 'n':
not_exist_ = 1;
break;
case '?':
fprintf(stderr,"Neznama volba -%c\n", optopt);
printHelpAndExit(stderr, EXIT_FAILURE);
default:
break;
}
} while(opt != -1);
if(optind < argc ) {
strncpy(file_path, argv[argc - 1], sizeof(file_path));
} else {
getPathFromChild();
}
}
int main(int argc, char * argv[]) {
SETTINGS settings;
parseArguments(argc, argv, &settings);
if( settings.help == SET ) {
printHelpAndExit(stdout, EXIT_SUCCESS);
}
validateArguments(&settings);
printSymbolicLinkInfo(&settings); //hlavna funkcionalita programu
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int numPanels= 1000, recursions = 4, p = 5, k = 3, max_iterations = 500;
FMMOptions opts = get_options(argc,argv);
opts.sparse_local = true;
SolverOptions solver_options;
bool second_kind = false;
char *mesh_name;
bool mesh = false;
// solve / PC settings
SOLVERS solver = SOLVE_GMRES;
PRECONDITIONERS pc = IDENTITY;
// use lazy evaluator by default
// opts.lazy_evaluation = true;
// parse command line args
// check if no arguments given
printf("\nLaplaceBEM on a sphere\n");
if (argc == 1) printHelpAndExit();
printf("parameters : \n");
printf("============ \n");
for (int i = 1; i < argc; ++i) {
if (strcmp(argv[i],"-theta") == 0) {
i++;
printf("theta = %s\n", argv[i]);
} else if (strcmp(argv[i],"-recursions") == 0) {
i++;
recursions = atoi(argv[i]);
// print out problem size based on the # of recursions
printf("N = %i\n", 2* (int) pow(4, recursions));
} else if (strcmp(argv[i],"-eval") == 0) {
i++;
} else if (strcmp(argv[i], "-ncrit") == 0) {
i++;
printf("ncrit = %s\n", argv[i]);
} else if (strcmp(argv[i], "-printtree") == 0) {
} else if (strcmp(argv[i],"-p") == 0) {
i++;
p = atoi(argv[i]);
solver_options.max_p = p;
printf("max-p = %i\n", p);
} else if (strcmp(argv[i],"-k") == 0) {
i++;
k = atoi(argv[i]);
} else if (strcmp(argv[i],"-second_kind") == 0) {
second_kind = true;
printf("second-kind = True\n");
} else if (strcmp(argv[i],"-fixed_p") == 0) {
solver_options.variable_p = false;
printf("relaxed = False\n");
} else if (strcmp(argv[i],"-solver_tol") == 0) {
i++;
solver_options.residual = (double)atof(argv[i]);
printf("solver_tol = %.2e\n", solver_options.residual);
} else if (strcmp(argv[i],"-max_iters") == 0) {
i++;
max_iterations = atoi(argv[i]);
} else if (strcmp(argv[i],"-gmres") == 0) {
solver = SOLVE_GMRES;
} else if (strcmp(argv[i],"-fgmres") == 0) {
solver = SOLVE_FGMRES;
} else if (strcmp(argv[i],"-local") == 0) {
solver = SOLVE_FGMRES;
pc = LOCAL;
} else if (strcmp(argv[i],"-diagonal") == 0) {
pc = DIAGONAL;
} else if (strcmp(argv[i],"-help") == 0) {
printHelpAndExit();
} else if (strcmp(argv[i],"-mesh") == 0) {
i++;
mesh_name = argv[i];
mesh = true;
}
else {
printf("[W]: Unknown command line arg: \"%s\"\n",argv[i]);
printHelpAndExit();
}
}
printf("============\n");
solver_options.max_iters = max_iterations;
solver_options.restart = max_iterations;
// opts.sparse_local = true;
double tic, toc;
// Init the FMM Kernel
typedef LaplaceSphericalBEM kernel_type;
kernel_type K(p,k);
// useful typedefs
typedef kernel_type::point_type point_type;
typedef kernel_type::source_type source_type;
typedef kernel_type::target_type target_type;
typedef kernel_type::charge_type charge_type;
typedef kernel_type::result_type result_type;
// Init points and charges
std::vector<source_type> panels(numPanels);
std::vector<charge_type> charges(numPanels);
if (mesh) {
printf("reading mesh from: %s\n",mesh_name);
MeshIO::readMsh<point_type,source_type>(mesh_name, panels); // , panels);
} else {
Triangulation::UnitSphere(panels, recursions);
// initialiseSphere(panels, charges, recursions); //, ProblemOptions());
}
// run case solving for Phi (instead of dPhi/dn)
if (second_kind)
for (auto& it : panels) it.switch_BC();
// set constant Phi || dPhi/dn for each panel
charges.resize(panels.size());
// set up a more complicated charge, from BEM++
for (unsigned i=0; i<panels.size(); i++) {
#if BEMCPP_TEST
auto center = panels[i].center;
double x = center[0], y = center[1], z = center[2];
double r = norm(center);
charges[i] = 2*x*z/(r*r*r*r*r) - y/(r*r*r);
#else
charges[i] = 1.;
#endif
}
// charges = std::vector<charge_type>(panels.size(),1.);
// Build the FMM structure
FMM_plan<kernel_type> plan = FMM_plan<kernel_type>(K, panels, opts);
// generate the RHS and initial condition
std::vector<charge_type> x(panels.size(),0.);
tic = get_time();
std::vector<result_type> b(panels.size(),0.);
double tic2, toc2;
// generate RHS using temporary FMM plan
{
tic2 = get_time();
for (auto& it : panels) it.switch_BC();
toc2 = get_time();
printf("Flipping BC: %g\n",toc2-tic2);
tic2 = get_time();
FMM_plan<kernel_type> rhs_plan = FMM_plan<kernel_type>(K,panels,opts);
toc2 = get_time();
printf("Creating plan: %g\n",toc2-tic2);
tic2 = get_time();
b = rhs_plan.execute(charges);
toc2 = get_time();
printf("Executing plan: %g\n",toc2-tic2);
for (auto& it : panels) it.switch_BC();
}
toc = get_time();
double setup_time = toc-tic;
// Solve the system using GMRES
// generate the Preconditioner
tic = get_time();
Preconditioners::Diagonal<charge_type> M(K,
plan.source_begin(),
plan.source_end()
);
// M.print();
SolverOptions inner_options(1e-2,1,2);
inner_options.variable_p = true;
/*
// Preconditioners::FMGMRES<FMM_plan<kernel_type>,Preconditioners::Diagonal<charge_type>> inner(plan, b, inner_options, M);
// Local preconditioner
Preconditioners::LocalInnerSolver<FMM_plan<kernel_type>, Preconditioners::Diagonal<result_type>> local(K, panels, b);
// block diagonal preconditioner
Preconditioners::BlockDiagonal<FMM_plan<kernel_type>> block_diag(K,panels);
*/
// Initial low accuracy solve
//
/*
double tic2, toc2;
tic2 = get_time();
{
printf("Initial solve starting..\n");
// initial solve to 1e-2 accuracy, 5 iterations, P = 2
SolverOptions initial_solve(5e-3,50,3);
// fmm_gmres(plan, x, b, solver_options, M);
GMRES(plan, x, b, initial_solve, M);
printf("Initial solve finished..\n");
}
toc2 = get_time();
printf("Initial solve took: %.4es\n",toc2-tic2);
*/
// Outer GMRES solve with diagonal preconditioner & relaxation
FGMRESContext<result_type> context(x.size(), solver_options.restart);
if (second_kind) printf("2nd-kind equation being solved\n");
else printf("1st-kind equation being solved\n");
#if 1
if (solver == SOLVE_GMRES && pc == IDENTITY){
printf("Solver: GMRES\nPreconditioner: Identity\n");
// straight GMRES, no preconditioner
// DirectMV<kernel_type> MV(K, panels, panels);
GMRES(plan,x,b,solver_options);
}
else if (solver == SOLVE_GMRES && pc == DIAGONAL) {
printf("Solver: GMRES\nPreconditioner: Diagonal\n");
// GMRES, diagonal preconditioner
GMRES(plan, x, b, solver_options, M, context);
}
#else
else if (solver == SOLVE_GMRES && pc == DIAGONAL) {
printf("Solver: GMRES\nPreconditioner: Diagonal\n");
// GMRES, diagonal preconditioner
GMRES(plan,x,b,solver_options, M, context);
}
else if (solver == SOLVE_FGMRES && pc == IDENTITY) {
printf("Solver: FMRES\nPreconditioner: Identity\n");
// GMRES, diagonal preconditioner
FGMRES(plan,x,b,solver_options);
}
else if (solver == SOLVE_FGMRES && pc == DIAGONAL) {
printf("Solver: FGMRES\nPreconditioner: Block Diagonal\n");
// GMRES, diagonal preconditioner
FGMRES(plan,x,b,solver_options, block_diag, context);
}
else if (solver == SOLVE_FGMRES && pc == LOCAL) {
printf("Solver: FGMRES\nPreconditioner: Local solve\n");
// FGMRES, Local inner solver
FGMRES(plan,x,b,solver_options, local, context);
}
else {
printf("[E] no valid solver / preconditioner option chosen\n");
exit(0);
}
#endif
// GMRES(MV,x,b,solver_options, M, context);
// FGMRES(plan,x,b,solver_options, inner, context); // , context);
// Outer/Inner FGMRES / GMRES (Diagonal)
toc = get_time();
double solve_time = toc-tic;
printf("\nTIMING:\n");
printf("\tsetup : %.4es\n",setup_time);
printf("\tsolve : %.4es\n",solve_time);
// check errors -- analytical solution for dPhi/dn = 1.
double e = 0.;
double e2 = 0.;
#if BEMCPP_TEST
std::vector<result_type> analytical(panels.size());
for (unsigned i=0; i<panels.size(); i++) {
auto center = panels[i].center;
double x = center[0], y = center[1], z = center[2];
double r = norm(center);
analytical[i] = -(-6 * x * z / (r*r*r*r*r*r) + 2 * y / (r*r*r*r));
}
auto ai = analytical.begin();
for (auto xi : x) {
// printf("approx: %.4g, analytical: %.4g\n",xi,*ai);
e += (xi-*ai)*(xi-*ai);
e2 += (*ai)*(*ai);
++ai;
}
#else
double an = 1.;
for (auto xi : x) { e += (xi-an)*(xi-an); e2 += an*an; }
#endif
#define EXTERNAL_ERROR
#ifdef EXTERNAL_ERROR
std::vector<target_type> outside_point(1);
outside_point[0] = target_type(point_type(3.,3.,3.),point_type(3.,3.,3.),point_type(3.,3.,3.));
outside_point[0].center = point_type(3.,3.,3.);
std::vector<result_type> outside_result_1(1);
std::vector<result_type> outside_result_2(1);
outside_result_1[0] = 0.;
outside_result_2[0] = 0.;
// first layer
Direct::matvec(K, panels.begin(), panels.end(), x.begin(), outside_point.begin(), outside_point.end(), outside_result_2.begin());
// for (auto& pi : panels) pi.switch_BC();
for (auto& op : outside_point) op.switch_BC();
Direct::matvec(K, panels.begin(), panels.end(), charges.begin(), outside_point.begin(), outside_point.end(), outside_result_1.begin());
double exact = 1. / norm(static_cast<point_type>(outside_point[0])) * 1;
double outside_result = (outside_result_2[0]-outside_result_1[0])/4/M_PI;
double outside_error = fabs(outside_result-exact)/fabs(exact);
printf("external phi: %.5g, exact: %.5g, error: %.4e\n",outside_result,exact, outside_error);
#endif
printf("relative error: %.3e\n",sqrt(e/e2));
}
void validateARGS(ARGS *args) {
if(args->startDir == NULL) {
printf("Nebolo by zle zadat <pociatocny_precinok>\n");
printHelpAndExit(stderr, EXIT_FAILURE);
}
}
int main(int argc, const char * argv[]) {
int i;
FILE *trace = NULL;
for (i = 0; i < argc; i++) {
char arg = *++argv[i];
switch (arg) {
case 'h':
help = 1;
break;
case 'v':
verbose = 1;
break;
case 's':
sbits = atoi(argv[i+1]);
S = 1 << sbits;
break;
case 'E':
E = atoi(argv[i+1]);
break;
case 'b':
bbits = atoi(argv[i+1]);
break;
case 't':
trace = fopen(argv[i+1], "r");
break;
default:
break;
}
}
if (help == 1) {
printHelpAndExit(argv[0]);
}
CacheSet cacheSets[S];
buildCache(cacheSets);
if (trace != NULL) {
long address;
int bufLen = 30;
char buffer[bufLen], instruction, blockSize;
while (fgets(buffer, bufLen, trace) != NULL) {
sscanf(buffer, " %c %lx,%c", &instruction, &address, &blockSize);
if (instruction != INSTRUCTION) {
for (i = 0; i < bufLen; i++) {
if (buffer[i] == '\n') {
buffer[i] = '\0';
}
}
char hitType = 0;
if (instruction == MODIFY) {
for (i = 0; i < 2; i++) {
hitType += cacheOperation(cacheSets, address);
}
} else {
hitType = cacheOperation(cacheSets, address);
}
if (verbose == 1) {
printVerbose(hitType, buffer);
}
}
}
fclose(trace);
} else {
printf("Error: Must specify trace file, see usage\n");
printHelpAndExit(argv[0]);
}
for (i = 0; i < S; i++) {
free(cacheSets[i].lines);
}
printSummary(hits, misses, evictions);
return 0;
}
