pyemaps 2.0.0__py3-none-any.whl

pyemaps/samples/si_bloch.py

@@ -0,0 +1,120 @@
+"""
+This file is part of pyemaps
+___________________________
+
+pyemaps is free software. You can redistribute it and/or modify 
+it under the terms of the GNU General Public License as published 
+by the Free Software Foundation, either version 3 of the License, 
+or (at your option) any later version.
+
+pyemaps 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pyemaps.  If not, see <https://www.gnu.org/licenses/>.
+
+Contact supprort@emlabsoftware.com for any questions and comments.
+___________________________
+
+Author:     EMLab Solutions, Inc.
+Date:       July 07, 2022  
+
+This sample code is to demostrate using pyemaps to generate and render
+dynamic diffraction patterns.   
+
+"""
+
+from pyemaps import EMC, DEF_CBED_DSIZE
+
+MAX_PROCWORKERS = 4
+em_keys = ['tilt', 'zone']
+
+def generate_bloch_images(name = 'Silicon', dsize = DEF_CBED_DSIZE, ckey = 'tilt', sim_rand=False):
+    '''
+    This routine demonstrate how to use pyemaps bloch module to generate dynamic diffraction paterns
+    : name: crystal name from builtin database
+    : dsize: diffracted beams size
+    : ckey: emcontrol key name
+    : sim_rand: randomized simulation control which is added to EMControl class, these controls
+    :           are not changed much (default values if not set). But if changes are needed, then they 
+    :           are also set from within EMControl class
+    '''
+    import concurrent.futures
+    from pyemaps import Crystal as cryst
+    from pyemaps import BImgList, SIMC
+
+    cr = cryst.from_builtin(name)
+    
+    fs=[]
+   
+    emclist =[] 
+
+    if sim_rand:
+        sc = SIMC._from_random()
+    else:
+        sc = SIMC()
+
+    for i in range(-3,3): 
+        emc=EMC(cl=200)
+        if ckey == 'tilt':
+           emc.tilt=(i*0.5, 0.0)
+        
+        if ckey == 'zone':
+            emc.zone=(0, i, 1)
+
+        if sim_rand:
+            emc.simc = sc
+
+        emc(simc=sc)
+        emclist.append(emc)
+
+    with concurrent.futures.ProcessPoolExecutor(max_workers=MAX_PROCWORKERS) as e:
+
+        for ec in emclist:
+            fs.append(e.submit(cr.generateBloch, 
+                               disk_size=dsize, 
+                               sampling = 20, 
+                               sample_thickness=(1750,1750,100),
+                               em_controls = ec))
+        
+        bimgs = BImgList(name) 
+        for f in concurrent.futures.as_completed(fs):
+            try:
+              imgs = f.result()
+              
+            except Exception as e:
+                print(f'Unable to obtain bloch image(s): {e}') 
+                return None
+            else: 
+                emc, img = imgs[0]
+                bimgs.add(emc, img)
+   
+        # sorting the images by their associated controls
+        bimgs.sort()   
+        return bimgs
+
+from pyemaps import showBloch
+
+def main():
+    em_keys = ['tilt', 'zone']
+    
+    for k in em_keys:
+        imgs = generate_bloch_images(ckey=k)
+        if imgs is not None:
+            showBloch(imgs, layout='table', bSave=True, bClose=True)
+        else:
+            exit(1)
+
+    for k in em_keys:
+        imgs = generate_bloch_images(ckey=k, sim_rand=True)
+        if imgs is not None:
+            showBloch(imgs, bClose=True)
+        else:
+            exit(1)
+
+if __name__ == '__main__':
+    
+    main()
+        

pyemaps/samples/si_constructor.py

