def test_LennardJones_6_12(self):
''' Test validation code using LennardJones_6_12 '''
# Material needs to be of shape of 2, both instance of Material
materials = (meta_class.Material(), meta_class.Material())
meta_obj = meta_class.LennardJones_6_12(material=materials)
# van_der_waals has to be a float
with self.assertRaises(TypeError):
# Casting None to float would raise an Error
meta_obj.van_der_waals_radius = None
# But this is fine
meta_obj.van_der_waals_radius = 1.0
# This is fine too, integer is upcasted to float
meta_obj.van_der_waals_radius = 1
self.assertIsInstance(meta_obj.van_der_waals_radius, float)
with self.assertRaises(ValueError):
# Has to be between two materials
meta_obj.material = [1, 3, 5]
with self.assertRaises(TypeError):
# The items of the sequence are not instance of Material
meta_obj.material = [1, 2]
def _convertMaterial(self, properties, mesh_name):
material = api.Material(name='material' + mesh_name)
materialData = material.data
for key, val in self.supportedMaterialProp:
if properties.GetValue(val):
materialData[key] = properties.GetValue(val)
material.data = materialData
return material
def generate_particles(smp_particles, smp_conditions, smp_materials, smp_pe):
# Define the particle containers.
particles = SParticles(name='particles')
# Fill the data ( particle )
data = DataContainer()
data[CUBA.RADIUS] = 5e-5
particles.add([
SParticle(
coordinates=(0.002, 0.004, 0.004),
data=DataContainer(data),
)
])
material = api.Material(name='material_' + particles.name)
materialData = material.data
materialData[CUBA.DENSITY] = 950.0
materialData[CUBA.YOUNG_MODULUS] = 35e9
materialData[CUBA.POISSON_RATIO] = 0.20
materialData[CUBA.FRICTION_COEFFICIENT] = 0.5773502691896257
# materialData[CUBA.PARTICLE_COHESION] = 0.0
materialData[CUBA.RESTITUTION_COEFFICIENT] = 0.02
materialData[CUBA.ROLLING_FRICTION] = 0.01
# materialData[CUBA.DEM_CONTINUUM_CONSTITUTIVE_LAW_NAME] = \
# "DEM_KDEMFabric"
# materialData[CUBA.DEM_DISCONTINUUM_CONSTITUTIVE_LAW_NAME] = \
# "DEM_D_Hertz_viscous_Coulomb"
# materialData[CUBA.CONTACT_TAU_ZERO] = 25
# materialData[CUBA.CONTACT_SIGMA_MIN] = 5
# materialData[CUBA.CONTACT_INTERNAL_FRICC] = 1
material.data = materialData
particlesData = particles.data
particlesData[CUBA.MATERIAL] = material.name
particles.data = particlesData
# Pack the return objects
smp_particles.append(particles)
smp_materials.append(material)
# Add the datasets that will be used by the wrapper
smp_pe.data[CUBA.DATA_SET].append(particles.name)
return {
'datasets': smp_particles,
'conditions': smp_conditions,
'materials': smp_materials,
'pe': smp_pe,
}
def test_whether_data_is_reference(self):
material = meta_class.Material()
data = material.data
self.assertEqual(data, material.data)
def test_NoseHooverBoundary(self):
material = meta_class.Material()
nose_hoover = meta_class.NoseHoover(material=[material])
self.assertIsNotNone(nose_hoover.data)
def test_Thermostat(self):
material = meta_class.Material()
thermostat = meta_class.Thermostat([material])
self.assertIsNotNone(thermostat.data)
def test_Coulomb(self):
meta_class.Coulomb(material=(meta_class.Material(),
meta_class.Material()))
# create cuds
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
# these are already by default set in CFD
cfd.rheology_model = api.NewtonianFluidModel(name='newtonian')
cfd.thermal_model = api.IsothermalModel(name='isothermal')
cfd.turbulence_model = api.LaminarFlowModel(name='laminar')
cfd.compressibility_model = api.IncompressibleFluidModel(name='incompressible')
# add to cuds
cuds.add([cfd])
# material
mat = api.Material(name='a_material')
mat.data[CUBA.DENSITY] = 1.0
mat.data[CUBA.DYNAMIC_VISCOSITY] = 1.0
cuds.add([mat])
# time setting
sim_time = api.IntegrationTime(name='simulation_time',
current=0.0,
final=1.0,
size=0.01)
cuds.add([sim_time])
# solver parameter to write data
sp = api.SolverParameter(name='solver_parameters')
sp.data[CUBA.NUMBER_OF_PHYSICS_STATES] = 5
cuds.add([sp])
# create cuds
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
# these are already by default set in CFD
cfd.rheology_model = api.NewtonianFluidModel(name='newtonian')
cfd.thermal_model = api.IsothermalModel(name='isothermal')
cfd.turbulence_model = api.LaminarFlowModel(name='laminar')
cfd.compressibility_model = api.IncompressibleFluidModel(name='incompressible')
# add to cuds
cuds.add([cfd])
# materials
water = api.Material(name='water')
water.data[CUBA.DENSITY] = 1000.0
water.data[CUBA.DYNAMIC_VISCOSITY] = 0.001
cuds.add([water])
air = api.Material(name='air')
air.data[CUBA.DENSITY] = 1.0
air.data[CUBA.DYNAMIC_VISCOSITY] = 1.0e-5
cuds.add([air])
# surface tension
st = api.SurfaceTensionRelation(material=[water, air],
surface_tension=72.86e-3)
cuds.add([st])
def test_PairPotential(self):
meta_class.PairPotential(material=(meta_class.Material(),
meta_class.Material()))
def test_Neumann(self):
meta_class.Neumann(material=meta_class.Material())
def test_MaterialRelation(self):
meta_class.MaterialRelation(material=(meta_class.Material(),
meta_class.Material()))
def test_InteratomicPotential(self):
meta_class.InteratomicPotential(material=(meta_class.Material(),
meta_class.Material()))
def test_DissipationForce(self):
meta_class.DissipationForce(material=(meta_class.Material(),
meta_class.Material()))
def test_Dirichlet(self):
meta_class.Dirichlet(material=meta_class.Material())
def test_CoulombFrictionForce(self):
# CoulombFrictionForce is a material relation
# material should be a sequence of Material (any number)
meta_class.CoulombFrictionForce(material=(meta_class.Material(),
meta_class.Material()))
def setUp(self):
case_name = "simplemeshIO"
mesh_name = "simplemeshIO_mesh"
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
cuds.add([cfd])
self.sim_time = api.IntegrationTime(name='simulation_time',
current=0.0,
final=1.0,
size=0.5)
cuds.add([self.sim_time])
mat = api.Material(name='a_material')
mat._data[CUBA.DENSITY] = 1.0
mat._data[CUBA.DYNAMIC_VISCOSITY] = 1.0
cuds.add([mat])
vel_inlet = api.Dirichlet(mat, name='vel_inlet')
vel_inlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_inlet._data[CUBA.VELOCITY] = (0.1, 0, 0)
pres_inlet = api.Neumann(mat, name='pres_inlet')
pres_inlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_outlet = api.Neumann(mat, name='vel_outlet')
vel_outlet._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_outlet = api.Dirichlet(mat, name='pres_outlet')
pres_outlet._data[CUBA.VARIABLE] = CUBA.PRESSURE
pres_outlet._data[CUBA.PRESSURE] = 0.0
vel_walls = api.Dirichlet(mat, name='vel_walls')
vel_walls._data[CUBA.VARIABLE] = CUBA.VELOCITY
vel_walls._data[CUBA.VELOCITY] = (0, 0, 0)
pres_walls = api.Neumann(mat, name='pres_walls')
pres_walls._data[CUBA.VARIABLE] = CUBA.PRESSURE
vel_frontAndBack = api.EmptyCondition(name='vel_frontAndBack')
vel_frontAndBack._data[CUBA.VARIABLE] = CUBA.VELOCITY
pres_frontAndBack = api.EmptyCondition(name='pres_frontAndBack')
pres_frontAndBack._data[CUBA.VARIABLE] = CUBA.PRESSURE
inlet = api.Boundary(name='inlet', condition=[vel_inlet, pres_inlet])
walls = api.Boundary(name='walls', condition=[vel_walls, pres_walls])
outlet = api.Boundary(name='outlet',
condition=[vel_outlet, pres_outlet])
frontAndBack = api.Boundary(
name='frontAndBack',
condition=[vel_frontAndBack, pres_frontAndBack])
cuds.add([inlet, walls, outlet, frontAndBack])
corner_points = [(0.0, 0.0, 0.0), (5.0, 0.0, 0.0), (5.0, 5.0, 0.0),
(0.0, 5.0, 0.0), (0.0, 0.0, 1.0), (5.0, 0.0, 1.0),
(5.0, 5.0, 1.0), (0.0, 5.0, 1.0)]
self.mesh_path = tempfile.mkdtemp()
mesh = create_quad_mesh(self.mesh_path, mesh_name, corner_points, 5, 5,
5)
cuds.add([mesh])
self.cuds = cuds
self.sim = Simulation(cuds,
'OpenFOAM',
engine_interface=EngineInterface.FileIO)
self.mesh_in_cuds = self.cuds.get_by_name(mesh_name)
def test_SjkrCohesionForce(self):
meta_class.SjkrCohesionForce(material=(meta_class.Material(),
meta_class.Material()))
# time setting
sim_time = api.IntegrationTime(name='simulation_time',
current=0.0,
final=640.0,
size=0.1)
cuds.add([sim_time])
# create computational mesh
mesh = foam_controlwrapper.create_block_mesh(tempfile.mkdtemp(), mesh_name,
dahl_mesh.blockMeshDict)
cuds.add([mesh])
# materials
sludge = api.Material(name='sludge')
sludge.data[CUBA.DENSITY] = 1900.0
sludge.data[CUBA.DYNAMIC_VISCOSITY] = 0.01
cuds.add([sludge])
water = api.Material(name='water')
water.data[CUBA.DENSITY] = 1000.0
water.data[CUBA.DYNAMIC_VISCOSITY] = 1.0e-3
cuds.add([water])
# mixture model
mm = api.MixtureModel(name='mixture')
mm.disperse = cuds.get_by_name('sludge').uid
cuds.add([mm])
# use Bingham plastic for sludge rheology model
def test_SurfaceTensionRelation(self):
meta_class.SurfaceTensionRelation(material=(meta_class.Material(),
meta_class.Material()))
case_name = 'aqueous_foam'
mesh_name = 'aqueous_foam_mesh'
cuds = CUDS(name=case_name)
# physics model
cfd = api.Cfd(name='default model')
# these are already bt default set in CFD
cfd.thermal_model = api.IsothermalModel(name='isothermal')
cfd.turbulence_model = api.LaminarFlowModel(name='laminar')
cfd.compressibility_model = api.IncompressibleFluidModel(name='incompressible')
# material
foam = api.Material(name='foam')
foam.data[CUBA.DENSITY] = 250.0
foam.data[CUBA.DYNAMIC_VISCOSITY] = 4.37
cuds.add([foam])
# use Herschel Bulkley viscosity model for aqueous foam
hb = api.HerschelBulkleyModel(name='foam_rheology')
hb.initial_viscosity = 0.01748
hb.relaxation_time = 0.0148
hb.linear_constant = 0.00268
hb.power_law_index = 0.5
hb.material = cuds.get_by_name('foam').uid
cfd.rheology_model = hb
cuds.add([cfd])
def test_Berendsen(self):
material = meta_class.Material()
berendsen = meta_class.Berendsen(material=[material])
self.assertIsNotNone(berendsen.material)
def generate_fibers(smp_particles, smp_conditions, smp_materials, smp_pe):
# Define the particle containers.
fibers = SParticles(name='fibers')
# Fill the data ( fiber )
data = DataContainer()
data[CUBA.RADIUS] = 1e-5
fiberCoords = [
(0.1166666666666666685, 0.5083333333333333037, 0.5166666666666666075),
(0.1499999999999999944, 0.5250000000000000222, 0.5500000000000000444),
(0.1833333333333333481, 0.5416666666666667407, 0.5833333333333332593),
(0.2166666666666666741, 0.5583333333333333481, 0.6166666666666666963),
(0.2500000000000000000, 0.5749999999999999556, 0.6499999999999999112),
(0.2833333333333333259, 0.5916666666666665630, 0.6833333333333333481)
]
fibers.add([
SParticle(
coordinates=fiberCoords[0],
data=DataContainer(data),
),
SParticle(
coordinates=fiberCoords[1],
data=DataContainer(data),
),
SParticle(
coordinates=fiberCoords[2],
data=DataContainer(data),
),
SParticle(
coordinates=fiberCoords[3],
data=DataContainer(data),
),
SParticle(
coordinates=fiberCoords[4],
data=DataContainer(data),
),
SParticle(
coordinates=fiberCoords[5],
data=DataContainer(data),
)
])
material = api.Material(name='material_' + fibers.name)
materialData = material.data
materialData[CUBA.DENSITY] = 1050.0
materialData[CUBA.YOUNG_MODULUS] = 1.0e9
materialData[CUBA.POISSON_RATIO] = 0.20
materialData[CUBA.FRICTION_COEFFICIENT] = 0.9999999999999999
# materialData[CUBA.PARTICLE_COHESION] = 0.0
materialData[CUBA.RESTITUTION_COEFFICIENT] = 0.02
materialData[CUBA.ROLLING_FRICTION] = 0.01
# materialData[CUBA.FABRIC_COEFFICIENT] = 0.1
# materialData[CUBA.DEM_CONTINUUM_CONSTITUTIVE_LAW_NAME] = \
# "DEM_KDEMFabric"
# materialData[CUBA.DEM_DISCONTINUUM_CONSTITUTIVE_LAW_NAME] = \
# "DEM_D_Hertz_viscous_Coulomb"
# materialData[CUBA.CONTACT_TAU_ZERO] = 25
# materialData[CUBA.CONTACT_SIGMA_MIN] = 5
# materialData[CUBA.CONTACT_INTERNAL_FRICC] = 1
material.data = materialData
fibersData = fibers.data
fibersData[CUBA.MATERIAL] = material.name
fibers.data = fibersData
# Pack the return objects
smp_particles.append(fibers)
smp_materials.append(material)
# Add the datasets that will be used by the wrapper
smp_pe.data[CUBA.DATA_SET].append(fibers.name)
return {
'datasets': smp_particles,
'conditions': smp_conditions,
'materials': smp_materials,
'pe': smp_pe,
}
def test_TemperatureRescaling(self):
material = meta_class.Material()
temp_rescaling = meta_class.TemperatureRescaling(material=[material])
self.assertIsNotNone(temp_rescaling.data)
