static inline void apply(Range1 const& source, Range2& destination)
{
geometry::clear(destination);
rview_type rview(source);
// We consider input always as closed, and skip last
// point for open output.
view_type view(rview);
int n = pdalboost::size(view);
if (geometry::closure<Range2>::value == geometry::open)
{
n--;
}
int i = 0;
for (typename pdalboost::range_iterator<view_type const>::type it
= pdalboost::begin(view);
it != pdalboost::end(view) && i < n;
++it, ++i)
{
geometry::append(destination, *it);
}
}
void
do_not_call_me_i_am_only_here_to_get_these_symbols(AboutWindow **win, AboutView **view)
{
AboutWindow rwin;
AboutView rview(BRect(0, 0, 2, 3), "");
*win = &rwin;
*view = &rview;
}
static inline typename Strategy::return_type
apply(Ring const& ring, Strategy const& strategy)
{
BOOST_CONCEPT_ASSERT( (geometry::concept::AreaStrategy<Strategy>) );
assert_dimension<Ring, 2>();
// Ignore warning (because using static method sometimes) on strategy
boost::ignore_unused_variable_warning(strategy);
// An open ring has at least three points,
// A closed ring has at least four points,
// if not, there is no (zero) area
if (int(boost::size(ring))
< core_detail::closure::minimum_ring_size<Closure>::value)
{
return typename Strategy::return_type();
}
typedef typename reversible_view<Ring const, Direction>::type rview_type;
typedef typename closeable_view
<
rview_type const, Closure
>::type view_type;
typedef typename boost::range_iterator<view_type const>::type iterator_type;
rview_type rview(ring);
view_type view(rview);
typename Strategy::state_type state;
iterator_type it = boost::begin(view);
iterator_type end = boost::end(view);
for (iterator_type previous = it++;
it != end;
++previous, ++it)
{
strategy.apply(*previous, *it, state);
}
return strategy.result(state);
}
int main(int argc, char* argv[])
{
// Instantiate a class with global functions.
Hermes2D hermes_2D;
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Initial mesh refinements.
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Initialize boundary conditions.
DefaultEssentialBCConst left_t("Left", 1.0);
EssentialBCs bcs_t(&left_t);
DefaultEssentialBCConst left_c("Left", 0.0);
EssentialBCs bcs_c(&left_c);
// Create H1 spaces with default shapesets.
H1Space* t_space = new H1Space(&mesh, &bcs_t, P_INIT);
H1Space* c_space = new H1Space(&mesh, &bcs_c, P_INIT);
int ndof = Space::get_num_dofs(Hermes::vector<Space*>(t_space, c_space));
info("ndof = %d.", ndof);
// Define initial conditions.
InitialSolutionTemperature t_prev_time_1(&mesh, x1);
InitialSolutionConcentration c_prev_time_1(&mesh, x1, Le);
InitialSolutionTemperature t_prev_time_2(&mesh, x1);
InitialSolutionConcentration c_prev_time_2(&mesh, x1, Le);
Solution t_prev_newton;
Solution c_prev_newton;
// Filters for the reaction rate omega and its derivatives.
CustomFilter omega(Hermes::vector<MeshFunction*>(&t_prev_time_1, &c_prev_time_1), Le, alpha, beta, kappa, x1, TAU);
CustomFilterDt omega_dt(Hermes::vector<MeshFunction*>(&t_prev_time_1, &c_prev_time_1), Le, alpha, beta, kappa, x1, TAU);
CustomFilterDc omega_dc(Hermes::vector<MeshFunction*>(&t_prev_time_1, &c_prev_time_1), Le, alpha, beta, kappa, x1, TAU);
// Initialize visualization.
ScalarView rview("Reaction rate", new WinGeom(0, 0, 800, 230));
scalar* coeff_vec = new scalar[Space::get_num_dofs(Hermes::vector<Space*>(t_space, c_space))];
memset(coeff_vec, 0, ndof * sizeof(double));
Solution::vector_to_solutions(coeff_vec, Hermes::vector<Space*>(t_space, c_space),
Hermes::vector<Solution *>(&t_prev_time_1, &c_prev_time_1));
// Initialize the weak formulation.
double current_time = 0;
CustomWeakForm wf(Le, alpha, beta, kappa, x1, TAU, false, PRECOND, &omega, &omega_dt,
&omega_dc, &t_prev_time_1, &c_prev_time_1, &t_prev_time_2, &c_prev_time_2);
// Initialize the FE problem.
DiscreteProblem dp(&wf, Hermes::vector<Space*>(t_space, c_space));
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Time stepping:
int ts = 1;
bool jacobian_changed = true;
do
{
info("---- Time step %d, time %3.5f s", ts, current_time);
if (NEWTON)
{
// Perform Newton's iteration.
info("Solving nonlinear problem:");
bool verbose = true;
bool jacobian_changed = true;
if (!hermes_2D.solve_newton(coeff_vec, &dp, solver, matrix, rhs, jacobian_changed,
NEWTON_TOL, NEWTON_MAX_ITER, verbose)) error("Newton's iteration failed.");
Solution::vector_to_solutions(coeff_vec, Hermes::vector<Space*>(t_space, c_space),
Hermes::vector<Solution*>(&t_prev_newton, &c_prev_newton));
// Saving solutions for the next time step.
if(ts > 1)
{
t_prev_time_2.copy(&t_prev_time_1);
c_prev_time_2.copy(&c_prev_time_1);
}
t_prev_time_1.copy(&t_prev_newton);
c_prev_time_1.copy(&c_prev_newton);
}
// Visualization.
rview.set_min_max_range(0.0,2.0);
rview.show(&omega);
// Increase current time and time step counter.
current_time += TAU;
ts++;
}
while (current_time < T_FINAL);
// Clean up.
delete [] coeff_vec;
delete matrix;
delete rhs;
delete solver;
// Wait for all views to be closed.
View::wait();
return 0;
}
int
main(int argc, char *argv[])
{
#define check(ol,al) if (argv[i][ol] || \
badarg(argc-i-1,argv+i+1,al)) \
goto badopt
#define check_bool(olen,var) switch (argv[i][olen]) { \
case '\0': var = !var; break; \
case 'y': case 'Y': case 't': case 'T': \
case '+': case '1': var = 1; break; \
case 'n': case 'N': case 'f': case 'F': \
case '-': case '0': var = 0; break; \
default: goto badopt; }
char *octnm = NULL;
char *err;
int rval;
int i;
/* global program name */
progname = argv[0] = fixargv0(argv[0]);
/* set our defaults */
shadthresh = .1;
shadcert = .25;
directrelay = 0;
vspretest = 128;
srcsizerat = 0.;
specthresh = .3;
specjitter = 1.;
maxdepth = 6;
minweight = 1e-2;
ambacc = 0.3;
ambres = 32;
ambdiv = 256;
ambssamp = 64;
/* option city */
for (i = 1; i < argc; i++) {
/* expand arguments */
while ((rval = expandarg(&argc, &argv, i)) > 0)
;
if (rval < 0) {
sprintf(errmsg, "cannot expand '%s'", argv[i]);
error(SYSTEM, errmsg);
}
if (argv[i] == NULL || argv[i][0] != '-')
break; /* break from options */
if (!strcmp(argv[i], "-version")) {
puts(VersionID);
quit(0);
}
if (!strcmp(argv[i], "-defaults") ||
!strcmp(argv[i], "-help")) {
printdefaults();
quit(0);
}
if (!strcmp(argv[i], "-devices")) {
printdevices();
quit(0);
}
rval = getrenderopt(argc-i, argv+i);
if (rval >= 0) {
i += rval;
continue;
}
rval = getviewopt(&ourview, argc-i, argv+i);
if (rval >= 0) {
i += rval;
continue;
}
switch (argv[i][1]) {
case 'n': /* # processes */
check(2,"i");
nproc = atoi(argv[++i]);
if (nproc <= 0)
error(USER, "bad number of processes");
break;
case 'v': /* view file */
if (argv[i][2] != 'f')
goto badopt;
check(3,"s");
rval = viewfile(argv[++i], &ourview, NULL);
if (rval < 0) {
sprintf(errmsg,
"cannot open view file \"%s\"",
argv[i]);
error(SYSTEM, errmsg);
} else if (rval == 0) {
sprintf(errmsg,
"bad view file \"%s\"",
argv[i]);
error(USER, errmsg);
}
break;
case 'b': /* grayscale */
check_bool(2,greyscale);
break;
case 'p': /* pixel */
switch (argv[i][2]) {
case 's': /* sample */
check(3,"i");
psample = atoi(argv[++i]);
break;
case 't': /* threshold */
check(3,"f");
maxdiff = atof(argv[++i]);
break;
case 'e': /* exposure */
check(3,"f");
exposure = atof(argv[++i]);
if (argv[i][0] == '+' || argv[i][0] == '-')
exposure = pow(2.0, exposure);
break;
default:
goto badopt;
}
break;
case 'w': /* warnings */
rval = erract[WARNING].pf != NULL;
check_bool(2,rval);
if (rval) erract[WARNING].pf = wputs;
else erract[WARNING].pf = NULL;
break;
case 'e': /* error file */
check(2,"s");
errfile = argv[++i];
break;
case 'o': /* output device */
check(2,"s");
dvcname = argv[++i];
break;
case 'R': /* render input file */
check(2,"s");
strcpy(rifname, argv[++i]);
break;
default:
goto badopt;
}
}
err = setview(&ourview); /* set viewing parameters */
if (err != NULL)
error(USER, err);
/* set up signal handling */
sigdie(SIGINT, "Interrupt");
sigdie(SIGTERM, "Terminate");
#if !defined(_WIN32) && !defined(_WIN64)
sigdie(SIGHUP, "Hangup");
sigdie(SIGPIPE, "Broken pipe");
sigdie(SIGALRM, "Alarm clock");
#endif
/* open error file */
if (errfile != NULL) {
if (freopen(errfile, "a", stderr) == NULL)
quit(2);
fprintf(stderr, "**************\n*** PID %5d: ",
getpid());
printargs(argc, argv, stderr);
putc('\n', stderr);
fflush(stderr);
}
#ifdef NICE
nice(NICE); /* lower priority */
#endif
/* get octree */
if (i == argc)
octnm = NULL;
else if (i == argc-1)
octnm = argv[i];
else
goto badopt;
if (octnm == NULL)
error(USER, "missing octree argument");
/* set up output & start process(es) */
SET_FILE_BINARY(stdout);
ray_init(octnm); /* also calls ray_init_pmap() */
/* temporary shortcut, until winrview is refactored into a "device" */
#ifndef WIN_RVIEW
rview(); /* run interactive viewer */
devclose(); /* close output device */
#endif
/* PMAP: free photon maps */
ray_done_pmap();
#ifdef WIN_RVIEW
return 1;
#endif
quit(0);
badopt:
sprintf(errmsg, "command line error at '%s'", argv[i]);
error(USER, errmsg);
return 1; /* pro forma return */
#undef check
#undef check_bool
}
int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinemets.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Create H1 spaces with default shapesets.
H1Space* t_space = new H1Space(&mesh, bc_types, essential_bc_values_t, P_INIT);
H1Space* c_space = new H1Space(&mesh, bc_types, essential_bc_values_c, P_INIT);
int ndof = get_num_dofs(Tuple<Space *>(t_space, c_space));
info("ndof = %d.", ndof);
// Define initial conditions.
Solution t_prev_time_1, c_prev_time_1, t_prev_time_2,
c_prev_time_2, t_iter, c_iter, t_prev_newton, c_prev_newton;
t_prev_time_1.set_exact(&mesh, temp_ic);
c_prev_time_1.set_exact(&mesh, conc_ic);
t_prev_time_2.set_exact(&mesh, temp_ic);
c_prev_time_2.set_exact(&mesh, conc_ic);
t_iter.set_exact(&mesh, temp_ic);
c_iter.set_exact(&mesh, conc_ic);
// Filters for the reaction rate omega and its derivatives.
DXDYFilter omega(omega_fn, Tuple<MeshFunction*>(&t_prev_time_1, &c_prev_time_1));
DXDYFilter omega_dt(omega_dt_fn, Tuple<MeshFunction*>(&t_prev_time_1, &c_prev_time_1));
DXDYFilter omega_dc(omega_dc_fn, Tuple<MeshFunction*>(&t_prev_time_1, &c_prev_time_1));
// Initialize visualization.
ScalarView rview("Reaction rate", new WinGeom(0, 0, 800, 230));
// Initialize weak formulation.
WeakForm wf(2, JFNK ? true : false);
if (!JFNK || (JFNK && PRECOND == 1))
{
wf.add_matrix_form(callback(newton_bilinear_form_0_0), H2D_UNSYM, H2D_ANY, &omega_dt);
wf.add_matrix_form_surf(0, 0, callback(newton_bilinear_form_0_0_surf), 3);
wf.add_matrix_form(1, 1, callback(newton_bilinear_form_1_1), H2D_UNSYM, H2D_ANY, &omega_dc);
wf.add_matrix_form(0, 1, callback(newton_bilinear_form_0_1), H2D_UNSYM, H2D_ANY, &omega_dc);
wf.add_matrix_form(1, 0, callback(newton_bilinear_form_1_0), H2D_UNSYM, H2D_ANY, &omega_dt);
}
else if (PRECOND == 2)
{
wf.add_matrix_form(0, 0, callback(precond_0_0));
wf.add_matrix_form(1, 1, callback(precond_1_1));
}
wf.add_vector_form(0, callback(newton_linear_form_0), H2D_ANY,
Tuple<MeshFunction*>(&t_prev_time_1, &t_prev_time_2, &omega));
wf.add_vector_form_surf(0, callback(newton_linear_form_0_surf), 3);
wf.add_vector_form(1, callback(newton_linear_form_1), H2D_ANY,
Tuple<MeshFunction*>(&c_prev_time_1, &c_prev_time_2, &omega));
// Project the functions "t_iter" and "c_iter" on the FE space
// in order to obtain initial vector for NOX.
info("Projecting initial solutions on the FE meshes.");
Vector* coeff_vec = new AVector(ndof);
project_global(Tuple<Space *>(t_space, c_space), Tuple<int>(H2D_H1_NORM, H2D_H1_NORM),
Tuple<MeshFunction*>(&t_prev_time_1, &c_prev_time_1), Tuple<Solution*>(&t_prev_time_1, &c_prev_time_1),
coeff_vec);
// Measure the projection time.
double proj_time = cpu_time.tick().last();
// Initialize finite element problem.
FeProblem fep(&wf, Tuple<Space*>(t_space, c_space));
// Initialize NOX solver and preconditioner.
NoxSolver solver(&fep);
MlPrecond pc("sa");
if (PRECOND)
{
if (JFNK) solver.set_precond(&pc);
else solver.set_precond("Ifpack");
}
if (TRILINOS_OUTPUT)
solver.set_output_flags(NOX::Utils::Error | NOX::Utils::OuterIteration |
NOX::Utils::OuterIterationStatusTest |
NOX::Utils::LinearSolverDetails);
// Time stepping loop:
double total_time = 0.0;
cpu_time.tick_reset();
for (int ts = 1; total_time <= 60.0; ts++)
{
info("---- Time step %d, t = %g s", ts, total_time + TAU);
cpu_time.tick(HERMES_SKIP);
solver.set_init_sln(coeff_vec->get_c_array());
bool solved = solver.solve();
if (solved)
{
double* s = solver.get_solution_vector();
AVector *tmp_vector = new AVector(ndof);
tmp_vector->set_c_array(s, ndof);
t_prev_newton.set_fe_solution(t_space, tmp_vector);
c_prev_newton.set_fe_solution(c_space, tmp_vector);
delete tmp_vector;
cpu_time.tick();
info("Number of nonlin iterations: %d (norm of residual: %g)",
solver.get_num_iters(), solver.get_residual());
info("Total number of iterations in linsolver: %d (achieved tolerance in the last step: %g)",
solver.get_num_lin_iters(), solver.get_achieved_tol());
// Time measurement.
cpu_time.tick(HERMES_SKIP);
// Visualization.
DXDYFilter omega_view(omega_fn, Tuple<MeshFunction*>(&t_prev_newton, &c_prev_newton));
rview.set_min_max_range(0.0,2.0);
cpu_time.tick(HERMES_SKIP);
// Skip visualization time.
cpu_time.tick(HERMES_SKIP);
// Update global time.
total_time += TAU;
// Saving solutions for the next time step.
t_prev_time_2.copy(&t_prev_time_1);
c_prev_time_2.copy(&c_prev_time_1);
t_prev_time_1 = t_prev_newton;
c_prev_time_1 = c_prev_newton;
}
else
error("NOX failed.");
info("Total running time for time level %d: %g s.", ts, cpu_time.tick().last());
}
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Time measurement.
Hermes::Mixins::TimeMeasurable cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh mesh;
MeshReaderH2D mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinemets.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Initialize boundary conditions.
DefaultEssentialBCConst<double> left_t("Left", 1.0);
EssentialBCs<double> bcs_t(&left_t);
DefaultEssentialBCConst<double> left_c("Left", 0.0);
EssentialBCs<double> bcs_c(&left_c);
// Create H1 spaces with default shapesets.
H1Space<double>* t_space = new H1Space<double>(&mesh, &bcs_t, P_INIT);
H1Space<double>* c_space = new H1Space<double>(&mesh, &bcs_c, P_INIT);
int ndof = Space<double>::get_num_dofs(Hermes::vector<const Space<double>*>(t_space, c_space));
Hermes::Mixins::Loggable::Static::info("ndof = %d.", ndof);
// Define initial conditions.
InitialSolutionTemperature t_prev_time_1(&mesh, x1);
InitialSolutionConcentration c_prev_time_1(&mesh, x1, Le);
InitialSolutionTemperature t_prev_time_2(&mesh, x1);
InitialSolutionConcentration c_prev_time_2(&mesh, x1, Le);
Solution<double> t_prev_newton;
Solution<double> c_prev_newton;
// Filters for the reaction rate omega and its derivatives.
CustomFilter omega(Hermes::vector<Solution<double>*>(&t_prev_time_1, &c_prev_time_1), Le, alpha, beta, kappa, x1, TAU);
CustomFilterDt omega_dt(Hermes::vector<Solution<double>*>(&t_prev_time_1, &c_prev_time_1), Le, alpha, beta, kappa, x1, TAU);
CustomFilterDc omega_dc(Hermes::vector<Solution<double>*>(&t_prev_time_1, &c_prev_time_1), Le, alpha, beta, kappa, x1, TAU);
// Initialize visualization.
ScalarView rview("Reaction rate", new WinGeom(0, 0, 800, 230));
// Initialize weak formulation.
CustomWeakForm wf(Le, alpha, beta, kappa, x1, TAU, TRILINOS_JFNK, PRECOND, &omega, &omega_dt,
&omega_dc, &t_prev_time_1, &c_prev_time_1, &t_prev_time_2, &c_prev_time_2);
// Project the functions "t_prev_time_1" and "c_prev_time_1" on the FE space
// in order to obtain initial vector for NOX.
Hermes::Mixins::Loggable::Static::info("Projecting initial solutions on the FE meshes.");
double* coeff_vec = new double[ndof];
OGProjection<double> ogProjection; ogProjection.project_global(Hermes::vector<const Space<double> *>(t_space, c_space),
Hermes::vector<MeshFunction<double>*>(&t_prev_time_1, &c_prev_time_1),
coeff_vec);
// Measure the projection time.
double proj_time = cpu_time.tick().last();
// Initialize finite element problem.
DiscreteProblem<double> dp(&wf, Hermes::vector<const Space<double>*>(t_space, c_space));
// Initialize NOX solver and preconditioner.
NewtonSolverNOX<double> solver(&dp);
MlPrecond<double> pc("sa");
if (PRECOND)
{
if (TRILINOS_JFNK)
solver.set_precond(pc);
else
solver.set_precond("New Ifpack");
}
if (TRILINOS_OUTPUT)
solver.set_output_flags(NOX::Utils::Error | NOX::Utils::OuterIteration |
NOX::Utils::OuterIterationStatusTest |
NOX::Utils::LinearSolverDetails);
// Time stepping loop:
double total_time = 0.0;
cpu_time.tick_reset();
for (int ts = 1; total_time <= T_FINAL; ts++)
{
Hermes::Mixins::Loggable::Static::info("---- Time step %d, t = %g s", ts, total_time + TAU);
cpu_time.tick();
try
{
solver.solve(coeff_vec);
}
catch(std::exception& e)
{
std::cout << e.what();
}
Solution<double>::vector_to_solutions(solver.get_sln_vector(), Hermes::vector<const Space<double> *>(t_space, c_space),
Hermes::vector<Solution<double> *>(&t_prev_newton, &c_prev_newton));
cpu_time.tick();
Hermes::Mixins::Loggable::Static::info("Number of nonlin iterations: %d (norm of residual: %g)",
solver.get_num_iters(), solver.get_residual());
Hermes::Mixins::Loggable::Static::info("Total number of iterations in linsolver: %d (achieved tolerance in the last step: %g)",
solver.get_num_lin_iters(), solver.get_achieved_tol());
// Time measurement.
cpu_time.tick();
// Skip visualization time.
cpu_time.tick();
// Update global time.
total_time += TAU;
// Saving solutions for the next time step.
if(ts > 1)
{
t_prev_time_2.copy(&t_prev_time_1);
c_prev_time_2.copy(&c_prev_time_1);
}
t_prev_time_1.copy(&t_prev_newton);
c_prev_time_1.copy(&c_prev_newton);
// Visualization.
rview.set_min_max_range(0.0,2.0);
rview.show(&omega);
cpu_time.tick();
Hermes::Mixins::Loggable::Static::info("Total running time for time level %d: %g s.", ts, cpu_time.tick().last());
}
// Wait for all views to be closed.
View::wait();
return 0;
}