diff --git a/gui/src/components/Quantity.js b/gui/src/components/Quantity.js index 45f8f05d699f0f13b6c3b646764f41df9cf444ba..99c6e30cc4a9cb9fc2d26b00e8c7cb4252abf195 100644 --- a/gui/src/components/Quantity.js +++ b/gui/src/components/Quantity.js @@ -42,7 +42,8 @@ import NoData from './visualization/NoData' import { formatNumber, formatTimestamp, authorList, serializeMetainfo } from '../utils' import { Quantity as Q, Unit, useUnits } from '../units' import { filterData } from './search/FilterRegistry' -import { RouteLink } from './nav/Routes' +// eslint-disable-next-line no-unused-vars +import { MaterialLink, RouteLink } from './nav/Routes' /** * Component for showing a metainfo quantity value together with a name and @@ -152,7 +153,15 @@ const Quantity = React.memo((props) => { }, []) - const children = props.children || (presets.render && presets.render(data)) || (quantity?.name && quantity.type && getRenderFromType(quantity, data)) + // Determine the rendered children. They may have been given explicitly, or + // this quantity may have a default rendering function for a value, or this + // quantity may have a default rendering function for data, or the data type + // may be associated with a particular rendering function. + const children = props.children || + ((presets.render && !isNil(data)) && presets.render(data)) || + ((presets.renderValue && !isNil(value)) && presets.renderValue(value)) || + ((quantity?.name && !isNil(quantity.type)) && getRenderFromType(quantity, data)) + const units = useUnits() let content = null let clipboardContent = null @@ -394,7 +403,33 @@ const quantityPresets = { }, 'results.material.material_id': { noWrap: true, - withClipboard: true + hideIfUnavailable: true, + placeholder: 'unavailable', + withClipboard: true, + render: (data) => { + return data?.results?.material?.material_id + ? + + {data.results.material.material_id} + + + : null + } + }, + 'results.material.topology.material_id': { + noWrap: true, + hideIfUnavailable: true, + placeholder: 'unavailable', + withClipboard: true, + renderValue: (value) => { + return value + ? + + {value} + + + : null + } }, mainfile: { noWrap: true, diff --git a/gui/src/components/entry/properties/MaterialCard.js b/gui/src/components/entry/properties/MaterialCard.js index ae7e193a51907e54b54bd42e60cbf78753149567..a157ee072a2e8b70c8eb16bc086331452d9cc633 100644 --- a/gui/src/components/entry/properties/MaterialCard.js +++ b/gui/src/components/entry/properties/MaterialCard.js @@ -160,8 +160,8 @@ const MaterialCard = React.memo(({index, properties, archive}) => { {hasStructures ? diff --git a/gui/src/components/entry/properties/MaterialCardTopology.js b/gui/src/components/entry/properties/MaterialCardTopology.js index bb12722332c5c86df5730722a6e0d1f33bbaf1ad..877f08058aa2f6a97389ffebedb02b9b09d51df9 100644 --- a/gui/src/components/entry/properties/MaterialCardTopology.js +++ b/gui/src/components/entry/properties/MaterialCardTopology.js @@ -17,7 +17,7 @@ */ import React, { useCallback, useEffect, useState, useMemo, useRef } from 'react' import PropTypes from 'prop-types' -import { isEmpty, range, flattenDeep, isEqual } from 'lodash' +import { isEmpty, isString, range, flattenDeep, isEqual, has } from 'lodash' import { PropertyCard, PropertyGrid, PropertySubGrid, PropertyItem } from './PropertyCard' import { Tab, Tabs, Typography, Box } from '@material-ui/core' import { makeStyles, useTheme } from '@material-ui/core/styles' @@ -55,38 +55,58 @@ const MaterialCardTopology = React.memo(({index, properties, archive}) => { const [selected, setSelected] = useState(topologyTree.system_id) const [tab, setTab] = useState(0) const [structure, setStructure] = useState() - const structureRef = useRef() + const [structuralType, setStructuralType] = useState('unavailable') + const [cellType, setCellType] = useState('original') + const structureMap = useRef({}) const [selection, setSelection] = useState() + // Returns a reference to a structure in the given topology if one can be found + const resolveAtomRef = useCallback((top) => { + return isString(top.atoms) ? top.atoms : top.atoms_ref + }, []) + + // Used to resolve a structure for the given topology item + const resolveStructure = useCallback((top, archive) => { + const atomsRef = resolveAtomRef(top) + const atoms = top.atoms + const id = top.system_id + if (!has(structureMap.current, id)) { + let structure + if (atomsRef) { + const atoms = resolveInternalRef(atomsRef, archive) + structure = toMateriaStructure(atoms) + } else if (atoms) { + structure = toMateriaStructure(atoms) + } else if (top.indices) { + const parent = topologyMap[top.parent_system] + structure = resolveStructure(parent, archive) + } + structureMap.current[id] = structure + } + return structureMap.current[id] + }, [resolveAtomRef, topologyMap]) + // When archive is loaded, this effect handles changes in visualizing the // selected system useEffect(() => { if (!archive) return const top = topologyMap[selected] - const atomsRef = top.atoms const indices = top.indices + let structure let transparent let selection let focus let isSubsystem - if (atomsRef) { - transparent = undefined - selection = undefined - focus = undefined - if (atomsRef !== structureRef.current) { - const atoms = resolveInternalRef(top.atoms, archive) - const structure = toMateriaStructure(atoms) - structureRef.current = atomsRef - setStructure(structure) - } - setSelection(undefined) - } else if (indices) { + + // If the topology has indices, visualize a subsection of the parent system + if (indices) { const structuralType = top.structural_type const isMonomer = structuralType === 'monomer' const child_types = top.child_systems ? new Set(top.child_systems.map(x => x.structural_type)) : new Set() const isMonomerGroup = structuralType === 'group' && isEqual(child_types, new Set(['monomer'])) const isMolecule = structuralType === 'molecule' const parent = topologyMap[top.parent_system] + structure = resolveStructure(parent, archive) // Set the opaque atoms selection = ((isMolecule || isMonomer) @@ -107,14 +127,17 @@ const MaterialCardTopology = React.memo(({index, properties, archive}) => { ? indices[0] : indices).flat() isSubsystem = isMolecule || isMonomer || isMonomerGroup - setSelection({ - transparent, - selection, - focus, - isSubsystem - }) + } else { + transparent = undefined + selection = undefined + focus = undefined + structure = resolveStructure(top, archive) } - }, [archive, selected, topologyMap]) + setStructuralType(top?.label === 'conventional cell' ? 'bulk' : 'unavailable') + setCellType(top?.label === 'conventional cell' ? 'conventional' : 'original') + setStructure(structure) + setSelection({transparent, selection, focus, isSubsystem}) + }, [archive, selected, topologyMap, resolveStructure]) // Handle tab change const handleTabChange = useCallback((event, value) => { @@ -132,6 +155,8 @@ const MaterialCardTopology = React.memo(({index, properties, archive}) => { data={structure} selection={selection} data-testid="viewer-material" + structuralType={structuralType} + cellType={cellType} /> : } @@ -314,19 +339,31 @@ TopologyItem.propTypes = { /** * Displays the information that is present for a single node within tabs. */ +const useMaterialTabsStyles = makeStyles(theme => ({ + noData: { + height: 116.81 // The height of two QuantityRows + } +})) const MaterialTabs = React.memo(({value, onChange, node}) => { - const cellTab = {...(node?.cell || {})} - const symmetryTab = {...(node?.symmetry || {})} - const prototypeTab = {...(node?.prototype || {})} - const wyckoffTab = {...(node?.atoms?.wyckoff_sets || {})} - const hasTopology = !isEmpty(node) - const hasCell = !isEmpty(cellTab) - const hasSymmetry = !isEmpty(symmetryTab) - const hasPrototype = !isEmpty(prototypeTab) - const hasWyckoff = !isEmpty(wyckoffTab) + const styles = useMaterialTabsStyles() const nElems = node?.n_elements const nElemsLabel = nElementMap[nElems] const n_elements = `${nElems}${nElemsLabel ? ` (${nElemsLabel})` : ''}` + const tabMap = useMemo(() => { + const cellTab = {...(node?.cell || {})} + const symmetryTab = {...(node?.symmetry || {})} + const prototypeTab = {...(node?.prototype || {})} + const hasTopology = !isEmpty(node) + const hasCell = !isEmpty(cellTab) + const hasSymmetry = !isEmpty(symmetryTab) + const hasPrototype = !isEmpty(prototypeTab) + return { + 0: {disabled: !hasTopology, label: 'Composition'}, + 1: {disabled: !hasCell, label: 'Cell'}, + 2: {disabled: !hasSymmetry, label: 'Symmetry'}, + 3: {disabled: !hasPrototype, label: 'Prototype'} + } + }, [node]) return <> { indicatorColor="primary" textColor="primary" > - - - - - + + + + - {hasTopology && - + + {!tabMap[0].disabled + ? @@ -362,9 +399,11 @@ const MaterialTabs = React.memo(({value, onChange, node}) => { - } - {hasCell && - + : } + + + {!tabMap[1].disabled + ? @@ -379,33 +418,38 @@ const MaterialTabs = React.memo(({value, onChange, node}) => { - } - {hasSymmetry && - - - - - - - - - - - - - - - } - {hasPrototype && - - - - - - - - } - {hasWyckoff && } + : } + + + {!tabMap[2].disabled + ? + + + + + + + + + + + + + + : + } + + + {!tabMap[3].disabled + ? + + + + + + + : } + }) MaterialTabs.propTypes = { diff --git a/gui/src/components/nav/Routes.js b/gui/src/components/nav/Routes.js index bb600d3b017d47db26e61f4272bacaae23d70afa..81b038377b8cffe1ba3bf1f16eedc6ed24f13783 100644 --- a/gui/src/components/nav/Routes.js +++ b/gui/src/components/nav/Routes.js @@ -564,6 +564,19 @@ UploadButton.propTypes = { uploadId: PropTypes.string.isRequired } +/** + * A link that allows to navigate to the material page (currently an external link). + * @param {string} materialId + */ +export const MaterialLink = React.forwardRef(({materialId, ...rest}, ref) => { + const href = `${encyclopediaBase}/material/${materialId}` + return +}) + +MaterialLink.propTypes = { + materialId: PropTypes.string.isRequired +} + /** * A button that allows to navigate to the material page (currently an external link). * @param {string} materialId diff --git a/gui/src/components/visualization/Structure.js b/gui/src/components/visualization/Structure.js index 35c65211a79bd3d5fa3328789e977e4fad6b4076..8950c723d5bd54d3218b5622033ff6270c6ebe98 100644 --- a/gui/src/components/visualization/Structure.js +++ b/gui/src/components/visualization/Structure.js @@ -115,8 +115,8 @@ const Structure = React.memo(({ classes, data, options, - materialType, - structureType, + structuralType, + cellType, m_path, captureName, sizeLimit, @@ -130,32 +130,82 @@ const Structure = React.memo(({ // States const [anchorEl, setAnchorEl] = React.useState(null) const [fullscreen, setFullscreen] = useState(false) - const [showLatticeConstants, setShowLatticeConstants] = useState(true) - const [showCell, setShowCell] = useState(true) + const [showLatticeConstants, setShowLatticeConstantsState] = useState(true) + const [showCell, setShowCellState] = useState(true) const [center, setCenter] = useState('COP') const [fit, setFit] = useState('full') - const [wrap, setWrap] = useState(true) + const [wrap, setWrapState] = useState(true) const [showPrompt, setShowPrompt] = useState(false) const [accepted, setAccepted] = useState(false) - const [showBonds, setShowBonds] = useState(true) + const [showBonds, setShowBondsState] = useState(true) const [species, setSpecies] = useState() const [loading, setLoading] = useState(true) + const [ready, setReady] = useState(false) const throwError = useAsyncError() + const setShowBonds = useCallback((value, render = false) => { + setShowBondsState(value) + if (refViewer?.current) { + try { + refViewer.current.bonds({enabled: value}) + if (render) refViewer.current.render() + } catch (e) { + } + } + }, []) + + const setWrap = useCallback((value, showBonds, render = false) => { + setWrapState(value) + if (refViewer?.current) { + try { + refViewer.current.wrap(value) + refViewer.current.bonds({enabled: showBonds}) + if (render) refViewer.current.render() + } catch (e) { + } + } + }, []) + + const setShowLatticeConstants = useCallback((value, render = false) => { + setShowLatticeConstantsState(value) + if (refViewer?.current) { + try { + refViewer.current.latticeConstants({enabled: value}) + if (render) refViewer.current.render() + } catch (e) { + } + } + }, []) + + const setShowCell = useCallback((value, render = false) => { + setShowCellState(value) + if (refViewer?.current) { + try { + refViewer.current.cell({enabled: value}) + if (render) refViewer.current.render() + } catch (e) { + } + } + }, []) + // Variables const history = useHistory() const open = Boolean(anchorEl) + const readyRef = useRef(true) const refViewer = useRef(null) const refCanvasDiv = useRef(null) - const originalCenter = useRef() - const firstLoad = useRef(true) const styles = useStyles(classes) const hasSelection = !isEmpty(selection?.selection) - const nAtoms = useMemo(() => data?.positions.length, [data]) + const nAtoms = useMemo(() => data?.positions?.length, [data]) const hasCell = useMemo(() => { - return !data?.cell + const hasCell = !data?.cell ? false : !flattenDeep(data.cell).every(v => v === 0) + // If there is no valid cell, the property is set as undefined + if (!hasCell && data) { + data.cell = undefined + } + return hasCell }, [data]) // In order to properly detect changes in a reference, a reference callback is @@ -191,6 +241,7 @@ const Structure = React.memo(({ await delay(() => { // Initialize the viewer. A new viewer is used for each system as the // render settings may differ. + const nAtoms = system?.positions?.length const isHighQuality = nAtoms <= 3000 const options = { renderer: { @@ -204,80 +255,14 @@ const Structure = React.memo(({ outline: {enabled: isHighQuality} }, bonds: { - enabled: showBonds, + enabled: false, smoothness: isHighQuality ? 145 : 130, outline: {enabled: isHighQuality} } } refViewer.current = new StructureViewer(undefined, options) - - // If there is no valid cell, the property is set as undefined - if (!hasCell) { - system.cell = undefined - } - - // Determine the orientation and view centering based on material type and - // the structure type. - let centerValue = 'COP' - let rotations = [ - [0, 1, 0, 60], - [1, 0, 0, 30] - ] - let alignments = hasCell - ? [ - ['up', 'c'], - ['right', 'b'] - ] - : undefined - if (structureType === 'conventional' || structureType === 'primitive') { - if (materialType === 'bulk') { - centerValue = 'COC' - alignments = [ - ['up', 'c'], - ['right', 'b'] - ] - } else if (materialType === '2D') { - centerValue = 'COC' - alignments = [ - ['right', 'a'], - ['up', 'b'] - ] - rotations = [ - [1, 0, 0, -60] - ] - } else if (materialType === '1D') { - centerValue = 'COC' - alignments = [ - ['right', 'a'] - ] - rotations = [ - [1, 0, 0, -60], - [0, 1, 0, 30], - [1, 0, 0, 30] - ] - } - } - refViewer.current.load(system) - refViewer.current.setRotation([1, 0, 0, 0]) - refViewer.current.atoms() - refViewer.current.bonds({enabled: showBonds}) - if (hasCell) { - refViewer.current.wrap(wrap) - refViewer.current.cell({enabled: showCell}) - refViewer.current.latticeConstants({enabled: showLatticeConstants}) - refViewer.current.align(alignments) - } - refViewer.current.rotate(rotations) refViewer.current.controls({resetOnDoubleClick: false}) - originalCenter.current = centerValue - const fitValue = 'full' - refViewer.current.center(centerValue) - refViewer.current.fit(fitValue, fitMargin) - setCenter(centerValue) - setFit(fitValue) - refViewer.current.render() - refViewer.current.saveCameraReset() // Get a list of all species ordered by atomic number const species = Object.entries(refViewer.current.elements) @@ -290,18 +275,18 @@ const Structure = React.memo(({ .sort((a, b) => a.atomicNumber - b.atomicNumber) setSpecies(species) }) - // eslint-disable-next-line react-hooks/exhaustive-deps - }, [structureType, materialType, hasCell]) + }, []) // Called whenever the system changes. Loads the structure asynchronously. useEffect(() => { if (!data) return + readyRef.current = false + setReady(false) setLoading(true) + // If the system is very large, ask the user first for permission to attempt + // to visualize it. if (!accepted) { - if (nAtoms > bondLimit) { - setShowBonds(false) - } if (nAtoms > sizeLimit) { setShowPrompt(true) return @@ -313,56 +298,110 @@ const Structure = React.memo(({ loadSystem(data, refViewer) .catch(throwError) .finally(() => { - setLoading(false) - firstLoad.current = false + setReady(true) + readyRef.current = true }) - // eslint-disable-next-line react-hooks/exhaustive-deps - }, [data, nAtoms, accepted, sizeLimit, bondLimit]) + }, [data, nAtoms, accepted, sizeLimit, throwError, loadSystem]) - // Handles selections. If a selection is given, the selected atoms will be - // higlighted. Additionally the view will be centered on the selection if this - // is requested. + // Once the system is loaded, this effect will determine the final visual + // layout. By monitoring the ready-state, the selections are updated correctly + // once the system is loaded. By also monitoring the readyRef-reference, this + // effect can know the status within the same render cycle as well. useEffect(() => { - if (firstLoad.current) { + if (!ready || !readyRef.current) { return } - // No selection: show all + // Reset camera and system rotations refViewer.current.resetCamera() - let center - let fit + refViewer.current.setRotation([1, 0, 0, 0]) + + // Determine the orientation and view centering based on material type and + // the structure type. + let center = 'COP' + let fit = 'full' + let showBondsValue = nAtoms < bondLimit + let rotations = [ + [0, 1, 0, 60], + [1, 0, 0, 30] + ] + let alignments = hasCell + ? [ + ['up', 'c'], + ['right', 'b'] + ] + : undefined + if (cellType === 'conventional' || cellType === 'primitive') { + if (structuralType === 'bulk') { + center = 'COC' + alignments = [ + ['up', 'c'], + ['right', 'b'] + ] + } else if (structuralType === '2D') { + center = 'COC' + alignments = [ + ['right', 'a'], + ['up', 'b'] + ] + rotations = [ + [1, 0, 0, -60] + ] + } else if (structuralType === '1D') { + center = 'COC' + alignments = [ + ['right', 'a'] + ] + rotations = [ + [1, 0, 0, -60], + [0, 1, 0, 30], + [1, 0, 0, 30] + ] + } + } + + // No selection: show all if (isEmpty(selection?.selection)) { - center = originalCenter.current - fit = 'full' - refViewer.current.center(center) - refViewer.current.fit(fit, fitMargin) refViewer.current.atoms() - refViewer.current.bonds({enabled: showBonds}) - refViewer.current.cell({enabled: showCell}) - refViewer.current.latticeConstants({enabled: showLatticeConstants}) + showBondsValue = nAtoms < bondLimit + setShowBonds(showBondsValue, false) + if (hasCell) { + setShowCell(true) + setShowLatticeConstants(true) + } // Focused selection: show only selected atoms } else { - center = selection.isSubsystem ? selection.focus : originalCenter.current + center = selection.isSubsystem ? selection.focus : center fit = selection.isSubsystem ? selection.focus : 'full' - refViewer.current.center(center) - refViewer.current.fit(fit, fitMargin) refViewer.current.atoms([ {opacity: 0}, {opacity: 0.1, include: selection.transparent}, {opacity: 1, include: selection.selection} ]) - refViewer.current.bonds({enabled: false}) - refViewer.current.cell({enabled: !selection.isSubsystem}) - refViewer.current.latticeConstants({enabled: !selection.isSubsystem}) - setFit(fit) - setCenter(center) + // Bonds are not shown for selections + if (!selection.isSubsystem) { + showBondsValue = false + setShowBonds(showBondsValue, false) + } + if (hasCell) { + setShowCell(!selection.isSubsystem) + setShowLatticeConstants(!selection.isSubsystem) + } } + if (hasCell) { + setWrap(true, showBondsValue, false) + refViewer.current.align(alignments) + } + refViewer.current.rotate(rotations) + refViewer.current.center(center) + refViewer.current.fit(fit, fitMargin) refViewer.current.render() refViewer.current.saveCameraReset() setFit(fit) setCenter(center) + setLoading(false) // eslint-disable-next-line react-hooks/exhaustive-deps - }, [selection]) + }, [selection, ready]) // Memoized callbacks const openMenu = useCallback((event) => { @@ -478,11 +517,7 @@ const Structure = React.memo(({ { - setShowBonds(!showBonds) - refViewer.current.bonds({enabled: !showBonds}) - refViewer.current.render() - }} + onChange={(event) => { setShowBonds(!showBonds, true) }} color='primary' /> } @@ -495,11 +530,7 @@ const Structure = React.memo(({ { - setShowLatticeConstants(!showLatticeConstants) - refViewer.current.latticeConstants({enabled: !showLatticeConstants}) - refViewer.current.render() - }} + onChange={(event) => { setShowLatticeConstants(!showLatticeConstants, true) }} color='primary' /> } @@ -512,11 +543,7 @@ const Structure = React.memo(({ { - setShowCell(!showCell) - refViewer.current.cell({enabled: !showCell}) - refViewer.current.render() - }} + onChange={(event) => { setShowCell(!showCell, true) }} color='primary' /> } @@ -529,12 +556,7 @@ const Structure = React.memo(({ { - setWrap(!wrap) - refViewer.current.wrap(!wrap) - refViewer.current.bonds({enabled: showBonds}) - refViewer.current.render() - }} + onChange={(event) => { setWrap(!wrap, showBonds, true) }} color='primary' /> } @@ -555,8 +577,8 @@ Structure.propTypes = { PropTypes.object ]), options: PropTypes.object, // Viewer options - materialType: PropTypes.oneOf(['bulk', '2D', '1D', 'molecule / cluster', 'unavailable']), - structureType: PropTypes.oneOf(['original', 'conventional', 'primitive']), + structuralType: PropTypes.oneOf(['bulk', 'surface', '2D', '1D', 'molecule / cluster', 'unavailable']), + cellType: PropTypes.oneOf(['original', 'conventional', 'primitive']), m_path: PropTypes.string, // Path of the structure data in the metainfo captureName: PropTypes.string, // Name of the file that the user can download sizeLimit: PropTypes.number, // Maximum system size before a prompt is shown diff --git a/nomad/datamodel/results.py b/nomad/datamodel/results.py index 915092856662746d39c7a5c65b8fadfcdabfab09..a166e4a45434de38d1978d78086f500f51e54460 100644 --- a/nomad/datamodel/results.py +++ b/nomad/datamodel/results.py @@ -386,46 +386,9 @@ class Structure(MSection): ) species = SubSection(sub_section=OptimadeSpecies.m_def, repeats=True) lattice_parameters = SubSection(sub_section=LatticeParameters.m_def) - - -class StructureOriginal(Structure): - m_def = Section( - description=''' - Contains a selected representative structure from the the original - data. - ''' - ) - - -class StructurePrimitive(Structure): - m_def = Section( - description=''' - Contains the primitive structure that is derived from - structure_original. This primitive stucture has been idealized and the - conventions employed by spglib are used. - ''' - ) - - -class StructureConventional(Structure): - m_def = Section( - description=''' - Contains the conventional structure that is derived from - structure_original. This conventional stucture has been idealized and - the conventions employed by spglib are used. - ''' - ) wyckoff_sets = SubSection(sub_section=WyckoffSet.m_def, repeats=True) -class StructureOptimized(Structure): - m_def = Section( - description=''' - Contains a structure that is the result of a geometry optimization. - ''' - ) - - class Structures(MSection): m_def = Section( description=''' @@ -434,15 +397,29 @@ class Structures(MSection): ''', ) structure_original = SubSection( - sub_section=StructureOriginal.m_def, + description=''' + Contains a selected representative structure from the the original + data. + ''', + sub_section=Structure.m_def, repeats=False, ) structure_conventional = SubSection( - sub_section=StructureConventional.m_def, + description=''' + Contains the conventional structure that is derived from + structure_original. This conventional stucture has been idealized and + the conventions employed by spglib are used. + ''', + sub_section=Structure.m_def, repeats=False, ) structure_primitive = SubSection( - sub_section=StructurePrimitive.m_def, + description=''' + Contains the primitive structure that is derived from + structure_original. This primitive stucture has been idealized and the + conventions employed by spglib are used. + ''', + sub_section=Structure.m_def, repeats=False, ) @@ -889,103 +866,6 @@ class Species(MSection): ) -class Atoms(MSection): - ''' - Describes the atomic structure of the physical system. This includes the atom - positions, lattice vectors, etc. - ''' - m_def = Section(validate=False) - - concentrations = Quantity( - type=np.dtype(np.float64), - shape=['n_atoms'], - description=''' - Concentrations of the species defined by labels which can be assigned for systems - with variable compositions. - ''' - ) - labels = Quantity( - type=str, - shape=['n_atoms'], - description=''' - List containing the labels of the atoms. In the usual case, these correspond to - the chemical symbols of the atoms. One can also append an index if there is a - need to distinguish between species with the same symbol, e.g., atoms of the - same species assigned to different atom-centered basis sets or pseudo-potentials, - or simply atoms in different locations in the structure such as those in the bulk - and on the surface. In the case where a species is not an atom, and therefore - cannot be representated by a chemical symbol, the label can simply be the name of - the particles. - ''' - ) - positions = Quantity( - type=np.dtype(np.float64), - shape=['n_atoms', 3], - unit='meter', - description=''' - Positions of all the species, in cartesian coordinates. This metadata defines a - configuration and is therefore required. For alloys where concentrations of - species are given for each site in the unit cell, it stores the position of the - sites. - ''' - ) - velocities = Quantity( - type=np.dtype(np.float64), - shape=['n_atoms', 3], - unit='meter / second', - description=''' - Velocities of the nuclei, defined as the change in cartesian coordinates of the - nuclei with respect to time. - ''' - ) - lattice_vectors = Quantity( - type=np.dtype(np.float64), - shape=[3, 3], - unit='meter', - description=''' - Lattice vectors in cartesian coordinates of the simulation cell. The - last (fastest) index runs over the $x,y,z$ Cartesian coordinates, and the first - index runs over the 3 lattice vectors. - ''' - ) - lattice_vectors_reciprocal = Quantity( - type=np.dtype(np.float64), - shape=[3, 3], - unit='1/meter', - description=''' - Reciprocal lattice vectors in cartesian coordinates of the simulation cell. The - first index runs over the $x,y,z$ Cartesian coordinates, and the second index runs - over the 3 lattice vectors. - ''' - ) - local_rotations = Quantity( - type=np.dtype(np.float64), - shape=['n_atoms', 3, 3], - description=''' - A rotation matrix defining the orientation of each atom. If the rotation matrix - cannot be specified for an atom, the remaining atoms should set it to - the zero matrix (not the identity!) - ''' - ) - periodic = Quantity( - type=bool, - shape=[3], - description=''' - Denotes if periodic boundary condition is applied to each of the lattice vectors.' - ''' - ) - supercell_matrix = Quantity( - type=np.dtype(np.int32), - shape=[3, 3], - description=''' - Specifies the matrix that transforms the unit-cell into the super-cell in which - the actual calculation is performed. - ''' - ) - species = SubSection(sub_section=Species.m_def, repeats=False) - wyckoff_sets = SubSection(sub_section=WyckoffSet.m_def, repeats=True) - - class Relation(MSection): ''' Contains information about the relation between two different systems. @@ -1180,7 +1060,15 @@ class System(MSection): ''', a_elasticsearch=Elasticsearch(material_type) ) - atoms = Quantity( + atoms = SubSection( + description=''' + The atomistic structure that is associated with this + system'. + ''', + sub_section=Structure.m_def, + repeats=False + ) + atoms_ref = Quantity( type=Structure, description=''' Reference to an atomistic structure that is associated with this @@ -1891,7 +1779,10 @@ class GeometryOptimization(MSection): ''', ) structure_optimized = SubSection( - sub_section=StructureOptimized.m_def, + description=''' + Contains a structure that is the result of a geometry optimization. + ''', + sub_section=Structure.m_def, repeats=False, ) type = MGeometryOptimization.type.m_copy() diff --git a/nomad/normalizing/common.py b/nomad/normalizing/common.py new file mode 100644 index 0000000000000000000000000000000000000000..b45ed93139ec71c8aa73f4dab29305704f8b0149 --- /dev/null +++ b/nomad/normalizing/common.py @@ -0,0 +1,248 @@ +# +# Copyright The NOMAD Authors. +# +# This file is part of NOMAD. See https://nomad-lab.eu for further info. +# +# Licensed under the Apache License, Version 2.0 (the 'License'); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an 'AS IS' BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +import numpy as np +from ase import Atoms +from typing import List, Set, Any, Optional +from nptyping import NDArray +from matid.symmetry.wyckoffset import WyckoffSet as WyckoffSetMatID +from nomad import atomutils +from nomad.units import ureg +from nomad.datamodel.metainfo.simulation.system import System +from nomad.datamodel.optimade import Species +from nomad.datamodel.results import ( + Cell, + Structure, + LatticeParameters, + WyckoffSet, +) + + +def wyckoff_sets_from_matid(wyckoff_sets: List[WyckoffSetMatID]) -> List[WyckoffSet]: + '''Given a dictionary of wyckoff sets, returns the metainfo equivalent. + + Args: + wyckoff_sets: List of Wyckoff sets as returned by MatID. + + Returns: + List of NOMAD WyckoffSet objects. + ''' + wsets = [] + for group in wyckoff_sets: + wset = WyckoffSet() + if group.x is not None or group.y is not None or group.z is not None: + if group.x is not None: + wset.x = float(group.x) + if group.y is not None: + wset.y = float(group.y) + if group.z is not None: + wset.z = float(group.z) + wset.indices = group.indices + wset.element = group.element + wset.wyckoff_letter = group.wyckoff_letter + wsets.append(wset) + return wsets + + +def species(labels: List[str], atomic_numbers: List[int], logger=None) -> Optional[List[Species]]: + '''Given a list of atomic labels and atomic numbers, returns the + corresponding list of Species objects. + + Args: + labels: List of atomic labels. + atomic_numbers: List of atomic numbers. If the atomic number does not + correspond to an actual element, an error message is logged and the + species for thatitem is not created. + + Returns: + List of Species objects. + ''' + if labels is None or atomic_numbers is None: + return None + species: Set[str] = set() + species_list = [] + for label, atomic_number in zip(labels, atomic_numbers): + if label not in species: + species.add(label) + i_species = Species() + i_species.name = label + try: + symbol = atomutils.chemical_symbols([atomic_number])[0] + except ValueError: + if logger: + logger.info(f'could not identify chemical symbol for atomic number {atomic_number}') + else: + i_species.chemical_symbols = [symbol] + i_species.concentration = [1.0] + species_list.append(i_species) + + return species_list + + +def lattice_parameters_from_array(lattice_vectors: NDArray[Any]) -> LatticeParameters: + '''Converts the given 3x3 numpy array into metainfo LatticeParameters. + Undefined angle values are not stored. + + Args: + lattice_vectors: 3x3 array where the lattice vectors are the rows. + Should be given in meters. + + Returns: + LatticeParameters object. + ''' + param_values = atomutils.cell_to_cellpar(lattice_vectors) + params = LatticeParameters() + params.a = float(param_values[0]) + params.b = float(param_values[1]) + params.c = float(param_values[2]) + alpha = float(param_values[3]) + params.alpha = None if np.isnan(alpha) else alpha + beta = float(param_values[4]) + params.beta = None if np.isnan(beta) else beta + gamma = float(param_values[5]) + params.gamma = None if np.isnan(gamma) else gamma + return params + + +def cell_from_ase_atoms(atoms: Atoms) -> Cell: + '''Extracts Cell metainfo from the given ASE Atoms. + Undefined angle values are not stored. + + Args: + atoms: The system from which the information is extracted from. + + Returns: + Cell object. + ''' + param_values = atomutils.cell_to_cellpar(atoms.cell) + cell = Cell() + cell.a = float(param_values[0]) * ureg.angstrom + cell.b = float(param_values[1]) * ureg.angstrom + cell.c = float(param_values[2]) * ureg.angstrom + alpha = float(param_values[3]) + cell.alpha = None if np.isnan(alpha) else alpha * ureg.radian + beta = float(param_values[4]) + cell.beta = None if np.isnan(beta) else beta * ureg.radian + gamma = float(param_values[5]) + cell.gamma = None if np.isnan(gamma) else gamma * ureg.radian + + volume = atoms.cell.volume * ureg.angstrom ** 3 + mass = atomutils.get_summed_atomic_mass(atoms.get_atomic_numbers()) * ureg.kg + mass_density = mass / volume + number_of_atoms = atoms.get_number_of_atoms() + atomic_density = number_of_atoms / volume + cell.volume = volume + cell.atomic_density = atomic_density + cell.mass_density = mass_density + + return cell + + +def cell_from_structure(structure: Structure) -> Cell: + '''Extracts Cell metainfo from the given Structure. + Undefined angle values are not stored. + + Args: + structure: The system from which the information is extracted from. + + Returns: + Cell object. + ''' + return Cell( + a=structure.lattice_parameters.a, + b=structure.lattice_parameters.b, + c=structure.lattice_parameters.c, + alpha=structure.lattice_parameters.alpha, + beta=structure.lattice_parameters.beta, + gamma=structure.lattice_parameters.gamma, + volume=structure.cell_volume, + atomic_density=structure.atomic_density, + mass_density=structure.mass_density, + ) + + +def structure_from_ase_atoms(atoms: Atoms, wyckoff_sets: List[WyckoffSetMatID] = None, logger=None) -> Structure: + '''Returns a populated instance of the given structure class from an + ase.Atoms-object. + + Args: + atoms: The system to transform + wyckoff_sets: Optional dictionary of Wyckoff sets. + logger: Optional logger to use + + Returns: + A new Structure created from the given data. + ''' + if atoms is None: + return None + struct = Structure() + labels = atoms.get_chemical_symbols() + atomic_numbers = atoms.get_atomic_numbers() + struct.species_at_sites = atoms.get_chemical_symbols() + struct.cartesian_site_positions = atoms.get_positions() * ureg.angstrom + struct.species = species(labels, atomic_numbers, logger) + lattice_vectors = atoms.get_cell() + if lattice_vectors is not None: + lattice_vectors = (lattice_vectors * ureg.angstrom).to(ureg.meter).magnitude + struct.dimension_types = [1 if x else 0 for x in atoms.get_pbc()] + struct.lattice_vectors = lattice_vectors + cell_volume = atomutils.get_volume(lattice_vectors) + struct.cell_volume = cell_volume + if atoms.get_pbc().all() and cell_volume: + mass = atomutils.get_summed_atomic_mass(atomic_numbers) + struct.mass_density = mass / cell_volume + struct.atomic_density = len(atoms) / cell_volume + if wyckoff_sets: + struct.wyckoff_sets = wyckoff_sets_from_matid(wyckoff_sets) + struct.lattice_parameters = lattice_parameters_from_array(lattice_vectors) + return struct + + +def structure_from_nomad_atoms(system: System, logger=None) -> Structure: + '''Returns a populated instance of the given structure class from a + NOMAD System-section. + + Args: + system: The system to transform + logger: Optional logger to use + + Returns: + A new Structure created from the given data. + ''' + if system is None: + return None + struct = Structure() + struct.cartesian_site_positions = system.atoms.positions + struct.species_at_sites = system.atoms.labels + labels = system.atoms.labels + atomic_numbers = system.atoms.species + struct.species = species(labels, atomic_numbers, logger) + lattice_vectors = system.atoms.lattice_vectors + if lattice_vectors is not None: + lattice_vectors = lattice_vectors.magnitude + struct.dimension_types = np.array(system.atoms.periodic).astype(int) + struct.lattice_vectors = lattice_vectors + cell_volume = atomutils.get_volume(lattice_vectors) + struct.cell_volume = cell_volume + if all(system.atoms.periodic) and cell_volume: + if system.atoms.species is not None: + mass = atomutils.get_summed_atomic_mass(atomic_numbers) + struct.mass_density = mass / cell_volume + struct.atomic_density = len(system.atoms.labels) / cell_volume + struct.lattice_parameters = lattice_parameters_from_array(lattice_vectors) + return struct diff --git a/nomad/normalizing/material.py b/nomad/normalizing/material.py index 3ec39c80afd3bb95d2e07990ea745065ffe3a2e7..beba2f130f863a0a335623aacfcb8d91e518b7cd 100644 --- a/nomad/normalizing/material.py +++ b/nomad/normalizing/material.py @@ -3,14 +3,14 @@ # # This file is part of NOMAD. See https://nomad-lab.eu for further info. # -# Licensed under the Apache License, Version 2.0 (the 'License'); +# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an 'AS IS' BASIS, +# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. @@ -28,10 +28,12 @@ import matid.geometry from matid.classification.structureclusterer import StructureClusterer from matid import Classifier from matid.classifications import Class0D, Atom, Class1D, Material2D, Surface, Class3D, Unknown - -from nomad.datamodel.results import Symmetry, Material, System, Cell, Relation, StructureOriginal +from matid.symmetry.symmetryanalyzer import SymmetryAnalyzer +from nomad.datamodel.results import Symmetry, Material, System, Relation, Structure, Prototype from nomad import atomutils from nomad.utils import hash +from nomad.units import ureg +from nomad.normalizing.common import cell_from_ase_atoms, cell_from_structure, structure_from_ase_atoms class MaterialNormalizer(): @@ -428,13 +430,15 @@ class MaterialNormalizer(): except Exception: return None - topology, original, structure_original = self._init_orig_topology(material) + topology = {} + top_id_original = f'/results/material/topology/0' + original, structure_original = self._create_orig_topology(material, top_id_original) + if structure_original is None: return [] - top_id = 0 - top_id_original = f'/results/material/topology/{top_id}' - top_id += 1 + topology[top_id_original] = original + top_id = 1 if groups: label_to_instances: Dict[str, List] = defaultdict(list) label_to_id: Dict[str, str] = {} @@ -549,74 +553,56 @@ class MaterialNormalizer(): ''' if material.structural_type not in {'2D', 'surface', 'unavailable'}: return None - topology, original, structure_original = self._init_orig_topology(material) + topologies = [] + id_original = f'/results/material/topology/0' + original, structure_original = self._create_orig_topology(material, id_original) if structure_original is None: return None + # TODO: MatID does not currently support non-periodic structures if structure_original.nperiodic_dimensions == 0: return None # TODO: It still needs to be decided what this limit should be. n_atoms = len(structure_original.species_at_sites) if n_atoms > 500: return None - top_id = 1 - top_id_str = f'/results/material/topology/{top_id}' - - # Perform clustering clusters = self._perform_matid_clustering(structure_original) + cluster_indices_list, cluster_symmetries = self._filter_clusters(clusters) + # Add all meaningful clusters to the topology - cluster_indices_list = self._filter_clusters(clusters) - for indices in cluster_indices_list: - system_type = self._system_type_analysis(structure_original, indices) - if system_type not in {"2D", "surface"}: + topologies.append(original) + for indices, symm in zip(cluster_indices_list, cluster_symmetries): + id_subsystem = f'/results/material/topology/{len(topologies)}' + subsystem = self._create_subsystem( + structure_original, indices, id_subsystem, id_original) + if subsystem.structural_type not in {"2D", "surface"}: continue - subsystem = self._create_subsystem(structure_original, indices, system_type, top_id) - - topology[top_id_str] = subsystem - parent_children = original.child_systems if original.child_systems else [] - parent_children.append(top_id_str) - original.child_systems = parent_children - top_id += 1 - top_id_str = f'/results/material/topology/{top_id}' - - # TODO: Analyze the connected cells - # (matid.core.linkedunits.LinkedUnitCollection) in the subsystem to - # figure out the structure type, conventional cell, orientation, - # etc. This data should be stored as children of the subsystem - # within the topology. - - # If the returned clusters contain more than one 2D/surface component, - # the topology is accepted and returned. TODO: This should be extended - # to also output more complex topologies. - if len(topology) < 3: + topologies.append(subsystem) + original = self._add_child_system(original, id_subsystem) + if subsystem.structural_type == 'surface': + id_conv = f'/results/material/topology/{len(topologies)}' + symmsystem = self._create_conv_cell_system(symm, id_conv, id_subsystem) + topologies.append(symmsystem) + subsystem = self._add_child_system(subsystem, id_conv) + + # If the returned clusters contain more than one 2D/surface subsystems, + # the topology is accepted and returned. TODO: This should be modified + # in the future to also accept other kind of topologies besides + # heterostructures. + if len([x for x in topologies if (x.structural_type in ('surface', '2D') and x.label == "subsystem")]) < 2: return None + return topologies - return list(topology.values()) - - def _init_orig_topology(self, material: Material) -> Tuple[Dict[str, System], System, StructureOriginal]: - topology: Dict[str, System] = {} - + def _create_orig_topology(self, material: Material, top_id: str) -> Tuple[System, Structure]: + ''' + Creates a new topology item for the original structure. + ''' structure_original = self._check_original_structure() if structure_original is None: - return None, None, None - - top_id = 0 - original = self._add_orig_topology_as_root(material, top_id) - - if structure_original: - original.cell = self._create_cell(structure_original) - original.atoms = structure_original - original.n_atoms = structure_original.n_sites - topology[str(top_id)] = original + return None, None - return topology, original, structure_original - - def _add_orig_topology_as_root(self, material: Material, top_id: int) -> System: - '''Adds the original system topology as root - ''' - top_id_str = f'/results/material/topology/{top_id}' original = System( - system_id=top_id_str, + system_id=top_id, method='parser', label='original', description='A representative system chosen from the original simulation.', @@ -631,29 +617,80 @@ class MaterialNormalizer(): elements=material.elements, ) - return original + if structure_original: + original.cell = cell_from_structure(structure_original) + original.atoms_ref = structure_original + original.n_atoms = structure_original.n_sites + return original, structure_original - def _check_original_structure(self) -> StructureOriginal: + def _create_subsystem(self, structure_original: Structure, indices: List[int], top_id: str, parent_id: str) -> System: + ''' + Creates a new subsystem as detected by MatID. + ''' + subsystem = System( + system_id=top_id, + method='matid', + label='subsystem', + description='Automatically detected subsystem.', + system_relation=Relation(type='subsystem'), + parent_system=parent_id + ) + system_type = self._system_type_analysis(structure_original, indices) + subsystem.structural_type = system_type + subsystem.indices = [indices] + subspecies = np.array(structure_original.species_at_sites)[indices] + subsystem = self._add_subsystem_properties(subspecies, subsystem) + return subsystem + + def _add_child_system(self, subsystem: System, top_id_str: str) -> System: + parent_children_subsystem = subsystem.child_systems if subsystem.child_systems else [] + parent_children_subsystem.append(top_id_str) + subsystem.child_systems = parent_children_subsystem + return subsystem + + def _create_conv_cell_system(self, symm, top_id: str, parent_id: str): + ''' + Creates a new topology item for a conventional cell. + ''' + symmsystem = System( + system_id=top_id, + method='matid', + label='conventional cell', + description='The conventional cell of the bulk material from which the surface is constructed from.', + system_relation=Relation(type='subsystem'), + parent_system=parent_id + ) + conv_system = symm.get_conventional_system() + wyckoff_sets = symm.get_wyckoff_sets_conventional() + symmsystem.atoms = structure_from_ase_atoms(conv_system, wyckoff_sets, logger=self.logger) + subspecies = conv_system.get_chemical_symbols() + symmsystem.structural_type = 'bulk' + symmsystem = self._add_subsystem_properties(subspecies, symmsystem) + symmsystem = self._create_symmsystem(symm, symmsystem) + return symmsystem + + def _check_original_structure(self) -> Optional[Structure]: ''' Checks if original system is available and if system size is processable. The topology is created only if structural_type == unavailable and a meaningful topology can be extracted. ''' + structure_original = None try: structure_original = self.properties.structures.structure_original except Exception: - return None + pass return structure_original - def _perform_matid_clustering(self, structure_original: StructureOriginal) -> list: + def _perform_matid_clustering(self, structure_original: Structure) -> List: ''' Creates an ase.atoms and performs the clustering with MatID ''' system = Atoms( symbols=structure_original.species_at_sites, - positions=structure_original.cartesian_site_positions * 1e10, - cell=complete_cell(structure_original.lattice_vectors * 1e10), + positions=structure_original.cartesian_site_positions.to(ureg.angstrom), + cell=complete_cell(structure_original.lattice_vectors.to(ureg.angstrom)), pbc=np.array(structure_original.dimension_types, dtype=bool) ) @@ -669,24 +706,7 @@ class MaterialNormalizer(): ) return clusters - def _create_cell(self, structure_original: StructureOriginal) -> Cell: - ''' - Creates a Cell from the given structure. - ''' - cell = Cell( - a=structure_original.lattice_parameters.a, - b=structure_original.lattice_parameters.b, - c=structure_original.lattice_parameters.c, - alpha=structure_original.lattice_parameters.alpha, - beta=structure_original.lattice_parameters.beta, - gamma=structure_original.lattice_parameters.gamma, - volume=structure_original.cell_volume, - atomic_density=structure_original.atomic_density, - mass_density=structure_original.mass_density, - ) - return cell - - def _filter_clusters(self, clusters: StructureClusterer) -> List[List[int]]: + def _filter_clusters(self, clusters: StructureClusterer) -> Tuple[List[List[int]], List[Symmetry]]: ''' Filters all clusters < 2 atoms and creates a cluster indices list of the remaining clusters @@ -702,13 +722,25 @@ class MaterialNormalizer(): # would be grouped into one cluster? filtered_cluster = filter(lambda x: len(x.indices) > 1, clusters) cluster_indices_list: List[List[int]] = [] + cluster_symmetries: List[Symmetry] = [] for cluster in filtered_cluster: indices = list(cluster.indices) cluster_indices_list += [indices] - - return cluster_indices_list - - def _system_type_analysis(self, structure_original: StructureOriginal, indices: List[int]) -> matid.classifications: + regions = cluster.regions + number_of_atoms: List[int] = [] + for region in regions: + if region: + number_of_atoms.append(region.cell.get_number_of_atoms()) + + # TODO: What happens when there are 2 regions that have the same size? + largest_region_index = number_of_atoms.index(max(number_of_atoms)) + largest_region_system = regions[largest_region_index].cell + # TODO: only SymmetryAnalyzer for 2D and surface + symm = SymmetryAnalyzer(largest_region_system) + cluster_symmetries += [symm] + return cluster_indices_list, cluster_symmetries + + def _system_type_analysis(self, structure_original: Structure, indices: List[int]) -> matid.classifications: ''' Classifies ase.atoms and returns the MatID system type as a string. ''' @@ -722,8 +754,8 @@ class MaterialNormalizer(): # Create the system as ASE.Atoms cluster_atoms = Atoms( symbols=np.array(structure_original.species_at_sites)[indices], - positions=np.array(structure_original.cartesian_site_positions)[indices] * 1e10, - cell=complete_cell(structure_original.lattice_vectors * 1e10), + positions=structure_original.cartesian_site_positions.to(ureg.angstrom)[indices], + cell=complete_cell(structure_original.lattice_vectors.to(ureg.angstrom)), pbc=np.array(structure_original.dimension_types, dtype=bool) ) try: @@ -743,31 +775,77 @@ class MaterialNormalizer(): system_type = 'unavailable' return system_type - def _create_subsystem(self, structure_original: StructureOriginal, indices: List[int], system_type: str, top_id: int) -> System: - ''' - Creates the subsystem with system type - ''' - subspecies = np.array(structure_original.species_at_sites)[indices] - formula = atomutils.Formula(''.join(subspecies)) + def _add_subsystem_properties(self, subspecies: List[str], subsystem) -> System: + formula = atomutils.Formula("".join(subspecies)) formula_hill = formula.format('hill') formula_anonymous = formula.format('anonymous') formula_reduced = formula.format('reduce') elements = formula.elements() - top_id_str = f'/results/material/topology/{top_id}' + subsystem.formula_hill = formula_hill + subsystem.formula_anonymous = formula_anonymous + subsystem.formula_reduced = formula_reduced + subsystem.elements = elements + return subsystem - subsystem = System( - system_id=top_id_str, - method='matid', - label='subsystem', - description='Automatically detected subsystem.', - structural_type=system_type, - indices=[indices], - system_relation=Relation(type='subsystem'), - formula_hill=formula_hill, - formula_anonymous=formula_anonymous, - formula_reduced=formula_reduced, - elements=elements, - parent_system='/results/material/topology/0', - n_atoms=len(indices) - ) + def _create_symmsystem(self, symm: SymmetryAnalyzer, subsystem: System) -> System: + """ + Creates the subsystem with the symmetry information of the conventional cell + """ + conv_system = symm.get_conventional_system() + subsystem.cell = cell_from_ase_atoms(conv_system) + symmetry = self._create_symmetry(subsystem, symm) + subsystem.symmetry = symmetry + prototype = self._create_prototype(symm, conv_system) + spg_number = symm.get_space_group_number() + subsystem.prototype = prototype + wyckoff_sets = symm.get_wyckoff_sets_conventional() + material_id = self.material_id_bulk(spg_number, wyckoff_sets) + subsystem.material_id = material_id return subsystem + + def _create_symmetry(self, subsystem: System, symm: SymmetryAnalyzer) -> Symmetry: + international_short = symm.get_space_group_international_short() + + sec_symmetry = Symmetry() + sec_symmetry.symmetry_method = 'MatID' + sec_symmetry.space_group_number = symm.get_space_group_number() + sec_symmetry.space_group_symbol = international_short + sec_symmetry.hall_number = symm.get_hall_number() + sec_symmetry.hall_symbol = symm.get_hall_symbol() + sec_symmetry.international_short_symbol = international_short + sec_symmetry.point_group = symm.get_point_group() + sec_symmetry.crystal_system = symm.get_crystal_system() + sec_symmetry.bravais_lattice = symm.get_bravais_lattice() + sec_symmetry.origin_shift = symm._get_spglib_origin_shift() + sec_symmetry.transformation_matrix = symm._get_spglib_transformation_matrix() + return sec_symmetry + + def _create_prototype(self, symm: SymmetryAnalyzer, conv_system: System) -> Prototype: + spg_number = symm.get_space_group_number() + atom_species = conv_system.get_atomic_numbers() + wyckoffs = conv_system.wyckoff_letters + norm_wyckoff = atomutils.get_normalized_wyckoff(atom_species, wyckoffs) + protoDict = atomutils.search_aflow_prototype(spg_number, norm_wyckoff) + + if protoDict is not None: + aflow_prototype_name = protoDict["Prototype"] + aflow_strukturbericht_designation = protoDict["Strukturbericht Designation"] + prototype_label = '%d-%s-%s' % ( + spg_number, + aflow_prototype_name, + protoDict.get("Pearsons Symbol", "-") + ) + prototype = Prototype() + prototype.label = prototype_label + + prototype.formula = atomutils.Formula("".join(protoDict['atom_labels'])).format('hill') + prototype.aflow_id = protoDict["aflow_prototype_id"] + prototype.aflow_url = protoDict["aflow_prototype_url"] + prototype.assignment_method = "normalized-wyckoff" + prototype.m_cache["prototype_notes"] = protoDict["Notes"] + prototype.m_cache["prototype_name"] = aflow_prototype_name + if aflow_strukturbericht_designation != "None": + prototype.m_cache["strukturbericht_designation"] = aflow_strukturbericht_designation + else: + prototype = None + return prototype diff --git a/nomad/normalizing/results.py b/nomad/normalizing/results.py index 4a6e0f7d9e9e1247bd26ac41ad246acf5320218b..765919918959cd1f830fb785e8aab51d35ae362b 100644 --- a/nomad/normalizing/results.py +++ b/nomad/normalizing/results.py @@ -19,15 +19,14 @@ import re from nomad.datamodel.metainfo.workflow import Workflow import numpy as np -from typing import Dict, List, Union, Any, Set, Optional +from typing import List, Union, Any, Set, Optional import ase.data -from ase import Atoms from matid import SymmetryAnalyzer import matid.geometry from nomad import config -from nomad.units import ureg from nomad import atomutils +from nomad.normalizing.common import structure_from_ase_atoms, structure_from_nomad_atoms from nomad.normalizing.normalizer import Normalizer from nomad.normalizing.method import MethodNormalizer from nomad.normalizing.material import MaterialNormalizer @@ -51,12 +50,6 @@ from nomad.datamodel.results import ( StructuralProperties, Structures, Structure, - StructureOriginal, - StructurePrimitive, - StructureConventional, - StructureOptimized, - LatticeParameters, - WyckoffSet, EnergyVolumeCurve, BulkModulus, ShearModulus, @@ -414,7 +407,7 @@ class ResultsNormalizer(Normalizer): geo_opt_wf = workflow.geometry_optimization geo_opt.trajectory = workflow.calculations_ref system_ref = workflow.calculation_result_ref.system_ref - structure_optimized = self.nomad_system_to_structure(StructureOptimized, system_ref) + structure_optimized = structure_from_nomad_atoms(system_ref) if structure_optimized: geo_opt.structure_optimized = structure_optimized if geo_opt_wf is not None: @@ -560,10 +553,10 @@ class ResultsNormalizer(Normalizer): elif structural_type == "1D": conv_atoms, prim_atoms = self.structures_1d(original_atoms) - struct_orig = self.ase_atoms_to_structure(StructureOriginal, original_atoms) - struct_prim = self.ase_atoms_to_structure(StructurePrimitive, prim_atoms) + struct_orig = structure_from_ase_atoms(original_atoms, logger=self.logger) + struct_prim = structure_from_ase_atoms(prim_atoms, logger=self.logger) wyckoff_sets_serialized = wyckoff_sets if structural_type == "bulk" else None - struct_conv = self.ase_atoms_to_structure(StructureConventional, conv_atoms, wyckoff_sets_serialized) + struct_conv = structure_from_ase_atoms(conv_atoms, wyckoff_sets_serialized, logger=self.logger) if struct_orig or struct_prim or struct_conv: structures = Structures() @@ -643,22 +636,6 @@ class ResultsNormalizer(Normalizer): return properties, conv_atoms, wyckoff_sets, spg_number - def wyckoff_sets(self, struct: StructureConventional, wyckoff_sets: Dict) -> None: - """Populates the Wyckoff sets in the given structure. - """ - for group in wyckoff_sets: - wset = struct.m_create(WyckoffSet) - if group.x is not None or group.y is not None or group.z is not None: - if group.x is not None: - wset.x = float(group.x) - if group.y is not None: - wset.y = float(group.y) - if group.z is not None: - wset.z = float(group.z) - wset.indices = group.indices - wset.element = group.element - wset.wyckoff_letter = group.wyckoff_letter - def structures_bulk(self, repr_symmetry): """The symmetry of bulk structures has already been analyzed. Here we use the cached results. @@ -812,75 +789,6 @@ class ResultsNormalizer(Normalizer): ) return conv_atoms, prim_atoms - def ase_atoms_to_structure(self, structure_class, atoms: Atoms, wyckoff_sets: dict = None): - """Returns a populated instance of the given structure class from an - ase.Atoms-object. - """ - if not atoms or not structure_class: - return None - struct = structure_class() - struct.species_at_sites = atoms.get_chemical_symbols() - self.species(atoms.get_chemical_symbols(), atoms.get_atomic_numbers(), struct) - struct.cartesian_site_positions = atoms.get_positions() * ureg.angstrom - lattice_vectors = atoms.get_cell() - if lattice_vectors is not None: - lattice_vectors = (lattice_vectors * ureg.angstrom).to(ureg.meter).magnitude - struct.dimension_types = [1 if x else 0 for x in atoms.get_pbc()] - struct.lattice_vectors = lattice_vectors - cell_volume = atomutils.get_volume(lattice_vectors) - struct.cell_volume = cell_volume - if atoms.get_pbc().all() and cell_volume: - mass = atomutils.get_summed_atomic_mass(atoms.get_atomic_numbers()) - struct.mass_density = mass / cell_volume - struct.atomic_density = len(atoms) / cell_volume - if wyckoff_sets: - self.wyckoff_sets(struct, wyckoff_sets) - struct.lattice_parameters = self.lattice_parameters(lattice_vectors) - return struct - - def nomad_system_to_structure(self, structure_class, system: System) -> Structure: - """Returns a populated instance of the given structure class from a - NOMAD System-section. - """ - if not system or not structure_class: - return None - - struct = structure_class() - struct.cartesian_site_positions = system.atoms.positions - struct.species_at_sites = system.atoms.labels - self.species(system.atoms.labels, system.atoms.species, struct) - lattice_vectors = system.atoms.lattice_vectors - if lattice_vectors is not None: - lattice_vectors = lattice_vectors.magnitude - struct.dimension_types = np.array(system.atoms.periodic).astype(int) - struct.lattice_vectors = lattice_vectors - cell_volume = atomutils.get_volume(lattice_vectors) - struct.cell_volume = cell_volume - if all(system.atoms.periodic) and cell_volume: - if system.atoms.species is not None: - mass = atomutils.get_summed_atomic_mass(system.atoms.species) - struct.mass_density = mass / cell_volume - struct.atomic_density = len(system.atoms.labels) / cell_volume - struct.lattice_parameters = self.lattice_parameters(lattice_vectors) - return struct - - def lattice_parameters(self, lattice_vectors) -> LatticeParameters: - """Converts the given cell into LatticeParameters. Undefined angle - values are not stored. - """ - param_values = atomutils.cell_to_cellpar(lattice_vectors) - params = LatticeParameters() - params.a = float(param_values[0]) - params.b = float(param_values[1]) - params.c = float(param_values[2]) - alpha = float(param_values[3]) - params.alpha = None if np.isnan(alpha) else alpha - beta = float(param_values[4]) - params.beta = None if np.isnan(beta) else beta - gamma = float(param_values[5]) - params.gamma = None if np.isnan(gamma) else gamma - return params - def energy_volume_curves(self) -> List[EnergyVolumeCurve]: """Returns a list containing the found EnergyVolumeCurves. """ diff --git a/requirements.txt b/requirements.txt index 2c83a7d68cda083026b02faf56d10bc94d438aa5..dcd43781a3bcf25580c425053ed0dd6d665be612 100644 --- a/requirements.txt +++ b/requirements.txt @@ -119,4 +119,4 @@ markupsafe==2.0.1 mkdocs==1.2.3 mkdocs-material==8.1.1 mkdocs-material-extensions==1.0.3 -mkdocs-macros-plugin==0.6.3 +mkdocs-macros-plugin==0.6.3 \ No newline at end of file diff --git a/tests/data/normalizers/topology/heterostructure_surface_1.json b/tests/data/normalizers/topology/heterostructure_surface_1.json index 32e03a13b1dd424668decddc283930304fc32810..796681b218596b955f4d204add4674b3b0a17bb9 100644 --- a/tests/data/normalizers/topology/heterostructure_surface_1.json +++ b/tests/data/normalizers/topology/heterostructure_surface_1.json @@ -13,9 +13,9 @@ "method": "parser", "label": "original", "structural_type": "unavailable", - "elements": ["Ba","In","La","O","Sn"], + "elements": ["Ba","In","La","O","Sn"], "formula_hill": "Ba8In8La10O50Sn8", - "children": [1,2,3,4,5,6,7] + "children": [1,3] }, { "description": "Automatically detected subsystem.", "id": "1", "method": "matid", @@ -25,9 +25,44 @@ "parent": "0", "indices": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39], "structural_type": "surface" + }, { + "id": "2", + "label": "conventional cell", + "method": "matid", + "description": "This is the calulated conventional cell of the bulk material to which the surface belongs.", + "material_id": "xu7SAVpJAcbRCUCT_DFeXzk5eRC8", + "structural_type": "bulk", + "elements": ["Ba","O","Sn" + ], + "formula_hill": "BaO3Sn", + "parent": "1", + "system_relation": { + "type": "subsystem" + }, + "cell": { + "a": 4.156981936464707e-10, + "b": 4.156981936464707e-10, + "c": 4.156981936464707e-10, + "alpha": 1.5707963267948966, + "beta": 1.5707963267948966, + "gamma": 1.5707963267948966, + "volume": 7.183472144822988e-29, + "atomic_density": 6.9604223406134025e+28, + "mass_density": 7028.081687087191 + }, + "symmetry": { + "m_def": "nomad.datamodel.results.Symmetry", + "bravais_lattice": "cP", + "crystal_system": "cubic", + "hall_number": 517, + "hall_symbol": "-P 4 2 3", + "point_group": "m-3m", + "space_group_number": 221, + "space_group_symbol": "Pm-3m" + } }, { "description": "Automatically detected subsystem.", - "id": "7", + "id": "3", "method": "matid", "label": "subsystem", "elements": ["In","La","O"], diff --git a/tests/data/normalizers/topology/heterostructure_surface_2.json b/tests/data/normalizers/topology/heterostructure_surface_2.json index 56c66b37ebf23a5cecba442050e878148219681f..81b2a2a33ee4288112d218b6c5f964c3d39e18cd 100644 --- a/tests/data/normalizers/topology/heterostructure_surface_2.json +++ b/tests/data/normalizers/topology/heterostructure_surface_2.json @@ -15,7 +15,7 @@ "structural_type": "unavailable", "elements": ["Ba","In","La","O","Sn","Ti"], "formula_hill": "Ba32In8La8O116Sn22Ti8", - "children": [1,2,3,4,5] + "children": [1,3,5] }, { "description": "Automatically detected subsystem.", "id": "1", @@ -27,8 +27,44 @@ "indices": [150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193], "structural_type": "surface" }, { - "description":"Automatically detected subsystem.", "id": "2", + "label": "conventional cell", + "method": "matid", + "description": "This is the calulated conventional cell of the bulk material to which the surface belongs.", + "material_id": "sQqatLgYtaNbe4huwmDtJgtXzGwV", + "structural_type": "bulk", + "elements": ["Ba","O","Ti"], + "formula_hill": "BaO3Ti", + "formula_reduced": "BaO3Ti", + "formula_anonymous": "A3BC", + "parent": "1", + "system_relation": { + "type": "subsystem" + }, + "cell": { + "a": 4.0407750027833107e-10, + "b": 4.0407750027833107e-10, + "c": 4.0407750027833107e-10, + "alpha": 1.5707963267948966, + "beta": 1.5707963267948966, + "gamma": 1.5707963267948966, + "volume": 6.597721913637704e-29, + "atomic_density": 7.578373361970348e+28, + "mass_density": 5869.036867505874 + }, + "symmetry": { + "m_def": "nomad.datamodel.results.Symmetry", + "bravais_lattice": "cP", + "crystal_system": "cubic", + "hall_number": 517, + "hall_symbol": "-P 4 2 3", + "point_group": "m-3m", + "space_group_number": 221, + "space_group_symbol": "Pm-3m" + } + }, { + "description":"Automatically detected subsystem.", + "id": "3", "method": "matid", "label": "subsystem", "elements": ["Ba","O","Sn"], @@ -36,6 +72,42 @@ "parent": "0", "indices": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,112,113], "structural_type": "surface" + }, { + "id": "4", + "label": "conventional cell", + "method": "matid", + "description": "This is the calulated conventional cell of the bulk material to which the surface belongs.", + "material_id": "xu7SAVpJAcbRCUCT_DFeXzk5eRC8", + "structural_type": "bulk", + "elements": ["Ba","O","Sn"], + "formula_hill": "BaO3Sn", + "formula_reduced": "BaO3Sn", + "formula_anonymous": "A3BC", + "parent": "3", + "system_relation": { + "type": "subsystem" + }, + "cell": { + "a": 4.109036559040578e-10, + "b": 4.109036559040578e-10, + "c": 4.109036559040578e-10, + "alpha": 1.5707963267948966, + "beta": 1.5707963267948966, + "gamma": 1.5707963267948966, + "volume": 6.937771882094769e-29, + "atomic_density": 7.206924766298767e+28, + "mass_density": 7276.980259473133 + }, + "symmetry": { + "m_def": "nomad.datamodel.results.Symmetry", + "bravais_lattice": "cP", + "crystal_system": "cubic", + "hall_number": 517, + "hall_symbol": "-P 4 2 3", + "point_group": "m-3m", + "space_group_number": 221, + "space_group_symbol": "Pm-3m" + } }, { "description": "Automatically detected subsystem.", "id": "5", diff --git a/tests/normalizing/conftest.py b/tests/normalizing/conftest.py index 1d37530fd388733abc50c72d56c49d9b19e2ae7d..d82dad4d2fd94f4461986c68367e2195c0327e43 100644 --- a/tests/normalizing/conftest.py +++ b/tests/normalizing/conftest.py @@ -628,8 +628,7 @@ def molecular_dynamics() -> EntryArchive: return run_normalize(template) -@pytest.fixture(scope='session') -def topology_calculation() -> EntryArchive: +def get_template_topology(pbc=False) -> EntryArchive: template = get_template_dft() run = template.run[0] del run.system[0] @@ -640,8 +639,8 @@ def topology_calculation() -> EntryArchive: water2.translate([5, 0, 0]) sys = water1 + water2 sys.set_cell([10, 10, 10]) - sys.set_pbc(True) - system = get_section_system(water1 + water2) + sys.set_pbc(pbc) + system = get_section_system(sys) run.m_add_sub_section(Run.system, system) # Topology diff --git a/tests/normalizing/test_material.py b/tests/normalizing/test_material.py index b1fbd03768acb3ffea23506ee38f3d52a118a330..4fc49194170c9f23b613866a9d346068ebc5913d 100644 --- a/tests/normalizing/test_material.py +++ b/tests/normalizing/test_material.py @@ -27,7 +27,7 @@ from matid.symmetry.wyckoffset import WyckoffSet from nomad.units import ureg from nomad import atomutils from nomad.utils import hash -from tests.normalizing.conftest import get_template_for_structure +from tests.normalizing.conftest import get_template_for_structure, get_template_topology def assert_material(material): @@ -562,19 +562,30 @@ def test_conventional_structure(atoms, expected): assert np.allclose(cell, expected.get_cell()) -def test_topology_calculation(topology_calculation): +@pytest.mark.parametrize( + "pbc", + [ + pytest.param(True, id="fully periodic"), + pytest.param(True, id="non-periodic"), + ] +) +def test_topology_calculation(pbc): """Tests that a topology that originates from the calculation itself is correctly extracted. """ + topology_calculation = get_template_topology(pbc) topology = topology_calculation.results.material.topology assert len(topology) == 5 + # Test the original structure original = topology[0] assert original.structural_type == "unavailable" - assert original.atoms.cartesian_site_positions.shape == (6, 3) - assert len(original.atoms.species_at_sites) == 6 - assert original.atoms.lattice_vectors.shape == (3, 3) - assert original.atoms.dimension_types == [False, False, False] + assert original.atoms_ref.cartesian_site_positions.shape == (6, 3) + assert len(original.atoms_ref.species_at_sites) == 6 + assert original.atoms_ref.lattice_vectors.shape == (3, 3) + expected_pbc = np.zeros(3, bool) + expected_pbc[:] = pbc + assert original.atoms_ref.dimension_types == expected_pbc.tolist() assert original.formula_hill == "H4O2" assert original.formula_reduced == "H4O2" assert original.formula_anonymous == "A4B2" @@ -646,7 +657,7 @@ def test_topology_calculation(topology_calculation): pytest.param('surface', id='surface'), ]) def test_no_topology(fixture, request): - # Test that some entries don't get a topology. This will change later, but + # Test that some entries don't get a topology. This will changed later, but # for now we only create topologies for a subset of systems. entry = request.getfixturevalue(fixture) assert not entry.results.material.topology @@ -679,64 +690,141 @@ def test_topology_matid(entry_id): # Parse ase.atoms and get calculated topology entry_archive = get_template_for_structure(atoms) topology = entry_archive.results.material.topology - assert len(topology) == len(ref_topology) + + number_of_systems = 1 outlier_threshold = 1 # Compare topology with reference system topology. topology[0] is the original system for cluster in topology[1:]: - elements = cluster['elements'] - formula_hill = cluster['formula_hill'] - indices = cluster['indices'] - system_type = cluster['structural_type'] - if len(indices[0]) <= outlier_threshold: + if cluster['label'] == 'subsystem': + ref_number_of_systems = assert_subsystem(cluster, ref_topology, outlier_threshold) + number_of_systems += 1 + if ref_number_of_systems is None: + continue + elif cluster['label'] == 'conventional cell': + assert_conventional_cell(cluster, ref_topology) + assert number_of_systems == ref_number_of_systems + + +def assert_subsystem(cluster, ref_topology, outlier_threshold): + elements = cluster['elements'] + formula_hill = cluster['formula_hill'] + indices = cluster['indices'] + system_type = cluster['structural_type'] + if len(indices[0]) <= outlier_threshold: + return None + similarity_value = [] + ref_number_of_systems = 1 + for ref_cluster in ref_topology[1:]: + if ref_cluster['label'] != 'subsystem': + similarity_value += [0] + continue + ref_number_of_systems += 1 + # Load reference cluster. Pass if system type is not a surface or 2D. + ref_system_type = ref_cluster['structural_type'] + assert ref_system_type in {'2D', 'surface'} + + ref_elements = ref_cluster['elements'] + ref_formula_hill = ref_cluster['formula_hill'] + ref_indices = ref_cluster['indices'] + # Similarity calculation + indices_overlap = set( + ref_indices).intersection(set(indices[0])) + indices_similarity = len( + indices_overlap) / len(ref_indices) > 0.90 + element_similarity = set(ref_elements) == set(elements) + formula_hill_similarity = ref_formula_hill == formula_hill + system_type_similarity = ref_system_type == system_type + + similarity_value += [indices_similarity + element_similarity + + formula_hill_similarity + system_type_similarity] + + # Get most similar reference cluster. +1 because 0 is the original system + max_similarity = similarity_value.index(max(similarity_value)) + 1 + topology_max_similarity = ref_topology[max_similarity] + + # Indices: passes if the index overlapp is great enough + ref_indices_most_similar = topology_max_similarity['indices'] + indices_overlap_most_similar = set( + ref_indices_most_similar).intersection(set(indices[0])) + assert len(indices_overlap_most_similar) / \ + len(ref_indices_most_similar) > 0.85 + + # Elements + assert set(topology_max_similarity['elements']) == set(elements) + + # Formula hill: passes if the deviation is smaller than 15% + if topology_max_similarity['formula_hill'] != formula_hill: + ref_element_quantity = Formula(topology_max_similarity['formula_hill']).count() + element_quantity = Formula(formula_hill).count() + diff = 0 + for element in ref_element_quantity.keys(): + diff += abs(ref_element_quantity[element] - element_quantity[element]) + deviation = diff / sum(ref_element_quantity.values()) + assert deviation < 0.15 + + # System type + assert topology_max_similarity['structural_type'] == system_type + + return ref_number_of_systems + + +def assert_conventional_cell(cluster, ref_topology): + elements = cluster['elements'] + formula_hill = cluster['formula_hill'] + material_id = cluster['material_id'] + cell = cluster['cell'] + symmetry = cluster['symmetry'].m_to_dict() + + similarity_value = [] + + for ref_cluster in ref_topology[1:]: + if ref_cluster['label'] != 'conventional cell': + similarity_value += [0] continue - max_similarity = [] - similarity_value = [] - for ref_cluster in ref_topology[1:]: - - # Load reference cluster. Pass if system type is not a surface or 2D. - ref_system_type = ref_cluster['structural_type'] - assert ref_system_type in {'2D', 'surface'} - - ref_elements = ref_cluster['elements'] - ref_formula_hill = ref_cluster['formula_hill'] - ref_indices = ref_cluster['indices'] - - # Similarity calculation - indices_overlap = set( - ref_indices).intersection(set(indices[0])) - indices_similarity = len( - indices_overlap) / len(ref_indices) > 0.90 - element_similarity = set(ref_elements) == set(elements) - formula_hill_similarity = ref_formula_hill == formula_hill - system_type_similarity = ref_system_type == system_type - - similarity_value += [indices_similarity + element_similarity - + formula_hill_similarity + system_type_similarity] - - # Get most similar reference cluster. +1 because 0 is the original system - max_similarity = similarity_value.index(max(similarity_value)) + 1 - topology_max_similarity = ref_topology[max_similarity] - - # Indices: passes if the index overlapp is great enough - ref_indices_most_similar = topology_max_similarity['indices'] - indices_overlap_most_similar = set( - ref_indices_most_similar).intersection(set(indices[0])) - assert len(indices_overlap_most_similar) / \ - len(ref_indices_most_similar) > 0.85 - - # Elements - assert set(topology_max_similarity['elements']) == set(elements) - - # Formula hill: passes if the deviation is smaller than 10% - if topology_max_similarity['formula_hill'] != formula_hill: - ref_element_quantity = Formula(topology_max_similarity['formula_hill']).count() - element_quantity = Formula(formula_hill).count() - diff = 0 - for element in ref_element_quantity.keys(): - diff += abs(ref_element_quantity[element] - element_quantity[element]) - deviation = diff / sum(ref_element_quantity.values()) - assert deviation < 0.15 - - # System type - assert topology_max_similarity['structural_type'] == system_type + ref_elements = ref_cluster['elements'] + ref_formula_hill = ref_cluster['formula_hill'] + ref_material_id = ref_cluster['material_id'] + ref_cell = ref_cluster['cell'] + ref_symmetry = ref_cluster['symmetry'] + + element_similarity = set(ref_elements) == set(elements) + formula_hill_similarity = ref_formula_hill == formula_hill + material_id_similarity = ref_material_id == material_id + symmetrie_similarity = 0 + + # Cell + cell_similarity = np.allclose(list(cell.values()), list(ref_cell.values()), rtol=1e-05, atol=1e-12) + + # Symmetry + for ref_symmetry_property_key, ref_symmetry_property in ref_symmetry.items(): + symmetry_property = symmetry[ref_symmetry_property_key] + symmetrie_similarity += symmetry_property == ref_symmetry_property + + symmetrie_similarity = symmetrie_similarity / len(symmetry) + + similarity_value += [element_similarity + formula_hill_similarity + material_id_similarity + cell_similarity + symmetrie_similarity] + + if similarity_value == []: + return + + # TODO: For now, this is necessary to prevent some tests from failing. The algorithm calculates conventional cells that are most likely not correct. Therefore, these conventional cells are not included in the reference data, but are calculated nevertheless. To prevent the comparison of these conventional cells, I set a threshold for the similarity value for comparison. This should be removed as soon as the test data is more suitable! + if max(similarity_value) <= 3: + return + + # Get most similar reference cluster. +1 because 0 is the original system + max_similarity = similarity_value.index(max(similarity_value)) + 1 + topology_max_similarity = ref_topology[max_similarity] + + # Elements, formula hill, material id: + assert topology_max_similarity['elements'] == elements + assert topology_max_similarity['formula_hill'] == formula_hill + assert topology_max_similarity['material_id'] == material_id + + # Cell: + assert np.allclose(list(cell.values()), list(topology_max_similarity['cell'].values()), rtol=3e-03, atol=1e-12) + + # Symmetry: + for ref_symmetry_property_key, ref_symmetry_property in ref_symmetry.items(): + symmetry_property = symmetry[ref_symmetry_property_key] + assert symmetry_property == ref_symmetry_property