def addMatrices(db, matricesDir, order, dynamicRuptureMethod,
numberOfElasticQuantities, numberOfQuantities):
numberOfBasisFunctions = Tools.numberOfBasisFunctions(order)
if dynamicRuptureMethod == 'quadrature':
numberOfPoints = (order + 1)**2
elif dynamicRuptureMethod == 'cellaverage':
numberOfPoints = int(4**math.ceil(math.log(order * (order + 1) / 2,
4)))
else:
raise ValueError('Unknown dynamic rupture method.')
clones = dict()
# Load matrices
db.update(
Tools.parseMatrixFile(
'{}/dr_{}_matrices_{}.xml'.format(matricesDir,
dynamicRuptureMethod, order),
clones))
# Determine matrices
# Note: This does only work because the flux does not depend on the mechanisms in the case of viscoelastic attenuation
godunovMatrixSpp = np.matlib.zeros(
(numberOfQuantities, numberOfQuantities))
godunovMatrixSpp[0:numberOfElasticQuantities,
0:numberOfElasticQuantities] = 1.
db.insert(
DB.MatrixInfo('godunovMatrix',
numberOfQuantities,
numberOfQuantities,
matrix=godunovMatrixSpp))
fluxSolverSpp = np.matlib.zeros((numberOfQuantities, numberOfQuantities))
fluxSolverSpp[0:numberOfElasticQuantities, :] = 1.
db.insert(
DB.MatrixInfo('fluxSolver',
numberOfQuantities,
numberOfQuantities,
matrix=fluxSolverSpp))
godunovStateSpp = np.matlib.zeros((numberOfPoints, numberOfQuantities))
godunovStateSpp[:, 0:numberOfElasticQuantities] = 1.
db.insert(
DB.MatrixInfo('godunovState',
numberOfPoints,
numberOfQuantities,
matrix=godunovStateSpp))
stiffnessOrder = {'Xi': 0, 'Eta': 1, 'Zeta': 2}
globalMatrixIdRules = [(r'^pP(\d{1})$', lambda x: (int(x[0]) - 1) * 4),
(r'^pM(\d{1})(\d{1})$', lambda x:
(int(x[0]) - 1) * 4 + int(x[1])),
(r'^nP(\d{1})$', lambda x: 16 +
(int(x[0]) - 1) * 4),
(r'^nM(\d{1})(\d{1})$', lambda x: 16 +
(int(x[0]) - 1) * 4 + int(x[1]))]
DB.determineGlobalMatrixIds(globalMatrixIdRules, db, 'dr')
def addMatrices(db, order):
numberOfBasisFunctions = Tools.numberOfBasisFunctions(order)
for depth in range(0, maxDepth + 1):
numberOfSubTriangles = 4**depth
db.insert(
DB.MatrixInfo('subTriangleProjectionMatrix{}'.format(depth),
numberOfSubTriangles,
numberOfBasisFunctions,
forceAligned=True))
db.insert(
DB.MatrixInfo('velocityDOFS',
numberOfBasisFunctions,
3,
forceAligned=True))
def addMatrices(db, matricesDir, PlasticityMethod, order):
numberOfBasisFunctions = Tools.numberOfBasisFunctions(order)
clones = dict()
# Load matrices
db.update(Tools.parseMatrixFile('{}/plasticity_{}_matrices_{}.xml'.format(matricesDir, PlasticityMethod, order), clones))
# force Aligned in order to be compatible with regular DOFs.
db.insert(DB.MatrixInfo('stressDOFS', numberOfBasisFunctions, 6, forceAligned=True))
matrixOrder = { 'v': 0, 'vInv': 1 }
globalMatrixIdRules = [
(r'^(v|vInv)$', lambda x: matrixOrder[x[0]])
]
DB.determineGlobalMatrixIds(globalMatrixIdRules, db, 'plasticity')
numberOfElasticQuantities = 9
numberOfMechanismQuantities = 6
numberOfReducedQuantities = numberOfElasticQuantities + numberOfMechanismQuantities
numberOfQuantities = numberOfElasticQuantities + 6*numberOfMechanisms
clones = {
'star': [ 'AstarT', 'BstarT', 'CstarT' ]
}
# Load matrices
db = Tools.parseMatrixFile('{}/matrices_{}.xml'.format(cmdLineArgs.matricesDir, numberOfBasisFunctions), clones)
db.update(Tools.parseMatrixFile('{}/matrices_viscoelastic.xml'.format(cmdLineArgs.matricesDir), clones))
# Determine sparsity patterns that depend on the number of mechanisms
riemannSolverSpp = np.bmat([[np.matlib.ones((9, numberOfReducedQuantities), dtype=np.float64)], [np.matlib.zeros((numberOfReducedQuantities-9, numberOfReducedQuantities), dtype=np.float64)]])
db.insert(DB.MatrixInfo('AplusT', numberOfReducedQuantities, numberOfReducedQuantities, matrix=riemannSolverSpp))
db.insert(DB.MatrixInfo('AminusT', numberOfReducedQuantities, numberOfReducedQuantities, matrix=riemannSolverSpp))
DynamicRupture.addMatrices(db, cmdLineArgs.matricesDir, order, cmdLineArgs.dynamicRuptureMethod, numberOfElasticQuantities, numberOfReducedQuantities)
Plasticity.addMatrices(db, cmdLineArgs.matricesDir, cmdLineArgs.PlasticityMethod, order)
SurfaceDisplacement.addMatrices(db, order)
# Load sparse-, dense-, block-dense-config
Tools.memoryLayoutFromFile(cmdLineArgs.memLayout, db, clones)
# Set rules for the global matrix memory order
stiffnessOrder = { 'Xi': 0, 'Eta': 1, 'Zeta': 2 }
globalMatrixIdRules = [
(r'^k(Xi|Eta|Zeta)DivMT$', lambda x: stiffnessOrder[x[0]]),
(r'^k(Xi|Eta|Zeta)DivM$', lambda x: 3 + stiffnessOrder[x[0]]),
(r'^r(\d{1})DivM$', lambda x: 6 + int(x[0])-1),
source[r,0:6] = db['ET'].spp
source[r,r] = np.matlib.identity(6)
db.insert(DB.MatrixInfo('source', numberOfQuantities, numberOfQuantities, source))
# Load sparse-, dense-, block-dense-config
Tools.memoryLayoutFromFile(cmdLineArgs.memLayout, db, clones)
# Set rules for the global matrix memory order
stiffnessOrder = { 'Xi': 0, 'Eta': 1, 'Zeta': 2 }
globalMatrixIdRules = [
(r'^k(Xi|Eta|Zeta)DivMT$', lambda x: stiffnessOrder[x[0]]),
(r'^k(Xi|Eta|Zeta)DivM$', lambda x: 3 + stiffnessOrder[x[0]]),
(r'^fM(\d{1})$', lambda x: 6 + int(x[0])-1),
(r'^fP(\d{1})(\d{1})(\d{1})$', lambda x: 10 + (int(x[0])-1)*12 + (int(x[1])-1)*3 + (int(x[2])-1))
]
DB.determineGlobalMatrixIds(globalMatrixIdRules, db)
# Kernels
kernels = list()
db.insert(DB.MatrixInfo('timeIntegrated', numberOfBasisFunctions, numberOfQuantities))
db.insert(DB.MatrixInfo('timeDerivative0', numberOfBasisFunctions, numberOfQuantities))
volume = db['kXiDivM'] * db['timeIntegrated'] * db['AstarT'] \
+ db['kEtaDivM'] * db['timeIntegrated'] * db['BstarT'] \
+ db['kZetaDivM'] * db['timeIntegrated'] * db['CstarT'] \
+ db['timeIntegrated'] * db['source']
kernels.append(('volume', volume))
for i in range(0, 4):
localFlux = db['fM{}'.format(i+1)] * db['timeIntegrated'] * db['AplusT']
db.update(
Tools.parseMatrixFile(
'{}/matrices_viscoelastic.xml'.format(cmdLineArgs.matricesDir),
clones))
# Determine sparsity patterns that depend on the number of mechanisms
riemannSolverSpp = np.bmat(
[[np.matlib.ones((9, numberOfReducedQuantities), dtype=np.float64)],
[
np.matlib.zeros(
(numberOfReducedQuantities - 9, numberOfReducedQuantities),
dtype=np.float64)
]])
db.insert(
DB.MatrixInfo('AplusT',
numberOfReducedQuantities,
numberOfReducedQuantities,
matrix=riemannSolverSpp))
db.insert(
DB.MatrixInfo('AminusT',
numberOfReducedQuantities,
numberOfReducedQuantities,
matrix=riemannSolverSpp))
DynamicRupture.addMatrices(db, cmdLineArgs.matricesDir, order,
cmdLineArgs.dynamicRuptureMethod,
numberOfElasticQuantities,
numberOfReducedQuantities)
Plasticity.addMatrices(db, cmdLineArgs.matricesDir,
cmdLineArgs.PlasticityMethod, order)
SurfaceDisplacement.addMatrices(db, order)
cmdLineParser.add_argument('--PlasticityMethod')
cmdLineArgs = cmdLineParser.parse_args()
architecture = Arch.getArchitectureByIdentifier(cmdLineArgs.arch)
libxsmmGenerator = cmdLineArgs.generator
order = int(cmdLineArgs.order)
numberOfBasisFunctions = Tools.numberOfBasisFunctions(order)
numberOfQuantities = 9
clones = {'star': ['AstarT', 'BstarT', 'CstarT']}
db = Tools.parseMatrixFile(
'{}/matrices_{}.xml'.format(cmdLineArgs.matricesDir,
numberOfBasisFunctions), clones)
db.insert(DB.MatrixInfo('AplusT', numberOfQuantities, numberOfQuantities))
db.insert(DB.MatrixInfo('AminusT', numberOfQuantities, numberOfQuantities))
DynamicRupture.addMatrices(db, cmdLineArgs.matricesDir, order,
cmdLineArgs.dynamicRuptureMethod,
numberOfQuantities, numberOfQuantities)
Plasticity.addMatrices(db, cmdLineArgs.matricesDir,
cmdLineArgs.PlasticityMethod, order)
SurfaceDisplacement.addMatrices(db, order)
# Load sparse-, dense-, block-dense-config
Tools.memoryLayoutFromFile(cmdLineArgs.memLayout, db, clones)
# Set rules for the global matrix memory order
stiffnessOrder = {'Xi': 0, 'Eta': 1, 'Zeta': 2}
globalMatrixIdRules = [
numberOfBasisFunctions), clones)
db.update(
Tools.parseMatrixFile(
'{}/matrices_viscoelastic.xml'.format(cmdLineArgs.matricesDir),
clones))
# Determine sparsity patterns that depend on the number of mechanisms
riemannSolverSpp = np.bmat(
[[np.matlib.ones((9, numberOfQuantities), dtype=np.float64)],
[
np.matlib.zeros((numberOfQuantities - 9, numberOfQuantities),
dtype=np.float64)
]])
db.insert(
DB.MatrixInfo('AplusT',
numberOfQuantities,
numberOfQuantities,
sparsityPattern=riemannSolverSpp))
db.insert(
DB.MatrixInfo('AminusT',
numberOfQuantities,
numberOfQuantities,
sparsityPattern=riemannSolverSpp))
mechMatrix = np.matlib.zeros((15, numberOfQuantities))
mechMatrix[0:9, 0:9] = np.matlib.identity(9)
for m in range(0, numberOfMechanisms):
mechMatrix[9:15, 9 + 6 * m:9 + 6 * (m + 1)] = np.matlib.identity(6)
tallMatrix = np.matlib.zeros((numberOfQuantities, 15))
tallMatrix[0:15, 0:15] = db[clones['star'][0]].spp
starMatrix = tallMatrix * mechMatrix
for clone in clones['star']: