Trace:

doc:user:remeshing:remeshing

This shows you the differences between two versions of the page.

Both sides previous revision Previous revision Next revision | Previous revision | ||

doc:user:remeshing:remeshing [2016/06/13 16:55] joris [Quasi-static balancing] |
doc:user:remeshing:remeshing [2018/05/04 15:47] (current) boman ↷ Links adapted because of a move operation |
||
---|---|---|---|

Line 29: | Line 29: | ||

Which is why all of this has been kindly automatized, | Which is why all of this has been kindly automatized, | ||

- | ===== How does FENRIR work ? ===== | + | ===== How does remeshing work ? ===== |

First, you need to have an operational 2D test case, and the will to introduce remeshing into it. | First, you need to have an operational 2D test case, and the will to introduce remeshing into it. | ||

Line 44: | Line 44: | ||

Second, [[doc/ | Second, [[doc/ | ||

- | Once this is done (it used to take a bloody hell of a f***ing time, but now the time required is more reasonable, see [[commit: | + | Once this is done (it used to take a bloody hell of a f***ing time, but now the time required is more reasonable, see [[commit:2016:01_19]] for details), we have a good new mesh, containing data from the previous computation. From this, the simulation can be restarted, which means that the time integration is carried out further, until the remeshing criterion is met again and another remeshing operation takes place. |

And that's it for the basics ! But as they say, a picture is worth a thousand words, and I guess that a video is worth a thousand pictures, so just enjoy the following video, about the modelling of forging, to see how it works : | And that's it for the basics ! But as they say, a picture is worth a thousand words, and I guess that a video is worth a thousand pictures, so just enjoy the following video, about the modelling of forging, to see how it works : | ||

Line 258: | Line 258: | ||

| | ||

autoRemesh.setBalancing(True) | autoRemesh.setBalancing(True) | ||

- | | + | |

+ | autoRemesh.makeAnim = False | ||

+ | | ||

autoRemesh.execute() | autoRemesh.execute() | ||

| | ||

Line 272: | Line 274: | ||

* '' | * '' | ||

| | ||

- | * Finally, the line '' | + | * The line ''. |

+ | | ||

+ | * Finally, the line ''. | ||

Now that you have altered your test case to include remeshing, and that you have defined this little script, all that remains is to launch Metafor and execute your script (execute, not load/meta). Everything should work out perfectly. | Now that you have altered your test case to include remeshing, and that you have defined this little script, all that remains is to launch Metafor and execute your script (execute, not load/meta). Everything should work out perfectly. | ||

Line 301: | Line 305: | ||

==== Changing the critical remeshing value during the computation ==== | ==== Changing the critical remeshing value during the computation ==== | ||

- | It may be possible that we want to change the critical value after a few remeshing. If you recall, this value is defined in the [[# | + | It may be possible that we want to change the critical value after a few remeshing (see for example ''. If you recall, this value is defined in the [[# |

However, since the same two files are used to generate all the remeshing, it is not possible to know how far in the computation we are. But to change the critical value, we need to know whether the current integration is the first or the tenth. | However, since the same two files are used to generate all the remeshing, it is not possible to know how far in the computation we are. But to change the critical value, we need to know whether the current integration is the first or the tenth. | ||

Line 335: | Line 339: | ||

==== Changing mesh density during the computation ==== | ==== Changing mesh density during the computation ==== | ||

- | Actually, the key '' | + | Actually, the key ''(see for example ''. For example, if we want to double the mesh density after two remeshing, we simply add in the '' |

if p[' | if p[' | ||

Line 346: | Line 350: | ||

Two different remeshing criteria have been implemented yet, one based on a '' | Two different remeshing criteria have been implemented yet, one based on a '' | ||

- | Previously, the one relying on a valueExtractor was used in a very simple way : on one side of the part, with the field '' | + | Previously, the one relying on a ''valueExtractor'' was used in a very simple way : on one side of the part, with the field '' |

#Stop Criterion | #Stop Criterion | ||

Line 359: | Line 363: | ||

But then, there is also a simple criterion based on time, if you want to remesh every few seconds or so. | But then, there is also a simple criterion based on time, if you want to remesh every few seconds or so. | ||

- | In this case, you must first define a vector containing all the times at which you want to remesh ('' | + | In this case, you must first define a vector containing all the times at which you want to remesh ('', or see ''for the example : |

def getParameters(_p={}): | def getParameters(_p={}): | ||

Line 415: | Line 419: | ||

CopyRemesher(side, | CopyRemesher(side, | ||

- | Therefore, if you have a complex domain, just divide it into the appropriate sides and copy/remesh as you see fit. | + | Therefore, if you have a complex domain, just divide it into the appropriate sides and copy/remesh as you see fit. However, when you want to remesh one side, copy another side, and that the two sides have a common edge, then you must first use CopyRemesher, |

- | | + | |

- | <you want to remesh one side, copy another side, and that the two sides have a common edge, then you must first use CopyRemesher,</ | + | |

==== Transfinite Meshers ==== | ==== Transfinite Meshers ==== | ||

Line 434: | Line 436: | ||

By default, the transfer of data is done using Philippe' | By default, the transfer of data is done using Philippe' | ||

- | For the advanced user, changing these parameters is possible (in the '' | + | For the __advanced__ user, changing these parameters is possible (in the '' |

==== Changing the transfer method ==== | ==== Changing the transfer method ==== | ||

Line 466: | Line 468: | ||

cell.addOption(INTPT_NB, | cell.addOption(INTPT_NB, | ||

- | To understand all these options, please look at [[doc: | + | To understand all these options, please look at [[doc:. |

==== Changing the fields to transfer ==== | ==== Changing the fields to transfer ==== | ||

Line 542: | Line 544: | ||

$$ = (1-\alpha_F) \boldsymbol{F}^{\text{ext}}(t^{n+1}) + \alpha_F \boldsymbol{F}^{\text{ext}}(t^n)$$ | $$ = (1-\alpha_F) \boldsymbol{F}^{\text{ext}}(t^{n+1}) + \alpha_F \boldsymbol{F}^{\text{ext}}(t^n)$$ | ||

- | The idea is similar : after remeshing, there is some imbalance and the equation is no longer verified, so we want to apply a balancing algorithm to restore equilibrium before restarting the computation. Since the time is stopped, inertial forces are kept as they are and only internal forces are modified to satisfy equilibrium. In the same way as for a quasi-static simulation, this is done by applying as external forces an increasing fraction of the unbalanced forces. | + | The idea is similar : after remeshing, there is some imbalance and the equation is no longer verified, so we want to apply a balancing algorithm to restore equilibrium before restarting the computation. Since the time is stopped, inertial forces are kept as they are and only internal forces are modified to satisfy equilibrium. In the same way as for a quasi-static simulation, this is done by applying as external forces an increasing fraction of the unbalanced forces. The difference with respect to the quasi-static algorithm is the expression of the unbalanced forces, which will here also contains the inertial forces and the forces computed at the previous time step. |

Since we conserve the inertial forces and correct the internal ones, this post-remeshing algorithm works quite well for quasi-static and low speed dynamic computations. For high speed dynamic computations, | Since we conserve the inertial forces and correct the internal ones, this post-remeshing algorithm works quite well for quasi-static and low speed dynamic computations. For high speed dynamic computations, | ||

+ | |||

+ | ==== Options ==== | ||

+ | |||

+ | The complete '' | ||

+ | |||

+ | setBalancing(executeBalancing, | ||

+ | | ||

+ | The first argument has already been described and indicates whether balancing should be done or not. | ||

+ | |||

+ | For the advanced user, a few options can be played with by changing the three of arguments. | ||

+ | |||

+ | First of all, it is possible to deactivate the '' | ||

+ | |||

+ | Second, the number of iterations for each step of the balancing can be changed. By default, seven iterations are tried before increasing the fraction of the unbalanced forces and starting again. | ||

+ | |||

+ | Finally, the tolerance can also be changed. The parameter $\alpha$, used to ponder the unbalanced forces, starts at 1 and is progressively divided by 2 when a step fails. Once $\alpha$ becomes smaller than the tolerance, the algo stops itself, returns an error, and the temporal integrationdoes not restart. The default value of 0.001 can be changed if needed. | ||

+ | |||

+ | --- // |

doc/user/remeshing/remeshing.1465829712.txt.gz · Last modified: 2016/06/13 16:55 by joris