-Defining a step
-==================
+Defining steps in a catalog
+===========================
Definition and Usage
____________________
-A Vimmp dataset is a collection of 'step'. each step is a process and is a coherent piece of the complete datastep. It helps to apprehend the whole scheme of the dataflow.
-The treatment to study the behavior of a structure decomposes in operations, for example:
- * introduction of the geometry and the mesh of the structure;
- * definition of the digital mesh;
- * definition of materials;
- * definition of the physical properties of the structure (material-element association of geometry);
- * definition of the type of calculation (linear static, nonlinear static ...)
+The generated python parameter files can be seen in two ways :
+ * This can be seen as an organized way of calling data object contructors with their parameters
+ * This can be seen as an a set of computational steps (commands) with their arguments
-each operation is a step for VIMMP Data Model
+| Constructing a new user data set that conforms to a dataflow model consists in selecting the desired data objects from the available data organized by the model.
+| Constructing a new user commands set that conforms to a workflow model consists in selecting the desired commands from the available commands organized by the model.
+
+| Each selected data/command has its specific parameters that the user must define. Some are required, some require multiple occurrences, others require the user to name the returned concept
+
+| The data/commands available as hierarchical graph roots are called steps.
+| A VIMMP user data/commands set is a collection of 'step'.
+| Each step is a coherent process/part of the complete workflow/dataflow. This allows to understand the whole scheme of the workflow/dataflow.
+
+For example, VIMMP platform will typically address/execute the following steps for :
+
+CFD-type simulations :
+ * Upload the mesh of the domain (note that the geometry of the domain is contained in the mesh);
+ * Define the physical properties of the fluid(s) involved (e.g., density, viscosity, thermal diffusivity, etc.);
+ * Define the boundary conditions to be applied (e.g., inlet/outlet/symmetry/wall boundaries);
+ * Define the simulation parameters (e.g., time step, number of iterations of the simulated time lapse);
+ * Define the fields to be stored as outputs (note that “classical CFD methods” usually handles fields and, therefore, mesh- and vector-based fields)
+
+DPD-type simulations :
+ * Upload the geometry of the domain in which the simulation is to be performed;
+ * Define the variables attached to each particle (note that classical DPD formulations, as most particle-based mesoscopic methods, relies on the kinetic approach in which only particle positions and velocities are retained (meaning that 6 variables are attached to each particle).
+ However, this is not necessarily always the case for recent DPD formulations for multi-component systems, such as fluid-colloids systems, and for other particle-based methods used, for instance, in hybrid particle/fluid models!);
+ * Define the boundary conditions to be applied (when needed)
+ * Define the parameters entering the selected expressions of inter-particle forces (e.g., expression and parameters entering the soft potential used for the conservative force between DPD particles, weight function and friction coefficient for the dissipative force, temperature (thermostat) used explicitly in the random or Brownian force);
+ * Define the simulation parameters (e.g., number of particles to be simulated in the domain. Note that each particle is a “computational element” similar to a cell in a mesh);
+ * Define the statistics to be extracted from the particle set (e.g., diffusivity, surface tension, etc.), which are the outputs to be mapped to another code in a linked workflow.
+
+These several points will be steps for VIMMP data/commands models.
Syntax
______
General syntax
~~~~~~~~~~~~~~
A step can be :
-
* PROC : a simple procedure
* OPER : a command returning a concept
+
::
-MonPROC = PROC (nom = MonOPER, ..
- );
-MonOPER = OPER (nom = MonPROC, sd_prod= myUserClass,
- );
+ MonPROC = PROC (nom = MonOPER, ..
+ );
+ MonOPER = OPER (nom = MonPROC, sd_prod= myUserClass,
+ );
To describe a PROC, attribute 'nom' is mandatory and has to be the lvalue. Note that the name has to begin with a upper character. after that, inside elements are added.
+
::
- Solver_Input = PROC(nom = 'Solver_Input',
- simulation_title = SIMP(statut='o', typ='TXM', defaut='Simple test'),
- time_step = SIMP(statut='o', typ='R', defaut=0.01, val_min=0),
- number_of_steps = SIMP(statut='o', typ='I', defaut=10000, val_min=1),
- number_of_equilibration_steps = SIMP(statut='o', typ='I', defaut=1000, val_min=1),
+
+ Solver_Input = PROC(nom = 'Solver_Input',
+ simulation_title = SIMP(statut='o', typ='TXM', defaut='Simple test'),
+ time_step = SIMP(statut='o', typ='R' , defaut=0.01 , val_min=0),
+ number_of_steps = SIMP(statut='o', typ='I' , defaut=10000, val_min=1),
+ number_of_equilibration_steps = SIMP(statut='o', typ='I' , defaut=1000 , val_min=1),
job_properties= FACT(statut='o',
- job_duration = SIMP(statut='o', typ='R', defaut=1000, val_min=0),
- stack_size = SIMP(statut='f', typ='R', defaut=1000, val_min=0),
+ job_duration = SIMP(statut='o', typ='R' , defaut=1000, val_min=0),
+ stack_size = SIMP(statut='f', typ='R' , defaut=1000, val_min=0),
print_frequency = SIMP(statut='f', typ='TXM', defaut='every', into=['every','never','sometimes']),
- close_time = SIMP(statut='f', typ='R', defaut=1000, val_min=0),
+ close_time = SIMP(statut='f', typ='R' , defaut=1000, val_min=0),
),
-);
+ );
-Defining user concept type
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+Defining a user concept type
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
To describe an OPER , you have first to describe a user-defined type of concept. Declarations appears at the beginning of the catalogs. User classes inherits from ASSD. Most of the time, pass statement is all you need.
::
+
from Accas import *
class myInteger(ASSD) : pass
class mesh(ASSD) : pass
OPERs return value. The return_type is a user-definded data type.
::
+
class mesh(ASSD) : pass
ReadMesh = OPER (nom = 'ReadMesh', sd_prod = mesh,
MyFile= (typ=’Fichier’, statut ='o'),