@@ -0,0 +1,51 @@
+'''
+This file is part of pyemaps
+___________________________
+
+pyemaps is free software. You can redistribute it and/or modify 
+it under the terms of the GNU General Public License as published 
+by the Free Software Foundation, either version 3 of the License, 
+or (at your option) any later version.
+
+pyemaps 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pyemaps.  If not, see <https://www.gnu.org/licenses/>.
+
+Contact supprort@emlabsoftware.com for any questions and comments.
+___________________________
+
+Author:     EMLab Solutions, Inc.
+Date:       October 21, 2022    
+
+
+This sample code is to demonstrate how to generate .xyz crystal 
+construction data that can be visualized by Jmol and cloudEMAPS 2.0. 
+'''
+def test_mxtal(bPrint=True, bSave=True):
+    
+    from pyemaps import Crystal as cr
+    from pyemaps import CrystalClassError
+    from pyemaps import MxtalError
+    mx=None
+    try:
+        si = cr.from_builtin('Silicon')
+        if si and bPrint:
+            print(f'crytsal data to generate mxtal: {si}')
+            mx = si.generateMxtal(bound=0.1)
+    except (CrystalClassError, MxtalError) as e:
+        print(f'error: generating crystal structure data: {e.message}')
+    except Exception as e:
+        print(f'error: generating crystal structure data: {e}')
+    else:
+        if bPrint:
+            print(f'\nCrystal Structure Data Generated for {si.name}:')
+            si.printXYZ(mx)
+        if bSave:
+            si.writeXYZ(mx)
+        return mx
+if __name__ == "__main__":
+    test_mxtal()

pyemaps/samples/si_csf.py

@@ -0,0 +1,59 @@
+'''
+This file is part of pyemaps
+___________________________
+
+pyemaps is free software. You can redistribute it and/or modify 
+it under the terms of the GNU General Public License as published 
+by the Free Software Foundation, either version 3 of the License, 
+or (at your option) any later version.
+
+pyemaps 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pyemaps.  If not, see <https://www.gnu.org/licenses/>.
+
+Contact supprort@emlabsoftware.com for any questions and comments.
+___________________________
+
+Author:     EMLab Solutions, Inc.
+Date:       May 24, 2022    
+
+
+This sample code is to demonstrate how to generate crystal structure 
+factors. 
+'''
+c_name = 'Silicon'
+
+def runCSFTests(bPrint=True):
+    from pyemaps import Crystal as cr
+    si = cr.from_builtin(c_name)
+    if bPrint:
+        print(si)
+    # generate diffraction on the crystal instance with all default controls
+    # parameters, default controls returned as the first output ignored
+    v = 100
+    sm = 1.0
+
+    sfl = [1,2,3,4] # structure factor type list
+    # 1 -----X-ray Structure Factors
+    # 2 -----Electron Strcture Factors in kV
+    # 3 -----Electron Structure Factor in 1/Å
+    # 4 -----Electron Absorption Structure Factor in 1/Å^2
+
+    ampl = [1, 0] # structure factor format
+    # 1 -----amplitude and phase
+    # 0 -----real and imaginary
+
+    for i in sfl:
+        for j in ampl:
+            
+            sfs = si.generateCSF(kv = v, smax = sm, sftype = i, aptype = j)
+            if bPrint:
+                si.printCSF(sfs)
+    return sfs
+    
+if __name__ == "__main__":
+    runCSFTests()

pyemaps/samples/si_dif.py

