def run(self,transient = None):
"""
Simulation, steady or transient;
The default flow solver is elmer.
The simulation is supposed to be a steady one by default.
"""
if self.flowComponent == None:
#
# is it possible ?
#
self.flowComponent = ElmerHydro(self.mesh)
pass
if not transient:
#raw_input(" running elmer ")
self.flowComponent.run()
pass
else:
self.flowComponent.launch()
#dir(self.flowComponent)
self.flowComponent.run()
pass
def setComponent(self, componentName):
if type(componentName) == StringType:
self.componentName = componentName.lower()
from elmerhydro import ElmerHydro
if (self.componentName != "elmer") and (self.componentName !=
"openfoam"):
self.componentName == "elmer"
self.flowComponent = ElmerHydro(
self.mesh) # by default the problem is set to saturated
if (self.timeStepIntervals == None
and self.calculationTimes != None):
self.timeStepIntervals = len(self.calculationTimes) - 1
self.timeStepSizes = [
self.calculationTimes[i + 1] - self.calculationTimes[i]
for i in range(len(self.calculationTimes) - 1)
]
pass
self.flowComponent.setTimeDiscretisation(
self.timeStepIntervals, self.timeStepSizes)
self.flowComponent.setSimulationKind(self.simulationType)
raise Warning(" the default hydraulic are elmer or openfoam "+\
", other hydraulic tools could be introduced in the near future")
elif (self.componentName == "openfoam"):
from openfoamhydro import OpenfoamHydro
self.saturation = "saturated"
#self.simulationType = "Steady"
self.componentName == "openfoam"
self.flowComponent = OpenfoamHydro(self.problem, self.mesh,
self.saturation)
self.flowComponent.setSimulationType(self.simulationType)
#
# we check the dimensionality of the mesh
#
if self.mesh.spaceDimensions != 3:
raise Warning("Openfoam is handling only 3D meshes.")
pass
else:
self.componentName == "elmer"
self.flowComponent = ElmerHydro(self.mesh, self.saturation)
if (self.timeStepIntervals == None
and self.calculationTimes != None):
self.timeStepIntervals = len(self.calculationTimes) - 1
self.timeStepSizes = [
self.calculationTimes[i + 1] - self.calculationTimes[i]
for i in range(len(self.calculationTimes) - 1)
]
pass
elif (self.timeStepIntervals != None):
self.flowComponent.setTimeDiscretisation(
self.timeStepIntervals, self.timeStepSizes)
pass
self.flowComponent.setSimulationKind(self.simulationType)
print(" the flow component has been set")
pass
print(" the flow component has been set: %s" %
(self.componentName))
pass
else:
raise Warning(" the default hydraulic has been fixed to elmer ")
self.componentName = "elmer"
pass
#
self.flowComponent.setBodyList(self.problem.getRegions())
#
self.flowComponent.setBoundaryConditions(self.boundaryConditions)
#
# Density
#
# print " self.flowComponent",self.flowComponent
# raw_input()
if self.density: self.flowComponent.setDensity(self.density)
#
# print " dbg hm we set the ic "
self.flowComponent.setInitialConditions(self.initialConditions)
#
# Gravity
#
if self.gravity:
# print " dbg hm we set the gravity "
self.flowComponent.setGravity(self.gravity)
pass
#
# Permeability
#
if self.permeability:
self.flowComponent.setPermeability(self.permeability)
pass
#
# Intrinsic Permeability
#
if self.intrinsicPermeability:
self.flowComponent.setIntrinsicPermeability(
self.intrinsicPermeability)
pass
#
# Porosity
#
if self.hydraulicPorosity:
self.flowComponent.setPorosity(self.hydraulicPorosity)
pass
elif self.porosity:
self.flowComponent.setPorosity(self.porosity)
pass
#
# Viscosity
#
if self.viscosity:
self.flowComponent.setViscosity(self.viscosity)
pass
#
# Matrix compressibility factor
#
if self.matrixCompressibilityFactor:
self.flowComponent.setMatrixCompressibilityFactor(
self.matrixCompressibilityFactor)
pass
if self.liquidResidualSaturation:
self.flowComponent.setLiquidResidualSaturation(
self.liquidResidualSaturation)
pass
#
# Source
#
if self.sourceField:
self.flowComponent.setSource(self.sourceField)
pass
#
# time steps treatment
#
if self.simulationType == "Transient":
self.flowComponent.calcTimesDico[
'finalTime'] = self.problem.calculationTimes[-1]
pass
class HydraulicModule(object):
"""
For saturated flows, openfoam and elmer can be used in a generic way.
This means, openfoam and elmer can be used to simulate saturated flows.
The hydraulic module can treat (un)saturated flows. Only one software is relevant for unsaturated flows: Elmer.
An unsaturated flow solver (Richards) is running.
For openfoam; only 3D meshes are relevant. It means that a checking is made of the mesh relevance for openfoam. If the mesh isn't 3D, a warning is raised.
"""
def __init__(self):
self.calculationTimes = None
self.density = None
self.gravity = None
self.hydraulicPorosity = None
self.intrinsicPermeability = None
self.liquidResidualSaturation = None
self.matrixCompressibilityFactor = None
self.permeability = None
self.porosity = None
self.saturation = "saturated"
self.simulationType = "Steady"
self.timeStepIntervals = None
self.sourceField = None
self.viscosity = None
#
# All physical parameters relevant to the phenomenology are treated here
#
# The hydraulic module can treat saturated flows and
#
# in the near future unsaturated flows, transient or steady.
#
# Boundary conditions are defined through head or pressure boundary conditions. Nevertheless,
# they are applied as head boundary conditions
#
# module.setData(my_problem, dicobc,dicoic)
#
def setData(self, problem,\
mesh = None,\
dicobc = None,\
dicoic = None):
self.expectedOutput = None
self.problem = problem
self.saturation = self.problem.saturation
if not isinstance(problem, HydraulicProblem):
raise Exception(
" the problem must be an hydraulic problem (SaturatedHydraulicProblem or an unSaturatedHydraulicProblem)"
)
self.problemName = problem.getName()
self.regions = problem.getRegions()
self.mesh = mesh
#
# Permeability
#
# The permeability is a real for the moment,
# depending only on parameters to be treated
# We introduce here a dictionnary,
# to handle in the near future the "ad hoc" version.
#
mediumProperties = {
"density": None,
"gravity": None,
"HydraulicConductivity": None,
"intrinsicPermeability": None,
"permeability": None,
"viscosity": None,
}
#
# regionProperties is a dictionnary. It is made of a list of tuples, each region is associated to a dictionnary,
# the dictionnary containing the medium region properties.
#
self.regionProperties = {}
#
self.times = problem.getCalculationTimes()
#
if self.times == None:
self.simulationType = "Steady"
pass
else:
self.simulationType = "Transient"
pass
#
self.boundaryConditions = {}
#
self.initialConditions = {}
#
# we fill the medium properties dictionnary
#
# Density
self.density = problem.getDensity()
# Gravity
self.gravity = problem.getGravity()
# gravity effect
#viscosity
self.viscosity = problem.getViscosity()
self.intrinsicPermeability = problem.getIntrinsicPermeability()
#
for reg in self.regions:
regionName = reg.support.getBodyName()
material = reg.getMaterial()
self.regionProperties[regionName] = mediumProperties
if not self.problem.saturation:
permeability = material.getPermeability()
pass
else:
permeability = None
pass
hydraulicConductivity = material.getHydraulicConductivity()
intrinsicPermeability = material.getIntrinsicPermeability()
self.regionProperties[regionName]["density"] = self.density
self.regionProperties[regionName]["gravity"] = self.gravity
self.regionProperties[regionName][
"HydraulicConductivity"] = hydraulicConductivity
self.regionProperties[regionName][
"intrinsicPermeability"] = intrinsicPermeability
self.regionProperties[regionName]["permeability"] = permeability
self.regionProperties[regionName]["viscosity"] = self.viscosity
pass
# print self.regionProperties
#
# We treat here the boundary conditions.
# We establish a dictionnary independant from
# the tool to be treated.
#
boundarySpecification = {
"typ": None,
"head": None,
"pressure": None,
"temperature": None,
"material": None,
}
boundaryconditions = problem.getBoundaryConditions()
from vector import V as Vector
#
#
#
ind = 0
for boundarycondition in boundaryconditions:
#print ("dbh hydraulicmodule: ", type(boundarycondition), boundarycondition.__class__.__name__)
#print ("debug hydraulicmodule type value: ", boundarycondition.value, boundarycondition.getValue().__class__.__name__)
#raw_input("debug "+__name__)
value = boundarycondition.getValue()
print("debug type value: ", value.__class__.__name__,
boundarycondition.value)
boundaryName = boundarycondition.getSupport().getBodyName()
#print boundaryName
#print " cont ",boundarycondition.boundary.support.body[0]
#print " cont0 ",type(boundarycondition.boundary.support)
#print (value)
#print (boundarycondition.getType())
#raw_input(__name__)
#val = value.getValue()
self.boundaryConditions[ind] = { #"head":value.getValue(),\
"typ": boundarycondition.getType(),
"material": boundarycondition.getRegion().getMaterial(),
"boundaryName": boundaryName,
"ind": boundarycondition.getSupport().body[0]
}
print(" value type: ", __name__, type(value))
print(" value: ", __name__, value)
if type(value) is dict: print(" value dict: ", value.keys())
#raw_input(" hydraulicmodule debug of value")
if isinstance(value, Head):
self.boundaryConditions[ind]["head"] = value.getValue()
elif type(value) is dict and value.keys() == ["head"]:
self.boundaryConditions[ind]["head"] = value["head"]
elif isinstance(value, Pressure):
self.boundaryConditions[ind]["pressure"] = value.getValue()
elif type(value) is dict and value.keys() == ["pressure"]:
self.boundaryConditions[ind]["head"] = value["pressure"]
elif isinstance(
value, (ListType, TupleType, DictType)
): # the only allowed list or tuple is made of Pressure and Temperature
#print ("hydraulic module, we reach that point: ", value)
#raw_input(__name__)
if len(value) == 1:
self.boundaryConditions[ind]["pressure"] = value[
"pressure"]
pass
elif len(value) == 2:
self.boundaryConditions[ind]["pressure"] = value[
"pressure"]
self.boundaryConditions[ind]["temperature"] = value[
"temperature"]
ind += 1
pass
# self.boundaryConditions[boundaryName]["head"] = value.getValue()
# self.boundaryConditions[boundaryName]["typ"] = boundarycondition.getType()
# self.boundaryConditions[boundaryName]["material"] = boundarycondition.getRegion().getMaterial()
# print "D ",self.boundaryConditions[boundaryName]
# print self.boundaryConditions
#
# We treat here the initial conditions
#
initialconditions = problem.getInitialConditions()
for initialcondition in initialconditions:
#print ("dbg hydraulicmodule initial condition: ", initialcondition)
#raw_input("dbg hydraulicmodule initial condition")
#value = initialcondition.getValue()
value = initialcondition.value
initialConditionName = initialcondition.domain.getSupport(
).getBodyName()
# print " dbg hm ",initialConditionName
# print " dbg hm ",type(value)
# print " dbg hm ",value
# raw_input()
#self.initialConditions[initialConditionName] = {"head": value,\
# "material":initialcondition.getRegion().getMaterial(),
# "ind":initialcondition.getRegion().support.body[0]
# }
self.initialConditions[initialConditionName] = {
"material": initialcondition.getRegion().getMaterial(),
"ind": initialcondition.getRegion().support.body[0]
}
#print (type(value))
if type(value) is not DictType:
self.initialConditions[initialConditionName][
value.__class__.__name__.lower()] = value
#print (" value is not dict ", value.__class__.__name__.lower(), value)
else:
for val in value.keys():
self.initialConditions[initialConditionName][
val.lower()] = value[val]
pass
pass
#raw_input("initialconditions")
#
# We treat here the sources
#
pass
sourceList = problem.getSource()
sourceCtrl = 0
if sourceList:
from datamodel import Flowrate
sourceFlowrate = NumericZoneField('source', mesh, ["source"])
sourceList = toList(sourceList)
for source in sourceList:
value = source.getValue()
if isInstance(value, Flowrate):
sourceFlowrate.setZone(source.getZone(),
[value.getValue()])
sourceCtrl = 1
pass
pass
pass
if sourceCtrl:
self.sourceField = sourceFlowrate
pass
#
# We treat outputs: outputs -> list of dictionnary
#
if self.expectedOutput:
for eo in self.expectedOutput:
varnames = ['Pressure']
eo['varnames'] = varnames
pass
pass
def setComponent(self, componentName):
if type(componentName) == StringType:
self.componentName = componentName.lower()
from elmerhydro import ElmerHydro
if (self.componentName != "elmer") and (self.componentName !=
"openfoam"):
self.componentName == "elmer"
self.flowComponent = ElmerHydro(
self.mesh) # by default the problem is set to saturated
if (self.timeStepIntervals == None
and self.calculationTimes != None):
self.timeStepIntervals = len(self.calculationTimes) - 1
self.timeStepSizes = [
self.calculationTimes[i + 1] - self.calculationTimes[i]
for i in range(len(self.calculationTimes) - 1)
]
pass
self.flowComponent.setTimeDiscretisation(
self.timeStepIntervals, self.timeStepSizes)
self.flowComponent.setSimulationKind(self.simulationType)
raise Warning(" the default hydraulic are elmer or openfoam "+\
", other hydraulic tools could be introduced in the near future")
elif (self.componentName == "openfoam"):
from openfoamhydro import OpenfoamHydro
self.saturation = "saturated"
#self.simulationType = "Steady"
self.componentName == "openfoam"
self.flowComponent = OpenfoamHydro(self.problem, self.mesh,
self.saturation)
self.flowComponent.setSimulationType(self.simulationType)
#
# we check the dimensionality of the mesh
#
if self.mesh.spaceDimensions != 3:
raise Warning("Openfoam is handling only 3D meshes.")
pass
else:
self.componentName == "elmer"
self.flowComponent = ElmerHydro(self.mesh, self.saturation)
if (self.timeStepIntervals == None
and self.calculationTimes != None):
self.timeStepIntervals = len(self.calculationTimes) - 1
self.timeStepSizes = [
self.calculationTimes[i + 1] - self.calculationTimes[i]
for i in range(len(self.calculationTimes) - 1)
]
pass
elif (self.timeStepIntervals != None):
self.flowComponent.setTimeDiscretisation(
self.timeStepIntervals, self.timeStepSizes)
pass
self.flowComponent.setSimulationKind(self.simulationType)
print(" the flow component has been set")
pass
print(" the flow component has been set: %s" %
(self.componentName))
pass
else:
raise Warning(" the default hydraulic has been fixed to elmer ")
self.componentName = "elmer"
pass
#
self.flowComponent.setBodyList(self.problem.getRegions())
#
self.flowComponent.setBoundaryConditions(self.boundaryConditions)
#
# Density
#
# print " self.flowComponent",self.flowComponent
# raw_input()
if self.density: self.flowComponent.setDensity(self.density)
#
# print " dbg hm we set the ic "
self.flowComponent.setInitialConditions(self.initialConditions)
#
# Gravity
#
if self.gravity:
# print " dbg hm we set the gravity "
self.flowComponent.setGravity(self.gravity)
pass
#
# Permeability
#
if self.permeability:
self.flowComponent.setPermeability(self.permeability)
pass
#
# Intrinsic Permeability
#
if self.intrinsicPermeability:
self.flowComponent.setIntrinsicPermeability(
self.intrinsicPermeability)
pass
#
# Porosity
#
if self.hydraulicPorosity:
self.flowComponent.setPorosity(self.hydraulicPorosity)
pass
elif self.porosity:
self.flowComponent.setPorosity(self.porosity)
pass
#
# Viscosity
#
if self.viscosity:
self.flowComponent.setViscosity(self.viscosity)
pass
#
# Matrix compressibility factor
#
if self.matrixCompressibilityFactor:
self.flowComponent.setMatrixCompressibilityFactor(
self.matrixCompressibilityFactor)
pass
if self.liquidResidualSaturation:
self.flowComponent.setLiquidResidualSaturation(
self.liquidResidualSaturation)
pass
#
# Source
#
if self.sourceField:
self.flowComponent.setSource(self.sourceField)
pass
#
# time steps treatment
#
if self.simulationType == "Transient":
self.flowComponent.calcTimesDico[
'finalTime'] = self.problem.calculationTimes[-1]
pass
#
# to affect numerical parameters
#
def setParameter(self, *tuple, **dico):
if self.flowComponent:
self.flowComponent.setParameter(*tuple, **dico)
pass
else:
raise Exception(" You have to set the Hydraulic component solver")
#
def setTimeDiscretisation(self,
timeStepIntervals=None,
timeStepSizes=None):
"""
setting time steps through the number of time Steps or the size of time steps.
Every time, a real is used. It should become a list.
"""
if timeStepIntervals != None:
self.timeStepIntervals = timeStepIntervals
pass
elif timeStepSizes != None:
self.timeStepSizes = timeStepSizes
pass
else:
raise Warning(
"You should give at least an argument to the setTimeDiscretisation function"
)
if self.timeStepIntervals != None:
print("dbg hm ", self.timeStepIntervals)
print("dbg hm ", self.problem.calculationTimes[-1])
self.timeStepSizes = self.problem.calculationTimes[
-1] / self.timeStepIntervals
pass
else:
self.timeStepIntervals = self.problem.calculationTimes[
-1] / self.timeStepSizes
pass
setCalculationTimes = setTimeDiscretisation
def writeToFile(self):
pass
def getOutput(self, name, outputType=None):
"""
The velocity is read from the file HeVel.ep within the mesh file.
This file is issued from the successfull run of the two method,
Darcy and Flux
"""
#
# transient part
#
if self.simulationType == "Transient":
#
# charge
#
# raw_input(" trying to retrieve charge")
self.charge = self.flowComponent.essai.getCharge()
print(self.charge[0:10])
# raw_input(" trying to retrieve points")
self.points = self.flowComponent.essai.getCoordinates()
self.points = self.mesh.getNodesCoordinates()
#print self.points
# raw_input(" trying to retrieve velocity")
self.velocity = self.flowComponent.essai.getVelocity()
return self.points, self.charge, self.velocity
#
# steady part
#
if type(name) == StringType:
if (self.componentName == "elmer"):
if name.lower() == "velocity":
fileName = "./" + self.flowComponent.meshDirectoryName + "/" + "HeVel.ep"
if not os.path.isfile(fileName):
message = " problem with the velocity file: " + fileName
raise Exception(message)
return None
elif name.lower() == "watercontent":
fileName = "./" + "watercontent.vtu"
pass
velocityFile = open(fileName, 'r')
velocityFile.readline()
velocityFile.readline()
line = velocityFile.readline()
f = len(line) / 3
self.points = []
while "#group all" not in line:
#line = line.split()
#print " line ",line
#raw_input("line : ")
self.points.append([
float(line[0:17]),
float(line[17:34]),
float(line[34:53])
])
line = velocityFile.readline()
pass
while "#time" not in velocityFile.readline():
pass
line = velocityFile.readline()
physic = []
while len(line) > 1:
physic.append([float(line[0:17]),\
float(line[17:34]),\
float(line[34:51]),\
float(line[51:68])])
line = velocityFile.readline()
pass
self.charge = []
self.velocity = []
ind = 0
for iunknown in range(0, len(physic)):
a = physic[iunknown]
self.charge.append(a[0])
self.velocity.append([a[1], a[2], a[3]])
ind += 1
pass
pass
return self.points, self.charge, self.velocity
elif (self.componentName == "openfoam"):
self.points = self.mesh.getNodesCoordinates()
pressureFile = open("./1/p", 'r')
line = pressureFile.readline()
while "internalField" not in line:
line = pressureFile.readline()
pass
numberOfPoints = pressureFile.readline()
line = pressureFile.readline()
self.pressure = []
line = pressureFile.readline()
while ")" not in line:
self.pressure.append(float(line))
line = pressureFile.readline()
pass
#
velocityFile = open("./1/U", 'r')
line = velocityFile.readline()
while "internalField" not in line:
line = velocityFile.readline()
pass
numberOfPoints = velocityFile.readline()
line = velocityFile.readline()
self.velocity = []
line = velocityFile.readline()
while ")" not in line:
self.velocity.append(line)
line = velocityFile.readline()
pass
pass
return self.points, self.pressure, self.velocity
pass
def end(self):
"""simulation stop and clean"""
if self.flowComponent:
self.flowComponent.end()
pass
def getComponentName(self):
"""
to get the name of the component, that has been defined, if any
"""
if self.componentName:
return self.componentName
else:
raise Warning("No component name has been currently defined")
def getComponent(self):
"""
to get the component
"""
return self.flowComponent
def getHelp(self, func=None):
"""
That function is used to get some help on the
class and on relevant functions
Ex: getHelp() or getHelp(a.function)
"""
if func == None:
print(self.__doc__)
pass
else:
print(func.__doc__)
pass
def run(self, transient=None):
"""
Simulation, steady or transient;
The default flow solver is elmer.
The simulation is supposed to be a steady one by default.
"""
if self.flowComponent == None:
#
# Is it possible ? No
#
raise Exception(
" the flowcomponent solver has to be defined prior to the call of the run method"
)
if not transient:
#raw_input(" running elmer ")
self.flowComponent.run()
pass
else:
self.flowComponent.launch()
#dir(self.flowComponent)
self.flowComponent.run()
pass
def setInitialPermeability(self, permeabilityField):
"""
That function is used to set the initial permeability field.
"""
if self.flowComponent != None:
self.flowComponent.setpermeabilityfield(permeabilityField)
pass
else:
raise Exception(
" the flow component must be launched before trying to setup K "
)
def writeVelocityPlot(self):
"""
The velocity is plotted using the legacy format of vtk
"""
name = "velocity.vtk"
chargeFile = open(name, 'w')
chargeFile.write("%s\n" % ("# vtk DataFile Version 2.0"))
chargeFile.write("%s\n" % ("obtained via hydraulicmodule"))
chargeFile.write("%s\n" % ("ASCII"))
chargeFile.write("%s\n" % ("DATASET UNSTRUCTURED_GRID"))
chargeFile.write("%s %i %s\n" % ("POINTS", len(self.points), "double"))
dim = self.mesh.getSpaceDimensions()
if (dim == 2):
for ind in range(0, len(self.points)):
chargeFile.write("%15.8e %15.8e %15.8e\n"%(self.points[ind][0],\
self.points[ind][1],\
0.))
pass
pass
elif (dim == 3):
for ind in range(0, len(self.points)):
chargeFile.write("%15.8e %15.8e %15.8e\n"%(self.points[ind][0],\
self.points[ind][1],\
self.points[ind][2]))
pass
pass
else:
raise Exception(" error in mesh dimension ")
numberOfCells = self.mesh.getNumberOfCells()
connectivity = self.mesh.getConnectivity()
cellListSize = 0
for i in range(0, numberOfCells): # gmsh meshes: type of elements
gmshType = connectivity[i][1]
if gmshType == 1: # 2-node line
cellListSize += 3
pass
elif gmshType == 2: # 3-node triangles
cellListSize += 4
pass
elif gmshType == 3: # 4-node quadrangles
cellListSize += 5
pass
elif gmshType == 4: # 4-node tetrahedron
cellListSize += 5
pass
elif gmshType == 5: # 8-node hexahedrons
cellListSize += 9
pass
pass
chargeFile.write("CELLS %i %i\n" % (numberOfCells, cellListSize))
ind = 0
for cell in connectivity:
ind = cell[2] + 3
# print " ctm dbg cell ",vtkTyp,ind,cell," perm ",permutation[ind],permutation[ind+1],permutation[ind+2],permutation[ind+3]
#
vtkTyp = _vtkGmsh(cell[1])
if (vtkTyp == 3): # 2-node line
ind = cell[2] + 3
chargeFile.write("%i %i %i\n"%(
2,\
cell[ind]-1,\
cell[ind+1]-1)
)
pass
elif (vtkTyp == 5): # triangles
chargeFile.write("%i %i %i %i\n"%(
3,
cell[ind]-1,\
cell[ind+1]-1,\
cell[ind+2]-1)
)
pass
elif (vtkTyp == 9): # quadr
chargeFile.write("%i %i %i %i %i\n"%(
4,\
cell[ind]-1,\
cell[ind+1]-1,\
cell[ind+2]-1,\
cell[ind+3]-1)
)
pass
elif (vtkTyp == 10): # tetra
chargeFile.write("%i %i %i %i %i\n"%(
4,\
cell[ind]-1,\
cell[ind+1]-1,\
cell[ind+2]-1,\
cell[ind+3]-1)
)
pass
elif (vtkTyp == 12): # hexahedron
chargeFile.write("%i %i %i %i %i %i %i %i %i\n"%(
8,\
cell[ind]-1,\
cell[ind+1]-1,\
cell[ind+2]-1,\
cell[ind+3]-1,\
cell[ind+4]-1,\
cell[ind+5]-1,\
cell[ind+6]-1,\
cell[ind+7]-1)
)
pass
pass
chargeFile.write("%s %i\n" % ("CELL_TYPES", numberOfCells))
#
for i in range(0, numberOfCells):
gmshType = connectivity[i][1]
if (gmshType) == 1:
cellTyp = 3
pass
elif (gmshType) == 2:
cellTyp = 5
pass
elif (gmshType) == 3:
cellTyp = 9
pass
elif (gmshType) == 4:
cellTyp = 10
pass
elif (gmshType) == 5:
cellTyp = 12
pass
elif (gmshType) == 6:
cellTyp = 13
pass
elif gmshType == 7:
cellTyp = 14
pass
else:
raise Exception(" check gmshtype ")
chargeFile.write("%i\n" % (cellTyp))
chargeFile.write("%s %d\n" % ("POINT_DATA", len(self.points)))
chargeFile.write("%s\n" % ("VECTORS vectors float"))
for velocityComponent in self.velocity:
chargeFile.write(" %e %e %e\n " %
(velocityComponent[0], velocityComponent[1],
velocityComponent[2]))
chargeFile.write("%s\n" % ("SCALARS charge double"))
chargeFile.write("%s\n" % ("LOOKUP_TABLE default"))
#
chargeDataFile = open(
"./" + self.flowComponent.meshDirectoryName + "/" + "HeVel.dat",
'r')
line = chargeDataFile.readline()
while "Number Of Nodes" not in line:
line = chargeDataFile.readline()
#line.split()
nodesNumber = line.split()[-1]
while "Perm" not in line:
line = chargeDataFile.readline()
#
# We read the permutation
#
for i in range(int(nodesNumber)):
chargeDataFile.readline()
#
# We read the charge
#
for i in range(int(nodesNumber)):
chargeFile.write(" %15.10e\n " %
(float(chargeDataFile.readline())))
def setComponent(self,componentName):
if type(componentName) == StringType:
self.componentName = componentName.lower()
from elmerhydro import ElmerHydro
if (self.componentName!="elmer"):
self.componentName == "elmer"
self.flowComponent = ElmerHydro(self.mesh) # by default the problem is set to saturated
if (self.timeStepIntervals == None and self.calculationTimes != None):
self.timeStepIntervals = len(self.calculationTimes)-1
self.timeStepSizes = [self.calculationTimes[i+1]-self.calculationTimes[i] for i in range(len(self.calculationTimes)-1)]
self.flowComponent.setTimeDiscretisation(self.timeStepIntervals, self.timeStepSizes)
self.flowComponent.setSimulationKind(self.simulationType)
raise Warning(" the default hydraulic has been fixed to elmer"+\
", other hydraulic tools should be introduced in the near future")
else:
self.componentName == "elmer"
self.flowComponent = ElmerHydro(self.mesh, self.saturation)
if (self.timeStepIntervals == None and self.calculationTimes != None):
self.timeStepIntervals = len(self.calculationTimes)-1
self.timeStepSizes = [self.calculationTimes[i+1]-self.calculationTimes[i] for i in range(len(self.calculationTimes)-1)]
elif (self.timeStepIntervals != None):
self.flowComponent.setTimeDiscretisation(self.timeStepIntervals, self.timeStepSizes)
self.flowComponent.setSimulationKind(self.simulationType)
print(" the flow component has been set")
pass
else:
raise Warning(" the default hydraulic has been fixed to elmer ")
self.componentName = "elmer"
pass
#
#
#
# print "dbg setBodyList"
self.flowComponent.setBodyList(self.problem.getRegions())
#
#
#
# print " dbg hm we set the bic ",self.boundaryConditions
self.flowComponent.setBoundaryConditions(self.boundaryConditions)
#
# Density
#
# print " self.flowComponent",self.flowComponent
# raw_input()
if self.density: self.flowComponent.setDensity(self.density)
#
#
#
# print " dbg hm we set the ic "
self.flowComponent.setInitialConditions(self.initialConditions)
#
# Gravity
#
if self.gravity:
# print " dbg hm we set the gravity "
self.flowComponent.setGravity(self.gravity)
pass
#
# Permeability
#
if self.permeability:
self.flowComponent.setPermeability(self.permeability)
pass
#
# Intrinsic Permeability
#
if self.intrinsicPermeability:
self.flowComponent.setIntrinsecPermeability(self.intrinsicPermeability)
pass
#
# Porosity
#
if self.hydraulicPorosity:
self.flowComponent.setPorosity(self.hydraulicPorosity)
pass
elif self.porosity:
self.flowComponent.setPorosity(self.porosity)
pass
#
# Viscosity
#
if self.viscosity:
self.flowComponent.setViscosity(self.viscosity)
pass
#
# Matrix compressibility factor
#
if self.matrixCompressibilityFactor:
self.flowComponent.setMatrixCompressibilityFactor(self.matrixCompressibilityFactor)
pass
if self.liquidResidualSaturation:
self.flowComponent.setLiquidResidualSaturation(self.liquidResidualSaturation)
pass
#
# Source
#
if self.sourceField :
self.flowComponent.setSource(self.sourceField)
pass
#
# time steps treatment
#
if self.simulationType == "Transient":
self.flowComponent.calcTimesDico ['finalTime']= self.problem.calculationTimes[-1]
pass
class HydraulicModule:
"""
The hydraulic module can treat (un)saturated flows. Only one software is relevant: Elmer.
An unsaturated flow solver (Richards) is running.
"""
def __init__(self):
self.calculationTimes = None
self.density = None
self.gravity = None
self.hydraulicPorosity = None
self.intrinsicPermeability = None
self.liquidResidualSaturation = None
self.matrixCompressibilityFactor = None
self.permeability=None
self.porosity=None
self.saturation = "saturated"
self.simulationType = "Steady"
self.timeStepIntervals = None
self.sourceField = None
self.viscosity = None
#
# All physical parameters relevant to the phenomenology are treated here
#
# The hydraulic module can treat saturated flows and
#
# in the near future unsaturated flows, transient or steady.
#
# Boundary conditions are defined through head or pressure boundary conditions. Nevertheless,
# they are applied as head boundary conditions
#
# module.setData(my_problem, dicobc,dicoic)
#
def setData(self, problem,\
mesh = None,\
dicobc = None,\
dicoic = None):
self.expectedOutput = None
self.problem = problem
self.saturation = self.problem.saturation
if not isinstance(problem, HydraulicProblem):
raise Exception(" the problem must be an hydraulic problem (SaturatedHydraulicProblem or an unSaturatedHydraulicProblem)")
self.problemName = problem.getName()
self.regions = problem.getRegions()
self.mesh = mesh
#
# Permeability
#
# The permeability is a real for the moment,
# depending only on parameters to be treated
# We introduce here a dictionnary,
# to handle in the near future the "ad hoc" version.
#
mediumProperties = {
"density" : None,
"gravity" : None,
"HydraulicConductivity" : None,
"intrinsicPermeability" : None,
"permeability" : None,
"viscosity" : None,
}
#
# regionProperties is a dictionnary. It is made of a list of tuples, each region is associated to a dictionnary,
# the dictionnary containing the medium region properties.
#
self.regionProperties = {}
#
self.times = problem.getCalculationTimes()
#
if self.times == None:
self.simulationType = "Steady"
pass
else:
self.simulationType = "Transient"
pass
#
self.boundaryConditions = {}
#
self.initialConditions = {}
#
# we fill the medium properties dictionnary
#
# Density
self.density = problem.getDensity()
# Gravity
self.gravity = problem.getGravity()
# gravity effect
#viscosity
self.viscosity = problem.getViscosity()
#
for reg in self.regions:
regionName = reg.support.getBodyName()
material = reg.getMaterial()
self.regionProperties[regionName] = mediumProperties
if not self.problem.saturation:
permeability = material.getPermeability()
pass
else:
permeability = None
pass
hydraulicConductivity = material.getHydraulicConductivity()
intrinsicPermeability = material.getIntrinsicPermeability()
self.regionProperties[regionName]["density"] = self.density
self.regionProperties[regionName]["gravity"] = self.gravity
self.regionProperties[regionName]["HydraulicConductivity"] = hydraulicConductivity
self.regionProperties[regionName]["intrinsicPermeability"] = intrinsicPermeability
self.regionProperties[regionName]["permeability"] = permeability
self.regionProperties[regionName]["viscosity"] = self.viscosity
# print self.regionProperties
#
# We treat here the boundary conditions.
# We establish a dictionnary independant from
# the tool to be treated.
#
boundarySpecification = {
"typ" : None,
"head" : None,
"material" : None,
}
boundaryconditions = problem.getBoundaryConditions()
from vector import V as Vector
#
#
#
ind = 0
for boundarycondition in boundaryconditions:
#print type(boundarycondition),boundarycondition.__class__.__name__
#print "debug type value ",boundarycondition.getValue().__class__.__name__
value = boundarycondition.getValue()
#print "debug type value ",value.__class__.__name__
boundaryName = boundarycondition.getSupport().getBodyName()
## print boundaryName
# print " cont ",boundarycondition.boundary.support.body[0]
# print " cont0 ",type(boundarycondition.boundary.support)
# print type(value)
# print value.getValue()
# print boundarycondition.getType()
# raw_input(" hydraulic module")
val = value.getValue()
self.boundaryConditions[ind] = {"head":value.getValue(),\
"typ":boundarycondition.getType(),
"material":boundarycondition.getRegion().getMaterial(),
"boundaryName": boundaryName,
"ind":boundarycondition.getSupport().body[0]
}
ind+=1
# self.boundaryConditions[boundaryName]["head"] = value.getValue()
# self.boundaryConditions[boundaryName]["typ"] = boundarycondition.getType()
# self.boundaryConditions[boundaryName]["material"] = boundarycondition.getRegion().getMaterial()
# print "D ",self.boundaryConditions[boundaryName]
# print self.boundaryConditions
#
# We treat here the initial conditions
#
initialconditions = problem.getInitialConditions()
for initialcondition in initialconditions:
# print " dbg hm ",initialcondition
# print " dbg hm ",initialcondition.domain.getSupport()
value = initialcondition.getValue()
initialConditionName = initialcondition.domain.getSupport().getBodyName()
# print " dbg hm ",initialConditionName
# print " dbg hm ",type(value)
# print " dbg hm ",value
# raw_input()
self.initialConditions[initialConditionName] = { "head":value,\
"material":initialcondition.getRegion().getMaterial(),
"ind":initialcondition.getRegion().support.body[0]
}
#
# We treat here the sources
#
pass
sourceList = problem.getSource()
sourceCtrl = 0
if sourceList:
from datamodel import Flowrate
sourceFlowrate = NumericZoneField('source', mesh, ["source"])
sourceList = toList(sourceList)
for source in sourceList:
value = source.getValue()
if isInstance(value,Flowrate):
sourceFlowrate.setZone(source.getZone(), [value.getValue()])
sourceCtrl = 1
pass
pass
pass
if sourceCtrl:
self.sourceField = sourceFlowrate
pass
#
# We treat outputs: outputs -> list of dictionnary
#
if self.expectedOutput:
for eo in self.expectedOutput:
varnames=['Pressure']
eo['varnames'] = varnames
pass
pass
def setComponent(self,componentName):
if type(componentName) == StringType:
self.componentName = componentName.lower()
from elmerhydro import ElmerHydro
if (self.componentName!="elmer"):
self.componentName == "elmer"
self.flowComponent = ElmerHydro(self.mesh) # by default the problem is set to saturated
if (self.timeStepIntervals == None and self.calculationTimes != None):
self.timeStepIntervals = len(self.calculationTimes)-1
self.timeStepSizes = [self.calculationTimes[i+1]-self.calculationTimes[i] for i in range(len(self.calculationTimes)-1)]
self.flowComponent.setTimeDiscretisation(self.timeStepIntervals, self.timeStepSizes)
self.flowComponent.setSimulationKind(self.simulationType)
raise Warning(" the default hydraulic has been fixed to elmer"+\
", other hydraulic tools should be introduced in the near future")
else:
self.componentName == "elmer"
self.flowComponent = ElmerHydro(self.mesh, self.saturation)
if (self.timeStepIntervals == None and self.calculationTimes != None):
self.timeStepIntervals = len(self.calculationTimes)-1
self.timeStepSizes = [self.calculationTimes[i+1]-self.calculationTimes[i] for i in range(len(self.calculationTimes)-1)]
elif (self.timeStepIntervals != None):
self.flowComponent.setTimeDiscretisation(self.timeStepIntervals, self.timeStepSizes)
self.flowComponent.setSimulationKind(self.simulationType)
print(" the flow component has been set")
pass
else:
raise Warning(" the default hydraulic has been fixed to elmer ")
self.componentName = "elmer"
pass
#
#
#
# print "dbg setBodyList"
self.flowComponent.setBodyList(self.problem.getRegions())
#
#
#
# print " dbg hm we set the bic ",self.boundaryConditions
self.flowComponent.setBoundaryConditions(self.boundaryConditions)
#
# Density
#
# print " self.flowComponent",self.flowComponent
# raw_input()
if self.density: self.flowComponent.setDensity(self.density)
#
#
#
# print " dbg hm we set the ic "
self.flowComponent.setInitialConditions(self.initialConditions)
#
# Gravity
#
if self.gravity:
# print " dbg hm we set the gravity "
self.flowComponent.setGravity(self.gravity)
pass
#
# Permeability
#
if self.permeability:
self.flowComponent.setPermeability(self.permeability)
pass
#
# Intrinsic Permeability
#
if self.intrinsicPermeability:
self.flowComponent.setIntrinsecPermeability(self.intrinsicPermeability)
pass
#
# Porosity
#
if self.hydraulicPorosity:
self.flowComponent.setPorosity(self.hydraulicPorosity)
pass
elif self.porosity:
self.flowComponent.setPorosity(self.porosity)
pass
#
# Viscosity
#
if self.viscosity:
self.flowComponent.setViscosity(self.viscosity)
pass
#
# Matrix compressibility factor
#
if self.matrixCompressibilityFactor:
self.flowComponent.setMatrixCompressibilityFactor(self.matrixCompressibilityFactor)
pass
if self.liquidResidualSaturation:
self.flowComponent.setLiquidResidualSaturation(self.liquidResidualSaturation)
pass
#
# Source
#
if self.sourceField :
self.flowComponent.setSource(self.sourceField)
pass
#
# time steps treatment
#
if self.simulationType == "Transient":
self.flowComponent.calcTimesDico ['finalTime']= self.problem.calculationTimes[-1]
pass
#
#setExpectedOutput
#
# Module.setExpectedOutput(self)
#
# to affect numerical parameters
#
def setParameter(self,*tuple,**dico):
if self.flowComponent:
self.flowComponent.setParameter(*tuple,**dico)
pass
else:
raise Exception(" You have to set the Hydraulic component solver")
#
def setTimeDiscretisation(self,timeStepIntervals = None, timeStepSizes = None):
"""
setting time steps through the number of time Steps or the size of time steps.
Every time, a real is used. It should become a list.
"""
if timeStepIntervals != None:
self.timeStepIntervals = timeStepIntervals
pass
elif timeStepSizes != None:
self.timeStepSizes = timeStepSizes
pass
else:
raise Warning("You should give at least an argument to the setTimeDiscretisation function")
if self.timeStepIntervals != None:
print("dbg hm ",self.timeStepIntervals)
print("dbg hm ",self.problem.calculationTimes[-1])
self.timeStepSizes = self.problem.calculationTimes[-1]/self.timeStepIntervals
pass
else:
self.timeStepIntervals = self.problem.calculationTimes[-1]/self.timeStepSizes
pass
setCalculationTimes = setTimeDiscretisation
def writeToFile(self):
pass
def getOutput(self,name, outputType = None):
"""
The velocity is read from the file HeVel.ep within the mesh file.
This file is issued from the successfull run of the two method,
Darcy and Flux
"""
#
# transient part
#
if self.simulationType == "Transient":
#
# charge
#
# raw_input(" trying to retrieve charge")
self.charge = self.flowComponent.essai.getCharge()
print(self.charge[0:10])
# raw_input(" trying to retrieve points")
self.points = self.flowComponent.essai.getCoordinates()
self.points = self.mesh.getNodesCoordinates()
#print self.points
# raw_input(" trying to retrieve velocity")
self.velocity = self.flowComponent.essai.getVelocity()
return self.points, self.charge, self.velocity
#
# steady part
#
#print " we re here "
#raw_input()
if type(name) == StringType:
if name.lower() == "velocity":
fileName = "./" + self.flowComponent.meshDirectoryName + "/" + "HeVel.ep"
if not os.path.isfile(fileName):
message = " problem with the velocity file: " + fileName
raise Exception(message)
return None
elif name.lower() == "watercontent":
fileName = "./" + "watercontent.vtu"
pass
velocityFile=open(fileName,'r')
velocityFile.readline()
velocityFile.readline()
line = velocityFile.readline()
f = len(line)/3
self.points = []
while "#group all" not in line:
#line = line.split()
#print " line ",line
#raw_input("line : ")
self.points.append([float(line[0:17]),float(line[17:34]),float(line[34:53])])
line = velocityFile.readline()
pass
while "#time" not in velocityFile.readline():
pass
line = velocityFile.readline()
physic = []
while len(line) > 1:
physic.append([float(line[0:17]),\
float(line[17:34]),\
float(line[34:51]),\
float(line[51:68])])
line = velocityFile.readline()
pass
self.charge = []
self.velocity = []
ind = 0
for iunknown in range(0,len(physic)):
a = physic[iunknown]
self.charge.append(a[0])
self.velocity.append([a[1],a[2],a[3]])
ind+=1
pass
pass
# print charge[0],charge[-1]
return self.points, self.charge, self.velocity
def end(self):
"""simulation stop and clean"""
if self.flowComponent:
self.flowComponent.end()
pass
def getComponentName(self):
"""
to get the name of the component, that has been defined, if any
"""
if self.componentName:
return self.componentName
else:
raise Warning("No component name has been currently defined")
def getComponent(self):
"""
to get the component
"""
return self.flowComponent
def getHelp(self,func = None):
"""
That function is used to get some help on the
class and on relevant functions
Ex: getHelp() or getHelp(a.function)
"""
if func == None:
print(self.__doc__)
pass
else:
print(func.__doc__)
pass
def run(self,transient = None):
"""
Simulation, steady or transient;
The default flow solver is elmer.
The simulation is supposed to be a steady one by default.
"""
if self.flowComponent == None:
#
# is it possible ?
#
self.flowComponent = ElmerHydro(self.mesh)
pass
if not transient:
#raw_input(" running elmer ")
self.flowComponent.run()
pass
else:
self.flowComponent.launch()
#dir(self.flowComponent)
self.flowComponent.run()
pass
def setInitialPermeability(self,permeabilityField):
"""
That function is used to set the initial permeability field.
"""
if self.flowComponent != None:
self.flowComponent.setpermeabilityfield(permeabilityField)
pass
else:
raise Exception(" the flow component must be launched before trying to setup K ")
def writeVelocityPlot(self):
"""
The velocity is plotted using the legacy format of vtk
"""
name = "velocity.vtk"
chargeFile = open(name,'w')
chargeFile.write("%s\n"%("# vtk DataFile Version 2.0"))
chargeFile.write("%s\n"%("obtained via hydraulicmodule"))
chargeFile.write("%s\n"%("ASCII"))
chargeFile.write("%s\n"%("DATASET UNSTRUCTURED_GRID"))
chargeFile.write("%s %i %s\n"%("POINTS",len(self.points),"double"))
dim = self.mesh.getSpaceDimensions()
if (dim==2):
for ind in range(0,len(self.points)):
chargeFile.write("%15.8e %15.8e %15.8e\n"%(self.points[ind][0],\
self.points[ind][1],\
0.))
pass
pass
elif (dim==3):
for ind in range(0,len(self.points)):
chargeFile.write("%15.8e %15.8e %15.8e\n"%(self.points[ind][0],\
self.points[ind][1],\
self.points[ind][2]))
pass
pass
else:
raise Exception(" error in mesh dimension ")
numberOfCells = self.mesh.getNumberOfCells()
connectivity = self.mesh.getConnectivity()
cellListSize = 0
for i in range(0,numberOfCells): # gmsh meshes: type of elements
gmshType = connectivity[i][1]
if gmshType == 1: # 2-node line
cellListSize += 3
pass
elif gmshType == 2: # 3-node triangles
cellListSize += 4
pass
elif gmshType == 3: # 4-node quadrangles
cellListSize += 5
pass
elif gmshType == 4: # 4-node tetrahedron
cellListSize += 5
pass
elif gmshType == 5: # 8-node hexahedrons
cellListSize += 9
pass
pass
chargeFile.write("CELLS %i %i\n"%(numberOfCells,cellListSize))
ind = 0
for cell in connectivity:
ind = cell[2]+3
# print " ctm dbg cell ",vtkTyp,ind,cell," perm ",permutation[ind],permutation[ind+1],permutation[ind+2],permutation[ind+3]
#
vtkTyp = _vtkGmsh(cell[1])
if (vtkTyp==3): # 2-node line
ind = cell[2]+3
chargeFile.write("%i %i %i\n"%(
2,\
cell[ind]-1,\
cell[ind+1]-1)
)
pass
elif (vtkTyp==5): # triangles
chargeFile.write("%i %i %i %i\n"%(
3,
cell[ind]-1,\
cell[ind+1]-1,\
cell[ind+2]-1)
)
pass
elif (vtkTyp==9): # quadr
chargeFile.write("%i %i %i %i %i\n"%(
4,\
cell[ind]-1,\
cell[ind+1]-1,\
cell[ind+2]-1,\
cell[ind+3]-1)
)
pass
elif (vtkTyp==10): # tetra
chargeFile.write("%i %i %i %i %i\n"%(
4,\
cell[ind]-1,\
cell[ind+1]-1,\
cell[ind+2]-1,\
cell[ind+3]-1)
)
pass
elif (vtkTyp==12): # hexahedron
chargeFile.write("%i %i %i %i %i %i %i %i %i\n"%(
8,\
cell[ind]-1,\
cell[ind+1]-1,\
cell[ind+2]-1,\
cell[ind+3]-1,\
cell[ind+4]-1,\
cell[ind+5]-1,\
cell[ind+6]-1,\
cell[ind+7]-1)
)
pass
pass
chargeFile.write("%s %i\n"%("CELL_TYPES",numberOfCells))
#
for i in range(0,numberOfCells):
gmshType = connectivity[i][1]
if (gmshType)==1:
cellTyp = 3
pass
elif (gmshType)==2:
cellTyp = 5
pass
elif (gmshType)==3:
cellTyp = 9
pass
elif (gmshType)==4:
cellTyp = 10
pass
elif (gmshType)==5:
cellTyp = 12
pass
elif (gmshType)==6:
cellTyp = 13
pass
elif gmshType == 7:
cellTyp = 14
pass
else:
raise Exception(" check gmshtype ")
chargeFile.write("%i\n"%(cellTyp))
chargeFile.write("%s %d\n"%("POINT_DATA",len(self.points)))
chargeFile.write("%s\n"%("VECTORS vectors float"))
for velocityComponent in self.velocity:
chargeFile.write(" %e %e %e\n "%(velocityComponent[0], velocityComponent[1], velocityComponent[2]))
chargeFile.write("%s\n"%("SCALARS charge double"))
chargeFile.write("%s\n"%("LOOKUP_TABLE default"))
#
chargeDataFile=open("./" + self.flowComponent.meshDirectoryName + "/" + "HeVel.dat",'r')
line = chargeDataFile.readline()
while "Number Of Nodes" not in line:
line = chargeDataFile.readline()
#line.split()
nodesNumber = line.split()[-1]
while "Perm" not in line:
line = chargeDataFile.readline()
#
# We read the permutation
#
for i in range(int(nodesNumber)): chargeDataFile.readline()
#
# We read the charge
#
for i in range(int(nodesNumber)): chargeFile.write(" %15.10e\n "%(float(chargeDataFile.readline())))
