Stage::Stage(Displayable *disp) : Displayable(disp) {
// Displayable characteristics
rot_off();
scale_off();
glob_trans_off();
cent_trans_off();
// put stage in lower part of image by default
Panels = 0;
panels(STAGE_PANELS); // really sets the panels, and panel size
stagePos = STAGEPOS_TOTAL; // (inits value so purify doesn't complain)
location(NO_STAGE); // position the stage
colorCat = scene->add_color_category("Stage");
scene->add_color_item(colorCat, "Even", STAGEEVENCOL);
scene->add_color_item(colorCat, "Odd", STAGEODDCOL);
do_color_changed(colorCat);
}
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 PluginLoader::loadPlugins(
iscore::ApplicationRegistrar& registrar,
const iscore::ApplicationContext& context)
{
auto folders = pluginsDir();
// Here, the plug-ins that are effectively loaded.
std::vector<iscore::Plugin_QtInterface*> availablePlugins;
// Load static plug-ins
for(QObject* plugin : QPluginLoader::staticInstances())
{
if(auto iscore_plug = dynamic_cast<iscore::Plugin_QtInterface*>(plugin))
availablePlugins.push_back(iscore_plug);
}
QSet<QString> pluginFiles;
#if !defined(ISCORE_STATIC_QT)
// Load dynamic plug-ins
for(const QString& pluginsFolder : folders)
{
QDir pluginsDir(pluginsFolder);
for(const QString& fileName : pluginsDir.entryList(QDir::Files))
{
auto plug = loadPlugin(pluginsDir.absoluteFilePath(fileName), availablePlugins);
if(!plug.first.isEmpty())
{
pluginFiles.insert(plug.first);
}
if(plug.second)
{
availablePlugins.push_back(plug.second);
}
}
}
#endif
// First bring in the plugin objects
registrar.registerPlugins(
pluginFiles.toList(),
availablePlugins);
// Here, it is important not to collapse all the for-loops
// because for instance a ApplicationPlugin from plugin B might require the factory
// from plugin A to be loaded prior.
// Load all the factories.
for(iscore::Plugin_QtInterface* plugin : availablePlugins)
{
auto facfam_interface = dynamic_cast<FactoryList_QtInterface*> (plugin);
if(facfam_interface)
{
for(auto&& elt : facfam_interface->factoryFamilies())
{
registrar.registerFactory(std::move(elt));
}
}
}
// Load all the application context plugins.
// We have to order them according to their dependencies
PluginDependencyGraph graph;
for(auto plugin : availablePlugins)
{
graph.addNode(dynamic_cast<QObject*>(plugin));
}
graph.visit([&] (QObject* plugin) {
auto ctrl_plugin = dynamic_cast<GUIApplicationContextPlugin_QtInterface*> (plugin);
if(ctrl_plugin)
{
auto plug = ctrl_plugin->make_applicationPlugin(context);
registrar.registerApplicationContextPlugin(plug);
}
});
// Load what the plug-ins have to offer.
for(auto plugin : availablePlugins)
{
auto panel_plugin = dynamic_cast<PanelFactory_QtInterface*> (plugin);
if(panel_plugin)
{
auto panels = panel_plugin->panels();
for(auto panel : panels)
{
registrar.registerPanel(panel);
}
}
auto commands_plugin = dynamic_cast<CommandFactory_QtInterface*> (plugin);
if(commands_plugin)
{
registrar.registerCommands(commands_plugin->make_commands());
}
auto factories_plugin = dynamic_cast<FactoryInterface_QtInterface*> (plugin);
if(factories_plugin)
{
for(auto& factory_family : registrar.components().factories)
{
for(auto&& new_factory : factories_plugin->factories(context, factory_family.first))
{
factory_family.second->insert(std::move(new_factory));
}
}
}
}
}