void BorderFilter::niepce(DImg& src, DImg& dest, const DColor& fg,
int borderWidth, const DColor& bg, int lineWidth)
{
DImg tmp;
solid(src, tmp, bg, lineWidth);
solid(tmp, dest, fg, borderWidth);
}
int not_solid_above(struct Player *p) {
if((!solid(p->x, p->y - 1)) &&
(!solid(p->x + (p->w / 2), p->y - 1)) &&
(!solid(p->x + (p->w - 1), p->y - 1))) {
return 1;
}
else {
return 0;
}
}
void on_ground(struct Player *p) {
if(solid(p->x, p->y + p->h) ||
solid(p->x + (p->w / 2), p->y + p->h) ||
solid(p->x + p->w - 1, p->y + p->h)) {
p->on_ground = 1;
}
else {
p->on_ground = 0;
}
}
void BorderFilter::pattern(DImg& src, DImg& dest, int borderWidth,
const DColor& firstColor, const DColor& secondColor,
int firstWidth, int secondWidth)
{
// Original image with the first solid border around.
DImg tmp;
solid(src, tmp, firstColor, firstWidth);
// Border tiled image using pattern with second solid border around.
int width, height;
if (d->settings.orgWidth > d->settings.orgHeight)
{
height = tmp.height() + borderWidth * 2;
width = (int)(height * d->orgRatio);
}
else
{
width = tmp.width() + borderWidth * 2;
height = (int)(width / d->orgRatio);
}
DImg tmp2(width, height, tmp.sixteenBit(), tmp.hasAlpha());
qCDebug(DIGIKAM_DIMG_LOG) << "Border File:" << d->settings.borderPath;
DImg border(d->settings.borderPath);
if (border.isNull())
{
return;
}
border.convertToDepthOfImage(&tmp2);
for (int x = 0 ; x < width ; x += border.width())
{
for (int y = 0 ; y < height ; y += border.height())
{
tmp2.bitBltImage(&border, x, y);
}
}
solid(tmp2, dest, secondColor, secondWidth);
// Merge both images to one.
if (d->settings.orgWidth > d->settings.orgHeight)
{
dest.bitBltImage(&tmp, (dest.width() - tmp.width()) / 2, borderWidth);
}
else
{
dest.bitBltImage(&tmp, borderWidth, (dest.height() - tmp.height()) / 2);
}
}
BOOL ExtTabControl::OnEraseBkgnd(CDC *pDC)
{
// REVIEW: this is a bit of a hack. The tab control uses its font to resize itself.
// However, we use prof-uis paint manager's font to draw. This font can change (and be deleted)
// when system settings change. But we don't know when to update it. So do it here.
SetFont(&g_PaintManager->m_FontBoldBC);
CRect rClient, rTab, rTotalTab, rBkgnd, rEdge;
int nTab, nTabHeight = 0;
__super::OnEraseBkgnd(pDC);
// calc total tab width
GetClientRect(rClient);
nTab = GetItemCount();
rTotalTab.SetRectEmpty();
while (nTab--)
{
GetItemRect(nTab, rTab);
rTotalTab.UnionRect(rTab, rTotalTab);
}
nTabHeight = rTotalTab.Height();
// add a bit
rTotalTab.InflateRect(2, 3);
rEdge = rTotalTab;
// then if background color is set, paint the visible background
// area of the tabs in the bkgnd color
// note: the mfc code for drawing the tabs makes all sorts of assumptions
// about the background color of the tab control being the same as the page
// color - in some places the background color shows thru' the pages!!
// so we must only paint the background color where we need to, which is that
// portion of the tab area not excluded by the tabs themselves
//CBrush *pBrush = &g_PaintManager->m_brushLighterDefault;
CBrush solid(g_PaintManager->GetColor(COLOR_3DFACE));
CBrush *pBrush = &solid;
// full width of tab ctrl above top of tabs
rBkgnd = rClient;
rBkgnd.bottom = rTotalTab.top + 3;
pDC->FillRect(&rBkgnd, pBrush);
// width of tab ctrl visible bkgnd including bottom pixel of tabs to left of tabs
rBkgnd = rClient;
rBkgnd.right = 2;
rBkgnd.bottom = rBkgnd.top + (nTabHeight + 2);
pDC->FillRect(&rBkgnd, pBrush);
// to right of tabs
rBkgnd = rClient;
rBkgnd.left += rTotalTab.Width() - 2;
rBkgnd.bottom = rBkgnd.top + (nTabHeight + 2);
pDC->FillRect(&rBkgnd, pBrush);
return TRUE;
}
virtual void on_ctrl_change()
{
if(m_benchmark.status())
{
int i;
on_draw();
update_window();
scanline_rasterizer ras;
pixfmt pixf(rbuf_window());
base_renderer rb(pixf);
solid_renderer solid(rb);
draft_renderer draft(rb);
char buf[256];
if(m_draft.status())
{
start_timer();
for(i = 0; i < 10; i++)
{
draw_scene(ras, solid, draft);
}
sprintf(buf, "%3.3f milliseconds", elapsed_time());
}
else
{
double times[5];
for(m_draw = 0; m_draw < 4; m_draw++)
{
start_timer();
for(i = 0; i < 10; i++)
{
draw_scene(ras, solid, draft);
}
times[m_draw] = elapsed_time();
}
m_draw = 3;
times[4] = times[3];
times[3] -= times[2];
times[2] -= times[1];
times[1] -= times[0];
FILE* fd = fopen(full_file_name("benchmark"), "a");
fprintf(fd, "%10.3f %10.3f %10.3f %10.3f %10.3f\n",
times[0], times[1], times[2], times[3], times[4]);
fclose(fd);
sprintf(buf, " pipeline add_path sort render total\n"
"%10.3f %10.3f %10.3f %10.3f %10.3f",
times[0], times[1], times[2], times[3], times[4]);
}
message(buf);
m_benchmark.status(false);
force_redraw();
}
}
void DrawDownloadsOverlay(UIContext &ctx) {
// Thin bar at the top of the screen like Chrome.
std::vector<float> progress = g_DownloadManager.GetCurrentProgress();
if (progress.empty()) {
return;
}
static const uint32_t colors[4] = {
0xFFFFFFFF,
0xFFCCCCCC,
0xFFAAAAAA,
0xFF777777,
};
ctx.Begin();
int h = 5;
for (int i = 0; i < progress.size(); i++) {
float barWidth = 10 + (dp_xres - 10) * progress[i];
Bounds bounds(0, h * i, barWidth, h);
UI::Drawable solid(colors[i & 3]);
ctx.FillRect(solid, bounds);
}
ctx.End();
ctx.Flush();
}
/* >>>>>>>>>> EXA12_1 <<<<<<<<<< */
void exa12_1 (void)
{ int n = 50 ,i, j;
static int ixp[4] = {200, 1999, 1999, 200},
iyp[4] = {2600, 2600, 801, 801};
double fpi = 3.1415927 / 180., step, x, y;
step = 360. / (n - 1);
for (i = 0; i < n; i++)
{ x = i * step;
for (j = 0; j < n; j++)
{ y = j * step;
zmat[i][j] = (float) (2 * sin (x * fpi) * sin (y * fpi));
}
}
setpag ("da4p");
disini ();
pagera ();
hwfont ();
axspos (200, 2600);
axslen (1800, 1800);
name ("X-axis", "x");
name ("Y-axis", "y");
name ("Z-axis", "z");
titlin ("Surface Plot (SURMAT)", 2);
titlin ("F(X,Y) = 2*SIN(X)*SIN(Y)", 4);
graf3d (0.f, 360.f, 0.f, 90.f, 0.f, 360.f, 0.f, 90.f,
-3.f, 3.f, -3.f, 1.f);
height (50);
title ();
shlsur ();
color ("green");
surmat ((float *) zmat, n, n, 1, 1);
color ("fore");
grfini (-1.f, -1.f, -1.f, 1.f, -1.f, -1.f, 1.f, 1.f, -1.f);
nograf ();
graf (0.f, 360.f, 0.f, 90.f, 0.f, 360.f, 0.f, 90.f);
dashl ();
grid (1,1);
grffin ();
grfini (-1.f, -1.f, -1.f, -1.f, 1.f, -1.f, -1.f, 1.f, 1.f);
graf (0.f, 360.f, 0.f, 90.f, -3.f, 3.f, -3.f, 1.f);
grid (1, 1);
grffin ();
grfini (-1.f, 1.f, -1.f, 1.f, 1.f, -1.f, 1.f, 1.f, 1.f);
shdpat (7L);
solid ();
areaf (ixp, iyp, 4);
grffin ();
disfin ();
}
void PushButton::dragEnterEvent(QDragEnterEvent *e) {
if (*(button) == Qt::LeftButton) {
emit solid();
}
else {
emit dot();
}
}
animation filler::bfs::fillSolid( PNG & img, int x, int y,
RGBAPixel fillColor, int tolerance, int frameFreq ) {
/**
* @todo Your code here! You should replace the following line with a
* correct call to fill with the correct colorPicker parameter.
*/
solidColorPicker solid(fillColor);
return filler::fill<Queue>(img, x, y, solid, tolerance, frameFreq);
}
point entity::midpoint() const
{
if(solid()) {
const rect r = solid_rect();
return point(r.x() + r.w()/2, r.y() + r.h()/2);
}
const frame& f = current_frame();
return point(x() + f.width()/2, y() + f.height()/2);
}
void check_against_map(struct Player *p) {
int i;
/* move down / fall */
if(p->vy > 0) {
for(i = 0; i < p->vy; i++) {
on_ground(p);
if(!p->on_ground) {
p->y += 1;
}
else {
break;
}
}
}
/* jump */
if(p->on_ground) {
if(p->vy < 0) {
for(i = 0; i > p->vy; i--) {
if(not_solid_above(p)) {
p->y -= 1;
}
else {
/* reset upward movement to prevent jumping if player hits above block and then moves left/right */
p->vy = 0;
}
}
}
}
/* move right */
if(p->vx > 0) {
for(i = 0; i < p->vx; i++) {
if((!solid(p->x + p->w, p->y)) && (!solid(p->x + p->w, p->y + p->h/2 - 1)) && (!solid(p->x + p->w, p->y + p->h - 1))) {
p->x += 1;
}
}
}
/* move left */
if(p->vx < 0) {
for(i = 0; i > p->vx; i--) {
if((!solid(p->x - 1, p->y)) && !solid(p->x - 1, p->y + p->h/2 - 1) && !solid(p->x - 1, p->y + p->h - 1)) {
p->x -= 1;
}
}
}
}
//------------------------------------------------------------------------
virtual void on_draw()
{
scanline_rasterizer ras;
pixfmt pixf(rbuf_window());
base_renderer rb(pixf);
solid_renderer solid(rb);
draft_renderer draft(rb);
rb.clear(agg::rgba(1, 1, 1));
draw_scene(ras, solid, draft);
ras.filling_rule(agg::fill_non_zero);
agg::render_ctrl(ras, m_sl, rb, m_type);
agg::render_ctrl(ras, m_sl, rb, m_width);
agg::render_ctrl(ras, m_sl, rb, m_benchmark);
agg::render_ctrl(ras, m_sl, rb, m_draw_nodes);
agg::render_ctrl(ras, m_sl, rb, m_draw_edges);
agg::render_ctrl(ras, m_sl, rb, m_draft);
agg::render_ctrl(ras, m_sl, rb, m_translucent);
}
void ResultsControlWidget::paint ( base_renderer& base )
{
scanline_rasterizer ras;
solid_renderer solid( base );
loadCaseText.start_point( ctrlLeft, 13 );
ras.add_path( textPoly );
solid.color( agg::rgba( 0, 0, 0 ) );
agg::render_scanlines( ras, scanline, solid );
ras.filling_rule( agg::fill_non_zero );
if ( ! deformAllowed ) {
deformSlider.pointer_color( agg::rgba( 1, 1, 1, 0 ) );
deformSlider.num_steps( 0 );
deformSlider.range( 1, 1 );
deformSlider.value( 1 );
deformSlider.label("");
deformCheckBox.active_color( agg::rgba( 0, 0, 0, 0.4 ) );
deformCheckBox.inactive_color( agg::rgba( 0, 0, 0, 0.4 ) );
deformCheckBox.text_color( agg::rgba( 0, 0, 0, 0.4 ) );
deformCheckBox.status( deformCbState );
}
else {
deformSlider.num_steps( 19 );
deformSlider.range( 1, 20 );
deformSlider.label( "Deform scale %2.0f:1" );
deformSlider.pointer_color( agg::rgba( 45, 165, 195, 0.5 ) );
deformCheckBox.active_color( agg::rgba( 0, 0, 0 ) );
deformCheckBox.inactive_color( agg::rgba( 0, 0, 0 ) );
deformCheckBox.text_color( agg::rgba( 0, 0, 0 ) );
}
agg::render_ctrl( ras, scanline, solid, deformSlider );
agg::render_ctrl( ras, scanline, solid, scaleSlider );
agg::render_ctrl( ras, scanline, solid, numberCheckBox );
agg::render_ctrl( ras, scanline, solid, deformCheckBox );
}
/* place block if there is enough room */
void place_block(int x, int y, struct Player *p) {
int cam_x = x + map.min_x;
int cam_y = y + map.min_y;
int dx = cam_x/map.blocksize;
int dy = cam_y/map.blocksize;
int mass = ((p->selected == WATER5) || (p->selected == OIL)) ? MAX_MASS : 0;
if((dx < map.w) && (dy < map.h) && not_player_position(dx, dy, p) ) {
/* not solid at new block position, dirt, grass or rock selected &
horizontal or vertical adjacent block exists (never place floating blocks) */
if(!solid(cam_x, cam_y) && (solid(cam_x + map.blocksize, cam_y) ||
solid(cam_x - map.blocksize, cam_y) ||
solid(cam_x, cam_y + map.blocksize) ||
solid(cam_x, cam_y - map.blocksize))) {
if((p->selected == DIRT) || (p->selected == GRASS) || (p->selected == ROCK)) {
map.tiles[dx][dy] = p->selected;
map.new_water_mass[dx][dy] = mass;
}
}
/* not solid at new block position and water, sand or oil selected */
if(!solid(cam_x, cam_y) && ((p->selected == WATER5) || (p->selected == SAND) || (p->selected == OIL))) {
map.tiles[dx][dy] = p->selected;
switch(p->selected) {
case WATER5:
map.new_water_mass[dx][dy] = mass;
break;
case OIL:
map.new_oil_mass[dx][dy] = mass;
break;
default:
break;
}
}
}
}
int main(int argc, char **argv)
{
sf::RenderWindow window(sf::VideoMode(600, 800), "The Floor Is Lava!");
//window.setVerticalSyncEnabled(true);
window.setFramerateLimit(60);
Camera camera(608, 800, 1);
camera.MoveTowards(0.0f, -1.0f);
std::unique_ptr<sf::Texture> lava(new sf::Texture);
std::unique_ptr<sf::Texture> solid(new sf::Texture);
std::unique_ptr<sf::Texture> player(new sf::Texture);
sf::Font font;
sf::Text score;
if(!font.loadFromFile("Assets/Roboto-Regular.ttf"))
{
std::cerr << "Unable to load font!" << std::endl;
}
score.setString("0");
score.setFont(font);
score.setCharacterSize(50);
sf::View gui_view;
gui_view.setSize(608, 800);
gui_view.setCenter(300, 400);
lava->loadFromFile("Assets/lava.png");
solid->loadFromFile("Assets/solid.png");
player->loadFromFile("Assets/player.png");
Tile lava_sprite(lava, Tile::LAVA);
Tile solid_sprite(solid, Tile::SOLID);
Player player_sprite(player, camera);
//sf::Sprite lava_sprite;
//sf::Sprite solid_sprite;
//lava_sprite.setTexture(lava);
//solid_sprite.setTexture(solid);
//solid_sprite.move(sf::Vector2f(32, 0));
while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
{
window.close();
}
if(event.type == sf::Event::KeyPressed)
{
if (player_sprite.IsAlive()){
switch (event.key.code)
{
case sf::Keyboard::Left:
player_sprite.Move(-32.0f, 0.0f);
break;
case sf::Keyboard::Right:
player_sprite.Move(32.0f, 0.0f);
break;
case sf::Keyboard::Up:
player_sprite.Move(0.0f, -32.0f);
break;
case sf::Keyboard::Down:
player_sprite.Move(0.0f, 32.0f);
}
}
}
}
window.clear(sf::Color::Black);
window.setView(camera.GetView());
if (player_sprite.IsAlive())
{
camera.Update();
player_sprite.Update();
score.setString(std::to_string(player_sprite.GetScore()));
}
window.draw(lava_sprite.GetSprite());
window.draw(solid_sprite.GetSprite());
window.draw(player_sprite.GetPlayer());
window.setView(gui_view);
window.draw(score);
window.display();
}
return 0;
}
std::unique_ptr<PNS::SOLID> PNS_KICAD_IFACE::syncPad( D_PAD* aPad )
{
LAYER_RANGE layers( 0, MAX_CU_LAYERS - 1 );
// ignore non-copper pads
if( ( aPad->GetLayerSet() & LSET::AllCuMask()).none() )
return NULL;
switch( aPad->GetAttribute() )
{
case PAD_ATTRIB_STANDARD:
break;
case PAD_ATTRIB_SMD:
case PAD_ATTRIB_HOLE_NOT_PLATED:
case PAD_ATTRIB_CONN:
{
LSET lmsk = aPad->GetLayerSet();
bool is_copper = false;
for( int i = 0; i < MAX_CU_LAYERS; i++ )
{
if( lmsk[i] )
{
is_copper = true;
if( aPad->GetAttribute() != PAD_ATTRIB_HOLE_NOT_PLATED )
layers = LAYER_RANGE( i );
break;
}
}
if( !is_copper )
return NULL;
}
break;
default:
wxLogTrace( "PNS", "unsupported pad type 0x%x", aPad->GetAttribute() );
return NULL;
}
std::unique_ptr< PNS::SOLID > solid( new PNS::SOLID );
solid->SetLayers( layers );
solid->SetNet( aPad->GetNetCode() );
solid->SetParent( aPad );
wxPoint wx_c = aPad->ShapePos();
wxSize wx_sz = aPad->GetSize();
wxPoint offset = aPad->GetOffset();
VECTOR2I c( wx_c.x, wx_c.y );
VECTOR2I sz( wx_sz.x, wx_sz.y );
RotatePoint( &offset, aPad->GetOrientation() );
solid->SetPos( VECTOR2I( c.x - offset.x, c.y - offset.y ) );
solid->SetOffset( VECTOR2I( offset.x, offset.y ) );
double orient = aPad->GetOrientation() / 10.0;
if( aPad->GetShape() == PAD_SHAPE_CIRCLE )
{
solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) );
}
else if( aPad->GetShape() == PAD_SHAPE_CUSTOM )
{
SHAPE_POLY_SET outline;
outline.Append( aPad->GetCustomShapeAsPolygon() );
aPad->CustomShapeAsPolygonToBoardPosition( &outline, wx_c, aPad->GetOrientation() );
SHAPE_CONVEX* shape = new SHAPE_CONVEX();
// We use the convex hull of the pad shape, because PnS knows
// only convex shapes.
std::vector<wxPoint> convex_hull;
BuildConvexHull( convex_hull, outline );
for( unsigned ii = 0; ii < convex_hull.size(); ii++ )
shape->Append( convex_hull[ii] );
solid->SetShape( shape );
}
else
{
if( orient == 0.0 || orient == 90.0 || orient == 180.0 || orient == 270.0 )
{
if( orient == 90.0 || orient == 270.0 )
sz = VECTOR2I( sz.y, sz.x );
switch( aPad->GetShape() )
{
case PAD_SHAPE_OVAL:
if( sz.x == sz.y )
solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) );
else
{
VECTOR2I delta;
if( sz.x > sz.y )
delta = VECTOR2I( ( sz.x - sz.y ) / 2, 0 );
else
delta = VECTOR2I( 0, ( sz.y - sz.x ) / 2 );
SHAPE_SEGMENT* shape = new SHAPE_SEGMENT( c - delta, c + delta,
std::min( sz.x, sz.y ) );
solid->SetShape( shape );
}
break;
case PAD_SHAPE_RECT:
solid->SetShape( new SHAPE_RECT( c - sz / 2, sz.x, sz.y ) );
break;
case PAD_SHAPE_TRAPEZOID:
{
wxPoint coords[4];
aPad->BuildPadPolygon( coords, wxSize( 0, 0 ), aPad->GetOrientation() );
SHAPE_CONVEX* shape = new SHAPE_CONVEX();
for( int ii = 0; ii < 4; ii++ )
{
shape->Append( wx_c + coords[ii] );
}
solid->SetShape( shape );
break;
}
case PAD_SHAPE_ROUNDRECT:
{
SHAPE_POLY_SET outline;
const int segmentToCircleCount = 64;
aPad->BuildPadShapePolygon( outline, wxSize( 0, 0 ), segmentToCircleCount, 1.0 );
// TransformRoundRectToPolygon creates only one convex polygon
SHAPE_LINE_CHAIN& poly = outline.Outline( 0 );
SHAPE_CONVEX* shape = new SHAPE_CONVEX();
for( int ii = 0; ii < poly.PointCount(); ++ii )
{
shape->Append( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) );
}
solid->SetShape( shape );
}
break;
default:
wxLogTrace( "PNS", "unsupported pad shape" );
return nullptr;
}
}
else
{
switch( aPad->GetShape() )
{
// PAD_SHAPE_CIRCLE and PAD_SHAPE_CUSTOM already handled above
case PAD_SHAPE_OVAL:
if( sz.x == sz.y )
solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) );
else
{
wxPoint start;
wxPoint end;
wxPoint corner;
SHAPE_CONVEX* shape = new SHAPE_CONVEX();
int w = aPad->BuildSegmentFromOvalShape( start, end, 0.0, wxSize( 0, 0 ) );
if( start.y == 0 )
corner = wxPoint( start.x, -( w / 2 ) );
else
corner = wxPoint( w / 2, start.y );
RotatePoint( &start, aPad->GetOrientation() );
RotatePoint( &corner, aPad->GetOrientation() );
shape->Append( wx_c + corner );
for( int rot = 100; rot <= 1800; rot += 100 )
{
wxPoint p( corner );
RotatePoint( &p, start, rot );
shape->Append( wx_c + p );
}
if( end.y == 0 )
corner = wxPoint( end.x, w / 2 );
else
corner = wxPoint( -( w / 2 ), end.y );
RotatePoint( &end, aPad->GetOrientation() );
RotatePoint( &corner, aPad->GetOrientation() );
shape->Append( wx_c + corner );
for( int rot = 100; rot <= 1800; rot += 100 )
{
wxPoint p( corner );
RotatePoint( &p, end, rot );
shape->Append( wx_c + p );
}
solid->SetShape( shape );
}
break;
case PAD_SHAPE_RECT:
case PAD_SHAPE_TRAPEZOID:
{
wxPoint coords[4];
aPad->BuildPadPolygon( coords, wxSize( 0, 0 ), aPad->GetOrientation() );
SHAPE_CONVEX* shape = new SHAPE_CONVEX();
for( int ii = 0; ii < 4; ii++ )
{
shape->Append( wx_c + coords[ii] );
}
solid->SetShape( shape );
break;
}
case PAD_SHAPE_ROUNDRECT:
{
SHAPE_POLY_SET outline;
const int segmentToCircleCount = 32;
aPad->BuildPadShapePolygon( outline, wxSize( 0, 0 ),
segmentToCircleCount, 1.0 );
// TransformRoundRectToPolygon creates only one convex polygon
SHAPE_LINE_CHAIN& poly = outline.Outline( 0 );
SHAPE_CONVEX* shape = new SHAPE_CONVEX();
for( int ii = 0; ii < poly.PointCount(); ++ii )
{
shape->Append( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) );
}
solid->SetShape( shape );
break;
}
default:
wxLogTrace( "PNS", "unsupported pad shape" );
return nullptr;
}
}
}
return solid;
}
TEST( SDCFsiTest, reuse )
{
std::vector<int> nbIter;
for ( int nbReuse = 0; nbReuse < 3; nbReuse++ )
{
scalar r0 = 0.2;
scalar a0 = M_PI * r0 * r0;
scalar u0 = 0.1;
scalar p0 = 0;
scalar dt = 0.01;
int N = 20;
scalar L = 1;
scalar T = 1;
scalar dx = L / N;
scalar rho = 1.225;
scalar E = 490;
scalar h = 1.0e-3;
scalar cmk = std::sqrt( E * h / (2 * rho * r0) );
scalar c0 = std::sqrt( cmk * cmk - p0 / (2 * rho) );
scalar kappa = c0 / u0;
bool parallel = false;
int extrapolation = 0;
scalar tol = 1.0e-5;
int maxIter = 50;
scalar initialRelaxation = 1.0e-3;
int maxUsedIterations = 50;
scalar singularityLimit = 1.0e-13;
int reuseInformationStartingFromTimeIndex = 0;
bool scaling = false;
bool updateJacobian = false;
scalar beta = 0.1;
int minIter = 5;
ASSERT_NEAR( kappa, 10, 1.0e-13 );
ASSERT_TRUE( dx > 0 );
std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> fluid( new tubeflow::SDCTubeFlowFluidSolver( a0, u0, p0, dt, cmk, N, L, T, rho ) );
std::shared_ptr<tubeflow::SDCTubeFlowSolidSolver> solid( new tubeflow::SDCTubeFlowSolidSolver( a0, cmk, p0, rho, L, N ) );
shared_ptr<RBFFunctionInterface> rbfFunction;
shared_ptr<RBFInterpolation> rbfInterpolator;
shared_ptr<RBFCoarsening> rbfInterpToCouplingMesh;
shared_ptr<RBFCoarsening> rbfInterpToMesh;
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
shared_ptr<MultiLevelSolver> fluidSolver( new MultiLevelSolver( fluid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 0, 0 ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
shared_ptr<MultiLevelSolver> solidSolver( new MultiLevelSolver( solid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 1, 0 ) );
std::shared_ptr< std::list<std::shared_ptr<ConvergenceMeasure> > > convergenceMeasures;
convergenceMeasures = std::shared_ptr<std::list<std::shared_ptr<ConvergenceMeasure> > >( new std::list<std::shared_ptr<ConvergenceMeasure> > );
convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new RelativeConvergenceMeasure( 0, false, tol ) ) );
convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new MinIterationConvergenceMeasure( 0, false, minIter ) ) );
shared_ptr<MultiLevelFsiSolver> fsi( new MultiLevelFsiSolver( fluidSolver, solidSolver, convergenceMeasures, parallel, extrapolation ) );
shared_ptr<PostProcessing> postProcessing( new AndersonPostProcessing( fsi, maxIter, initialRelaxation, maxUsedIterations, nbReuse, singularityLimit, reuseInformationStartingFromTimeIndex, scaling, beta, updateJacobian ) );
std::shared_ptr<sdc::SDCFsiSolverInterface> sdcFluidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( fluid );
std::shared_ptr<sdc::SDCFsiSolverInterface> sdcSolidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( solid );
assert( sdcFluidSolver );
assert( sdcSolidSolver );
std::shared_ptr<fsi::SDCFsiSolver> fsiSolver( new fsi::SDCFsiSolver( sdcFluidSolver, sdcSolidSolver, postProcessing, extrapolation ) );
int nbNodes = 3;
std::shared_ptr<fsi::quadrature::IQuadrature<scalar> > quadrature;
quadrature = std::shared_ptr<fsi::quadrature::IQuadrature<scalar> >( new fsi::quadrature::Uniform<scalar>( nbNodes ) );
std::shared_ptr<sdc::SDC> sdc( new sdc::SDC( fsiSolver, quadrature, 1.0e-10, nbNodes, nbNodes ) );
sdc->run();
nbIter.push_back( fsi->nbIter );
}
int iprev;
int index = 0;
for ( int i : nbIter )
{
std::cout << "nbIter = " << i << std::endl;
if ( index > 0 )
ASSERT_LE( i, iprev );
iprev = i;
index++;
}
}
void LocalImageLoaderPrivate::prepareImages() {
QString file, filename, mime, stickerMime = qsl("image/webp");
int32 filesize = 0;
QImage img;
QByteArray data;
PeerId peer;
uint64 id, thumbId = 0;
int32 duration = 0;
QString thumbExt = "jpg";
ToPrepareMediaType type;
bool animated = false;
bool ctrlShiftEnter = false;
MsgId replyTo = 0;
{
QMutexLocker lock(loader->toPrepareMutex());
ToPrepareMedias &list(loader->toPrepareMedias());
if (list.isEmpty()) return;
file = list.front().file;
img = list.front().img;
data = list.front().data;
peer = list.front().peer;
id = list.front().id;
type = list.front().type;
duration = list.front().duration;
ctrlShiftEnter = list.front().ctrlShiftEnter;
replyTo = list.front().replyTo;
}
if (img.isNull()) {
if (!file.isEmpty()) {
QFileInfo info(file);
if (type == ToPrepareAuto) {
QString lower(file.toLower());
const QStringList &photoExtensions(cPhotoExtensions());
for (QStringList::const_iterator i = photoExtensions.cbegin(), e = photoExtensions.cend(); i != e; ++i) {
if (lower.lastIndexOf(*i) == lower.size() - i->size()) {
if (info.size() < MaxUploadPhotoSize) {
type = ToPreparePhoto;
break;
}
}
}
if (type == ToPrepareAuto && info.size() < MaxUploadDocumentSize) {
type = ToPrepareDocument;
}
}
if (type == ToPrepareDocument) {
mime = mimeTypeForFile(info).name();
}
if (type != ToPrepareAuto && info.size() < MaxUploadPhotoSize) {
bool opaque = (mime != stickerMime);
img = App::readImage(file, 0, opaque, &animated);
}
filename = info.fileName();
filesize = info.size();
} else if (!data.isEmpty()) {
if (type != ToPrepareAudio) {
img = App::readImage(data, 0, true, &animated);
if (type == ToPrepareAuto) {
if (!img.isNull() && data.size() < MaxUploadPhotoSize) {
type = ToPreparePhoto;
} else if (data.size() < MaxUploadDocumentSize) {
type = ToPrepareDocument;
} else {
img = QImage();
}
}
}
MimeType mimeType = mimeTypeForData(data);
if (type == ToPrepareDocument || type == ToPrepareAudio) {
mime = mimeType.name();
}
if (mime == "image/jpeg") {
filename = filedialogDefaultName(qsl("image"), qsl(".jpg"), QString(), true);
} else if (type == ToPrepareAudio) {
filename = filedialogDefaultName(qsl("audio"), qsl(".ogg"), QString(), true);
mime = "audio/ogg";
} else {
QString ext;
QStringList patterns = mimeType.globPatterns();
if (!patterns.isEmpty()) {
ext = patterns.front().replace('*', QString());
}
filename = filedialogDefaultName((type == ToPrepareAudio) ? qsl("audio") : qsl("doc"), ext, QString(), true);
}
filesize = data.size();
}
} else {
if (type == ToPrepareDocument) {
filename = filedialogDefaultName(qsl("image"), qsl(".png"), QString(), true);
mime = mimeTypeForName("image/png").name();
data = QByteArray();
{
QBuffer b(&data);
img.save(&b, "PNG");
}
filesize = data.size();
} else {
if (img.hasAlphaChannel()) {
QImage solid(img.width(), img.height(), QImage::Format_ARGB32_Premultiplied);
solid.fill(st::white->c);
{
QPainter(&solid).drawImage(0, 0, img);
}
img = solid;
}
type = ToPreparePhoto;
filename = qsl("Untitled.jpg");
filesize = 0;
}
}
if ((img.isNull() && ((type != ToPrepareDocument && type != ToPrepareAudio) || !filesize)) || type == ToPrepareAuto || (img.isNull() && file.isEmpty() && data.isEmpty())) { // if could not decide what type
{
QMutexLocker lock(loader->toPrepareMutex());
ToPrepareMedias &list(loader->toPrepareMedias());
list.pop_front();
}
QTimer::singleShot(1, this, SLOT(prepareImages()));
emit imageFailed(id);
} else {
PreparedPhotoThumbs photoThumbs;
QVector<MTPPhotoSize> photoSizes;
QVector<MTPDocumentAttribute> attributes(1, MTP_documentAttributeFilename(MTP_string(filename)));
MTPPhotoSize thumb(MTP_photoSizeEmpty(MTP_string("")));
MTPPhoto photo(MTP_photoEmpty(MTP_long(0)));
MTPDocument document(MTP_documentEmpty(MTP_long(0)));
MTPAudio audio(MTP_audioEmpty(MTP_long(0)));
QByteArray jpeg;
if (type == ToPreparePhoto) {
int32 w = img.width(), h = img.height();
QPixmap thumb = (w > 100 || h > 100) ? QPixmap::fromImage(img.scaled(100, 100, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(img);
photoThumbs.insert('s', thumb);
photoSizes.push_back(MTP_photoSize(MTP_string("s"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(thumb.width()), MTP_int(thumb.height()), MTP_int(0)));
QPixmap medium = (w > 320 || h > 320) ? QPixmap::fromImage(img.scaled(320, 320, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(img);
photoThumbs.insert('m', medium);
photoSizes.push_back(MTP_photoSize(MTP_string("m"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(medium.width()), MTP_int(medium.height()), MTP_int(0)));
QPixmap full = (w > 1280 || h > 1280) ? QPixmap::fromImage(img.scaled(1280, 1280, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(img);
photoThumbs.insert('y', full);
photoSizes.push_back(MTP_photoSize(MTP_string("y"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0)));
{
QBuffer jpegBuffer(&jpeg);
full.save(&jpegBuffer, "JPG", 77);
}
if (!filesize) filesize = jpeg.size();
photo = MTP_photo(MTP_long(id), MTP_long(0), MTP_int(user), MTP_int(unixtime()), MTP_geoPointEmpty(), MTP_vector<MTPPhotoSize>(photoSizes));
thumbId = id;
} else if ((type == ToPrepareVideo || type == ToPrepareDocument) && !img.isNull()) {
int32 w = img.width(), h = img.height();
QByteArray thumbFormat = "JPG";
int32 thumbQuality = 87;
if (animated) {
attributes.push_back(MTP_documentAttributeAnimated());
} else if (mime == stickerMime && w > 0 && h > 0 && w <= StickerMaxSize && h <= StickerMaxSize && filesize < StickerInMemory) {
attributes.push_back(MTP_documentAttributeSticker(MTP_string(""), MTP_inputStickerSetEmpty()));
thumbFormat = "webp";
thumbExt = qsl("webp");
}
attributes.push_back(MTP_documentAttributeImageSize(MTP_int(w), MTP_int(h)));
if (w < 20 * h && h < 20 * w) {
QPixmap full = (w > 90 || h > 90) ? QPixmap::fromImage(img.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(img, Qt::ColorOnly);
{
QBuffer jpegBuffer(&jpeg);
full.save(&jpegBuffer, thumbFormat, thumbQuality);
}
photoThumbs.insert('0', full);
thumb = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0));
thumbId = MTP::nonce<uint64>();
}
}
if (type == ToPrepareDocument) {
document = MTP_document(MTP_long(id), MTP_long(0), MTP_int(unixtime()), MTP_string(mime), MTP_int(filesize), thumb, MTP_int(MTP::maindc()), MTP_vector<MTPDocumentAttribute>(attributes));
} else if (type == ToPrepareAudio) {
audio = MTP_audio(MTP_long(id), MTP_long(0), MTP_int(user), MTP_int(unixtime()), MTP_int(duration), MTP_string(mime), MTP_int(filesize), MTP_int(MTP::maindc()));
}
{
QMutexLocker lock(loader->readyMutex());
loader->readyList().push_back(ReadyLocalMedia(type, file, filename, filesize, data, id, thumbId, thumbExt, peer, photo, audio, photoThumbs, document, jpeg, ctrlShiftEnter, replyTo));
}
{
QMutexLocker lock(loader->toPrepareMutex());
ToPrepareMedias &list(loader->toPrepareMedias());
list.pop_front();
}
QTimer::singleShot(1, this, SLOT(prepareImages()));
emit imageReady();
}
}
void
GltSkySphere::draw() const
{
if (!visible())
return;
GLERROR
GltViewport viewport(true);
//
// Setup perspective camera mode,
// orthogonal doesn't really work...
//
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPerspective(_fov,double(viewport.width())/double(viewport.height()), 0.1, 200.0);
//
// Twiddle the current modelview matrix
// to cancel out translation and scale.
//
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
Matrix matrix(GL_MODELVIEW_MATRIX);
// No translation
matrix[12] = 0.0;
matrix[13] = 0.0;
matrix[14] = 0.0;
// No scale
const real sf = sqrt( SQ(matrix[0]) + SQ(matrix[1]) + SQ(matrix[2]) );
matrix *= matrixScale(1.0/sf);
//
matrix.glLoadMatrix();
transformation().glMultMatrix();
//
//
//
GLERROR
glPushAttrib(GL_ENABLE_BIT|GL_POLYGON_BIT|GL_LIGHTING_BIT);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
if (solid())
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glShadeModel(GL_SMOOTH);
}
else
{
glDisable(GL_BLEND);
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glShadeModel(GL_FLAT);
}
//
drawSphere(_map,_slices);
//
glPopAttrib();
GLERROR
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
GLERROR
}
TEST( SDIRKFsiSolidTest, linearized )
{
scalar r0 = 3.0e-3;
scalar h = 3.0e-4;
scalar L = 0.126;
scalar rho_s = 1000;
scalar E0 = 4.0e5;
scalar G = 4.0e5;
scalar nu = 0.5;
scalar a0 = M_PI * r0 * r0;
scalar u0 = 0.26;
scalar p0 = 0;
int N = 5;
scalar T = 1;
scalar rho_f = 1060;
scalar E = 490;
scalar cmk = std::sqrt( E * h / (2 * rho_f * r0) );
bool parallel = false;
int extrapolation = 0;
scalar tol = 1.0e-8;
int maxIter = 50;
scalar initialRelaxation = 1.0e-3;
int maxUsedIterations = 50;
int nbReuse = 0;
scalar singularityLimit = 1.0e-13;
int reuseInformationStartingFromTimeIndex = 0;
bool scaling = false;
scalar beta = 0.01;
bool updateJacobian = false;
int minIter = 5;
int nbComputations = 3;
std::deque<std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> > fluidSolvers;
std::deque<std::shared_ptr<tubeflow::SDCTubeFlowLinearizedSolidSolver> > solidSolvers;
std::deque<int> nbTimeStepsList;
for ( int iComputation = 0; iComputation < nbComputations; iComputation++ )
{
int nbTimeSteps = 120 * std::pow( 2, iComputation );
std::cout << "nbTimeSteps = " << nbTimeSteps << std::endl;
scalar dt = T / nbTimeSteps;
std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> fluid( new tubeflow::SDCTubeFlowFluidSolver( a0, u0, p0, dt, cmk, N, L, T, rho_f ) );
std::shared_ptr<tubeflow::SDCTubeFlowLinearizedSolidSolver> solid( new tubeflow::SDCTubeFlowLinearizedSolidSolver( N, nu, rho_s, h, L, dt, G, E0, r0, T ) );
shared_ptr<RBFFunctionInterface> rbfFunction;
shared_ptr<RBFInterpolation> rbfInterpolator;
shared_ptr<RBFCoarsening> rbfInterpToCouplingMesh;
shared_ptr<RBFCoarsening> rbfInterpToMesh;
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
shared_ptr<MultiLevelSolver> fluidSolver( new MultiLevelSolver( fluid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 0, 0 ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
shared_ptr<MultiLevelSolver> solidSolver( new MultiLevelSolver( solid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 1, 0 ) );
std::shared_ptr< std::list<std::shared_ptr<ConvergenceMeasure> > > convergenceMeasures;
convergenceMeasures = std::shared_ptr<std::list<std::shared_ptr<ConvergenceMeasure> > >( new std::list<std::shared_ptr<ConvergenceMeasure> >() );
convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new RelativeConvergenceMeasure( 0, true, tol ) ) );
convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new MinIterationConvergenceMeasure( 0, false, minIter ) ) );
shared_ptr<MultiLevelFsiSolver> fsi( new MultiLevelFsiSolver( fluidSolver, solidSolver, convergenceMeasures, parallel, extrapolation ) );
shared_ptr<PostProcessing> postProcessing( new AndersonPostProcessing( fsi, maxIter, initialRelaxation, maxUsedIterations, nbReuse, singularityLimit, reuseInformationStartingFromTimeIndex, scaling, beta, updateJacobian ) );
std::shared_ptr<sdc::SDCFsiSolverInterface> sdcFluidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( fluid );
std::shared_ptr<sdc::SDCFsiSolverInterface> sdcSolidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( solid );
assert( sdcFluidSolver );
assert( sdcSolidSolver );
std::shared_ptr<fsi::SDCFsiSolver> fsiSolver( new fsi::SDCFsiSolver( sdcFluidSolver, sdcSolidSolver, postProcessing, extrapolation ) );
std::shared_ptr<sdc::AdaptiveTimeStepper> adaptiveTimeStepper( new sdc::AdaptiveTimeStepper( false ) );
std::string method = "ESDIRK53PR";
std::shared_ptr<sdc::ESDIRK> esdirk( new sdc::ESDIRK( fsiSolver, method, adaptiveTimeStepper ) );
esdirk->run();
fluidSolvers.push_back( fluid );
solidSolvers.push_back( solid );
nbTimeStepsList.push_back( nbTimeSteps );
}
std::cout << "solid" << std::endl;
for ( int i = 0; i < 2; i++ )
{
fsi::vector ref;
if ( i == 0 )
ref = solidSolvers.back()->r;
else
ref = solidSolvers.back()->u;
std::deque<scalar> errors;
for ( int iComputation = 0; iComputation < nbComputations - 1; iComputation++ )
{
fsi::vector data;
if ( i == 0 )
data = solidSolvers.at( iComputation )->r;
else
data = solidSolvers.at( iComputation )->u;
scalar error = (ref - data).norm() / ref.norm();
errors.push_back( error );
}
for ( int iComputation = 0; iComputation < nbComputations - 2; iComputation++ )
{
scalar order = ( std::log10( errors.at( iComputation ) ) - std::log10( errors.at( iComputation + 1 ) ) ) / ( std::log10( nbTimeStepsList.at( iComputation + 1 ) ) - std::log10( nbTimeStepsList.at( iComputation ) ) );
std::cout << "order = " << order << std::endl;
if ( i == 0 )
ASSERT_NEAR( order, 3, 0.1 );
}
}
std::cout << "fluid" << std::endl;
for ( int i = 0; i < 3; i++ )
{
fsi::vector ref;
if ( i == 0 )
ref = fluidSolvers.back()->u;
if ( i == 1 )
ref = fluidSolvers.back()->a;
if ( i == 2 )
ref = fluidSolvers.back()->p;
std::deque<scalar> errors;
for ( int iComputation = 0; iComputation < nbComputations - 1; iComputation++ )
{
fsi::vector data;
if ( i == 0 )
data = fluidSolvers.at( iComputation )->u;
if ( i == 1 )
data = fluidSolvers.at( iComputation )->a;
if ( i == 2 )
data = fluidSolvers.at( iComputation )->p;
scalar error = (ref - data).norm() / ref.norm();
errors.push_back( error );
}
for ( int iComputation = 0; iComputation < nbComputations - 2; iComputation++ )
{
scalar order = ( std::log10( errors.at( iComputation ) ) - std::log10( errors.at( iComputation + 1 ) ) ) / ( std::log10( nbTimeStepsList.at( iComputation + 1 ) ) - std::log10( nbTimeStepsList.at( iComputation ) ) );
std::cout << "order = " << order << std::endl;
if ( i == 1 || i == 2 )
ASSERT_NEAR( order, 3, 0.1 );
}
}
}
int main(int argc, char **argv)
{
uint32_t timestamp;
PixmapPtr dest = NULL;
int fd, ret;
fd = open("replay.txt", 0);
if (fd < 0) {
ERROR_MSG("could not open");
return -1;
}
RD_START("replay", "replay");
init();
while(1) {
char *line = readline(fd);
DEBUG_MSG("line: %s", line);
if (strstr(line, "EXA: SOLID:") == line) {
int x1, y1, x2, y2;
uint32_t fill;
sscanf(line, "EXA: SOLID: x1=%d\ty1=%d\tx2=%d\ty2=%d\tfill=%08x",
&x1, &y1, &x2, &y2, &fill);
DEBUG_MSG("GOT: SOLID: x1=%d\ty1=%d\tx2=%d\ty2=%d\tfill=%08x",
x1, y1, x2, y2, fill);
dest = get_pixmap(fd);
solid(dest, x1, y1, x2, y2, fill);
} else if (strstr(line, "EXA: COPY:") == line) {
int srcX, srcY, dstX, dstY, width, height;
PixmapPtr src;
sscanf(line, "EXA: COPY: srcX=%d\tsrcY=%d\tdstX=%d\tdstY=%d\twidth=%d\theight=%d",
&srcX, &srcY, &dstX, &dstY, &width, &height);
DEBUG_MSG("GOT: COPY: srcX=%d\tsrcY=%d\tdstX=%d\tdstY=%d\twidth=%d\theight=%d",
srcX, srcY, dstX, dstY, width, height);
dest = get_pixmap(fd);
src = get_pixmap(fd);
copy(dest, src, srcX, srcY, dstX, dstY, width, height);
} else if (strstr(line, "EXA: COMPOSITE:") == line) {
ERROR_MSG("TODO");
end();
} else if (strstr(line, "EXA: WAIT:") == line) {
DEBUG_MSG("wait, timestamp=%u", timestamp);
wait(timestamp);
} else if (strstr(line, "FLUSH:") == line) {
flush(dest, ×tamp);
DEBUG_MSG("flush, timestamp=%u", timestamp);
} else {
ERROR_MSG("unexpected line: %s", line);
end();
}
}
return 0;
}
void BorderFilter::filterImage()
{
d->setup(m_orgImage);
switch (d->settings.borderType)
{
case BorderContainer::SolidBorder:
if (d->settings.preserveAspectRatio)
{
solid(m_orgImage, m_destImage, d->solidColor, d->borderMainWidth);
}
else
{
solid2(m_orgImage, m_destImage, d->solidColor, d->settings.borderWidth1);
}
break;
case BorderContainer::NiepceBorder:
if (d->settings.preserveAspectRatio)
niepce(m_orgImage, m_destImage, d->niepceBorderColor, d->borderMainWidth,
d->niepceLineColor, d->border2ndWidth);
else
niepce2(m_orgImage, m_destImage, d->niepceBorderColor, d->settings.borderWidth1,
d->niepceLineColor, d->settings.borderWidth4);
break;
case BorderContainer::BeveledBorder:
if (d->settings.preserveAspectRatio)
bevel(m_orgImage, m_destImage, d->bevelUpperLeftColor,
d->bevelLowerRightColor, d->borderMainWidth);
else
bevel2(m_orgImage, m_destImage, d->bevelUpperLeftColor,
d->bevelLowerRightColor, d->settings.borderWidth1);
break;
case BorderContainer::PineBorder:
case BorderContainer::WoodBorder:
case BorderContainer::PaperBorder:
case BorderContainer::ParqueBorder:
case BorderContainer::IceBorder:
case BorderContainer::LeafBorder:
case BorderContainer::MarbleBorder:
case BorderContainer::RainBorder:
case BorderContainer::CratersBorder:
case BorderContainer::DriedBorder:
case BorderContainer::PinkBorder:
case BorderContainer::StoneBorder:
case BorderContainer::ChalkBorder:
case BorderContainer::GraniteBorder:
case BorderContainer::RockBorder:
case BorderContainer::WallBorder:
if (d->settings.preserveAspectRatio)
pattern(m_orgImage, m_destImage, d->borderMainWidth,
d->decorativeFirstColor, d->decorativeSecondColor,
d->border2ndWidth, d->border2ndWidth);
else
pattern2(m_orgImage, m_destImage, d->settings.borderWidth1,
d->decorativeFirstColor, d->decorativeSecondColor,
d->settings.borderWidth2, d->settings.borderWidth2);
break;
}
}
bool entity::has_feet() const
{
return solid();
}
void FileLoadTask::process() {
const QString stickerMime = qsl("image/webp");
_result = FileLoadResultPtr(new FileLoadResult(_id, _to, _originalText));
QString filename, filemime;
qint64 filesize = 0;
QByteArray filedata;
uint64 thumbId = 0;
QString thumbname = "thumb.jpg";
QByteArray thumbdata;
bool animated = false, song = false, gif = false, voice = (_type == PrepareAudio);
QImage fullimage = _image;
if (!_filepath.isEmpty()) {
QFileInfo info(_filepath);
if (info.isDir()) {
_result->filesize = -1;
return;
}
filesize = info.size();
filemime = mimeTypeForFile(info).name();
filename = info.fileName();
if (filesize <= MaxUploadPhotoSize && !voice) {
bool opaque = (filemime != stickerMime);
fullimage = App::readImage(_filepath, 0, opaque, &animated);
}
} else if (!_content.isEmpty()) {
filesize = _content.size();
if (voice) {
filename = filedialogDefaultName(qsl("audio"), qsl(".ogg"), QString(), true);
filemime = "audio/ogg";
} else {
MimeType mimeType = mimeTypeForData(_content);
filemime = mimeType.name();
if (filesize <= MaxUploadPhotoSize && !voice) {
bool opaque = (filemime != stickerMime);
fullimage = App::readImage(_content, 0, opaque, &animated);
}
if (filemime == "image/jpeg") {
filename = filedialogDefaultName(qsl("image"), qsl(".jpg"), QString(), true);
} else {
QString ext;
QStringList patterns = mimeType.globPatterns();
if (!patterns.isEmpty()) {
ext = patterns.front().replace('*', QString());
}
filename = filedialogDefaultName(qsl("file"), ext, QString(), true);
}
}
} else if (!_image.isNull()) {
_image = QImage();
filemime = mimeTypeForName("image/png").name();
filename = filedialogDefaultName(qsl("image"), qsl(".png"), QString(), true);
{
QBuffer buffer(&_content);
fullimage.save(&buffer, "PNG");
}
filesize = _content.size();
if (fullimage.hasAlphaChannel()) {
QImage solid(fullimage.width(), fullimage.height(), QImage::Format_ARGB32_Premultiplied);
solid.fill(st::white->c);
{
QPainter(&solid).drawImage(0, 0, fullimage);
}
fullimage = solid;
}
}
_result->filesize = (int32)qMin(filesize, qint64(INT_MAX));
if (!filesize || filesize > MaxUploadDocumentSize) {
return;
}
PreparedPhotoThumbs photoThumbs;
QVector<MTPPhotoSize> photoSizes;
QPixmap thumb;
QVector<MTPDocumentAttribute> attributes(1, MTP_documentAttributeFilename(MTP_string(filename)));
MTPPhotoSize thumbSize(MTP_photoSizeEmpty(MTP_string("")));
MTPPhoto photo(MTP_photoEmpty(MTP_long(0)));
MTPDocument document(MTP_documentEmpty(MTP_long(0)));
if (!voice) {
if (filemime == qstr("audio/mp3") || filemime == qstr("audio/m4a") || filemime == qstr("audio/aac") || filemime == qstr("audio/ogg") || filemime == qstr("audio/flac") ||
filename.endsWith(qstr(".mp3"), Qt::CaseInsensitive) || filename.endsWith(qstr(".m4a"), Qt::CaseInsensitive) ||
filename.endsWith(qstr(".aac"), Qt::CaseInsensitive) || filename.endsWith(qstr(".ogg"), Qt::CaseInsensitive) ||
filename.endsWith(qstr(".flac"), Qt::CaseInsensitive)) {
QImage cover;
QByteArray coverBytes, coverFormat;
MTPDocumentAttribute audioAttribute = audioReadSongAttributes(_filepath, _content, cover, coverBytes, coverFormat);
if (audioAttribute.type() == mtpc_documentAttributeAudio) {
attributes.push_back(audioAttribute);
song = true;
if (!cover.isNull()) { // cover to thumb
int32 cw = cover.width(), ch = cover.height();
if (cw < 20 * ch && ch < 20 * cw) {
QPixmap full = (cw > 90 || ch > 90) ? QPixmap::fromImage(cover.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(cover, Qt::ColorOnly);
{
QByteArray thumbFormat = "JPG";
int32 thumbQuality = 87;
QBuffer buffer(&thumbdata);
full.save(&buffer, thumbFormat, thumbQuality);
}
thumb = full;
thumbSize = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0));
thumbId = rand_value<uint64>();
}
}
}
}
if (filemime == qstr("video/mp4") || filename.endsWith(qstr(".mp4"), Qt::CaseInsensitive) || animated) {
QImage cover;
MTPDocumentAttribute animatedAttribute = clipReadAnimatedAttributes(_filepath, _content, cover);
if (animatedAttribute.type() == mtpc_documentAttributeVideo) {
int32 cw = cover.width(), ch = cover.height();
if (cw < 20 * ch && ch < 20 * cw) {
attributes.push_back(MTP_documentAttributeAnimated());
attributes.push_back(animatedAttribute);
gif = true;
QPixmap full = (cw > 90 || ch > 90) ? QPixmap::fromImage(cover.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(cover, Qt::ColorOnly);
{
QByteArray thumbFormat = "JPG";
int32 thumbQuality = 87;
QBuffer buffer(&thumbdata);
full.save(&buffer, thumbFormat, thumbQuality);
}
thumb = full;
thumbSize = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0));
thumbId = rand_value<uint64>();
if (filename.endsWith(qstr(".mp4"), Qt::CaseInsensitive)) {
filemime = qstr("video/mp4");
}
}
}
}
}
if (!fullimage.isNull() && fullimage.width() > 0 && !song && !gif && !voice) {
int32 w = fullimage.width(), h = fullimage.height();
attributes.push_back(MTP_documentAttributeImageSize(MTP_int(w), MTP_int(h)));
if (w < 20 * h && h < 20 * w) {
if (animated) {
attributes.push_back(MTP_documentAttributeAnimated());
} else if (_type != PrepareDocument) {
QPixmap thumb = (w > 100 || h > 100) ? QPixmap::fromImage(fullimage.scaled(100, 100, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(fullimage);
photoThumbs.insert('s', thumb);
photoSizes.push_back(MTP_photoSize(MTP_string("s"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(thumb.width()), MTP_int(thumb.height()), MTP_int(0)));
QPixmap medium = (w > 320 || h > 320) ? QPixmap::fromImage(fullimage.scaled(320, 320, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(fullimage);
photoThumbs.insert('m', medium);
photoSizes.push_back(MTP_photoSize(MTP_string("m"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(medium.width()), MTP_int(medium.height()), MTP_int(0)));
QPixmap full = (w > 1280 || h > 1280) ? QPixmap::fromImage(fullimage.scaled(1280, 1280, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(fullimage);
photoThumbs.insert('y', full);
photoSizes.push_back(MTP_photoSize(MTP_string("y"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0)));
{
QBuffer buffer(&filedata);
full.save(&buffer, "JPG", 77);
}
photo = MTP_photo(MTP_long(_id), MTP_long(0), MTP_int(unixtime()), MTP_vector<MTPPhotoSize>(photoSizes));
}
QByteArray thumbFormat = "JPG";
int32 thumbQuality = 87;
if (!animated && filemime == stickerMime && w > 0 && h > 0 && w <= StickerMaxSize && h <= StickerMaxSize && filesize < StickerInMemory) {
attributes.push_back(MTP_documentAttributeSticker(MTP_string(""), MTP_inputStickerSetEmpty()));
thumbFormat = "webp";
thumbname = qsl("thumb.webp");
}
QPixmap full = (w > 90 || h > 90) ? QPixmap::fromImage(fullimage.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(fullimage, Qt::ColorOnly);
{
QBuffer buffer(&thumbdata);
full.save(&buffer, thumbFormat, thumbQuality);
}
thumb = full;
thumbSize = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0));
thumbId = rand_value<uint64>();
}
}
if (voice) {
attributes[0] = MTP_documentAttributeAudio(MTP_flags(MTPDdocumentAttributeAudio::Flag::f_voice | MTPDdocumentAttributeAudio::Flag::f_waveform), MTP_int(_duration), MTPstring(), MTPstring(), MTP_bytes(documentWaveformEncode5bit(_waveform)));
attributes.resize(1);
document = MTP_document(MTP_long(_id), MTP_long(0), MTP_int(unixtime()), MTP_string(filemime), MTP_int(filesize), thumbSize, MTP_int(MTP::maindc()), MTP_vector<MTPDocumentAttribute>(attributes));
} else {
document = MTP_document(MTP_long(_id), MTP_long(0), MTP_int(unixtime()), MTP_string(filemime), MTP_int(filesize), thumbSize, MTP_int(MTP::maindc()), MTP_vector<MTPDocumentAttribute>(attributes));
if (photo.type() == mtpc_photoEmpty) {
_type = PrepareDocument;
}
}
_result->type = _type;
_result->filepath = _filepath;
_result->content = _content;
_result->filename = filename;
_result->filemime = filemime;
_result->setFileData(filedata);
_result->thumbId = thumbId;
_result->thumbname = thumbname;
_result->setThumbData(thumbdata);
_result->thumb = thumb;
_result->photo = photo;
_result->document = document;
_result->photoThumbs = photoThumbs;
}
void thermalBaffle1DFvPatchScalarField<solidType>::updateCoeffs()
{
if (updated())
{
return;
}
// Since we're inside initEvaluate/evaluate there might be processor
// comms underway. Change the tag we use.
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag+1;
const mapDistribute& mapDist = this->mappedPatchBase::map();
const label patchi = patch().index();
const label nbrPatchi = samplePolyPatch().index();
if (baffleActivated_)
{
const fvPatch& nbrPatch = patch().boundaryMesh()[nbrPatchi];
const compressible::turbulenceModel& turbModel =
db().template lookupObject<compressible::turbulenceModel>
(
"turbulenceModel"
);
// local properties
const scalarField kappaw(turbModel.kappaEff(patchi));
const fvPatchScalarField& Tp =
patch().template lookupPatchField<volScalarField, scalar>(TName_);
scalarField Qr(Tp.size(), 0.0);
if (QrName_ != "none")
{
Qr = patch().template lookupPatchField<volScalarField, scalar>
(QrName_);
Qr = QrRelaxation_*Qr + (1.0 - QrRelaxation_)*QrPrevious_;
QrPrevious_ = Qr;
}
tmp<scalarField> Ti = patchInternalField();
scalarField myKDelta(patch().deltaCoeffs()*kappaw);
// nrb properties
scalarField nbrTp =
turbModel.thermo().T().boundaryField()[nbrPatchi];
mapDist.distribute(nbrTp);
// solid properties
scalarField kappas(patch().size(), 0.0);
forAll(kappas, i)
{
kappas[i] = solid().kappa(0.0, (Tp[i] + nbrTp[i])/2.0);
}
const scalarField KDeltaSolid(kappas/baffleThickness());
const scalarField alpha(KDeltaSolid - Qr/Tp);
valueFraction() = alpha/(alpha + myKDelta);
refValue() = (KDeltaSolid*nbrTp + Qs()/2.0)/alpha;
if (debug)
{
scalar Q = gAverage(kappaw*snGrad());
Info<< patch().boundaryMesh().mesh().name() << ':'
<< patch().name() << ':'
<< this->dimensionedInternalField().name() << " <- "
<< nbrPatch.name() << ':'
<< this->dimensionedInternalField().name() << " :"
<< " heat[W]:" << Q
<< " walltemperature "
<< " min:" << gMin(*this)
<< " max:" << gMax(*this)
<< " avg:" << gAverage(*this)
<< endl;
}
}
TEST( SDCFsiTest, order )
{
int N = 5;
scalar r0 = 0.2;
scalar a0 = M_PI * r0 * r0;
scalar u0 = 0.1;
scalar p0 = 0;
scalar L = 1;
scalar T = 1;
scalar dx = L / N;
scalar rho = 1.225;
scalar E = 490;
scalar h = 1.0e-3;
scalar cmk = std::sqrt( E * h / (2 * rho * r0) );
scalar c0 = std::sqrt( cmk * cmk - p0 / (2 * rho) );
scalar kappa = c0 / u0;
bool parallel = false;
int extrapolation = 0;
scalar tol = 1.0e-5;
int maxIter = 20;
scalar initialRelaxation = 1.0e-3;
int maxUsedIterations = 50;
int nbReuse = 0;
scalar singularityLimit = 1.0e-13;
int reuseInformationStartingFromTimeIndex = 0;
bool scaling = false;
scalar beta = 0.01;
bool updateJacobian = false;
int minIter = 5;
ASSERT_NEAR( kappa, 10, 1.0e-13 );
ASSERT_TRUE( dx > 0 );
int nbComputations = 5;
std::deque<std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> > fluidSolvers;
std::deque<int> nbTimeStepsList;
for ( int iComputation = 0; iComputation < nbComputations; iComputation++ )
{
int nbTimeSteps = 4 * std::pow( 2, iComputation );
std::cout << "nbTimeSteps = " << nbTimeSteps << std::endl;
scalar dt = T / nbTimeSteps;
std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> fluid( new tubeflow::SDCTubeFlowFluidSolver( a0, u0, p0, dt, cmk, N, L, T, rho ) );
std::shared_ptr<tubeflow::SDCTubeFlowSolidSolver> solid( new tubeflow::SDCTubeFlowSolidSolver( a0, cmk, p0, rho, L, N ) );
shared_ptr<RBFFunctionInterface> rbfFunction;
shared_ptr<RBFInterpolation> rbfInterpolator;
shared_ptr<RBFCoarsening> rbfInterpToCouplingMesh;
shared_ptr<RBFCoarsening> rbfInterpToMesh;
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
shared_ptr<MultiLevelSolver> fluidSolver( new MultiLevelSolver( fluid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 0, 0 ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() );
rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) );
rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) );
shared_ptr<MultiLevelSolver> solidSolver( new MultiLevelSolver( solid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 1, 0 ) );
std::shared_ptr< std::list<std::shared_ptr<ConvergenceMeasure> > > convergenceMeasures;
convergenceMeasures = std::shared_ptr<std::list<std::shared_ptr<ConvergenceMeasure> > >( new std::list<std::shared_ptr<ConvergenceMeasure> > );
convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new ResidualRelativeConvergenceMeasure( 0, false, tol ) ) );
convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new MinIterationConvergenceMeasure( 0, false, minIter ) ) );
shared_ptr<MultiLevelFsiSolver> fsi( new MultiLevelFsiSolver( fluidSolver, solidSolver, convergenceMeasures, parallel, extrapolation ) );
shared_ptr<PostProcessing> postProcessing( new AndersonPostProcessing( fsi, maxIter, initialRelaxation, maxUsedIterations, nbReuse, singularityLimit, reuseInformationStartingFromTimeIndex, scaling, beta, updateJacobian ) );
std::shared_ptr<sdc::SDCFsiSolverInterface> sdcFluidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( fluid );
std::shared_ptr<sdc::SDCFsiSolverInterface> sdcSolidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( solid );
assert( sdcFluidSolver );
assert( sdcSolidSolver );
std::shared_ptr<fsi::SDCFsiSolver> fsiSolver( new fsi::SDCFsiSolver( sdcFluidSolver, sdcSolidSolver, postProcessing, extrapolation ) );
int nbNodes = 3;
std::shared_ptr<fsi::quadrature::IQuadrature<scalar> > quadrature;
quadrature = std::shared_ptr<fsi::quadrature::IQuadrature<scalar> >( new fsi::quadrature::GaussLobatto<scalar>( nbNodes ) );
std::shared_ptr<sdc::SDC> sdc( new sdc::SDC( fsiSolver, quadrature, 1.0e-13, 10, 200 ) );
sdc->run();
ASSERT_TRUE( sdc->isConverged() );
fluidSolvers.push_back( fluid );
nbTimeStepsList.push_back( nbTimeSteps );
}
for ( int i = 0; i < 2; i++ )
{
fsi::vector ref;
if ( i == 0 )
ref = fluidSolvers.back()->u;
else
ref = fluidSolvers.back()->a;
std::deque<scalar> errors;
for ( int iComputation = 0; iComputation < nbComputations - 1; iComputation++ )
{
fsi::vector data;
if ( i == 0 )
data = fluidSolvers.at( iComputation )->u;
else
data = fluidSolvers.at( iComputation )->a;
scalar error = (ref - data).norm() / data.norm();
std::cout << "error = " << error << std::endl;
errors.push_back( error );
}
for ( int iComputation = 0; iComputation < nbComputations - 2; iComputation++ )
{
scalar order = ( std::log10( errors.at( iComputation ) ) - std::log10( errors.at( iComputation + 1 ) ) ) / ( std::log10( nbTimeStepsList.at( iComputation + 1 ) ) - std::log10( nbTimeStepsList.at( iComputation ) ) );
std::cout << "order = " << order << std::endl;
ASSERT_GE( order, 3.8 );
}
}
}