@@ -0,0 +1,134 @@
+'''
+This file is part of pyemaps
+___________________________
+
+pyemaps is free software. You can redistribute it and/or modify 
+it under the terms of the GNU General Public License as published 
+by the Free Software Foundation, either version 3 of the License, 
+or (at your option) any later version.
+
+pyemaps 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pyemaps.  If not, see <https://www.gnu.org/licenses/>.
+
+Contact supprort@emlabsoftware.com for any questions and comments.
+___________________________
+
+Author:     EMLab Solutions, Inc.
+Date:       May 11, 2022    
+
+
+This sample code is to render kinematic diffraction patterns generated
+by pyemaps by changing zone axis
+'''
+try:
+    from pyemaps import DEF_CBED_DSIZE, DEF_MODE
+except ImportError as e:
+    print(f'pyEMAPS importing error: {e}')
+    exit(1)
+
+from pyemaps import EMC, DPError,EMCError
+
+MAX_PROCWORKERS = 4
+em_keys = ['tilt', 'zone', 'defl', 'vt', 'cl']
+
+def generate_difs(name = 'Silicon', mode = DEF_MODE, ckey = 'tilt', sim_rand=False):
+    '''
+    This routine demonstrate how to use pyemaps dif module to generate kinematic diffraction paterns
+    
+    : name: crystal name from builtin database
+    : dsize: diffracted beams size
+    : ckey: emcontrol key name
+    : sim_rand: randomized simulation control which is added to EMControl class, these controls
+    :           are not changed much (default values if not set). But if changes are needed, then they 
+    :           are also set from within EMControl class
+    '''
+    from pyemaps import DPList, SIMC
+    import concurrent.futures
+    from pyemaps import Crystal as cryst
+
+    cr = cryst.from_builtin(name)
+
+    if mode == 2:
+        dsize = DEF_CBED_DSIZE
+    else:
+        dsize = None
+    
+    fs=[]
+    # create an empty diffraction pattern list
+    difs = DPList(name, mode = mode)
+
+    emclist =[] 
+
+    if sim_rand:
+        sc = SIMC._from_random()
+
+    for i in range(-3,3): 
+        emc = EMC()
+        if ckey == 'tilt':
+            emc.tilt = (i*0.5, 0.0)
+        
+        if ckey == 'zone':
+            emc.zone= (0, i, 1)
+
+        if ckey == 'defl':
+            emc.defl= (i*0.5, 0.0)
+
+        if ckey == 'vt':
+            emc.vt= 200 + i*10
+
+        if ckey == 'cl':
+            emc.cl= 1000 + i*50
+
+        if sim_rand:
+            emc.simc = sc
+
+        emclist.append(emc)
+
+    with concurrent.futures.ProcessPoolExecutor(max_workers=MAX_PROCWORKERS) as e:
+
+        for ec in emclist:
+            fs.append(e.submit(cr.generateDP, mode=mode,  dsize=dsize, em_controls = ec))
+
+        for f in concurrent.futures.as_completed(fs):
+            try:
+                emc, diffP = f.result()
+                difs.add(emc, diffP)
+                
+            except (DPError, EMCError) as e:
+                print(f'{f} generated an exception: {e.message}')
+                exit(1)
+            except Exception as e:
+                print('failed to generate diffraction patterns with  ' + str(e))
+                exit(1)
+
+    # sort the diffraction patern list by controls
+    difs.sort()       
+
+    return difs
+
+def main():
+    
+    from pyemaps import showDif
+    
+    for k in em_keys:
+        dpl = generate_difs(ckey=k, mode=2)
+        showDif(dpl, 
+                layout='table' if k == 'tilt' or k == 'zone' else 'individual', 
+                kShow=False, 
+                iShow=False, 
+                bSave=(k=='zone'),
+                bClose=True
+                )
+
+    for k in em_keys:
+        dpl = generate_difs(ckey=k, sim_rand=True)
+        showDif(dpl, bClose=True)
+
+if __name__ == '__main__':
+    
+   main()

pyemaps/samples/si_lacbed.py

@@ -0,0 +1,59 @@
+"""
+This file is part of pyemaps
+___________________________
+
+pyemaps is free software. You can redistribute it and/or modify 
+it under the terms of the GNU General Public License as published 
+by the Free Software Foundation, either version 3 of the License, 
+or (at your option) any later version.
+
+pyemaps 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pyemaps.  If not, see <https://www.gnu.org/licenses/>.
+
+Contact supprort@emlabsoftware.com for any questions and comments.
+___________________________
+
+Author:     EMLab Solutions, Inc.
+Date:       May 25, 2023  
+
+
+This sample code is to demostrate using pyemaps to generate and render
+dynamic diffraction patterns. 
+
+
+"""
+
+def generate_lacbed_images(name = 'Silicon', bSave = False, bShow=False):
+    
+    from pyemaps import Crystal as cryst
+
+    cr = cryst.from_builtin(name)
+    
+    try:
+        imgs = cr.generateBloch( disk_size = 0.5,
+                            sampling = 10,
+                            nType = 1, 
+                            sample_thickness=(1000,1000,100),
+                            bSave=bSave)
+    except Exception as e:
+        print(f'Faild to obtain large angle CBED images: {e}') 
+        return
+       
+    imgs.sort()
+    if bShow: 
+        showBloch(imgs,bClose=True)
+    return imgs
+
+def main():
+    generate_lacbed_images(bSave=True, bShow=True)
+
+from pyemaps import showBloch
+
+if __name__ == '__main__':
+    main()
+        

