convection | A fully generic , modular DSL for AWS CloudFormation | AWS library

That's a warning, not an error. It just means we're not being very smart about normalizing an equation with zero error.

The PDE still solves (although the solution isn't very interesting).

The answer is very similar to how you calculate ic. Just swap A and C in the transform call:

When setting ticklabels, it is important to also set the tick positions. For the colorbar, these positions need to be set with cb.set_ticks (this is confusing, as the labels need to be set via cb.ax.set_yticklabels). Tick positions can only be set at the extremes of the main colorbar, not exactly near the extensions.

So, logical positions are: one at the very bottom, one at the very top, and in the middle of the subsequent bounds. The label at the bottom can be top-aligned to set it closer to the downward triangle (and similar for the upward triangle).

As the labels now indicate a region, the ticks marks could be removed.

The issue was solved slightly updating the code as follows:

The two URLs you are scraping are single product pages, so you shouldn't need the for product in items loop.

Using only standard features:

First of all, you are working on a too small granularity for the multi-threading to be very efficient. Indeed, your sequential time is 9.6 ms and there is 999 time-step. As a result, each time-step take roughly 9.6 us which is rather small.

Additionally, memory accesses are not efficient:

• On one hand using std::vector>> produces internally an array that contains pointers to arrays that contains pointers to double-precision arrays (all dynamically allocated). Arrays will probably not be contiguous in memory and could also be badly aligned. This can significantly slow down the execution as it is more difficult for the processor to prefetch data from memory. Consider allocating one big array rather than many small one (eg. one big flatten std::vector).
• On the other hand, using padding the way you do result in a very inefficient memory access pattern. Indeed, you only use 1 double over 8, so 7/8 of the memory usage is wasted (probably more since std::vector can allocate additional memory). Additionally, the one read/written are not contiguous due to the added padding and it is hard for the processor to prefetch data and also use the memory efficiently (since reads/writes are performed per the cache line, ie. multiple double-precision scalars). Consider applying padding rows or chunks of your matrix (not scalar).

Finally, using a schedule with blocks of size 8 seems too small. Specifying just schedule(static) should be probably better here for both the parallel-for and the reduction (the schedule should be the same and static for both if you are using nowait and you want correct results I think).

Consequently, you are probably measuring latency and memory overheads.

Here is the corrected code with the most important fixes (false-sharing effects are ignored):

You can set the X and Y limits of the plot with:

An important consideration with FiPy is that the mesh indexing is not based on grid indexing so mapping from a grid array to cell values should not assume that the mesh is ordered in any particular way. This makes it necessary to use some form of interpolation. Let's first construct a velocity field with grid indexing where the points lie on the grid points (not cell centers).