spl-ethz / snow Goto Github PK

https://hydra.cc/docs/intro/

Hey @ltdeck, pick a theme: https://sphinx-themes.org/ ;)

Convert from latex (https://www.overleaf.com/project/61c4470e0f950bebf892149d) to rst/sphinx doc.

Hey Leif, can you add more comments re what's happening in the 'vectorization' part and right after? Maybe with better documentation I get it just by reading.

(This is a test to see how to open an issue.)

Hey Dave,

let me explain the general concepts about the part following the vectorization, i.e. the parfor loop. Basically this part is the "heart" of the model.

The loop runs the individual simulations of the freezing process in parallel, which is very handy since the runtime scales well with the number of available cores. To allow for reproducibility, it is necessary to initialize the random number generator in each iteration and to this differently.

The loop starts with a couple of definitions; they are temporary variables required to pass values to the outside of the loop. This also includes the state variables (T_time and sigma_time), for which I also extract some values, which is needed to make the thermal evolution figures.

There are two nested loops within the parfor loop. The outer one is the time loop, the inner one goes through all vials. For each timestep I calculate the heat flows q and store some information on the vials states.

The inner loop is based on an if..else structure, comprising the two cases liquid and ice growth state, which we distinguish based on the value of sigma. In the ice growth state, we calculate the new state variables by following the freezing point depression curve in the phase diagram. Doing so is a bit ugly, so I think I will make a slide outlining the equations here. When a certain ice fraction is reached (i.e. 90% here), we define that the solidification time is reached. However, the vial stays in this state also afterwards.

The second state is the liquid one. Here we just follow the energy balance and calculate the new temperature in each step. If supercooled, we test for stochastic nucleation. There is also the possibility to do controlled nucleation (i.e. when setting cont = 1), where nucleation will be forced at iteration i == T_insert_end. When nucleation is induced, we calculate the initial sigma and T in the same way as in the ice growth state.

Thats's basically it. We also need to define some more variables to extract the data from the loop. Also, after the loop I restructure the output variables in a 4D tensor (i.e. based on the number of vials in x,y, and z direction), because I used this format before vectorizing and I still use it for figures.

Please let me know if anything is unclear.

See explanation here: https://www.overleaf.com/project/61c4470e0f950bebf892149d

Hey @ltdeck, asking myself what the right behavior is for vials that are not supercooled at the end of holding, when controlled nucleation would be triggered.

Right now, only vials that are both liquid and supercooled are nucleated by controlled nucleation at the end of holding. What is the right behavior for vials that are not supercooled yet?

1. They should nucleate spontaneously whenever the dice decide
2. They should nucleate as soon as they become supercooled
3. They should nucleate as soon as they become supercooled if that time is within X seconds of the nucleation trigger, otherwise they should nucleate spontaneously whenever the dice decide.

need to update requirements to include only pyyaml versions newer than xx (when it was integrated).

The current plot() function does not show the thermal evolution of the shelf. When selecting temperature trajectories, only those for the vials are shown. For validation, it would be helpful to also directly see the shelf temperature.

The plot() function currently does not autogenerate physically meaningful labels for the x- and y-axis. This may impact the user experience. For the example below, that shows a box plot of simulated nucleation temperatures, I would recommend the following:
x-label: "vial position"
y-label: "nucleation temperature [°C]"

Ideally, the function would autogenerate such labels depending on the type of plot.

increases repo size unnecessarily probably.

Hi Dave,

gibt es einen bestimmten python editor, den du mir empfehlen kannst?

LG Leif

When using the returnStats() function to save the simulation outcome, an empty file is generated when selecting the solidification times. On the other hand, extracting the nucleation temperatures does work fine.

Can only have one right now, need to allow for multiple (pre and post controlled nucleation, e.g.)

When saving the pallet files for the 3D model validation, I noticed an excessive runtime for the first set up of data saved, see figure below:

The issue refers to the current version of the snowfall_validation file. However, I also noticed similar issues before; due to the smaller scale of the box and 2-D shelf simulations, this likely went unnoticed for quite some time.

Given that snowfall simulations may take some time to complete the simulation, it would be helpful to know the current progress of the simulation. For example, one may add the functionality that snowfall provides the number of completely simulated repetitions in live.

When using controlled nucleation, it may be possible that some vials are not supercooled at the time of the nucleation event. The program accounts for this by not introducing nucleation. However, there is no warning provided for the user to understand this situation. I think this may be helpful, however.

Look at the following example: In theory, nucleation should occur at the end of the first holding step at -5°C, however at this time the vial temperature is above 0°C, thus nothing happens. As we would expect in reality, nucleation occurs stochastically after the second holding step. However, there is no warning for the user that such behavior was observed. Indeed, it is only possible to understand it via plotting the thermal trajectories.

https://github.com/SPL-ethz/snow/actions/runs/5454004798/jobs/9923556336

Snowfall currently does not allow for an explicit argument to store states like snowflake. Consequently, the characteristic quantities (nucTemp etc) are automatically stored in stats_df, but not accessible via the direct functions, i.e. nucleationTemperatures(). This may be an issue since snowfall and snowflake behave different. For snowflake, direct access to the quantities is possible as of now.

Code:

from ethz_snow.snowfall import Snowfall
S = Snowfall(Nrep=10,N_vials=(3,3,1))
S.run()
S.plot(what="T_nucleation")
S.stats_df
S.nucleationTemperatures()

Screenshots:

How to use config + usage in general + installation.

@ltdeck let's discuss later today.

Badge?

Can you take a stab @ltdeck ?

from ethz_snow.snowflake import Snowflake
d = {"int": 20, "ext": 20, "s0": 20, "s_sigma_rel": 0}
S = Snowflake(storeStates='all',N_vials=(7,7,1),k=d)
S.run()
S.k

When manually adjusting the heat transfer parameters, the effect on the 'shelf' parameters in k is unclear. Setting s_sigma_rel to 0 or to a value higher than 0.1 has no significant impact. Also, when increasing s0 to 2000, the absolute difference between s0 and the 'shelf' parameters remains the same, while it should increase since it is defined in relation to s0.

Not sure how this is done on github, will check.

In the Matlab code, the kshelf heterogeneity is calculated with a different random seed for every simulation. The python code currently does not do this. Need to update.