pyemaps/samples/si_pyemaps.py

@@ -0,0 +1,80 @@
+"""
+This file is part of pyemaps
+___________________________
+
+pyemaps is free software. You can redistribute it and/or modify 
+it under the terms of the GNU General Public License as published 
+by the Free Software Foundation, either version 3 of the License, 
+or (at your option) any later version.
+
+pyemaps 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pyemaps.  If not, see <https://www.gnu.org/licenses/>.
+
+Contact supprort@emlabsoftware.com for any questions and comments.
+___________________________
+
+An example of using pyemaps crystal and diffraction modules to 
+1) create a crystal from built-in data for Silicon 
+2) generate kinematical diffraction patterns
+3) display the diffraction pattern using pyemaps's built-in plot function 
+
+See https://emlab-solutions.github.io/pyemaps/ for pemaps usage
+
+Author:     EMLab Solutions, Inc.
+Date:       May 07, 2022    
+
+"""
+
+
+def run_si_sample():
+    #import Crystal class from pyemaps as cryst
+    from pyemaps import Crystal as cr
+    from pyemaps import showDif, showBloch
+    from pyemaps import DPList
+    from pyemaps import BImgList
+    # create a crystal class instance and load it with builtin silicon data
+    c_name = 'Silicon'
+    si = cr.from_builtin(c_name)
+
+    # generate diffraction on the crystal instance with all default controls
+    # parameters, default controls returned as the first output ignored
+    
+    dpl = DPList(c_name)
+
+    emc, si_dp = si.generateDP()
+    dpl.add(emc, si_dp) 
+    
+    #plot and show the diffraction pattern using pyemaps built-in plot function
+    showDif(dpl, bClose=True)
+
+    #hide Kikuchi lines
+    showDif(dpl, kShow=False, bClose=True) 
+
+    #plot the following two DP in CBED mode (mode = 2)
+    dpl = DPList(c_name, mode = 2)
+
+    emc, si_dp = si.generateDP(mode = 2)
+    dpl.add(emc, si_dp) 
+
+    #hide both Kukuchi line and Miller Indices
+    showDif(dpl, kShow=False, iShow=False, bClose=True) 
+
+    #hide Miller Indices
+    showDif(dpl, iShow=False, bClose=True)
+
+    #Generate dynamic diffraction patterns using pyemaps' bloch module
+    
+    try:
+      bloch_imgs_list = si.generateBloch(sampling = 20) 
+      
+    except Exception as e:
+      print(f'Error: {e}')
+
+    else:        
+      showBloch(bloch_imgs_list, bClose=True) #grey color map
+      showBloch(bloch_imgs_list, bColor=True, bClose=True) #with predefined color map

pyemaps/samples/si_scm.py

