Tunable topological chirality in ferroelectric nanomaterials

The 21st century has witnessed a revolutionary shift in the understanding of properties of matter driven by the application of topological principles. While the traditional approach to material science has been focusing on local interactions, topology introduces a global, non-local description in which the geometry of a material profoundly influences its properties. Ferroelectric materials, with their spontaneous electric polarization, have long been essential for understanding fundamental physical phenomena, which have led to numerous practical applications. Recent discoveries have revealed that nanostructured ferroelectrics host a wealth of fundamental topological states, which effectively enrich the landscape of ferroelectric research. This Review explores the topological foundation of ferroelectricity, rooted in the electrostatic essence of these materials. Drawing upon the analogy between the hydrodynamics of incompressible fluids and the electrostatics of polarization fields, we establish a comprehensive framework for classifying the complex topological states observed in ferroelectrics. We demonstrate that the rich diversity of polarization structures can be exhaustively described using the advanced topological approach. By extending fundamental topological concepts such as helicity, fibration, foliation, and ergodicity, we offer a systematic analysis of the topological textures in ferroelectrics. This work provides a coherent framework for understanding and manipulating topological structures in nanostructured ferroelectrics, paving the way for innovations in materials science and technology.

#Template_programmable_filter:

class Input:

    def __init__(self, source):

        self._source = source

        self._accessor = None

    def set_accessor(self, accessor):

        self._accessor = accessor

    def clean_accessor(self):

        self._accessor = None

    def __getitem__(self, property_name):

        if not self._accessor:

            return self._source[property_name]

        else:

            return self._source.__getattribute__(self._accessor)[property_name]

    def get_coordinates(self):

        return self._source.Points

class IndexedInput(Input):

    def __init__(self, source, index):

        super().__init__(source[index])

class Output:

    def __init__(self, sink):

        self._sink = sink

        self._accessor = None

    def set_accessor(self, accessor):

        self._accessor = accessor

    def clean_accessor(self):

        self._accessor = None

    def write(self, characterictic):

        if not self._accessor:

            self._sink.append(characterictic.value, characterictic.name)

        else:

            self._sink.__getattribute__(self._accessor).append(characterictic.value, characterictic.name)

class Accessor:

    def __init__(self, connection, accessor):

        self._connection = connection

        self._accessor = accessor

    def __enter__(self):

        self._connection.set_accessor(self._accessor)

        return self

    def __exit__(self, exc_type, exc_value, exc_traceback):

        self._connection.clean_accessor()

    def __getitem__(self, property_name):

        return self._connection[property_name]

    @property

    def connection(self):

        return self._connection

class Characteristic:

    def __init__(self, name, value):

        self._name = name

        self._value = value

    @property

    def name(self):

        return self._name

    @property

    def value(self):

        return self._value

class PolarizationCharacteristics:

    def __init__(self, P):

        self._P = P

    def bound_charge(self):

        return Characteristic('Bound charge', -divergence(self._P))

    def chirality(self):

        return Characteristic('Chirality', dot(self._P, curl(self._P)))

    def toroidal_moment(self):

        return Characteristic('Toroidal moment', curl(self._P))

def main():

    data = IndexedInput(inputs, 0)

    with Accessor(data, "PointData") as point_data:

        polarization = point_data["polar"]

        polar_characteristics = PolarizationCharacteristics(polarization)

        chirality = polar_characteristics.chirality()

    sink = Output(output)

    with Accessor(sink, "PointData") as point_data:

        point_data.connection.write(chirality)

main()

#Driver:

from subprocess import run

def subs(string):

    mapper = {

        '\n': '
',

        '\'': ''',

        '\"': '"',

    }

    new_string = string

    for k in mapper.keys():

        new_string = new_string.replace(k, mapper[k])

    return new_string

def main():

    #Set proper path to paraview pvbatch

    command = 'path/to/ParaView/bin/pvbatch'

    #Prepare pvsm paraview state for proper screenshot

    #Check the line where the source of programmable filter is located

    template_pvsm = './template.pvsm'

    substitution_line_number = 38777

    with open(template_pvsm) as inp:

        template_lines = inp.readlines()

    with open("./template_programmable_filter.py") as inp:

        pr_filter_lines = inp.readlines()

    pr_filter_line = ''.join([ subs(s) for s in pr_filter_lines ])

    template_lines[substitution_line_number] = f'<Element index="0" value="{pr_filter_line}"/>'

    with open('./state.pvsm', 'w') as out:

        out.writelines(template_lines)

    #Write short trace using template.pvsm to take a screenshot with state.pvsm

    #Or loop through the xdmf files in some directory

    #Recorded trace should use state.pvsm

    i = 0

    res = run(f'{command} trace.py {i:0>10}.png', shell=True)

if __name__ == '__main__':

    main()