/*************************************************************************
* MeshOpt 类的构造函数. *
*************************************************************************/
MeshOpt::MeshOpt(const string& object_name,
tbox::Pointer<tbox::Database> input_db,
tbox::Pointer< appu::DeformingGridInputUtilities2 > grid_tool,
tbox::Pointer<geom::MultiblockDeformingGridGeometry<NDIM> > grid_geom)
{
#ifdef DEBUG_CHECK_ASSERTIONS
assert(!object_name.empty());
assert(!input_db.isNull());
assert(!grid_geom.isNull());
assert(!grid_tool.isNull());
#endif
d_grid_geometry = grid_geom;
d_grid_tool = grid_tool;
getFromInput(input_db);
d_flag = 0;
// 为影像区的宽度赋值.
d_zeroghosts = hier::IntVector<NDIM>(0);
d_oneghosts = hier::IntVector<NDIM>(1);
// 创建所有变量及数据片索引号, 注册可视化数据片.
registerModelVariables();
}
FACPreconditioner::FACPreconditioner(
const std::string& name,
boost::shared_ptr<FACOperatorStrategy> user_ops,
const boost::shared_ptr<tbox::Database>& input_db):
d_object_name(name),
d_fac_operator(user_ops),
d_coarsest_ln(0),
d_finest_ln(0),
d_max_iterations(10),
d_residual_tolerance(1.0e-6),
d_relative_residual_tolerance(-1.0),
d_presmoothing_sweeps(1),
d_postsmoothing_sweeps(1),
d_algorithm_choice("default"),
d_number_iterations(0),
d_residual_norm(tbox::MathUtilities<double>::getMax()),
d_convergence_factor(),
d_avg_convergence_factor(tbox::MathUtilities<double>::getMax()),
d_net_convergence_factor(tbox::MathUtilities<double>::getMax()),
d_controlled_level_ops()
{
t_solve_system = tbox::TimerManager::getManager()->
getTimer("solv::FACPreconditioner::solveSystem()_fac_cycling");
/*
* Initialize object with data read from input database.
*/
getFromInput(input_db);
}
IMPInitializer::IMPInitializer(const std::string& object_name,
Pointer<Database> input_db,
Pointer<PatchHierarchy<NDIM> > hierarchy,
Pointer<GriddingAlgorithm<NDIM> > gridding_alg)
: d_object_name(object_name),
d_hierarchy(hierarchy),
d_gridding_alg(gridding_alg),
d_level_is_initialized(d_gridding_alg->getMaxLevels(), false),
d_meshes(d_gridding_alg->getMaxLevels()),
d_num_vertex(d_gridding_alg->getMaxLevels()),
d_vertex_offset(d_gridding_alg->getMaxLevels()),
d_vertex_posn(d_gridding_alg->getMaxLevels()),
d_vertex_wgt(d_gridding_alg->getMaxLevels()),
d_vertex_subdomain_id(d_gridding_alg->getMaxLevels()),
d_silo_writer(NULL)
{
#if !defined(NDEBUG)
TBOX_ASSERT(!object_name.empty());
TBOX_ASSERT(input_db);
#endif
// Register the specification objects with the StreamableManager class.
MaterialPointSpec::registerWithStreamableManager();
// Initialize object with data read from the input database.
getFromInput(input_db);
return;
} // IMPInitializer
FACPreconditioner::FACPreconditioner(
const std::string& object_name,
Pointer<FACPreconditionerStrategy> fac_strategy,
tbox::Pointer<tbox::Database> input_db)
: d_object_name(object_name),
d_is_initialized(false),
d_fac_strategy(fac_strategy),
d_hierarchy(NULL),
d_coarsest_ln(0),
d_finest_ln(0),
d_cycle_type(V_CYCLE),
d_num_pre_sweeps(1),
d_num_post_sweeps(1),
d_f(),
d_r(),
d_do_log(false)
{
/*
* Register this class with the FACPreconditionerStrategy object.
*/
d_fac_strategy->setFACPreconditioner(Pointer<FACPreconditioner>(this,false));
/*
* Initialize object with data read from input database.
*/
if (!input_db.isNull())
{
getFromInput(input_db);
}
return;
}// FACPreconditioner
ForceProjector::ForceProjector(const std::string& object_name,
LDataManager* lag_data_manager,
Pointer<PatchHierarchy<NDIM> > patch_hierarchy,
Pointer<Database> input_db,
const std::string solver_type)
: d_object_name(object_name),
d_lag_data_manager(lag_data_manager),
d_patch_hierarchy(patch_hierarchy),
d_solver_type(solver_type),
d_grav_const(NDIM)
{
// put some default values.
d_rho_fluid = 1.0;
d_rho_body = 1.0;
// Initialize variables & variable contexts associated with Eulerian forces.
VariableDatabase<NDIM>* var_db = VariableDatabase<NDIM>::getDatabase();
d_body_force_context = var_db->getContext(d_object_name + "::BODYFORCE");
if (d_solver_type == "STAGGERED")
d_body_force_var = new SideVariable<NDIM, double>(d_object_name + "::BodyForce_sc_var");
if (d_solver_type == "COLLOCATED")
d_body_force_var = new CellVariable<NDIM, double>(d_object_name + "::BodyForce_cc_var", NDIM);
d_body_force_idx = var_db->registerVariableAndContext(d_body_force_var, d_body_force_context, 0);
getFromInput(input_db);
return;
} // ForceProjector
FACPreconditioner::FACPreconditioner(
const std::string& object_name,
Pointer<FACPreconditionerStrategy> fac_strategy,
tbox::Pointer<tbox::Database> input_db,
const std::string& /*default_options_prefix*/)
: d_fac_strategy(fac_strategy),
d_hierarchy(NULL),
d_coarsest_ln(0),
d_finest_ln(0),
d_cycle_type(V_CYCLE),
d_num_pre_sweeps(0),
d_num_post_sweeps(2),
d_f(),
d_r()
{
// Setup default options.
GeneralSolver::init(object_name, /*homogeneous_bc*/ true);
d_initial_guess_nonzero = false;
d_rel_residual_tol = 1.0e-5;
d_abs_residual_tol = 1.0e-50;
d_max_iterations = 1;
// Register this class with the FACPreconditionerStrategy object.
d_fac_strategy->setFACPreconditioner(Pointer<FACPreconditioner>(this,false));
// Initialize object with data read from input database.
if (input_db)
{
getFromInput(input_db);
}
return;
}// FACPreconditioner
PenaltyIBMethod::PenaltyIBMethod(const std::string& object_name, Pointer<Database> input_db, bool register_for_restart)
: IBMethod(object_name, input_db, register_for_restart)
{
// NOTE: Parent class constructor registers class with the restart manager, sets object
// name.
// Initialize object with data read from the input and restart databases.
bool from_restart = RestartManager::getManager()->isFromRestart();
if (from_restart) getFromRestart();
if (input_db) getFromInput(input_db, from_restart);
return;
} // PenaltyIBMethod
IBHierarchyIntegrator::IBHierarchyIntegrator(
const std::string& object_name,
Pointer<Database> input_db,
Pointer<IBStrategy> ib_method_ops,
Pointer<INSHierarchyIntegrator> ins_hier_integrator,
bool register_for_restart)
: HierarchyIntegrator(object_name, input_db, register_for_restart)
{
#if !defined(NDEBUG)
TBOX_ASSERT(ib_method_ops);
TBOX_ASSERT(ins_hier_integrator);
#endif
// Set the IB method operations objects.
d_ib_method_ops = ib_method_ops;
d_ib_method_ops->registerIBHierarchyIntegrator(this);
// Register the fluid solver as a child integrator of this integrator object
// and reuse the variables and variable contexts of the INS solver.
d_ins_hier_integrator = ins_hier_integrator;
registerChildHierarchyIntegrator(d_ins_hier_integrator);
d_u_var = d_ins_hier_integrator->getVelocityVariable();
d_p_var = d_ins_hier_integrator->getPressureVariable();
d_f_var = d_ins_hier_integrator->getBodyForceVariable();
d_q_var = d_ins_hier_integrator->getFluidSourceVariable();
d_current_context = d_ins_hier_integrator->getCurrentContext();
d_scratch_context = d_ins_hier_integrator->getScratchContext();
d_new_context = d_ins_hier_integrator->getNewContext();
VariableDatabase<NDIM>* var_db = VariableDatabase<NDIM>::getDatabase();
d_ib_context = var_db->getContext(d_object_name + "::IB");
// Set some default values.
d_integrator_is_initialized = false;
d_time_stepping_type = MIDPOINT_RULE;
d_regrid_cfl_interval = 0.0;
d_regrid_cfl_estimate = 0.0;
d_error_on_dt_change = true;
d_warn_on_dt_change = false;
// Do not allocate a workload variable by default.
d_workload_var.setNull();
d_workload_idx = -1;
// Initialize object with data read from the input and restart databases.
bool from_restart = RestartManager::getManager()->isFromRestart();
if (from_restart) getFromRestart();
if (input_db) getFromInput(input_db, from_restart);
return;
} // IBHierarchyIntegrator
LocationIndexRobinBcCoefs::LocationIndexRobinBcCoefs(
const tbox::Dimension& dim,
const std::string& object_name,
const std::shared_ptr<tbox::Database>& input_db):
d_dim(dim),
d_object_name(object_name)
{
TBOX_ASSERT(input_db);
for (int i = 0; i < 2 * d_dim.getValue(); ++i) {
d_a_map[i] = tbox::MathUtilities<double>::getSignalingNaN();
d_b_map[i] = tbox::MathUtilities<double>::getSignalingNaN();
d_g_map[i] = tbox::MathUtilities<double>::getSignalingNaN();
}
getFromInput(input_db);
}
QInit::QInit(
const string& object_name,
Pointer<GridGeometry<NDIM> > grid_geom,
Pointer<Database> input_db)
: CartGridFunction(object_name),
d_object_name(object_name),
d_grid_geom(grid_geom),
d_X(),
d_init_type("GAUSSIAN"),
d_gaussian_kappa(0.01),
d_zalesak_r(0.15),
d_zalesak_slot_w(0.025),
d_zalesak_slot_l(0.1)
{
#if !defined(NDEBUG)
TBOX_ASSERT(!object_name.empty());
TBOX_ASSERT(grid_geom);
#endif
d_object_name = object_name;
d_grid_geom = grid_geom;
#if !defined(NDEBUG)
TBOX_ASSERT(d_grid_geom);
#endif
// Default initial values.
const double* const x_upper = d_grid_geom->getXUpper();
const double* const x_lower = d_grid_geom->getXLower();
for (unsigned int d = 0; d < NDIM; ++d)
{
d_X[d] = x_lower[d] + 0.5*(x_upper[d] - x_lower[d]);
}
d_init_type = "GAUSSIAN";
d_gaussian_kappa = 0.01;
d_zalesak_r = 0.15;
d_zalesak_slot_w = 0.025;
d_zalesak_slot_l = 0.1;
// Initialize object with data read from the input database.
getFromInput(input_db);
return;
}// QInit
GeneralizedIBMethod::GeneralizedIBMethod(const std::string& object_name,
Pointer<Database> input_db,
bool register_for_restart)
: IBMethod(object_name, input_db, register_for_restart)
{
// NOTE: Parent class constructor registers class with the restart manager, sets object
// name.
// Initialize object with data read from the input and restart databases.
bool from_restart = RestartManager::getManager()->isFromRestart();
if (from_restart) getFromRestart();
if (input_db) getFromInput(input_db, from_restart);
// Indicate all Lagrangian data needs ghost values to be refilled, and that
// all intermediate data needs to be initialized.
d_N_current_needs_ghost_fill = true;
d_N_new_needs_ghost_fill = true;
return;
} // GeneralizedIBMethod
MainRestartData::MainRestartData(
const string& object_name,
std::shared_ptr<tbox::Database> input_db):
d_object_name(object_name)
{
TBOX_ASSERT(input_db);
tbox::RestartManager::getManager()->registerRestartItem(d_object_name, this);
/*
* Initialize object with data read from given input/restart databases.
*/
bool is_from_restart = tbox::RestartManager::getManager()->isFromRestart();
if (is_from_restart) {
getFromRestart();
}
getFromInput(input_db, is_from_restart);
/* if not starting from restart file, set loop_time and iteration_number */
if (!is_from_restart) {
d_loop_time = d_start_time;
d_iteration_number = 0;
}
}
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND hPencil, hLine, hBezier, hRectangle, hEllipse, hEraser, hFill, hBorderW, hEraserW, hClear;
RECT rect ;
PAINTSTRUCT ps;
HDC hdc = GetDC(hwnd);
int screenW, screenH;
int xMouse, yMouse;
int xFillPreview = 200;
int yFillPreview = 515;
int xStrokePreview = 310;
int yStrokePreview = 515;
HDC hdcMem;
BITMAP bitmap;
HBITMAP hbit;
static RECT drawingArea = {25, 55, 750, 500};
static RECT fillColorRect = {xFillPreview, yFillPreview, xFillPreview + 25, yFillPreview + 20};
static RECT borderColorRect = {xStrokePreview, yStrokePreview, xStrokePreview + 25, yStrokePreview + 20};
static RECT tempRect;
HBRUSH hBrush;
static POINT pointPen;
POINT point;
HPEN linePen;
int width;
static BOOL lineStarted, rectangleStarted, ellipseStarted;
static RECT rectangle, ellipse;
static int bezierStage = 0;
static POINT line;
static POINT bezierPoints[4];
HPEN borderPen;
HBRUSH fillBrush;
switch (message)
{
case WM_CREATE:
hImageBttn = LoadBitmap(GetModuleHandle(0), MAKEINTRESOURCE(IDB_PENCIL));
screenW = GetSystemMetrics(SM_CXSCREEN);
screenH = GetSystemMetrics(SM_CYSCREEN);
GetWindowRect(hwnd, &rect);
SetWindowPos(hwnd, 0, (screenW - rect.right)/2, (screenH - rect.bottom)/2, 0, 0, SWP_NOZORDER|SWP_NOSIZE);
hPencil = CreateWindowEx(
0,
"Button",
NULL,
WS_VISIBLE| WS_CHILD|BS_AUTORADIOBUTTON | BS_PUSHLIKE | BS_BITMAP ,
25, 15,
32, 32,
hwnd,
(HMENU)IDB_pencil,
hInst,
NULL);
SendMessage(hPencil, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hImageBttn);
hImageBttn = LoadBitmap(GetModuleHandle(0), MAKEINTRESOURCE(IDB_LINE));
hLine = CreateWindowEx(
0,
"Button",
NULL,
WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON | BS_PUSHLIKE | BS_BITMAP,
65, 15,
32, 32,
hwnd,
(HMENU)IDB_line,
hInst,
NULL);
SendMessage(hLine, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hImageBttn);
hImageBttn = LoadBitmap(GetModuleHandle(0), MAKEINTRESOURCE(IDB_BEZIER));
hBezier = CreateWindowEx(
0,
"Button",
NULL,
WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON | BS_PUSHLIKE | BS_BITMAP,
105, 15,
32, 32,
hwnd,
(HMENU)IDB_bezier,
hInst,
NULL);
SendMessage(hBezier, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hImageBttn);
hImageBttn = LoadBitmap(GetModuleHandle(0), MAKEINTRESOURCE(IDB_RECTANGLE));
hRectangle = CreateWindowEx(
0,
"Button",
NULL,
WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON | BS_PUSHLIKE | BS_BITMAP,
145, 15,
32, 32,
hwnd,
(HMENU)IDB_rectangle,
hInst,
NULL);
SendMessage(hRectangle, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hImageBttn);
hImageBttn = LoadBitmap(GetModuleHandle(0), MAKEINTRESOURCE(IDB_ELLIPSE));
hEllipse = CreateWindowEx(
0,
"Button",
NULL,
WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON | BS_PUSHLIKE | BS_BITMAP,
185, 15,
32, 32,
hwnd,
(HMENU)IDB_ellipse,
hInst,
NULL);
SendMessage(hEllipse, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hImageBttn);
hImageBttn = LoadBitmap(GetModuleHandle(0), MAKEINTRESOURCE(IDB_ERASER));
hEraser = CreateWindowEx(
0,
"Button",
NULL,
WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON | BS_PUSHLIKE | BS_BITMAP,
225, 15,
32, 32,
hwnd,
(HMENU)IDB_eraser,
hInst,
NULL);
SendMessage(hEraser, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hImageBttn);
hFill = CreateWindowEx(
0,
"Button",
"Fill object",
WS_VISIBLE | WS_CHILD | BS_AUTOCHECKBOX,
10, 515,
100, 20,
hwnd,
(HMENU)IDB_fill,
hInst,
NULL);
CreateWindowEx(
0,
"Static",
"Fill color",
WS_VISIBLE | WS_CHILD | SS_LEFT,
120, 515,
75, 20,
hwnd,
(HMENU)0,
hInst,
NULL);
CreateWindowEx(
0,
"Static",
"Line color",
WS_VISIBLE | WS_CHILD | SS_LEFT,
230, 515,
70, 20,
hwnd,
(HMENU)0,
hInst,
NULL);
CreateWindowEx(
0,
"Static",
"Border width",
WS_VISIBLE | WS_CHILD | SS_LEFT,
350, 515,
100, 20,
hwnd,
(HMENU)0,
hInst,
NULL);
hBorderW = CreateWindowEx(
0,
"Edit",
"1",
WS_VISIBLE | WS_CHILD | WS_BORDER | SS_CENTER,
460, 515,
40, 20,
hwnd,
(HMENU)0,
hInst,
NULL);
CreateWindowEx(
0,
"Static",
"Eraser width",
WS_VISIBLE | WS_CHILD | SS_LEFT,
515, 515,
100, 20,
hwnd,
(HMENU)0,
hInst,
NULL);
hEraserW = CreateWindowEx(
0,
"Edit",
"1",
WS_VISIBLE | WS_CHILD | WS_BORDER | SS_CENTER,
620, 515,
40, 20,
hwnd,
(HMENU)0,
hInst,
NULL);
hClear = CreateWindowEx(
NULL,
"Button",
"Clear",
WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
680, 515,
100, 20,
hwnd,
(HMENU)IDB_clear,
GetModuleHandle(NULL),
NULL);
RegisterHotKey(hwnd, HK_dellipse, MOD_CONTROL, 0x45);
RegisterHotKey(hwnd, HK_dblue, MOD_CONTROL, 0x43);
break;
case WM_PAINT:
hdc = BeginPaint(hwnd, &ps);
updateColorControls(hdc, fillColor, xFillPreview, yFillPreview);
updateColorControls(hdc, borderColor, xStrokePreview, yStrokePreview);
SelectObject(hdc, CreatePen(PS_SOLID, 1, RGB(0,0,0)));
SelectObject(hdc, (HBRUSH)GetStockObject(WHITE_BRUSH));
Rectangle(hdc, drawingArea.left, drawingArea.top, drawingArea.right, drawingArea.bottom);
EndPaint(hwnd, &ps);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDB_clear:
Button_SetCheck(hPencil, BST_UNCHECKED);
Button_SetCheck(hLine, BST_UNCHECKED);
Button_SetCheck(hBezier, BST_UNCHECKED);
Button_SetCheck(hRectangle, BST_UNCHECKED);
Button_SetCheck(hEllipse, BST_UNCHECKED);
Button_SetCheck(hEraser, BST_UNCHECKED);
InvalidateRect(hwnd, &drawingArea, FALSE);
InvalidateRect(hwnd, &drawingArea, TRUE);
break;
default:
DefWindowProc(hwnd, WM_COMMAND, wParam, lParam);
break;
}
break;
case WM_GETMINMAXINFO:
{
LPMINMAXINFO mmi = (LPMINMAXINFO)lParam;
mmi->ptMinTrackSize.x = 800;
mmi->ptMinTrackSize.y = 550;
mmi->ptMaxTrackSize.x = 850;
mmi->ptMaxTrackSize.y = 600;
break;
}
case WM_LBUTTONDOWN:
xMouse = GET_X_LPARAM(lParam);
yMouse = GET_Y_LPARAM(lParam);
if(xMouse >= fillColorRect.left && xMouse <= fillColorRect.right)
{
if(yMouse >= fillColorRect.top && yMouse <= fillColorRect.bottom)
{
fillColor = colorSelect(hwnd, fillColor);
updateColorControls(hdc, fillColor, xFillPreview, yFillPreview);
}
else if(yMouse >= borderColorRect.top && yMouse <= borderColorRect.bottom)
{
borderColor = colorSelect(hwnd, borderColor);
updateColorControls(hdc, borderColor, xStrokePreview, yStrokePreview);
}
return 0;
}
if( (xMouse > drawingArea.left) && (xMouse < drawingArea.right) &&
(yMouse > drawingArea.top) && (yMouse < drawingArea.bottom) )
{
width = getFromInput(hBorderW);
point = getCurrentPointPosition(xMouse, yMouse, drawingArea, width);
xMouse = point.x;
yMouse = point.y;
if((wParam == MK_LBUTTON) && (Button_GetCheck(hPencil) == BST_CHECKED))
{
pointPen.x = xMouse;
pointPen.y = yMouse;
}
if((wParam == MK_LBUTTON) && (Button_GetCheck(hLine) == BST_CHECKED))
{
line.x = xMouse;
line.y = yMouse;
lineStarted = true;
}
if((wParam == MK_LBUTTON) && (Button_GetCheck(hRectangle) == BST_CHECKED))
{
rectangle.left = xMouse;
rectangle.top = yMouse;
rectangleStarted = true;
}
if((wParam == MK_LBUTTON) && (Button_GetCheck(hEllipse) == BST_CHECKED))
{
ellipse.left = xMouse;
ellipse.top = yMouse;
ellipseStarted = true;
}
if((wParam == MK_LBUTTON) && (Button_GetCheck(hBezier) == BST_CHECKED))
{
if(bezierStage == 0)
{
bezierPoints[0] = point;
bezierStage = 1;
}
else
{
bezierPoints[2] = point;
bezierStage = 3;
}
}
}
break;
case WM_LBUTTONUP:
xMouse = GET_X_LPARAM(lParam);
yMouse = GET_Y_LPARAM(lParam);
width = getFromInput(hBorderW);
point = getCurrentPointPosition(xMouse, yMouse, drawingArea, width);
xMouse = point.x;
yMouse = point.y;
borderPen = CreatePen(PS_SOLID, width, borderColor);
if(Button_GetCheck(hFill) == BST_CHECKED)
fillBrush = CreateSolidBrush(fillColor);
else
fillBrush = (HBRUSH)GetStockObject(NULL_BRUSH);
if(lineStarted)
{
SelectObject(hdc, borderPen);
MoveToEx(hdc, xMouse, yMouse, NULL);
LineTo(hdc, line.x, line.y);
DeleteObject(borderPen);
lineStarted = false;
}
if(rectangleStarted)
{
SelectObject(hdc, borderPen);
SelectObject(hdc, fillBrush);
Rectangle(hdc, rectangle.left, rectangle.top, xMouse, yMouse);
DeleteObject(borderPen);
DeleteObject(fillBrush);
rectangleStarted = false;
}
if(ellipseStarted)
{
SelectObject(hdc, borderPen);
SelectObject(hdc, fillBrush);
Ellipse(hdc, ellipse.left, ellipse.top, xMouse, yMouse);
DeleteObject(borderPen);
DeleteObject(fillBrush);
ellipseStarted = false;
}
if(bezierStage == 1)
{
bezierPoints[1] = point;
bezierStage = 2;
}
if(bezierStage == 3)
{
bezierPoints[3] = point;
bezierStage = 0;
SelectObject(hdc, borderPen);
PolyBezier(hdc, bezierPoints, 4);
DeleteObject(borderPen);
}
break;
case WM_MOUSEMOVE:
xMouse = GET_X_LPARAM(lParam);
yMouse = GET_Y_LPARAM(lParam);
if( (xMouse > drawingArea.left) && (xMouse < drawingArea.right) &&
(yMouse > drawingArea.top) && (yMouse < drawingArea.bottom) )
{
if((wParam == MK_LBUTTON) && (Button_GetCheck(hPencil) == BST_CHECKED))
{
width = getFromInput(hBorderW);
point = getCurrentPointPosition(xMouse, yMouse, drawingArea, width);
xMouse = point.x;
yMouse = point.y;
linePen = CreatePen(PS_SOLID, width, borderColor);
SelectObject(hdc, linePen);
MoveToEx(hdc, xMouse, yMouse, NULL);
LineTo(hdc, pointPen.x, pointPen.y);
DeleteObject(linePen);
pointPen.x = xMouse;
pointPen.y = yMouse;
}
if((wParam == MK_LBUTTON) && (Button_GetCheck(hEraser) == BST_CHECKED))
{
width = getFromInput(hEraserW);
point = getCurrentPointPosition(xMouse, yMouse, drawingArea, width);
xMouse = point.x;
yMouse = point.y;
rect.left = point.x - (width / 2);
rect.right = point.x + (width / 2);
rect.top = point.y - (width / 2);
rect.bottom = point.y + (width / 2);
InvalidateRect(hwnd, &rect, FALSE);
SendMessage(hwnd, WM_PAINT, 0, 0);
}
}
break;
case WM_CTLCOLORSTATIC:
{
HDC hDC = (HDC)wParam;
SetBkColor(hDC, GetSysColor(COLOR_WINDOW));
SetTextColor(hDC, RGB(255,69,0));
SetBkMode(hDC, TRANSPARENT);
return (INT_PTR)CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
}
break;
case WM_HOTKEY:
{
switch(wParam)
{
case HK_dellipse:
Button_SetCheck(hPencil, BST_UNCHECKED);
Button_SetCheck(hLine, BST_UNCHECKED);
Button_SetCheck(hBezier, BST_UNCHECKED);
Button_SetCheck(hRectangle, BST_UNCHECKED);
Button_SetCheck(hEraser, BST_UNCHECKED);
Button_SetCheck(hEllipse, BST_CHECKED);
break;
case HK_dblue:
Button_SetCheck(hFill, BST_CHECKED);
fillColor = RGB(0,0,255);
updateColorControls(hdc, fillColor, xFillPreview, yFillPreview);
break;
default:
break;
}
break;
}
case WM_CLOSE:
if(MessageBox(hwnd, "Close application?", "Quit", MB_YESNO) == IDYES) DestroyWindow(hwnd);
break;
case WM_DESTROY:
PostQuitMessage (0);
break;
default:
return DefWindowProc (hwnd, message, wParam, lParam);
}
return 0;
}
/*
*************************************************************************
*
* This class creates the mapped multi-block grid geometry used
* for calculations in the MblkLinAdv code.
*
*************************************************************************
*/
MblkGeometry::MblkGeometry(
const std::string& object_name,
const tbox::Dimension& dim,
boost::shared_ptr<tbox::Database>& input_db,
boost::shared_ptr<hier::BaseGridGeometry>& grid_geom):
d_grid_geom(grid_geom),
d_dim(dim)
{
TBOX_ASSERT(!object_name.empty());
TBOX_ASSERT(input_db);
d_object_name = object_name;
//tbox::RestartManager::getManager()->registerRestartItem(d_object_name, this);
d_nblocks = static_cast<int>(grid_geom->getNumberBlocks());
d_metrics_set.resize(10);
for (int i = 0; i < 10; ++i) {
d_metrics_set[i].resize(d_nblocks);
for (int b = 0; b < d_nblocks; ++b) {
d_metrics_set[i][b] = false;
}
}
/*
* Initialize object with data read from given input/restart databases.
*/
bool is_from_restart = tbox::RestartManager::getManager()->isFromRestart();
if (is_from_restart) {
// getFromRestart(); // ADD
}
getFromInput(input_db, is_from_restart);
std::vector<hier::BoxContainer> domain_boxes(d_nblocks);
for (int b = 0; b < d_nblocks; ++b) {
grid_geom->computePhysicalDomain(domain_boxes[b],
hier::IntVector::getOne(dim),
hier::BlockId(b));
TBOX_ASSERT(domain_boxes[b].size() == 1);
}
if (d_geom_problem == "CARTESIAN") {
for (int b = 0; b < d_nblocks; ++b) {
if (!d_metrics_set[0][b]) {
setCartesianMetrics(domain_boxes[b].front(), 0, b);
}
}
}
if (d_geom_problem == "WEDGE") {
if (!d_metrics_set[0][0]) {
setWedgeMetrics(domain_boxes[0].front(), 0);
}
}
if (d_geom_problem == "SPHERICAL_SHELL") {
if (!d_metrics_set[0][0]) {
setSShellMetrics(domain_boxes[0].front(), 0);
}
}
}
CVODEModel::CVODEModel(
const string& object_name,
const Dimension& dim,
std::shared_ptr<CellPoissonFACSolver> fac_solver,
std::shared_ptr<Database> input_db,
std::shared_ptr<CartesianGridGeometry> grid_geom):
RefinePatchStrategy(),
CoarsenPatchStrategy(),
d_object_name(object_name),
d_dim(dim),
d_soln_var(new CellVariable<double>(dim, "soln", 1)),
d_FAC_solver(fac_solver),
d_grid_geometry(grid_geom)
{
/*
* set up variables and contexts
*/
VariableDatabase* variable_db = VariableDatabase::getDatabase();
d_cur_cxt = variable_db->getContext("CURRENT");
d_scr_cxt = variable_db->getContext("SCRATCH");
d_soln_cur_id = variable_db->registerVariableAndContext(d_soln_var,
d_cur_cxt,
IntVector(d_dim, 0));
d_soln_scr_id = variable_db->registerVariableAndContext(d_soln_var,
d_scr_cxt,
IntVector(d_dim, 1));
#ifdef USE_FAC_PRECONDITIONER
d_diff_var.reset(new SideVariable<double>(d_dim, "diffusion",
hier::IntVector::getOne(d_dim), 1));
d_diff_id = variable_db->registerVariableAndContext(d_diff_var,
d_cur_cxt,
IntVector(d_dim, 0));
/*
* Set default values for preconditioner.
*/
d_use_neumann_bcs = false;
d_current_soln_time = 0.;
#endif
/*
* Print solver data.
*/
d_print_solver_info = false;
/*
* Counters.
*/
d_number_rhs_eval = 0;
d_number_precond_setup = 0;
d_number_precond_solve = 0;
/*
* Boundary condition initialization.
*/
if (d_dim == Dimension(2)) {
d_scalar_bdry_edge_conds.resize(NUM_2D_EDGES);
for (int ei = 0; ei < NUM_2D_EDGES; ++ei) {
d_scalar_bdry_edge_conds[ei] = BOGUS_BDRY_DATA;
}
d_scalar_bdry_node_conds.resize(NUM_2D_NODES);
d_node_bdry_edge.resize(NUM_2D_NODES);
for (int ni = 0; ni < NUM_2D_NODES; ++ni) {
d_scalar_bdry_node_conds[ni] = BOGUS_BDRY_DATA;
d_node_bdry_edge[ni] = BOGUS_BDRY_DATA;
}
d_bdry_edge_val.resize(NUM_2D_EDGES);
MathUtilities<double>::setVectorToSignalingNaN(d_bdry_edge_val);
} else if (d_dim == Dimension(3)) {
d_scalar_bdry_face_conds.resize(NUM_3D_FACES);
for (int fi = 0; fi < NUM_3D_FACES; ++fi) {
d_scalar_bdry_face_conds[fi] = BOGUS_BDRY_DATA;
}
d_scalar_bdry_edge_conds.resize(NUM_3D_EDGES);
d_edge_bdry_face.resize(NUM_3D_EDGES);
for (int ei = 0; ei < NUM_3D_EDGES; ++ei) {
d_scalar_bdry_edge_conds[ei] = BOGUS_BDRY_DATA;
d_edge_bdry_face[ei] = BOGUS_BDRY_DATA;
}
d_scalar_bdry_node_conds.resize(NUM_3D_NODES);
d_node_bdry_face.resize(NUM_3D_NODES);
for (int ni = 0; ni < NUM_3D_NODES; ++ni) {
d_scalar_bdry_node_conds[ni] = BOGUS_BDRY_DATA;
d_node_bdry_face[ni] = BOGUS_BDRY_DATA;
}
d_bdry_face_val.resize(NUM_3D_FACES);
MathUtilities<double>::setVectorToSignalingNaN(d_bdry_face_val);
}
/*
* Initialize object with data read from given input/restart databases.
*/
bool is_from_restart = RestartManager::getManager()->isFromRestart();
if (is_from_restart) {
getFromRestart();
}
getFromInput(input_db, is_from_restart);
#ifdef USE_FAC_PRECONDITIONER
/*
* Construct outerface variable to hold boundary flags and Neumann fluxes.
*/
if (d_use_neumann_bcs) {
d_flag_var.reset(new OuterfaceVariable<int>(d_dim, "bdryflag", 1));
d_flag_id = variable_db->registerVariableAndContext(d_flag_var,
d_cur_cxt,
IntVector(d_dim, 0));
d_neuf_var.reset(new OuterfaceVariable<double>(d_dim, "neuflux", 1));
d_neuf_id = variable_db->registerVariableAndContext(d_neuf_var,
d_cur_cxt,
IntVector(d_dim, 0));
} else {
d_flag_id = -1;
d_neuf_id = -1;
}
/*
* Set boundary types for FAC preconditioner.
* bdry_types holds a flag where 0 = dirichlet, 1 = neumann
*/
if (d_dim == Dimension(2)) {
for (int i = 0; i < NUM_2D_EDGES; ++i) {
d_bdry_types[i] = 0;
if (d_scalar_bdry_edge_conds[i] == BdryCond::DIRICHLET) d_bdry_types[i] = 0;
if (d_scalar_bdry_edge_conds[i] == BdryCond::NEUMANN) d_bdry_types[i] = 1;
}
} else if (d_dim == Dimension(3)) {
for (int i = 0; i < NUM_3D_FACES; ++i) {
d_bdry_types[i] = 0;
if (d_scalar_bdry_face_conds[i] == BdryCond::DIRICHLET) d_bdry_types[i] = 0;
if (d_scalar_bdry_face_conds[i] == BdryCond::NEUMANN) d_bdry_types[i] = 1;
}
}
#endif
/*
* Postprocess boundary data from input/restart values. Note: scalar
* quantity in this problem cannot have reflective boundary conditions
* so we reset them to BdryCond::FLOW.
*/
if (d_dim == Dimension(2)) {
for (int i = 0; i < NUM_2D_EDGES; ++i) {
if (d_scalar_bdry_edge_conds[i] == BdryCond::REFLECT) {
d_scalar_bdry_edge_conds[i] = BdryCond::FLOW;
}
}
for (int i = 0; i < NUM_2D_NODES; ++i) {
if (d_scalar_bdry_node_conds[i] == BdryCond::XREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::XFLOW;
}
if (d_scalar_bdry_node_conds[i] == BdryCond::YREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::YFLOW;
}
if (d_scalar_bdry_node_conds[i] != BOGUS_BDRY_DATA) {
d_node_bdry_edge[i] =
CartesianBoundaryUtilities2::getEdgeLocationForNodeBdry(
i, d_scalar_bdry_node_conds[i]);
}
}
} else if (d_dim == Dimension(3)) {
for (int i = 0; i < NUM_3D_FACES; ++i) {
if (d_scalar_bdry_face_conds[i] == BdryCond::REFLECT) {
d_scalar_bdry_face_conds[i] = BdryCond::FLOW;
}
}
for (int i = 0; i < NUM_3D_EDGES; ++i) {
if (d_scalar_bdry_edge_conds[i] == BdryCond::XREFLECT) {
d_scalar_bdry_edge_conds[i] = BdryCond::XFLOW;
}
if (d_scalar_bdry_edge_conds[i] == BdryCond::YREFLECT) {
d_scalar_bdry_edge_conds[i] = BdryCond::YFLOW;
}
if (d_scalar_bdry_edge_conds[i] == BdryCond::ZREFLECT) {
d_scalar_bdry_edge_conds[i] = BdryCond::ZFLOW;
}
if (d_scalar_bdry_edge_conds[i] != BOGUS_BDRY_DATA) {
d_edge_bdry_face[i] =
CartesianBoundaryUtilities3::getFaceLocationForEdgeBdry(
i, d_scalar_bdry_edge_conds[i]);
}
}
for (int i = 0; i < NUM_3D_NODES; ++i) {
if (d_scalar_bdry_node_conds[i] == BdryCond::XREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::XFLOW;
}
if (d_scalar_bdry_node_conds[i] == BdryCond::YREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::YFLOW;
}
if (d_scalar_bdry_node_conds[i] == BdryCond::ZREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::ZFLOW;
}
if (d_scalar_bdry_node_conds[i] != BOGUS_BDRY_DATA) {
d_node_bdry_face[i] =
CartesianBoundaryUtilities3::getFaceLocationForNodeBdry(
i, d_scalar_bdry_node_conds[i]);
}
}
}
}
INSHierarchyIntegrator::INSHierarchyIntegrator(const std::string& object_name,
Pointer<Database> input_db,
Pointer<Variable<NDIM> > U_var,
Pointer<Variable<NDIM> > P_var,
Pointer<Variable<NDIM> > F_var,
Pointer<Variable<NDIM> > Q_var,
bool register_for_restart)
: HierarchyIntegrator(object_name, input_db, register_for_restart), d_U_var(U_var),
d_P_var(P_var), d_F_var(F_var), d_Q_var(Q_var), d_U_init(NULL), d_P_init(NULL),
d_default_bc_coefs(d_object_name + "::default_bc_coefs", Pointer<Database>(NULL)),
d_bc_coefs(NDIM, static_cast<RobinBcCoefStrategy<NDIM>*>(NULL)),
d_traction_bc_type(TRACTION), d_F_fcn(NULL), d_Q_fcn(NULL)
{
// Set some default values.
d_integrator_is_initialized = false;
d_viscous_time_stepping_type = TRAPEZOIDAL_RULE;
d_convective_time_stepping_type = ADAMS_BASHFORTH;
d_init_convective_time_stepping_type = MIDPOINT_RULE;
d_num_cycles = 1;
d_cfl_max = 1.0;
d_using_vorticity_tagging = false;
d_Omega_max = 0.0;
d_normalize_pressure = false;
d_normalize_velocity = false;
d_convective_op_type = "DEFAULT";
d_convective_difference_form = ADVECTIVE;
d_convective_op_input_db = new MemoryDatabase(d_object_name + "::convective_op_input_db");
d_creeping_flow = false;
d_regrid_max_div_growth_factor = 1.1;
d_U_scale = 1.0;
d_P_scale = 1.0;
d_F_scale = 1.0;
d_Q_scale = 1.0;
d_Omega_scale = 1.0;
d_Div_U_scale = 1.0;
d_output_U = true;
d_output_P = true;
d_output_F = false;
d_output_Q = false;
d_output_Omega = true;
d_output_Div_U = true;
d_velocity_solver = NULL;
d_pressure_solver = NULL;
// Setup default boundary condition objects that specify homogeneous
// Dirichlet (solid-wall) boundary conditions for the velocity.
for (unsigned int d = 0; d < NDIM; ++d)
{
d_default_bc_coefs.setBoundaryValue(2 * d, 0.0);
d_default_bc_coefs.setBoundaryValue(2 * d + 1, 0.0);
}
registerPhysicalBoundaryConditions(
std::vector<RobinBcCoefStrategy<NDIM>*>(NDIM, &d_default_bc_coefs));
// Setup physical boundary conditions objects.
d_U_star_bc_coefs.resize(NDIM);
for (unsigned int d = 0; d < NDIM; ++d)
{
d_U_star_bc_coefs[d] = new INSIntermediateVelocityBcCoef(d, d_bc_coefs);
}
d_Phi_bc_coef = new INSProjectionBcCoef(d_bc_coefs);
// Initialize object with data read from the input and restart databases.
bool from_restart = RestartManager::getManager()->isFromRestart();
if (from_restart) getFromRestart();
if (input_db) getFromInput(input_db, from_restart);
// Initialize an advection velocity variable. NOTE: Patch data are
// allocated for this variable only when an advection-diffusion solver is
// registered with the INSHierarchyIntegrator.
d_U_adv_diff_var = new FaceVariable<NDIM, double>(d_object_name + "::U_adv_diff");
return;
} // INSHierarchyIntegrator
