Diffusion tamaas (features/netcdf-mpi) Browse

netcdf-mpi

init.py
View Options

			# @file
			# @section LICENSE
			#
			# Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
			# Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
			#
			# This program is free software: you can redistribute it and/or modify
			# it under the terms of the GNU Affero General Public License as published
			# by the Free Software Foundation, either version 3 of the License, or
			# (at your option) any later version.
			#
			# This program is distributed in the hope that it will be useful,
			# but WITHOUT ANY WARRANTY; without even the implied warranty of
			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			# GNU Affero General Public License for more details.
			#
			# You should have received a copy of the GNU Affero General Public License
			# along with this program. If not, see <https://www.gnu.org/licenses/>.

			"""
			Dumpers for the class tamaas.Model
			"""
			from __future__ import print_function

			from .. import ModelDumper
			from ._helper import PeriodicHelper, step_dump, directory_dump

			import numpy as np


			class FieldDumper(ModelDumper):
			"""Abstract dumper for python classes using fields"""
			postfix = ''
			extension = ''
			name_format = "{basename}{postfix}.{extension}"

			def __init__(self, basename, *fields, all_fields=False):
			"""Construct with desired fields"""
			super().__init__()
			self.basename = basename
			self.fields = fields
			self.all_fields = all_fields
			self.make_periodic = PeriodicHelper()

			def add_field(self, field):
			"""Add another field to the dump"""
			if field not in self.fields:
			self.fields.append(field)

			def dump_to_file(self, fd, model):
			"""Dump to a file (name or handle)"""
			pass

			def get_fields(self, model):
			"""Get the desired fields"""
			if not self.all_fields:
			requested_fields = self.fields
			else:
			requested_fields = model.getFields()

			return {field: model.getField(field) for field in requested_fields}

			def get_attributes(self, model):
			"""Get model attributes"""
			return {
			'model_type': str(model.type),
			'system_size': model.getSystemSize(),
			'discretization': model.getDiscretization()
			}

			def dump(self, model):
			self.dump_to_file(self.file_path, model)

			@property
			def file_path(self):
			"""Get the default filename"""
			return self.name_format.format(basename=self.basename,
			postfix=self.postfix,
			extension=self.extension)


			@directory_dump('numpys')
			@step_dump
			class NumpyDumper(FieldDumper):
			"""Dumper to compressed numpy files"""
			extension = 'npz'

			def dump_to_file(self, fd, model):
			"""Saving to compressed multi-field Numpy format"""
			np.savez_compressed(fd, attrs=self.get_attributes(model),
			**self.get_fields(model))


			try:
			import h5py

			@directory_dump('hdf5')
			@step_dump
			class H5Dumper(FieldDumper):
			"""Dumper to HDF5 file format"""
			extension = 'h5'

			def dump_to_file(self, fd, model):
			"""Saving to HDF5 with metadata about the model"""
			with h5py.File(fd, 'w') as fh:
			# Writing data
			for name, field in self.get_fields(model).items():
			dset = fh.create_dataset(name, field.shape, field.dtype,
			compression='gzip',
			compression_opts=7)
			dset[:] = field

			# Writing metadata
			for name, attr in self.get_attributes(model).items():
			fh.attrs[name] = attr
			except ImportError:
			pass

			try:
			import uvw # noqa

			@directory_dump('paraview')
			@step_dump
			class UVWDumper(FieldDumper):
			"""Dumper to VTK files for elasto-plastic calculations"""
			extension = 'vtr'
			forbidden_fields = ['traction', 'gap'] # TODO make generic

			def dump_to_file(self, fd, model):
			"""Dump displacements, plastic deformations and stresses"""
			discretization = model.getDiscretization().copy()

			# Because we make fields periodic
			discretization[1] += 1
			discretization[2] += 1

			# Space coordinates
			coordinates = [np.linspace(0, L, N)
			for L, N in zip(model.getSystemSize(),
			discretization)]

			# Correct order of coordinate dimensions
			dimension_indices = [1, 2, 0]

			# Creating rectilinear grid with correct order for components
			grid = uvw.RectilinearGrid(fd, (coordinates[i]
			for i in dimension_indices))

			# Iterator over fields we want to dump
			# Avoid 2D fields (TODO make generic)
			fields_it = filter(lambda t: t[0] not in self.forbidden_fields,
			self.get_fields(model).items())

			# We make fields periodic for visualization
			for name, field in fields_it:
			array = uvw.DataArray(np.array(self.make_periodic[name](field),
			dtype=np.double),
			dimension_indices, name)
			grid.addPointData(array)

			grid.write()
			except ImportError as e:
			print(e)

tamaas/python/tamaas/dumpers/__init__.pyd81014204db3features/netcdf-mpi

__init__.pyView Options

tamaas/python/tamaas/dumpers/init.py
d81014204db3features/netcdf-mpi

init.py
View Options