--- /dev/null
+from Accas import *
+
+class composant(ASSD):pass
+class mapper(ASSD):pass
+class converter(mapper):pass
+class interpolator(mapper):pass
+class modeleNumDuCompo(UserASSD):pass
+class especeChimique(UserASSD):pass
+class userParticle(UserASSD) :pass
+class userAtom(userParticle) :pass
+class userMolecule(userParticle) :pass
+class userDiscrete(userParticle) :pass
+class userDPD(userParticle) :pass
+
+class spatialRegion(UserASSD):pass
+class cadShape(spatialRegion):pass
+#class meshGroup(spatialRegion,UserASSDMultiple):pass
+class meshGroup(UserASSDMultiple):pass
+class meshIdentifier(spatialRegion):pass
+class systemGeometry(UserASSD):pass
+class simulatedTime(UserASSD):pass
+class constitutiveRelation(UserASSD):pass
+class interaction(UserASSD):pass
+class transferId(UserASSD):pass
+class fileId(transferId):pass
+class memoryId(transferId):pass
+class corbaId(transferId):pass
+
+class stateVariable(UserASSDMultiple) : pass
+class scalar(stateVariable):pass
+class dynamicVariable(stateVariable):pass
+
+
+# PN a faire --> ajouter un MC modeleNumerique (apres avoir renomme le modeleNumerique actuel en classe de modele numerique)
+# et le dictionnaire d apres
+# dictTypModNumModNum = {
+# ('Continuum system','Particles') : ('SPH','Lagrangian one-fluid-particle pdf'),
+# ('Continuum system','Fields') : ('FV','FEM', 'Spectral method'),
+# ('Classical particle system','Particles') : ('MD', 'DPD', 'SDPD','SPH','CFD_Discrete_Particles'),
+# ('Classical particle system','Fields') : ('LBM',),
+# ('Quantum system','Particles') : ('Particle method',),
+# ('Quantum system','Fields') : ('Wave',),
+# }
+
+dictTypModNumModNum = {
+ ('Continuum system','N-Particle_Method') : ('SPH' , 'Lagrangian one-fluid-particle pdf'), #TODO 'N-Particle_Method --> N-Particle_Method
+ ('Continuum system','Field-based') : ('FV' , 'FEM', 'Spectral method'),
+ ('Classical particle system','N-Particle_Method') : ('MD' , 'DPD', 'SDPD','SPH','CFD_Discrete_N-Particle_Method'),
+ ('Classical particle system','Field-based') : ('LBM' ,),
+ ('Quantum system','N-Particle_Method') : ('Particle method',),
+ ('Quantum system','Field-based') : ('Wave',),
+}
+
+dictCodeModeleNumerique = {
+ 'Code_Saturne' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'Fluent' : ('FV',),
+ 'Culgi Package': (),
+ 'DEM_SD' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'DFTB+' : ('density functional tight binding method',),
+ 'DL_MESO_DPD' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'DL_MESO_LBE' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'DL_POLY_4' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'GROMACS' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'GROMACS_LS' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'LAMMPS' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'NWChem' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'OpenFOAM' : ('Lagrangian one-fluid-particle pdf', 'FV', 'CFD_Discrete_N-Particle_Method',),
+ 'Quantum EXPRESSO' : ('Particle method', 'Wave',),
+ 'RHEO_AGGRATE' : ('Particle method', 'Wave',),
+ 'RHEO_DROP' : ('Particle method', 'Wave',),
+ 'STAR_CCM+' : ('FV', 'Particles',),
+ 'Code Nill' : ('Spectral method', ),
+}
+# Le Code Nill est ajouté en dur au Solver
+
+dictCodeFormat = {
+ 'Code_Saturne' : ('Med', 'cgns', 'msh', 'des', 'unv', ),
+ 'Culgi Package': ('cof',),
+ 'DEM_SD' : ('geo', 'ascii'),
+ 'DFTB+' : ('geo', 'ascii'),
+ 'Fluent' : ('FluentFormat', ),
+ 'OpenFOAM' : ('OpenFoamFormat', 'Med', ),
+}
+
+dictInterpolatorFormat = {
+ 'Med Coupling' : ('Med',),
+}
+dictConvertorFormat = {
+ 'Gmsh' : ('Med', 'OpenFoamFormat'),
+}
+
+dictTermeLE = {
+ ('Fields','Particles') : ('Fluid_Velocity_Field',
+ 'Fluid_Temperature_Field',
+ 'Fluid_Species_Mass_Fraction_Fluid',),
+ ('Particles','Fields') : ('Fluid_Particle_Momentum_Exchange_Field',
+ 'Fluid_Particle_Thermal_Exchange_Field',
+ 'Lagrangian one-particle pdfFluid_Particle_Mass_Source_Field',
+ 'Particle_Volumetric_Concentration_Modified_Fluid_Viscosity',
+ 'Particle_Extra_Stress_Tensor'),
+ ('Particles','Particles') : ('Pas encore fait'),
+ ('Fields','Fields') : ('Pas encore fait'),
+}
+
+dictCodeConvertisseur = {
+ ('Saturne', 'OpenFOAM') : ('gmsh', 'Saturne2CDM and CDM2OpenFoam'),
+ ('Saturne', 'Fluent') : ('Saturne2CDM and CDM2Fluent'),
+ ('Fluent', 'OpenFOAM') : ('Fluent2CDM and CDM2OpenFoam'),
+}
+
+listeFormatGenerique =['Med', 'Cgns', 'Gmsh', ]
+
+#----------------------------------------
+def prepareBlocSystemType(systemType) :
+#----------------------------------------
+ condition = "SystemType == '" + systemType + "'"
+ Identifier = SIMP(statut='o', typ=(modeleNumDuCompo,'createObject'),)
+ SimulatedTimeLapse = SIMP(statut ='o', typ = simulatedTime)
+ # ModelType = SIMP(statut='o', typ='TXM', into = ('Particles', 'Fields'), position='inGetAttribut')
+ ChoiceOfApproach = SIMP(statut='o', typ='TXM', into=['Field-based', 'N-Particle_Method'], position='inGetAttribut')
+
+ dicoArgs={}
+
+ for typeMod in ('Field-based', 'N-Particle_Method'):
+ conditionType = "ChoiceOfApproach == '" + typeMod + "'"
+ NumericalMethod = SIMP(statut='o',typ='TXM', into=dictTypModNumModNum[systemType, typeMod],
+ position='global', intoXML=allValueInDict(dictTypModNumModNum))
+ dicoBloc = {}
+ for modeleNumerique in list(dictTypModNumModNum[systemType,typeMod]):
+ conditionNum = "NumericalMethod == '" + modeleNumerique + "'"
+ setCode = set()
+ for code in dictCodeModeleNumerique.keys():
+ if modeleNumerique in dictCodeModeleNumerique[code]: setCode.add(code)
+ # print('------------- conditionType -------->',conditionType)
+ if setCode ==set(): setCode.add('Code Nill')
+ Solver = SIMP(statut='o', typ='TXM', into=list(setCode), intoXML=list(dictCodeModeleNumerique.keys()) )
+ monNomBloc = 'bloc_ModelName_' + modeleNumerique.replace(' ','_') #les noms de blocs ne peuvent pas avoir de blanc !
+ if setCode !=set(): dicoBloc[monNomBloc]=BLOC(condition=conditionNum, nomXML='b_ModelName',Solver=Solver)
+ dicoArgs['blocModelType'+typeMod] = BLOC(condition=conditionType, NumericalMethod=NumericalMethod, **dicoBloc)
+
+ blocMeshRef = BLOC(condition = '( (ChoiceOfApproach == "Field-based") and (NumericalMethod == "FV") ) or '
+ '( (ChoiceOfApproach == "N-Particle_Method") and (NumericalMethod == "CFD_Discrete_N-Particle_Method") )',
+ MeshIdentifiers = SIMP(statut ='o', max ='**', typ = meshIdentifier,
+ metAJour=(('ApplyOnGroups',
+ 'self.etape.getChild("BoundaryConditions").getChild("BoundaryCondition")'),),
+ ),)
+ dicoArgs['blocMeshRef'] = blocMeshRef
+ NumericalModel = FACT(statut='o', max= '**', Identifier=Identifier, ChoiceOfApproach=ChoiceOfApproach,
+ SimulatedTimeLapse=SimulatedTimeLapse, **dicoArgs)
+ return BLOC(condition=condition, nomXML='b_systemType', NumericalModel=NumericalModel)
+
+
+#-----------------------------------
+def calculCommun(key1, key2, dico):
+#-----------------------------------
+# retourne la liste des valeurs communes a dico[key1] et dico[key2]
+ monSet=set()
+ if not key1 in dico: return ()
+ if not key2 in dico: return ()
+ for val in dico[key1]:
+ if val in dico[key2]:
+ monSet.add(val)
+ if monSet == set() : monSet.add ('No common format')
+ return list(monSet)
+
+#-------------------------
+def allValueInDict(dico):
+#-------------------------
+# retourne la liste de toutes les valeurs possibles dans dico
+ monSet=set()
+ for clef in dico :
+ for val in dico[clef] : monSet.add(val)
+ return monSet
+
+#--------------------------------------------------------------------------------------------------
+def creeBlocPourLesFichiers(laCondition, Prefixe='Empty', ListeFormats=[], FieldName=None):
+#---------------------------------------------------------------------------------------------------
+# il faut reflechir pour parametrer NomDuFichier
+# et le type (existing... du fichier)
+# et utiliser le creeBlocPourLesFichiers
+ SIMPFormatFichier = SIMP(statut='o', typ = 'TXM', into = tuple(ListeFormats) + ('All',), defaut='All' )
+ dicoDesBlocs = {}
+ NomDuFichier = Prefixe+'FileName'
+ formatName = Prefixe+'FileFormat'
+ dicoDesBlocs[formatName] = SIMPFormatFichier
+ ListeFormatsboucle = tuple(ListeFormats) + ('All',)
+ for formatFich in ListeFormatsboucle :
+ dicoArgs={}
+ nomBloc = 'blocFormatFichier' + str(formatFich)
+ typeDesFichiers = ('Fichier', formatFich + " Files (*." + formatFich + ");;All Files (*)",'Sauvegarde')
+ blocCondition = formatName + " == '" + formatFich + "'"
+ dicoArgs[NomDuFichier] = SIMP(statut='o', typ = typeDesFichiers, nomXML=NomDuFichier )
+ dicoDesBlocs[nomBloc] = BLOC(condition = blocCondition, **dicoArgs)
+ if FieldName:
+ SIMPFieldName = SIMP(statut='o', typ = 'TXM',)
+ dicoDesBlocs[FieldName] = SIMPFieldName
+ return BLOC(condition=laCondition, **dicoDesBlocs)
+
+#---------------------------------------------
+def prepareChamp(nomDelaContante, labels ,nbReels ) :
+#---------------------------------------------
+# PN : a reecrire
+# ajouter les extensions pour le fichier et les blocs associes
+# certains champs ne seront jamais uniformes
+# probablement a refaire
+#PNPN : Passer le nom du champ pour le label du vecteur
+# A revoir
+
+ dicoBloc = {}
+ dicoBloc[nomDelaContante] = SIMP(statut='o', typ='R')
+ return FACT(statut='o',
+ InputMode = SIMP(statut='o', typ='TXM', into=('uniform value','values directly assigned','values read in file','analytical function',)),
+ blocUniforme = BLOC(condition = "InputMode == 'uniform value'", **dicoBloc),
+ blocVsaisies = BLOC(condition = "InputMode == 'values directly assigned'",
+ Field = SIMP(typ='R', statut='o', max ='**'),
+ #Vecteur = SIMP(fenetreIhm='Tableau', homo = labels,
+ # statut='o', min=2, max='**',
+ # typ=Tuple(nbReels),
+ # validators=VerifTypeTuple(("'R',"*nbReels),),) # end particle
+ ), #b_vsaisie
+ blocVdsfich = BLOC(condition = "InputMode == 'values read in file'",
+ Format = SIMP(statut='o', typ='TXM', into=['txt','Med',], position='global' ),
+ td_txt = BLOC(condition = 'Format == "txt"',
+ File = SIMP(statut='o', typ=('Fichier','Text Files(*.txt);All Files (*)'),),
+ ), # fin vtd_txt
+ td_med_1 = BLOC(condition = 'Format == "Med"',
+ File = SIMP(statut='o', typ=('Fichier','Med Files(*.med);All Files (*)'),),
+ ),
+ td_med_2 = BLOC(condition = 'Format == "Med"',
+ FieldName = SIMP(statut='o', typ='TXM',),
+ ),
+ ),
+ blocFunct = BLOC(condition = "InputMode == 'analytical function'",
+ Function = SIMP(statut='o', typ='TXM',),
+ ),
+ #b_vserc = BLOC(condition = "InputMode == 'call to a service'",
+ # Service = SIMP(statut='o', typ='TXM',),
+ #),
+ )
+
+
+#------------------------------
+def prepareTermeSource(condition):
+#------------------------------
+ return BLOC (condition=condition,
+ OriginOfSourceTerm = SIMP(statut='o', typ='TXM',into=['Interaction', 'Chemical Reaction', 'Other Scalar']),
+ blocOriginOfSourceTermInteraction = BLOC(condition = 'OriginOfSourceTerm == "Interaction"',
+ SourceTermInteraction = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ blocOriginOfSourceTermOtherScalar = BLOC(condition = 'OriginOfSourceTerm == "Other Scalar"',
+ ApplyOnScalar = SIMP (statut ='o', typ=scalar, ), #PNPN A FAIRE : fenetreIhm='menuDeroulant'
+ ),
+ )
+
+#------------------------------
+def prepareTermeSourceDynVar(condition):
+#------------------------------
+ return BLOC (condition=condition,
+ OriginOfSourceTerm = SIMP(statut='o', typ='TXM',into=['Interaction', 'Other Scalar']),
+ )
+
+#------------------------------------------------------
+def prepareFactTurbulence(statut, ajout=None , position=None, positionChoice=None):
+#------------------------------------------------------
+ listInto = ['Fully resolved (DNS)', 'Spatial filtering (LES)', 'One-point moment', 'One-point PDF']
+ if ajout != None : listInto.append(ajout)
+ return FACT(statut=statut,
+ TurbulenceModellingType = SIMP(typ='TXM', statut='o', into =listInto, position=position ),
+
+# --------------- One-point moment ------------------
+ blocOnePoint = BLOC(condition= "TurbulenceModellingType == 'One-point moment'",
+ RANSModel = SIMP(statut="o", typ="TXM", position='global',
+ into=['Turbulent-Viscosity Model (TVM)', 'Reynolds Stress Model (RSM)']),
+ blocTVM = BLOC(condition= "RANSModel == 'Turbulent-Viscosity Model (TVM)'",
+ TVMChoice = SIMP(typ='TXM', statut='o', into=['K-Epsilon', 'K-Omega'] , position=positionChoice), ##PN PN : parametre vs reCalculeEtape
+ ), # fin blocTVM
+ blocRSM = BLOC(condition = "RANSModel == 'Reynolds Stress Model (RSM)'",
+ RSMChoice = SIMP(typ='TXM', statut='o', into=['Rotta', 'LRR-IP','LRR-QI','SSG'], position=positionChoice),
+ ), # fin blocRSM
+ ), # fin bloc_one_point
+
+# --------------- Spatial filtering (LES) ------------------
+ blocOneSpatial = BLOC(condition = "TurbulenceModellingType == 'Spatial filtering (LES)'",
+ ChoiceOfDescription = SIMP(typ='TXM', statut='o', into=['One-point filtered variables', 'Filtered Density Function (FDF)']),
+ blocOnePoint = BLOC(condition = "ChoiceOfDescription == 'One-point filtered variables'",
+ SubgridScaleModel = SIMP(typ='TXM', statut='o', into=['No SGS', 'Smagorinsky','Dynamical model', 'SGS Transport Equations']),
+ ),# fin bloc_OnePoint
+ blocFDF = BLOC(condition = "ChoiceOfDescription == 'Filtered Density Function (FDF)'",
+ SubgridScaleModel = SIMP(typ='TXM', statut='o', into=['SLM model for SGS', 'Viscous SLM model for SGS']),
+ ),# fin bloc_FDF
+ ), # fin bloc_one_spatial
+
+# --------------- One-point PDF ------------------
+ blocOnePointPdf = BLOC(condition = "TurbulenceModellingType == 'One-point PDF'",
+ ChoiceOfDescription = SIMP(typ='TXM', statut='o', into=['Velocity PDF', 'Velocity frequency PDF']),
+ blocVPdf = BLOC(condition = "ChoiceOfDescription == 'Velocity PDF'",
+ StochasticModel = SIMP(typ='TXM', statut='o', into=['SLM','GLM'], defaut='SLM'),
+ ), # fin blocVPdf
+ blocVFPdf = BLOC(condition = "ChoiceOfDescription == 'Velocity frequency PDF'",
+ StochasticModel = SIMP(typ='TXM', statut='o', into=['Log-normal model','Gamma model','User-defined form'], defaut='SLM'),
+ ), # fin blocVFPdf
+ ), # fin bloc_one_point_pdf
+
+# --------------- Fully resolved (DNS) ------------------
+ # blocNoModel = BLOC(condition = "TurbulenceModellingType == 'Fully resolved (DNS)'",
+ # ChoiceOfApproach = SIMP(statut='o', typ='TXM', into=['Field-based (DNS)', 'N-Particle_Method']),
+ # blocField = BLOC(condition = "ChoiceOfApproach == 'Field-based (DNS)'",
+ # NumericalMethod = SIMP(statut='o', typ='TXM', into=['FV', 'Spectral Method'],
+ # intoXML=['FV', 'Spectral Method','SPH', 'Vortex Method']),
+ # ),# fin bloc_Field
+ # blocNParticle = BLOC(condition = "ChoiceOfApproach == 'N-Particle_Method'",
+ # NumericalMethod = SIMP(statut='o', typ='TXM', into=['SPH', 'Vortex Method'],
+ # intoXML=['FV', 'Spectral Method','SPH', 'Vortex Method']),
+ # ),# fin bloc_N_particle
+ # ), # fin bloc_no_model
+ ) # fin du return de la fonction factTurbulence
+
+
+
+#------------------------------------------------------
+def prepareFactTurbulenceScalaire(statut, ajout=None , position=None):
+#------------------------------------------------------
+ listInto = ['Fully resolved (DNS)', 'Spatial filtering (LES)', 'One-point moment', 'One-point PDF']
+ if ajout != None : listInto.append(ajout)
+ return FACT(statut=statut,
+ TurbulenceModellingType = SIMP(typ='TXM', statut='o', into =listInto, position=position ),
+
+# --------------- One-point moment ------------------
+ blocOnePoint = BLOC(condition= "TurbulenceModellingType == 'One-point moment'",
+ RANSModel = SIMP(statut="o", typ="TXM",
+ into=['Algebraic flux models','Turbulent diffusivity models', 'Scalar-flux transport equations']),
+ # blocAlgebraic = BLOC(condition= "RANSModel == 'Algebraic flux models'",
+ # blocConsigne = BLOC(condition= "RANSModel == 'Algebraic flux models'",
+ # Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Not implemented yet'),
+ # ), # fin blocAlgebraic
+ blocTDM = BLOC(condition = "RANSModel == 'Turbulent diffusivity models'",
+ TDMChoice = SIMP(typ='TXM', statut='o', into=['SGDH', 'GGDH',]),
+ ), # fin blocTDM
+ blocSFTE = BLOC(condition = "RANSModel == 'Scalar-flux transport equations'",
+ SFTEChoice = SIMP(typ='TXM', statut='o', into=['Pressure-scrambling model', 'EB-DFM',]),
+ ), # fin blocSFTE
+ ), # fin bloc_one_point
+
+# --------------- Spatial filtering (LES) ------------------
+ blocOneSpatial = BLOC(condition = "TurbulenceModellingType == 'Spatial filtering (LES)'",
+ ChoiceOfDescription = SIMP(typ='TXM', statut='o', into=['One-point filtered variables', 'Filtered Density Function (FDF)']),
+ blocOnePoint = BLOC(condition = "ChoiceOfDescription == 'One-point filtered variables'",
+ SubgridScaleModel = SIMP(typ='TXM', statut='o', into=['No SGS model', 'SGS diffusivity', 'Transport eqs. for SGS scalar fluxes']),
+ ),# fin bloc_OnePoint
+ blocFDF = BLOC(condition = "ChoiceOfDescription == 'Filtered Density Function (FDF)'",
+ SubgridScaleModel = SIMP(typ='TXM', statut='o', into=['Composition FDF', 'Scalar-velocity FDF', 'Micro-mixing model']),
+ ),# fin bloc_FDF
+ ), # fin bloc_one_spatial
+
+# --------------- One-point PDF ------------------
+ blocOnePointPdf = BLOC(condition = "TurbulenceModellingType == 'One-point PDF'",
+ ChoiceOfDescription = SIMP(typ='TXM', statut='o', into=['Composition PDF','Velocity PDF', 'Micro-mixing models']),
+ # blocCPdf = BLOC(condition = "(ChoiceOfDescription == 'Composition PDF') or (ChoiceOfDescription == 'Velocity PDF')",
+ # blocConsigne = BLOC(condition = "(ChoiceOfDescription == 'Composition PDF') or (ChoiceOfDescription == 'Velocity PDF')",
+ # Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Not implemented yet.'),
+ # ), # fin blocCPdf
+ # blocVPdf = BLOC(condition = "ChoiceOfDescription == 'Velocity PDF'",
+ # ), # fin blocVPdf
+ blocMMMPdf = BLOC(condition = "ChoiceOfDescription == 'Micro-mixing models'",
+ ChoiceOfModel = SIMP(typ='TXM', statut='o', into=['IEM/CIEM','Curl model','Mapping','EMST'],),
+ ), # fin blocMMMdf
+ ), # fin bloc_one_point_pdf
+
+# --------------- Fully resolved (DNS) ------------------
+ # blocNoModel = BLOC(condition = "TurbulenceModellingType == 'Fully resolved (DNS)'",
+ # ChoiceOfApproach = SIMP(statut='o', typ='TXM', into=['Field-based (DNS)', 'N-Particle_Method']),
+ # blocField = BLOC(condition = "ChoiceOfApproach == 'Field-based (DNS)'",
+ # NumericalMethod = SIMP(statut='o', typ='TXM', into=['FV', 'Spectral Method'],
+ # intoXML=['FV', 'Spectral Method','SPH', 'Vortex Method']),
+ # ),# fin bloc_Field
+ # blocNParticle = BLOC(condition = "ChoiceOfApproach == 'N-Particle_Method'",
+ # NumericalMethod = SIMP(statut='o', typ='TXM', into=['SPH', 'Vortex Method'],
+ # intoXML=['FV', 'Spectral Method','SPH', 'Vortex Method']),
+ # ),# fin bloc_N_particle
+ # ), # fin bloc_no_model
+ ) # fin du return de la fonction factTurbulence
+
+
+#--------------------------
+def Particle(cardinalite) :
+#--------------------------
+ return FACT(statut='o', max=cardinalite,
+ ParticleNature = SIMP(statut='o', typ='TXM', into=['Atoms', 'Molecules', 'Dissipative', 'Fluid Particle', 'Discrete Particle']),
+ blocAtom = BLOC(condition='ParticleNature == "Atoms"',
+ AtomsName = SIMP(statut='o', typ=(userAtom,'createObject'),),
+ Atom = FACT(statut ='o', max= '**',
+ ChemicalSpecie = SIMP(statut='o', typ='TXM'),
+ Number = SIMP(statut='o', typ = 'I'),
+ ElectricCharge = SIMP(statut='o', typ='R'),
+ MagneticMoment = SIMP(statut='o', typ='R'),
+ Size = SIMP(statut='f', typ='R'), # relevant ?
+ ),# Atom
+ ), # fin b_Atom
+# --------------- Molecules ------------------
+ blocMolecule = BLOC(condition='ParticleNature == "Molecules"',
+ MoleculeName = SIMP(statut='o', typ=(userMolecule,'createObject'),),
+ ChemicalSpecie = FACT(max='**', statut='o',
+ ChemicalSpecieName = SIMP(statut='o', typ=userAtom),
+ Proportion = SIMP(statut='o', typ='R', val_max =1),
+ ),
+ ElectricCharge = SIMP(statut='o', typ='R'),
+ MagneticMoment = SIMP(statut='o', typ='R'),
+ Shape = SIMP(statut='f', typ='TXM', into=['Linear', 'Trigonal Planar', 'Angular', 'Tetrahedral', 'Octahedral', 'Trigonal pyramid', 'Other']),
+ ), #fin b_Molecule
+
+# --------------- Dissipative ------------------
+ blocDissipative = BLOC(condition='ParticleNature == "Dissipative"',
+ DPDName = SIMP(statut='o', typ=(userDPD,'createObject'),),
+ BondedParticles = SIMP(statut="o", typ=bool, defaut=False),
+ ), # b_Dissipative
+
+# --------------- Discrete Particle ------------------
+ blocDiscrete = BLOC(condition='ParticleNature == "Discrete Particle"',
+ DiscreteParticleName = SIMP(statut='o', typ=(userDiscrete,'createObject'),),
+ TypeOfDiscreteParticle = SIMP(statut='o', typ='TXM', into=['Solid', 'Droplets', 'Bubbles','Bio Organism'],),
+ blocTypeDPSolid = BLOC(condition ='TypeOfDiscreteParticle == "Solid"',
+ TypeOfSolid = SIMP(statut='o', typ='TXM', into=['Primary Particle', 'Assemblage / Aggregate'], position = 'global'),
+ b_SolidPrimary = BLOC(condition='TypeOfSolid == "Primary Particle"',
+ ),
+ b_SolidAggregate = BLOC(condition='TypeOfSolid == "Assemblage / Aggregate"',
+ ),
+ ),
+# --------------- Bio Organism ------------------
+ blocTypeBioSolid = BLOC(condition='TypeOfDiscreteParticle == "Bio Organism"',
+ TypeOfOrganism = SIMP(statut='o', typ='TXM', into=['Unicellular', 'Multicellular']),
+ blocUnicellular = BLOC(condition ='TypeOfOrganism=="Unicellular"',
+ Unicellular = SIMP(statut='o', typ='TXM', into=["Bactaria"], defaut='Bactaria')
+ ),
+ b_Multicellular = BLOC(condition ='TypeOfOrganism=="Multicellular"',
+ Multicellular = SIMP(statut='o', typ='TXM', into=["Animal","Fongus","Plant"])
+ ),
+ ), # b_TypeBio_Solid
+
+# --------------- Particule Properties ------------------
+ Properties = FACT(statut ='o',
+ Geometry = SIMP(statut='o', typ='TXM', into=['Sphere', 'Ellopsoids', 'Other Shape']),
+ b_geom_Sphere = BLOC(condition = 'Geometry == "Sphere"',
+ ParticleRadius = SIMP(statut='o', typ ='R', val_min = 0),
+ ),
+ Weight = FACT(statut = 'o',
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Choose between Mass or Density'),
+ Mass = SIMP(statut='f', typ ='R', val_min = 0),
+ Density = SIMP(statut='f', typ ='R', val_min = 0),
+ ),
+ Mechanical = SIMP(statut='o', typ='TXM', into=['Rigid', 'Flexible', 'Deformable']),
+ b_SolidAggregate = BLOC(condition='TypeOfSolid == "Assemblage / Aggregate"',
+ Morphological = FACT(statut = 'o',
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Choose optional properties'),
+ FractalDimension = SIMP(statut='f', typ='R'),
+ NumberOfPrimaryParticle = SIMP(statut ='f',typ='I'),
+ EquivalentSize = SIMP(statut='f', typ='R'),
+ Porosity = SIMP(statut='f', typ='R'),
+ ), # Morphological
+ ), # b_SolidAggregate
+ ElectroMagnetic = FACT(statut = 'f',
+ ElectricCharge = SIMP(statut='o', typ='R'),
+ MagneticMoment = SIMP(statut='o', typ='R'),
+ ),
+ b_SolidAggregateBonded = BLOC(condition='TypeOfSolid == "Assemblage / Aggregate"',
+ BondedParticles = FACT(
+ ListOfBondedParticles = SIMP(statut='o', max='**', typ = userParticle),
+ ),
+ ),
+ ), # Properties
+ ), # b_Discrete
+
+############################
+
+ ListOfBondedParticles = FACT(statut='f',
+ # --------------------------------------#
+ BondedParticles = FACT(statut='o', max = "**",
+ NameOfBonded_Particles = SIMP(statut='o', typ='TXM'),
+ SpeciesinParticle = SIMP(statut='o', min=2, typ='TXM' , max = "**"),
+ ), # BondedParticles
+ ), # ListOfBondedParticles
+
+ ListOfInteractions = FACT(statut='o', max = "**",
+ # ------------------------------------------------#
+
+ BondedInteractions = FACT(statut='o', max = "**",
+ TypeOfBondedInteraction = SIMP(statut='o', typ='TXM', into=['NoOne', 'Covalent Bond Length', 'FENE', 'Covalent Bond Angle', 'Dihedral Angles', 'Improper Dihedral', 'Frozen Motion' ], defaut='NoOne'),
+
+ #La saisie de l'ensemble des liaisons d'un meme type peut se faire ds le meme bloc (soit ds un fichier, soit manuelle)
+ #Une seule valeur de distante? est a saisir pour l'ensemble
+ # bloc_covalent_1 = BLOC(condition = 'TypeOfBondedInteraction in ("Covalent Bond Length","FENE")',
+ # ), # fin bloc_covalent_1
+
+# --------------- Covalent Bond Length ------------------
+ blocCovalentLength = BLOC(condition = 'TypeOfBondedInteraction == "Covalent Bond Length"',
+ InteractionLengthParameters = FACT(statut='o', max="**",
+ ApplyToBondedParticles = SIMP(statut='o', max='**', typ='TXM'),
+ SpringStifness = SIMP(statut='o', typ='R', val_min=0),
+ MeanBondLength = SIMP(statut='o', typ='R', val_min=0),
+ ), # fin Interation_Length_Parameters
+ ), # fin BondLengthParameters
+
+# --------------- Covalent Bond Angle ------------------
+ blocCovalentAngle = BLOC(condition = 'TypeOfBondedInteraction == "Covalent Bond Angle"',
+ InteractionAnglesParameters = FACT(statut='o', max="**",
+ ApplyToBondedParticles = SIMP(statut='o', max='**', typ='TXM'),
+ SpringStifness = SIMP(statut='o', typ='R', val_min=0),
+ MeanBondAngle = SIMP(statut='o', typ='R', val_min=0),
+ ), # fin Interation_Angles_Parameters
+ ), # fin bloccovalentlengthand_angle
+
+ #bloc_covalent_length_and_angle = BLOC(condition = 'TypeOfBondedInteraction == "Covalent Bond Length" or TypeOfBondedInteraction == "Covalent Bond Angle"',
+ # Bond_Parameters = FACT(statut='o', max="**",
+ # Apply_To_Bonded_Particles = SIMP(statut='o', max='**', typ='TXM'),
+ # Spring_Stifness = SIMP(statut='o', typ='R', val_min=0),
+ # bloc_covalent_length = BLOC(condition = 'TypeOfBondedInteraction == "Covalent Bond Length"',
+ # Mean_Bond_Length = SIMP(statut='o', typ='R', val_min=0),
+ # ), # fin Bond_Length_Parameters
+ # bloc_covalent_angle = BLOC(condition = 'TypeOfBondedInteraction == "Covalent Bond Angle"',
+ # Mean_Bond_Angle = SIMP(statut='o', typ='R', val_min=0),
+ # ), # fin Bond_Length_Parameters
+ # ), # fin Bond_Length_Parameters
+ #), # fin bloc_covalent_length_and_angle
+
+# --------------- Covalent Bond Angle ------------------
+ blocFENE = BLOC(condition = 'TypeOfBondedInteraction == "FENE"',
+ AppliesToAllParticles = SIMP(statut='o', typ=bool, defaut=True),
+ blocNotOnAll = BLOC(condition = 'AppliesToAllParticles == False',
+ FENEParameters = FACT(statut='o', max="**",
+ SpeciesPair = SIMP(statut='o', max=2, typ='TXM'),
+ SpringConstant_H = SIMP(statut='o', typ='R', val_min=0),
+ LMax = SIMP(statut='o', typ='R', val_min=0),
+ ), # fin FENE_Parameters
+ ), # fin bloc_not_on_all
+ blocOnAll = BLOC(condition = 'AppliesToAllParticles == True',
+ Spring_Constant_H = SIMP(statut='o', typ='R', val_min=0),
+ LMax = SIMP(statut='o', typ='R', val_min=0),
+ ), # fin bloc_on_all
+ ), # fin blocFENE
+
+ blocLeReste = BLOC(condition = 'TypeOfBondedInteraction in ("Dihedral Angles", "Improper Dihedral", "Frozen Motion")',
+ ParticleName = SIMP(statut="f", typ='TXM'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Not Implemented Yet'),
+ ),
+
+ ), # fin Bonded_Interaction
+
+ # ------------------------------- #
+
+ UnbondedInteractions = FACT(statut='o', max= "**",
+
+ TypeOfUnbondedInteraction = SIMP(statut='o', typ='TXM', into=['No', 'electro_magnetic', 'Repulsion_and_VdW', 'Soft_Potentiel', ], defaut='No', position='global',fenetreIhm='menuDeroulant'),
+
+ blocElec = BLOC(condition = 'TypeOfUnbondedInteraction == "electro_magnetic"',
+ Permittivity = SIMP(statut='o', typ='R', position='global_jdc'),
+ Magnetic = SIMP(statut='o', typ=bool, defaut=False,),
+ blocMagnetic = BLOC(condition = 'Magnetic == True',
+ Permability = SIMP(statut='o', typ='R'),
+ ), # bloc_magnetic
+ ),# fin bloc_elec
+
+ blocVdW = BLOC(condition = 'TypeOfUnbondedInteraction == "Repulsion_and_VdW"',
+ SpeciesPairParameters = FACT(statut='o', max="**",
+ TypeRepulsionAndVdW = SIMP(statut='o', typ='TXM', into = [ 'Lennard_Jones', 'Hard_sphere_model']),
+ SpeciesPair = SIMP(statut='o', max=2, typ='TXM'),
+ VdWRadius = SIMP(statut='o', typ='R', val_min=0),
+ blocLennard = BLOC(condition = "TypeRepulsionAndVdW == 'Lennard_Jones'",
+ DepthOfThePotentialWell = SIMP(statut='o', typ='R', val_min=0),
+ ), # fin b_Lennard
+ ), # fin Species_Pair_Parameters
+ ), # bloc_VdW
+
+ blocParamSoftPotentiel = BLOC(condition = "TypeOfUnbondedInteraction == 'Soft_Potentiel'",
+ GrootWarrenRepulsion = SIMP(statut='o', typ='R', defaut=25.0, val_min=0),
+ GrootWarrenCutoff = SIMP(statut='o', typ='R', defaut=1.0, val_min=0),
+ DragCoefficient = SIMP(statut='o', typ='R'), # les 2 valent 0 pour MD
+ DragForceCutoff = SIMP(statut='o', typ='R', val_min=0),
+ ), # b_Param_Soft_Potentiel
+
+ ), # fin UnBonded_Interactions
+
+ # ------------------------------- #
+
+ ExternalFieldInteraction = FACT(statut='o', max= "**",
+ TypeOfInteractionWithAnExternalField = SIMP(statut='o', typ='TXM', into=['NoOne','gravitational field','electric field','magnetic field', 'Hydrodynamic_Field'], fenetreIhm='menuDeroulant', defaut ='NoOne'),
+ blocGravite = BLOC(condition = 'TypeOfInteractionWithAnExternalField=="gravitational field"',
+ G = SIMP(statut='o', typ='R', defaut=9.81),
+ ),
+ blocElect = BLOC(condition = 'TypeOfInteractionWithAnExternalField=="electric field"',
+ ElectricField = prepareChamp('E', ('E',), 1),
+ ),
+ blocMagnetic = BLOC(condition = 'TypeOfInteractionWithAnExternalField=="magnetic field"',
+ MagneticField = prepareChamp('B', ('B',), 1),
+ ),
+ blocHydrodynamic = BLOC(condition = 'TypeOfInteractionWithAnExternalField=="hydrodynamic field"',
+ HydrodynamicField = prepareChamp('U', ('U',), 1),
+ ),
+ blocExternalFieldInteraction = BLOC(condition = 'TypeOfInteractionWithAnExternalField != "No"',
+ FieldAppliesOnAllSpecies = SIMP(statut='o', typ=bool, defaut=True),
+ blocPorteEspece = BLOC(condition = 'FieldAppliesOnAllSpecies == False ',
+ SpeciesList = SIMP(statut='o', typ='TXM', max= '**', homo='SansOrdreNiDoublon'), # faire un typ = "espece"
+ ),
+ ), # fin b_External_Field_Interaction
+ ), # fin Interaction_External_Field
+
+ ), # fin List_Of_Interactions
+
+############################
+) # fin Particle
+
+#--------------------
+def prepareBlocCPS():
+#--------------------
+ return BLOC(condition = 'SystemType == "Classical particle system"',
+ Particle = Particle('**'),
+ )
+
+#---------------------------
+def prepareBlocFluideMacro():
+#---------------------------
+ return BLOC(condition = 'SystemType == "Continuum system"',
+ ComplexFluid = SIMP(typ=bool, statut='o', defaut = False, position='global'),
+ FlowNature = SIMP(typ='TXM', statut='o', into =['Laminar', 'Turbulent'], position='global'),
+
+# --------------------------- Density -------------
+ DensityInitialisation = FACT(statut ='o',
+ DensityValueType = SIMP(typ='TXM', statut ='o', into = ['Value', 'Field'], defaut ='Value'),
+ blocDensityValue = BLOC(condition = 'DensityValueType == "Value"',
+ Density = SIMP(typ='R', statut ='o'),
+ ),
+ blocDensField= creeBlocPourLesFichiers('DensityValueType == "Field"', 'Density', ListeFormats=listeFormatGenerique, FieldName='DensityFieldName'),
+ ),# DensityInitialisation
+
+# --------------------------- Viscosity -------------
+ ViscosityInitialisation = FACT(statut ='o',
+ ViscosityValueType = SIMP(typ='TXM', statut ='o', into = ['Value', 'Field'], defaut ='Value'),
+ blocViscosityValue = BLOC(condition = 'ViscosityValueType == "Value"',
+ Viscosity = SIMP(typ='R', statut ='o'),
+ ),
+ blocViscosityField = creeBlocPourLesFichiers('ViscosityValueType == "Field"', 'Viscosity', ListeFormats=listeFormatGenerique, FieldName='ViscosityFieldName'),
+ ), #fin ViscosityityInitialisation
+
+# --------------------------- Turbulent -------------
+ blocFlowNatureTurbulent = BLOC(condition = ' FlowNature == "Turbulent"',
+ TurbulenceForFlowDynamics = prepareFactTurbulence('o',position='global',positionChoice='reCalculeEtape'),
+ ), #fin bloc_FlowNature_Turbulent
+
+ DynamicalVariables = FACT(statut ='o',
+ OriginOfDynamicalVariables = SIMP(statut='o', into =['Given', 'Interaction', 'to be simulated'], typ ='TXM', position='global'),
+ BlocGivenOrInteraction = BLOC(condition = 'OriginOfDynamicalVariables in ["Given", "Interaction",]',
+ Steady = SIMP(typ=bool, statut ='o', defaut = True, position = 'global'),
+ # BlocNotSteady = BLOC(condition = 'Steady == False',
+ BlocConsigne = BLOC(condition = 'Steady == False',
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Not implemented yet. Will ask for a range of calculation steps.'),
+ ), #BlocNotSteady
+ BlocSteady = BLOC(condition = 'Steady == True',
+ BlocGiven = BLOC(condition = 'OriginOfDynamicalVariables == "Given"',
+ InSameFile = SIMP(typ=bool, statut ='o', defaut = True, position = 'reCalculeEtape'),
+ BlocSameFile = creeBlocPourLesFichiers('InSameFile == True', 'DynamicalVariables', ('Med', 'cgns' ), None),
+ ), #BlocGiven
+ ), #BlocSteady
+ ), #BlocGivenOrInteraction
+ PressureDefinition = FACT(statut ='o',
+ Pressure = SIMP(typ=(dynamicVariable,'createObject'), statut='o', defaut ='Pressure', homo='constant'),
+ BlocSteady = BLOC(condition = 'Steady == True',
+ BlocFluidInSame = creeBlocPourLesFichiers('InSameFile == False', 'Pressure', ('Med', 'cgns' ), None),
+ BlocGivenPressure = BLOC(condition = 'OriginOfDynamicalVariables == "Given"',
+ PressureFieldName = SIMP(typ='TXM',statut='o'),
+ ),
+ BlocInteractionPressure = BLOC(condition = 'OriginOfDynamicalVariables == "Interaction"',
+ InteractionName = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ ),
+ BlocSimulatedPressure = BLOC(condition = 'OriginOfDynamicalVariables == "to be simulated"',
+ SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ blocSourceTerm = prepareTermeSourceDynVar('SourceTerm==True'),
+ ),
+ ),
+ VelocityDefinition = FACT(statut ='o',
+ blocFlowNatureTurbulent = BLOC(condition = 'FlowNature == "Turbulent"',
+ #sousBlocFlowNatureTurbulent = BLOC(condition = 'TurbulenceModellingType != "Fully resolved (DNS)"',
+ AverageVelocity = SIMP(typ=(dynamicVariable,'createObject'), statut='o', defaut ='Average_Velocity', homo='constant'),
+ BlocSteadyGivenVelocity1 = BLOC(condition = 'OriginOfDynamicalVariables == "Given" and Steady == True ',
+ AverageVelocityValue = SIMP(typ='R', statut='o' ),
+ ),
+ #),
+ ),
+ #blocFlowNatureLaminar = BLOC(condition = ' FlowNature == "Laminar" or TurbulenceModellingType == "Fully resolved (DNS)"',
+ blocFlowNatureLaminar = BLOC(condition = 'FlowNature == "Laminar"',
+ FluidVelocity = SIMP(typ=(dynamicVariable,'createObject'), statut='o', defaut ='Fluid_Velocity', homo='constant'),
+ BlocSteady = BLOC(condition = 'Steady == True',
+ BlocVelocityInSame = creeBlocPourLesFichiers('InSameFile == False', 'Velocity', ('Med', 'cgns' ), None),
+ BlocSteadyGivenVelocity2 = BLOC(condition = 'OriginOfDynamicalVariables == "Given"',
+ VelocityFieldName = SIMP(typ='TXM',statut='o'),
+ ),
+ ),
+ ),
+ BlocSimulatedVelocity = BLOC(condition = 'OriginOfDynamicalVariables == "to be simulated"',
+ SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ blocSourceTerm = prepareTermeSourceDynVar('SourceTerm==True'),
+ ),
+ BlocSteady = BLOC(condition = 'Steady == True',
+ BlocInteractionVelocity = BLOC(condition = 'OriginOfDynamicalVariables == "Interaction"',
+ InteractionName = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ ),
+ ),
+ BFlowNatureTurbulent = BLOC(condition ='FlowNature == "Turbulent"',
+ # K-epislon ou k-omega
+ blocTurbulenceTWMChoice1 = BLOC(condition = 'TVMChoice == "K-Epsilon" or TVMChoice == "K-Omega"',
+ KDefinition = FACT(statut ='o',
+ Name = SIMP(typ=(scalar,'createObject'), statut='o', defaut ='K', homo='constant'),
+ BlocSteady = BLOC(condition = 'Steady == True',
+ BlocKInSame = creeBlocPourLesFichiers('InSameFile == False', 'K', ('Med', 'cgns' ), None),
+ BlocKGiven = BLOC(condition = 'OriginOfDynamicalVariables == "Given"',
+ KFieldName = SIMP(typ='TXM',statut='o', defaut='K'),
+ ),
+ BlocKInteraction = BLOC(condition = 'OriginOfDynamicalVariables == "Interaction"',
+ InteractionName = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ ),
+ BlocSimulatedKDefinition = BLOC(condition = 'OriginOfDynamicalVariables == "to be simulated"',
+ SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ blocSourceTerm = prepareTermeSourceDynVar('SourceTerm==True'),
+ ),
+ ), # KDefinition
+ ),# fin blocTurbulenceTWMChoice1
+
+ # REM : L'existence des mc TVMChoice et RSMChoice est exclusive, du coup une évaluation de condition
+ # qui contient les deux renvoie forcément une exception, le bloc n'est alors pas evalué
+ # sauf si le mc de la première condition existe (ordre évaluation du or)
+ # blocTurbulenceTWMChoice2 = BLOC(condition = 'TVMChoice == "K-Epsilon" or RSMChoice != None',
+ # blocTurbulenceTWMChoice2 = BLOC(condition = '(RSMChoice != None) or (TVMChoice == "K-Epsilon")',
+ # blocTurbulenceTWMChoice2 = BLOC(condition = 'TVMChoice == "K-Epsilon"',
+ blocTurbulenceTWMChoice2 = BLOC(condition = 'RANSModel == "Reynolds Stress Model (RSM)" or TVMChoice == "K-Epsilon"',
+ EpsilonDefinition = FACT(statut ='o',
+ Name = SIMP(typ=(scalar,'createObject'), statut='o', defaut ='Epsilon', homo='constant'),
+ BlocSteady = BLOC(condition = 'Steady == True',
+ BlocEpsilonInSame = creeBlocPourLesFichiers('InSameFile == False', 'Epsilon', ('Med', 'cgns' ), None),
+ BlocEpsilonGiven = BLOC(condition = 'OriginOfDynamicalVariables == "Given"',
+ EpsilonFieldName = SIMP(typ='TXM',statut='o'),
+ ),
+ BlocEpsilonInteraction = BLOC(condition = 'OriginOfDynamicalVariables == "Interaction"',
+ InteractionName = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ ),
+ BlocSimulatedEpsilonDefinition = BLOC(condition = 'OriginOfDynamicalVariables == "to be simulated"',
+ SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ blocSourceTerm = prepareTermeSourceDynVar('SourceTerm==True'),
+ ),
+ ), #EpsilonDefinition
+ ), # bloc_Turbulence_TWMChoice2
+
+ blocTurbulenceTWMChoice3 = BLOC(condition = 'TVMChoice == "K-Omega"',
+ OmegaDefinition = FACT(statut ='o',
+ Name = SIMP(typ=(scalar,'createObject'), statut='o', defaut ='Omega', homo='constant'),
+ BlocSteady = BLOC(condition = 'Steady == True',
+ BlocOmegaInSame = creeBlocPourLesFichiers('InSameFile == False', 'Omega', ('Med', 'cgns' ), None),
+ BlocOmegaGiven = BLOC(condition = 'OriginOfDynamicalVariables == "Given"',
+ OmegaFieldName = SIMP(typ='TXM',statut='o'),
+ ),
+ BlocOmegaInteraction = BLOC(condition = 'OriginOfDynamicalVariables == "Interaction"',
+ InteractionName = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ ),
+ BlocSimulatedOmegaDefinition = BLOC(condition = 'OriginOfDynamicalVariables == "to be simulated"',
+ SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ blocSourceTerm = prepareTermeSourceDynVar('SourceTerm==True'),
+ ),
+ ),
+ ), # blocTurbulenceTWMChoice3
+
+ # blocTurbulenceRSMChoice1 = BLOC(condition = "(RANSModel == 'Reynolds Stress Model (RSM)') and (RSMChoice !=None)",
+ blocTurbulenceRSMChoice1 = BLOC(condition = "RSMChoice !=None",
+ RijDefinition = FACT(statut ='o',
+ Name = SIMP(typ=(scalar,'createObject'), statut='o', defaut ='Rij', homo='constant'),
+ BlocSteady = BLOC(condition = 'Steady == True',
+ BlocRijInSame = creeBlocPourLesFichiers('InSameFile == False', 'Rij', ('Med', 'cgns' ), None),
+ BlocRijGiven = BLOC(condition = 'OriginOfDynamicalVariables == "Given"',
+ RijFieldName = SIMP(typ='TXM',statut='o'),
+ ),
+ BlocRijInteraction = BLOC(condition = 'OriginOfDynamicalVariables == "Interaction"',
+ InteractionName = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ ),
+ BlocSimulatedRijDefinition = BLOC(condition = 'OriginOfDynamicalVariables == "to be simulated"',
+ SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ blocSourceTerm = prepareTermeSourceDynVar('SourceTerm==True'),
+ ),
+ ),
+ ), # blocTurbulenceRSMChoice1
+
+ # blocTurbulenceRSMChoice2 = BLOC(condition = 'RSMChoice != None',
+ # EpsilonDefinition = FACT(statut ='o',
+ # Name = SIMP(typ=(scalar,'createObject'), statut='o', defaut ='Epsilon', homo='constant'),
+ # BlocSteady = BLOC(condition = 'Steady == True',
+ # BlocEpsilonInSame = creeBlocPourLesFichiers('InSameFile == False', 'Epsilon', ('Med', 'cgns' ), None),
+ # BlocEpsilonGiven = BLOC(condition = 'OriginOfDynamicalVariables == "Given"',
+ # EpsilonFieldName = SIMP(typ='TXM',statut='o'),
+ # ),
+ # BlocEpsilonInteraction = BLOC(condition = 'OriginOfDynamicalVariables == "Interaction"',
+ # InteractionName = SIMP(typ=interaction,statut='o'),
+ # Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ # ),
+ # ),
+ # BlocSimulatedEpsilonDefinition = BLOC(condition = 'OriginOfDynamicalVariables == "to be simulated"',
+ # SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ # blocSourceTerm = prepareTermeSourceDynVar('SourceTerm==True'),
+ # ),
+ # ), #EpsilonDefinition
+ # ), # bloc_Turbulence_RSMChoice2
+
+ ), #BFlowNatureTurbulent
+ ), # DynamicalVariables
+
+# ---------------------- Effets thermiques
+ Thermal = FACT(statut ='o',
+ ThermalEffects = SIMP(typ='TXM', statut='o', into =['Non thermal', 'Thermal'] , defaut='Thermal', position='global' ),
+ blocNonThermalEffects = BLOC(condition = 'ThermalEffects == "Non thermal"',
+ ReferenceTemperature = SIMP(typ='R', statut='o', val_min=-273.15 ),
+ ), # fin bloc_NonThermal
+ bloc_ThermalEffects_ = BLOC(condition = 'ThermalEffects == "Thermal"',
+ ConductivityValueType = SIMP(typ='TXM', statut ='o', into = ['Value', 'Field'], defaut ='Value'),
+ blocCondValue = BLOC (condition = 'ConductivityValueType == "Value"',
+ Conductivity = SIMP(typ='R', statut ='o'),
+ ),
+ blocCondField = creeBlocPourLesFichiers('ConductivityValueType == "Field"', 'Conductivity', ListeFormats=listeFormatGenerique, FieldName='conductivityFieldName'),
+ #ActiveOnFlowEffect = ActiveOnFlowEffect(),
+ ),
+ ),# fin Fact Thermal
+
+# ---------------------- Scalaires
+
+ blocScalarFluidTurbulentOrLaminar = BLOC(condition = "(ComplexFluid == False and FlowNature == 'Turbulent') or (ComplexFluid == False and FlowNature == 'Laminar')",
+ Scalars = FACT(statut = 'o',
+ withScalars = SIMP(statut='o', typ=bool, defaut=False),
+ blocwithScalars = BLOC(condition = 'withScalars == True',
+ blocFlowNatureTurbulentForScalars = BLOC(condition = ' FlowNature == "Turbulent"',
+ AsTurbulenceForFlowDynamics = SIMP(statut='o', typ=bool, defaut=True),
+ BlocAsTFFD = BLOC(condition = "AsTurbulenceForFlowDynamics == False",
+ ScalarsTurbulenceModelling = prepareFactTurbulenceScalaire('o',),
+ ),
+ ),
+ blocThermalEffectsOn = BLOC(condition = ' ThermalEffects == "Thermal"',
+ TemperatureScalar = FACT(statut ='o',
+ #Name = SIMP(typ=(scalar,'createObject'), statut='o', defaut ='Temperature', homo='constant', position='reCalculeEtape'),
+ Name = SIMP(typ=(scalar,'createObject'), statut='o', defaut ='Temperature', homo='constant'),
+ SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ blocSourceTerm = prepareTermeSource('SourceTerm==True'),
+ TemperatureInitialisation = FACT(statut ='o',
+ OriginOfThermalFluxField = SIMP(statut='o', into =['Given', 'Interaction', 'to be simulated'], typ ='TXM'),
+ BlocGiven = creeBlocPourLesFichiers('OriginOfThermalFluxField == "Given"', 'Temperature', ('Med', 'cgns' ), FieldName='FieldName'),
+ ),# fin TemperatureInitialisation
+ ),# TemperatureScalar
+ ), # fin bloc_ThermalEffects_On
+ Scalar = FACT(statut = 'o', max ='**',
+ Name = SIMP(typ=(scalar,'createObject'), statut='o',),
+ DiffusivityValueType = SIMP(typ='TXM', statut ='o', into = ['Value', 'Field'], defaut ='Value'),
+ blocDiffValue = BLOC(condition = 'DiffusivityValueType == "Value"',
+ Diffusivity = SIMP(typ='R', statut ='o'),
+ ),
+ blocDiffField = creeBlocPourLesFichiers('DiffusivityValueType == "Field"', 'Diffusivity', ListeFormats=listeFormatGenerique, FieldName='DiffusivityFieldName'),
+ OriginOfScalar = SIMP(statut='o', into =['Given', 'Interaction', 'to be simulated'], typ ='TXM', defaut='to be simulated'),
+ blocSimulatedScalar = BLOC(condition = 'OriginOfScalar == "to be simulated"',
+ SourceTerm = SIMP(typ=bool, statut='o', defaut=False),
+ blocSourceTerm = prepareTermeSource('SourceTerm==True'),
+ Initialisation = FACT(statut ='o',
+ InitialisationOfScalar = SIMP(statut='o', into =['ValueInit', 'FileInit', 'InteractionInit'], typ ='TXM', defaut='ValueInit'),
+ BlocFileInit = creeBlocPourLesFichiers('InitialisationOfScalar == "FileInit"', 'ScalarInit', ListeFormats = listeFormatGenerique, FieldName='ScalarInitField'),
+ BlocInteractionInit = BLOC(condition = 'InitialisationOfScalar == "InteractionInit"',
+ InteractionName = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ BlocValueInit = BLOC(condition = 'InitialisationOfScalar == "ValueInit"',
+ ValueInit = SIMP (statut ='o', typ='R'),
+ ),
+ ),
+ ),
+ blocInteractionScalar = BLOC(condition = 'OriginOfScalar == "Interaction"',
+ InteractionName = SIMP(typ=interaction,statut='o'),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut='Create and choose suitable interaction'),
+ ),
+ blocGivenScalar = creeBlocPourLesFichiers('OriginOfScalar == "Given"', 'Scalar', ListeFormats = listeFormatGenerique, FieldName='ScalarField'),
+ EffectOnFlowDynamic = SIMP(typ='TXM', statut='o', into=[ 'Passive', 'Active'], defaut='Passive', ),
+ blocScalarActiveOnFlowDynamic = BLOC(condition = ' EffectOnFlowDynamic == "Active"',
+ ActiveOnFlowEffect = ActiveOnFlowEffect(),
+ ),
+ blocScalarFluidTurbulentAndNonComplexe = BLOC (condition = "FlowNature == 'Turbulent'",
+ ScalarFluxModel = prepareFactTurbulenceScalaire('f'),
+ ), # bloc_scalar_FluidTurbulentandNonComplexe
+ ),# Scalar
+ ),# blocwWithScalars
+ ),# Scalars
+ ), # fin FluidTurbulentandNonComplexe
+ # il faut une validation de coherence entre l existence de tous les turbulencesModelling
+ )# fin bloc_FluideMacro
+
+#----------------------------------------
+def ActiveOnFlowEffect(inTemperature=True):
+#----------------------------------------
+ return FACT(statut = 'o', max='**',
+ RelationType = SIMP(statut = 'o', into =['Equation Of State', 'Force-Flux Relation'], typ ='TXM'),
+ bloc_EOS = BLOC(condition = 'RelationType == "Equation Of State"',
+ TypeOfEquationOfState = SIMP(statut='o', into =['variable density', 'compressible'], typ ='TXM'),
+ ),
+ bloc_NonEOSAndSimple=BLOC(condition = 'RelationType == "Force-Flux Relation" and ComplexFluid == False',
+ TypeOfForceFluxRelation = SIMP(statut='o', into =['Viscosity', 'Diffusivity', 'Thermal Conductivity'], intoXML=['Viscosity', 'Diffusivity', 'Thermal Conductivity','Shear-stress closure', 'Scalar flux'], typ ='TXM', ),
+ blocViscosity=BLOC(condition = 'TypeOfForceFluxRelation == "Viscosity" ',
+ ViscosityLaw=SIMP(typ='TXM', statut = 'o', into=['law1', 'law2']),
+ ),
+ blocDiffusivity=BLOC(condition = 'TypeOfForceFluxRelation == "Diffusivity"',
+ DiffusivityLaw=SIMP(typ='TXM', statut = 'o', into=['law1', 'law2']),
+ ),
+ blocConductivity=BLOC(condition = 'TypeOfForceFluxRelation == "Thermal Conductivity"',
+ ConductivityLaw=SIMP(typ='TXM', statut = 'o', into=['law1', 'law2']),
+ ),
+ ),
+)
+
+#-----------------------------------------------------#
+def prepareBoundaryCondition():
+ return FACT(statut='o',max = '**', # max = nb de facette de bord
+ TypeOfBoundaryCondition = SIMP(statut='o', typ='TXM', into=['Inlet', 'Outlet', 'Symmetry','Periodicity', 'Wall', 'Free Surface'], ),
+
+ blocDesigneMesh = BLOC(condition = "SystemType == 'Continuum system'",
+ ApplyOnGroups = SIMP(statut ='o', typ=meshGroup, max='**', homo='SansOrdreNiDoublon',
+ filtre=( '(set(MeshIdentifiers).intersection( set(self.getParentsWithId().getListeUserASSD("MeshId")) ) != set()) ',
+ ( ('MeshIdentifiers', 'self.etape.getChild("blocModeleNumeriqueContinuum").getChild("NumericalModel")'), )
+ ),
+ ),
+ ),
+ blocDesigne_Shape = BLOC(condition = "SystemType == 'Classical particle system'",
+ #ApplyOnGroups = SIMP (statut ='o', typ=spatialRegion, max='**'
+ ApplyOnGroups = SIMP (statut ='o', typ=meshGroup, max='**', homo='SansOrdreNiDoublon',
+ filtre=( '(set(MeshIdentifiers).intersection( set(self.getParentsWithId().getListeUserASSD("MeshId")) ) != set()) ',
+ ( ('MeshIdentifiers', 'self.etape.getChild("blocModeleNumeriqueClassical").getChild("NumericalModel")'), )
+ ),
+ ),
+ ),
+
+ blocOnStateVariable = BLOC(condition = "TypeOfBoundaryCondition not in ['Wall',]",
+ ApplyOnStateVariable = SIMP (statut ='o', typ=stateVariable, max='**', homo='SansOrdreNiDoublon',
+ filtre=( 'etape in set(self.getEtapes()) ', (('etape', None),), ), #Il ne faut pas proposer les variables d'état des autres composants.
+ ), #PNPN A FAIRE : fenetreIhm='menuDeroulant'
+ ),
+ blocPeriodique = BLOC(condition = "TypeOfBoundaryCondition == 'Periodic'",
+ Direction = SIMP(statut='o', typ='TXM', into=['X','Y','Z', 'XYZ']),
+ ), # b_periodique
+ blocInlet = BLOC(condition = "TypeOfBoundaryCondition == 'Inlet'",
+ FormulationOfBoundary= SIMP(statut='o', typ='TXM', into=['Dirichlet','Neumann','Cauchy']),
+ blocDirichlet = BLOC(condition = 'FormulationOfBoundary == "Dirichlet"',
+ regles=(AU_MOINS_UN('InletProfile','IntegratedValue','IntegratedVectorValue',),
+ EXCLUS ('InletProfile','IntegratedValue','IntegratedVectorValue',), ),
+ Consigne = SIMP(statut ="o", homo="information", typ="TXM", defaut = "Choose between InletProfile,IntegratedValue,IntegratedVectorValue "),
+ InletProfile = SIMP (statut ='f', typ='TXM'),
+ IntegratedValue = SIMP (statut='f', typ='R'),
+ IntegratedVectorValue = FACT(statut='f',
+ U = SIMP (statut ='o', typ='R'),
+ V = SIMP (statut ='o', typ='R'),
+ W = SIMP (statut ='o', typ='R'),
+ ),
+ #PN : faire une regle
+ ),
+ blocNeumann = BLOC(condition = 'FormulationOfBoundary == "Neumann"',
+ Flux = SIMP (statut ='o', typ='TXM'),
+ ),
+ blocCauchy = BLOC(condition = 'FormulationOfBoundary == "Cauchy"',
+ ImposedFlux = SIMP (statut ='o', typ='TXM'),
+ _IntegratedValue = SIMP (statut='o', typ='R'),
+ ),
+ ), # b_inlet
+ blocWall = BLOC(condition = "TypeOfBoundaryCondition == 'Wall'",
+ VelocityAtBoundary = FACT(statut='o',
+ SlipVelocity = SIMP(statut='o', typ='R', defaut= 0.0),
+ WallMotion = FACT(statut='o',
+ U = SIMP (statut ='o', typ='R'),
+ V = SIMP (statut ='o', typ='R'),
+ W = SIMP (statut ='o', typ='R'),
+ ),
+ ),
+ LevelOfDescription = FACT(statut='o',
+ blocWall = BLOC(condition = "FlowNature == 'Turbulent'", ##JP+CH TODO : Choix des lois en fct du type du TurbulenceModelingType
+ WallFunction = SIMP(statut ='o', typ='TXM',
+ into=['No wall function','1-scale model (Log law)',
+ '2-scale model (Log law)','Scalable 2-scale model (Log law)',
+ ], defaut='No wall function', fenetreIhm='menuDeroulant'),
+ ),
+ ),
+ ), # b_Wall
+
+ ) # Boundary_Conditions
+
+
+# def prepareBoundaryCondition():
+# return FACT(statut='o',max = '**', # max = nb de facette de bord
+# ApplyOnStateVariable = SIMP (statut ='o', typ=stateVariable, ), #PNPN A FAIRE : fenetreIhm='menuDeroulant'
+# blocDesigneMesh = BLOC(condition = "SystemType == 'Continuum system'",
+# ApplyOnGroups = SIMP (statut ='o', typ=meshGroup, max='**', homo='SansOrdreNiDoublon'),
+# ),
+# blocDesigne_Shape = BLOC(condition = "SystemType == 'Classical particle system'",
+# ApplyOnCadGroups = SIMP (statut ='o', typ=spatialRegion, max='**'),
+# ),
+# TypeOfBoundaryCondition = SIMP(statut='o', typ='TXM', into=['Inlet', 'Outlet', 'Symmetry','Periodicity', 'Wall', 'Free Surface'], ),
+# blocPeriodique = BLOC(condition = "TypeOfBoundaryCondition == 'Periodic'",
+# Direction = SIMP(statut='o', typ='TXM', into=['X','Y','Z', 'XYZ']),
+# ), # b_periodique
+# blocInlet = BLOC(condition = "TypeOfBoundaryCondition == 'Inlet'",
+# FormulationOfBoundary= SIMP(statut='o', typ='TXM', into=['Dirichlet','Neumann','Cauchy']),
+# blocDirichlet = BLOC(condition = 'FormulationOfBoundary == "Dirichlet"',
+# regles=(AU_MOINS_UN('InletProfile','IntegratedValue','IntegratedVectorValue',),
+# EXCLUS ('InletProfile','IntegratedValue','IntegratedVectorValue',), ),
+# #Consigne = SIMP(statut ="o", homo="information", typ="TXM", defaut = "Choose between InletProfile,IntegratedValue,IntegratedVectorValue "),
+# InletProfile = SIMP (statut ='f', typ='TXM'),
+# IntegratedValue = SIMP (statut='f', typ='R'),
+# IntegratedVectorValue = FACT(statut='f',
+# x = SIMP (statut ='o', typ='R'),
+# y = SIMP (statut ='o', typ='R'),
+# z = SIMP (statut ='o', typ='R'),
+# ),
+# #PN : faire une regle
+# ),
+# blocNeumann = BLOC(condition = 'FormulationOfBoundary == "Neumann"',
+# Flux = SIMP (statut ='o', typ='TXM'),
+# ),
+# blocCauchy = BLOC(condition = 'FormulationOfBoundary == "Cauchy"',
+# ImposedFlux = SIMP (statut ='o', typ='TXM'),
+# IntegratedValue = SIMP (statut='o', typ='R'),
+# ),
+# ), # b_inlet
+# ) # Boundary_Conditions
+
+
+
+
+JdC = JDC_CATA (
+ #PN : TODO : regles = (AU_PLUS_UN('DataTransfer_Aspects',),),
+ code = 'Vimmp',
+ # faire un validateur qui verifie que si on active reactions chimiques il faut que les masses molaires soient rentrees
+)
+
+Component = OPER(nom='Component', sd_prod=composant,
+ SystemType = SIMP(typ='TXM', into=['Quantum system', 'Classical particle system', 'Continuum system'], statut='o',position='global'),
+ PhysicalDescription = FACT(statut = 'o',
+ blocFluideMacro = prepareBlocFluideMacro(),
+ blocCPS = prepareBlocCPS(),
+ ),
+ blocModeleNumeriqueQuantum = prepareBlocSystemType('Quantum system'),
+ blocModeleNumeriqueClassical = prepareBlocSystemType('Classical particle system'),
+ blocModeleNumeriqueContinuum = prepareBlocSystemType('Continuum system'),
+ BoundaryConditions = FACT(statut = 'o',
+ BoundaryCondition = prepareBoundaryCondition(),
+ )
+)
+
+Species = PROC(nom='Species',
+ Specie = FACT(statut='o', max ="**",
+ Name = SIMP(statut='o', typ=(especeChimique,'createObject') ),
+ MolarMass = SIMP(statut='f', typ='R',),
+ )
+)
+
+def monBlocInteractionTypeChamp ():
+ return BLOC (condition = '1 == 1' , # a distinguer selon les cas
+ fieldNameInOrigine = SIMP(typ='TXM', statut='o'),
+ fieldNameInDestination = SIMP(typ='TXM', statut='o'),
+ )
+
+def TousSelonLeTypeDeFormatDisponible(condition, prefixName=''):
+ TransfertType = SIMP(typ='TXM', statut='o', into =['File', 'Memory', 'CorbaObject'])
+ maListe = list(dictCodeFormat.keys())
+ dicoArgs={}
+ #index=0
+ #for Solv1 in maListe[index:]:
+ # for Solv2 in maListe[index:]:
+ # #print (Solv1,Solv2, calculCommun(Solv1, Solv2,dictCodeFormat))
+ # print ('PNPN attention changement de dictCodeFormat tant que getEficasAttribut n est pas correct')
+ # conditionSolv = 'TransfertType == "File" and getEficasAttribut(origine,"Solver")==Solv1 and getEficasAttribut(destination,"Solver")==Solv2' ,
+ # conditionSolv = 'TransfertType == "File"'
+ # monBlocFichier=creeBlocPourLesFichiers (conditionSolv, 'FileName', calculCommun(Solv1, Solv2,dictCodeFormat))
+ # dicoArgs['monBlocFichier'+str(index)]=monBlocFichier
+ # index=index+1
+ mesFormats=set()
+ for solv1 in dictCodeFormat.keys() :
+ for f in dictCodeFormat[solv1] : mesFormats.add(f)
+ conditionSolv='TransfertType == "File"'
+ BlocFichier=creeBlocPourLesFichiers (conditionSolv, prefixName, mesFormats, None)
+ dicoArgs['BlocFichier']=BlocFichier
+ monBlocChamp = BLOC(condition = "TransfertType=='File'", FieldName=SIMP(typ='TXM', statut='o'))
+ dicoArgs['monBlocChamp']=monBlocChamp
+ return BLOC(condition = condition,TransfertType=TransfertType, **dicoArgs)
+
+def SelonLeTypeDeFormatDisponibleMapper(condition):
+ TransferType = SIMP(typ='TXM', statut='o', into =['File', 'Memory', 'CorbaObject'])
+ maListe = list(dictCodeFormat.keys())
+ dicoArgs={}
+ index=0
+ for Solv1 in maListe[index:]:
+ for Solv2 in maListe[index:]:
+ #print (Solv1,Solv2, calculCommun(Solv1, Solv2,dictCodeFormat))
+ print ('PNPN attention changement de dictCodeFormat tant que getEficasAttribut n est pas correct')
+ conditionSolv = 'TransferType == "File" and getEficasAttribut(origine,"Solver")==Solv1 and getEficasAttribut(destination,"Solver")==Solv2' ,
+ conditionSolv = 'TransferType == "File"'
+ monBlocFichier=creeBlocPourLesFichiers (conditionSolv, '', calculCommun(Solv1, Solv2,dictCodeFormat),None)
+ dicoArgs['monBlocFichier'+str(index)]=monBlocFichier
+ index=index+1
+ BlocChamp = BLOC(condition = "TransferType=='File'", FieldName=SIMP(typ='TXM', statut='o'))
+ dicoArgs['BlocChamp'] = BlocChamp
+ return BLOC(condition = condition,TransferType=TransferType, **dicoArgs)
+
+Interpolator = OPER (nom= 'Interpolator',sd_prod=interpolator,
+ InterpolatorType=SIMP(statut='o', typ='TXM', into = list(dictInterpolatorFormat.keys())),
+ blocMedCoupling= BLOC(condition="InterpolatorType == 'Med Coupling'",
+ TargetMeshIdentifier = SIMP(statut ='o', typ = meshIdentifier,),
+ InterpolationType = SIMP(statut ='o', typ='TXM', into=['P0P0','P0P1','P1P1','P1P0'],),
+ ),
+)
+Converter = OPER (nom= 'Converter',sd_prod=converter)
+
+Interactions = PROC(nom='Interactions',
+
+ IOAspects = FACT(statut='o',
+
+ #WorkingDirectory = SIMP(statut='o', typ='Repertoire', defaut='/tmp'),
+
+ FileTransfer = FACT(statut='f', max='**',
+ TransferId = SIMP(statut='o', typ=(fileId,'createObject'),),
+ monBlocFormat = creeBlocPourLesFichiers('1', '', listeFormatGenerique, FieldName=None ),
+ ),
+ MemoryTransfer = FACT(statut='f', max='**',
+ TransferId = SIMP(statut='o', typ=(memoryId,'createObject'),),
+ ),
+ CorbaTransfer = FACT(statut='f', max='**',
+ TransferId = SIMP(statut='o', typ=(corbaId,'createObject'),),
+ ),
+ ),
+
+
+ Interaction = FACT(max = '**',
+ InteractionName = SIMP(statut='o', typ=(interaction,'createObject'),),
+ From = SIMP(typ=modeleNumDuCompo, statut='o'),
+ To = SIMP(typ=modeleNumDuCompo, statut='o'),
+ # ApplyOnStateVariable = SIMP(statut ='o', typ=stateVariable), #PNPN A FAIRE : fenetreIhm='menuDeroulant'
+ InvolvedStateVariable = SIMP(statut ='o', typ=stateVariable), #PNPN A FAIRE : Seulement du composant d'origine From
+ # monBloc_FFFF = BLOC (
+ # condition = 'getEficasAttribut(From,"ModelType") == "Fields" and getEficasAttribut(To,"ModelType") == "Fields"' ,
+ # TermeLE = SIMP(typ='TXM', statut='o', into = dictTermeLE['Fields','Fields'],fenetreIhm='menuDeroulant'),
+ # ),
+ # monBloc_DPDP = BLOC (
+ # condition = 'getEficasAttribut(From,"ModelType") == "Particles" and getEficasAttribut(To,"ModelType") == "Particles"' ,
+ # TermeLE = SIMP(typ='TXM', statut='o', into = dictTermeLE['Particles','Particles'],fenetreIhm='menuDeroulant'),
+ # ),
+ # monBloc_FFDP = BLOC (
+ # condition = 'getEficasAttribut(From,"ModelType") == "Fields" and getEficasAttribut(To,"ModelType") == "Particles"' ,
+ # TermeLE = SIMP(typ='TXM', statut='o', into = dictTermeLE['Fields','Particles'],fenetreIhm='menuDeroulant'),
+ # ),
+ # monBloc_DPFF = BLOC (
+ # condition = 'getEficasAttribut(From,"ModelType") == "Particles" and getEficasAttribut(To,"ModelType") == "Fields"' ,
+ # TermeLE = SIMP(typ='TXM', statut='o', into = dictTermeLE['Particles','Fields'],fenetreIhm='menuDeroulant'),
+ # ),
+ InteractionConfiguration = FACT(statut='o',
+
+ OutputId = SIMP(statut='o',typ=(transferId,),),
+ FieldName=SIMP(typ='TXM', statut='o'),
+ # ComponentProduction = FACT(statut='o',
+ # monBlocFormat = TousSelonLeTypeDeFormatDisponible("1", 'ComponentProduction' ),
+ # ),
+ # ),
+ #CouplingMode = SIMP(typ='TXM', statut='o', into =['Direct', 'DataProcessing', 'Conversion']),
+ CouplingMode = SIMP(typ='TXM', statut='o', into =['Direct', 'DataProcessing']),
+ #monBlocDirect = TousSelonLeTypeDeFormatDisponible("CouplingMode=='Direct'" ),
+
+ monBlocDataProcessing = BLOC (condition = "CouplingMode=='DataProcessing'",
+ DataProcessingNode = FACT(min=1, max='**', statut ='o',
+ Tool = SIMP(typ=mapper, statut ='o'),
+ OutputId = SIMP(statut='o',typ=(transferId,),),
+ FieldName = SIMP(typ='TXM', statut='o'),
+ monBlocInterpolator = BLOC (condition = "(Tool != None) and (isinstance(Tool,interpolator))",
+ FieldNature = SIMP(typ='TXM', statut='o', into=['ExtensiveMaximum', 'IntensiveMaximum',
+ 'ExtensiveConservation', 'IntensiveConservation']), #PN: DICO pour le into avec key==Tool
+ ),
+ ),
+ ), #fin monBlocDataProcessing
+ ), #fin InteractionConfiguration
+ ),
+)
+
+
+
+EnvironementAspects = PROC(nom ="EnvironementAspects",
+ WorkflowName = SIMP(statut='o', typ='TXM', defaut='MyStudyCasename'), #PN: -> path
+ WorkingDirectory = SIMP(statut='o', typ='Repertoire', defaut='/tmp'),
+)
+
+#Le dictionnaire dict_condition est un dictionnaire utilisé par eficas
+# pour les position='global_jdc' et position='inGetAttribut'
+dict_condition={
+'ChoiceOfApproach': ('Interactions', 'Component'),
+'Interactions' : ( 'Component'),
+}
+
+TemporalAspects = PROC(nom ="TemporalAspects",
+ Simulated_Time_Laps = FACT(statut='o', max='**',
+ name = SIMP(statut='o', typ=(simulatedTime,'createObject'),),
+ initialTime = SIMP(statut='o', typ='R'),
+ finalTime = SIMP(statut='o', typ='R'),
+ timeDiscretization = SIMP(statut ='o', typ = 'TXM', into = ['Constant Time Step', 'Varying Time Step']),
+ bloc_Constant = BLOC (condition = 'timeDiscretization == "Constant Time Step"',
+ constantTimeStep = SIMP (statut ='o', typ = 'R'),
+ ),
+ bloc_Varying = BLOC (condition = 'timeDiscretization == "Varying Time Step"',
+ CFLNumberCriteria = SIMP (statut ='o', typ = 'R'),
+ FourierNumberCriteria = SIMP (statut ='o', typ = 'R'),
+ ),
+ ),
+)
+
+
+
+
+#
+# -----------------------------------------
+SpatialAspects = PROC(nom='SpatialAspects',
+# -----------------------------------------
+ regles = (AU_MOINS_UN('SystemGeometry', 'SpatialDiscretization'),),
+
+ SystemGeometry = FACT(statut='f', max='**',
+ SystemGeometryName = SIMP(statut='o', typ=(systemGeometry, 'createObject'),),
+ Shape = FACT(statut ='o', max='**',
+ ShapeIdentifier = SIMP(statut='o', typ=(cadShape,'createObject'),max='**',),
+ ShapeNature = SIMP(statut='o', typ='TXM', into=['Typical Geometry', 'CAD']),
+
+ blocShape = BLOC(condition = 'Shape_Nature == "Typical Geometry"',
+ Box = SIMP(statut='o', typ='TXM', into=['Cube', 'Sphere','Cylinder'] ),
+ blocCube = BLOC(condition = 'Box == "Cube"',
+ #Taille_Box_Englobante = SIMP(statut='o', typ='R', max=3, min =3)
+ # derait etre un Tuple(3) mais a faire apres la projection
+ #Size_Of_Bounding_Box = SIMP(statut='o', typ=Tuple(3), validators=VerifTypeTuple(('R','R','R'),),)
+ Size_Of_Bounding_Box = SIMP(statut='o', typ='R', max=3, min=3, ),
+ ), # fin blocCube
+ blocBoule = BLOC(condition = 'Box == "Sphere"',
+ Center = SIMP(statut='o', typ='R', max=3, min =3),
+ ),# fin b_Boule
+ blocCylinder = BLOC(condition = 'Box == "Cylinder"',
+ Heigth = SIMP(statut="o", typ='R', val_min=0.0, ang='Nanotube length [m]'),
+ ),# fin blocCylinder
+ blocBouleOuCylinder = BLOC(condition = 'Box == "Sphere" or Box == "Cylinder"',
+ Radius = SIMP(statut='o', typ='R', val_min=0.0, ang='radius length [m]') ,
+ ),# fin blocBouleOuCylinder
+ ), # fin blocShape
+ blocCAO = creeBlocPourLesFichiers("Shape_Nature == 'CAD'",'Domain', ['txt','I-deas', 'Gmsh', 'top',],None),
+ ), # fin Shape
+ ),# SystemGeometry
+
+ SpatialDiscretization = FACT(statut='f', max="**",
+ MeshId = SIMP(statut='o', typ=(meshIdentifier,'createObject')),
+ MeshName = SIMP(statut='o', typ='TXM'),
+ blocMeshFile = creeBlocPourLesFichiers("1 == 1",'Mesh',listeFormatGenerique,None),
+ GroupIdentifier = SIMP(statut='o', typ=(meshGroup,'createObject'),max='**',),
+ ),# SpatialDiscretization
+
+ BoundaryConstraints = FACT(statut = 'f',
+ Motion = FACT(statut='f',
+ MotionNature = SIMP(statut='o', typ='TXM', into=['Fixed boudary', 'Translational motion', 'Rotational motion', 'Scaling']),
+
+ blocTranslationalMotion = BLOC(condition = 'MotionNature == "Translational motion"',
+ TranslationVelocity = SIMP(statut='o', typ='R'),
+ boundaries = SIMP(statut='o', typ=spatialRegion,max='**', homo='SansOrdreNiDoublon' ),
+ ),
+ blocRotationalMotion = BLOC(condition = 'MotionNature == "Rotational motion"',
+ RotationRate = SIMP(statut='o', typ='R'),
+ boundaries = SIMP(statut='o', typ=spatialRegion,max='**', homo='SansOrdreNiDoublon' ),
+ ),
+ blocFixed = BLOC(condition = 'MotionNature == "Fixed boudary"',
+ boundaries = SIMP(statut='o', typ=spatialRegion,max='**', homo='SansOrdreNiDoublon'),
+ ),
+ ),
+#PN decrire page 28
+ Mapping = FACT(statut='f',
+ ),
+ ), # Boundary_Constraints
+) # fin Geometric_Domain
+
+TEXTE_NEW_JDC = "\
+Velocity=scalar()\
+"
