Déplacements imposés

Fixations définitives

Pour déplacer des noeuds au cours du temps, on impose au déplacement une valeur exprimée par une fonction d'évolution temporelle grâce à l'objet LoadingSet du domaine.

loadingset.define(gObject, field, ampl, fct , incr)
loadingset.define(gObject, field, ampl, fctMultiChamps , fieldList, incr)

`gObject`	référence vers l'objet géométrique support des noeuds
`field`	Field : champ base de donnée décrivant la variable qui doit être fixée / modifiée
`ampl`	amplitude
`fct`	Functions y=f(t) (dépendance temporelle)
`fctMultiChamps`	Functions y=f(t) (dépendance spatio-temporelle)
`fieldList`	liste de champs de dépendances
`incr` (facultatif)	= `INCREMENTAL_LOAD` : incrémental (defaut) = `TOTAL_LOAD` : total (util pour appliquer un déplacement initial & pour les schemas d'intégration foireux)

On obtient donc une expression du déplacement suivant la composante

INCREMENTAL_LOAD: u(t1) = u(t0) + ampl * (fct(t1)-fct(t0))
TOTAL_LOAD: u(t) = ampl * fct(t)

loadingset.define(gObject, field, ampl, incr)

`gObject`	référence vers l'objet géométrique support des noeuds
`field`	Field : champ base de donnée décrivant la variable qui doit être fixée / modifiée
`ampl`	amplitude = 0 par défaut
`incr` (facultatif)	= `INCREMENTAL_LOAD` : incrémental (defaut)
	= `TOTAL_LOAD` : total (pour imposer une valeur non nulle ou pour fixer la configuration remaillée par rapport à l'origine)

Attention, il n'est pas permis d'avoir une amplitude != 0.0 en incremental (on n'a pas trouvé de sens à cette commande). Mtf sort sur une FATAL_ERROR.

Les valeurs par défaut permettent une écriture courte d'une simple fixation :

loadingset.define(gObject, field)

Fixations dynamiques

Il est possible d'ajouter ou supprimer des fixations au cours d'un calcul. Ceci est bien pratique pour éviter des vibrations parasites en dynamique ou éviter des modes rigides.

Le temps est découpé en phases de calcul par les commandes setNextTime (voir TimeStepManager). Il est alors possible d'activer (activate) et désactiver (deactivate) les chargements.

Récupération de l'ensemble des phases de calcul (les commandes sur le TimeStepManager doivent avoir déjà été effectuées):

stages = metafor.getStageManager()

Définition d'un chargement sur la courbe #4 et désactivation en phase #1 (la deuxième phase de calcul – les phases étant numérotées à partir de 0):

load1 = loadingset.define(curveset(4), Field1D(TY,RE),  1.0, fct2)
load1.deactivate(stages[1])

Définition d'un chargement sur la courbe #1, activé en phase #0 et désactivé en phase #1 et suivantes:

load2 = loadingset.define(curveset(1), Field1D(TY,RE),  -0.1, fct1)
load2.deactivate(stages[0])
load2.activate(stages[1])

Schématiquement, on obtient donc, si 3 phases ont été définies:

	load1	load2
phase #0	ACTIVE	INACTIVE
phase #1	INACTIVE	ACTIVE
phase #2	INACTIVE	ACTIVE

Règle de priorité des opérations :

    "L'ACTIVATION L'EMPORTE TOUJOURS SUR LA DESACTIVATION"

un même noeud peut faire partie de 2 entités dont l'une peut etre activée, l'autre désactivée. Les opérations se faisant toujours dans l'ordre de séquence : 1. désactivations - 2. activations l'activation l'emportera toujours …