@@ -0,0 +1,156 @@
+'''
+This file is part of pyemaps
+___________________________
+
+pyemaps is free software. You can redistribute it and/or modify 
+it under the terms of the GNU General Public License as published 
+by the Free Software Foundation, either version 3 of the License, 
+or (at your option) any later version.
+
+pyemaps 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pyemaps.  If not, see <https://www.gnu.org/licenses/>.
+
+Contact supprort@emlabsoftware.com for any questions and comments.
+___________________________
+
+Author:     EMLab Solutions, Inc.
+Date:       October 19th, 2022    
+
+
+This sample code is to demonstrate how to generated scattering matrix
+'''
+
+c_name = 'Silicon'
+
+def runSCMTests():
+
+    from pyemaps import Crystal as cr
+    from pyemaps import BlochError, EMC, SIMC
+    import random
+    
+    si = cr.from_builtin(c_name)
+    
+    print(si)
+    # -----generate scattering matrix on this crystal instance----- 
+    #      controls set as follows. 
+
+    #      For a list beams coordinates 
+    #      to generate more scattering matrix, run cr.printIBDetails()
+    
+    ec =EMC(cl=200,
+            tilt=(0.0, 0.0),
+            simc = SIMC(gmax=2.0, excitation=(1.0,2.0))
+            )
+    ds = 0.25
+    ib_coords = (0, 0)
+    lscm = []
+    try:
+        
+        ns, s = si.beginBloch(em_controls = ec, 
+                        dbsize = ds)
+
+    except Exception as e:
+        print(f'Failed to generate scattering matrix {e}')
+    else:
+        
+        print(f'----Sampling points in this dynamic diffraction session---:')
+        print(f'Number of sampling points: {ns}')
+        print(f'{s}')
+
+        # get the scattering matrix and associated eigen values now
+        try:
+            ndim, si_scm, si_ev, si_beams = si.getSCMatrix(ib_coords = ib_coords)
+        except BlochError as e:
+            print(f'Failed to generate scattering matrix {e.message}')
+        except Exception as e:
+            print(f'Failed to generate scattering matrix {e}')
+        else:
+            print(f'\n----Scattering matrix at sampling point {ib_coords}----:')
+            print(f'Size of the scattering matrix: {ndim}x{ndim}')
+            print(f' \n{si_scm}')
+
+            print(f'\n----Eigen values at: {ib_coords}----')
+            print(si_ev)
+
+            print(f'\n----Diffracted beams at: {ib_coords}----')
+            print(si_beams)
+
+            print(f'\n----More details associated with scattering matrix calculation') 
+            si.getIBDetails()
+            
+            # select a random sampling point from s and calculate scattering matrix
+            randnum = random.randrange(0, ns-1)
+            
+            ib_coords = s[randnum]
+            try:
+                nd, si_scm, si_ev, si_beams = si.getSCMatrix(ib_coords = ib_coords)
+                lscm.append(dict(ib=ib_coords, ndim=nd, scm=si_scm, ev=si_ev, beams=si_beams))
+            except Exception:
+                print(f'Error obtaining scattering matrix at random sampling points {ib_coords}')
+            else:
+                print(f'\n----Scattering matrix at a randomly selected sampling point {ib_coords}----:')
+                print(f'Size of the scattering matrix: {nd}x{nd}')
+                print(f'{si_scm}')
+                print(f'\n----Eigen values at: {ib_coords}----')
+                print(si_ev)
+                print(f'\n----Diffracted beams at: {ib_coords}----')
+                print(si_beams)
+
+        # show a list of calculated beams for current bloch session
+        ncb, cbs = si.getCalculatedBeams(bPrint=True)
+    # cleanup 
+    si.endBloch()
+    return (dict(ncb=ncb, cbs=cbs), lscm)
+
+def runSCMFullTests():
+
+    from pyemaps import Crystal as cr
+    from pyemaps import BlochError, EMC, SIMC
+    
+    si = cr.from_builtin(c_name)
+    
+    # -----generate scattering matrix on this crystal instance----- 
+    #      controls set as follows. 
+
+    #      For a list beams coordinates 
+    #      to generate more scattering matrix, run cr.printIBDetails()
+    
+    ec =EMC(cl=200,
+            tilt=(0.0, 0.0),
+            simc = SIMC(gmax=2.0, excitation=(1.0,2.0))
+            )
+    ds = 0.25
+    
+    lscm = []
+    try:
+        
+        ns, s = si.beginBloch(em_controls = ec, 
+                        dbsize = ds)
+        nib, isblist = si.getIBDetails(bPrint=False)
+        
+    except Exception as e:
+        print(f'Failed to generate scattering matrix {e}')
+    else:
+        # get the scattering matrix and associated eigen values now
+        try:
+            for i in range(ns):
+                ndim, si_scm, si_ev, si_beams = si.getSCMatrix(ib_coords = s[i])
+                lscm.append(dict(ib=s[i], ndim=ndim, scm=si_scm, ev=si_ev, beams=si_beams))
+        except BlochError as e:
+            print(f'Failed to generate scattering matrix {e.message}')
+        except Exception as e:
+            print(f'Failed to generate scattering matrix {e}')
+        
+        # show a list of calculated beams for current bloch session
+        ncb, cbs = si.getCalculatedBeams(bPrint=False)
+    # cleanup 
+    si.endBloch()
+    return (dict(ncb=ncb, cbs=cbs), dict(nscm=ns, lscm=lscm), dict(nib=nib, libt=isblist))
+
+if __name__ == "__main__":
+    runSCMTests() #only sampling and print out two of the results