GISAXS - User contributions [en]

ScatterSim

2017-07-28T17:55:43Z

JulienLhermitte: /* See Also */

'''[[ScatterSim]]''' is a set of [[Python]] code for simulating the one-dimensional curve (circular average) for [[Lattices of nano-objects|nanoparticle superlattices]].
* Citation: [[Yager, K.G.]]; Zhang, Y.; Lu, F.; Gang, O. "[http://scripts.iucr.org/cgi-bin/paper?S160057671302832X Periodic lattices of arbitrary nano-objects: modeling and applications for self-assembled systems]" ''Journal of Applied Crystallography'' '''2014''', 47, 118–129. [http://dx.doi.org/10.1107/S160057671302832X doi: 10.1107/S160057671302832X]
** See also [[Paper:Periodic lattices of arbitrary nano-objects: modeling and applications for self-assembled systems|summary of paper]].
* [http://github.com/CFN-softbio/ScatterSim Code available on github.]
[[Image:NanoLattice cartoon.jpg|center|500px]]

==See Also==
* [[ScatterSim:Installing| Installing ScatterSim]]
* [[ScatterSim:API | API]]
* [[ScatterSim:Examples | ScatterSim Examples]]
* [http://scattersim.readthedocs.io/en/latest/ ScatterSim Documentation]

ScatterSim:API

2017-07-20T13:49:20Z

JulienLhermitte:

== ScatterSim API ==
(Work in progress)

This page documents the general API for the ScatterSim code.

=== Structure ===
In general, the objects in the ScatterSim code used to generate simulations are either:

# NanoObject : the base object
# CompositeNanoObject : an arrangement of NanoObject objects
# Lattice objects : NanoObjects that are assembled into a lattice.

==== NanoObjects or Composite NanoObjects ====
Each of these elements is initialized by calling their initialization class.
To initialize a NanoObject or CompositeNanoObject, potential arguments must be supplied:
<source lang='python'>
from ScatterSim.NanoObjects import SphereNanoObject
pargs = {"radius" : 10}
sphere = SphereNanoObject(pargs=pargs)
</source>

where pargs is a dictionary containing the parameters that describe the system. Here, a SphereNanoObject only requires a radius as a parameter. Other more complex objects, like CylinderNanoObject may require more parameters (such as height in this case).

==== Creating a new CompositeNanoObject ====
Sometimes the objects available are not enough and a more complex objects is needed.
Objects may be compounded into more complex NanoObject objects by creating a new CompositeNanoObject.

=== Vectors ===
Rotations

Any object's canonical rotation is described in its docstring. From there, it is possible to re-orient it.

The orientation is defined with the following parameters
* x0, y0, z0 : the z y and z position with respect to the object's internal reference frame
* eta, theta, phi : the Euler angles. THe rotations are defined as follows:

Three-axis rotation:
1. Rotate about +z by eta (counter-clockwise in x-y plane)
2. Tilt by phi with respect to +z (rotation about y-axis,
clockwise in x-z plane) then
3. rotate by theta in-place (rotation about z-axis,
counter-clockwise in x-y plane)

ScatterSim:Installing

2017-07-18T22:33:05Z

JulienLhermitte: /* Installing ScatterSim */

== Installing ScatterSim ==
Here are some rough guidelines into installing ScatterSim.

<ol>
<li>
Download and install Anaconda 
https://www.continuum.io/downloads
</li>

<li> Download the ScatterSim Library, either:

<ol>
<li> Direct download
<ol>
<li>Download from https://github.com/CFN-softbio/SciAnalysis/archive/master.zip 
and install to the directory of your choice.

</li>

</ol></li>

<li>
Using git
<ol><li>
Download and install git: 

https://git-scm.com/downloads
</li>
<li>
Download the ScatterSim library using git
<ol>
<li> Open a terminal and choose a directory where you want to install ScatterSim, for example:
<pre>
cd ~/
mkdir -p software
cd software
</pre>
</li>

<li>clone: 

<pre>
git clone https://github.com/CFN-softbio/ScatterSim.git
</pre>
(For more information, you may also visit the [http://github.com/CFN-softbio/ScatterSim github page])
</li>
</ol>
</li>
</ol></li>
</ol></li>
<li>
Now install ScatterSim
<pre>
cd ScatterSim
python setup.py develop
</pre>
It should now be installed.

</ol>

You should be able to now run ScatterSim in a python environment.

== Testing ScatterSim ==
To test that ScatterSim was properly installed, let's make a folder where we can add code and test.
<ol>
<li>
Create a folder where you'll want to store your notebooks, for example, in a terminal, type:
<pre>
cd ~/software
mkdir -p ScatterSim-examples
cd ScatterSim-examples
</pre>
</li>
<li>
In this folder, in the terminal, type:
<pre>
jupyter notebook
</pre>
This will open your web browser to run jupyter notebooks.
</li>
<li>
Click "New" and select one of the entries under "Notebook". Likely it will say something like "Python 3" or something similar. You should only have one entry (unless you've manually created extra notebook kernels, or installed jupyter on its own).
</li>
<li>
To test that ScatterSim is installed, type in a cell:
<pre>
from ScatterSim.NanoObjects import SphereNanoObject
</pre>
and hit SHIFT + ENTER. If you do not receive an error, then it is installed. If you do receive an error, then try to use another kernel (the entries under notebook mentioned in the previous step).
</li>
</ol>

Troubleshooting If this was not successful, then here are some things you may try:
<ul>
<li> you have two instances of jupyter installed and you are not running the correct one. Try to find them and uninstall everything. The command (linux/mac) <pre>which jupyter</pre> can help hint where the jupyter version you're using is installed. </li>
<li> Another possibilty is that you are not in the right conda environment. Simply closing your terminal and opening it again could help. Else, you may need to find out the name of your conda environments by typing in a terminal:
<pre>
conda env list
</pre>
and finally selecting the correct environment by typing:
<pre>
source activate ENV
</pre>
where ENV is one of the names in the list you saw. (it should be one entry unless you've purposely added more environments)
</li>
</ul>

== Updating ScatterSim ==
If you installed using git, you can also update ScatterSim using git. When an update is pushed to the server, it may be retrieved as follows:

<ol>
<li>
Go into ScatterSim directory. Ex:
<pre>
cd ~/software/ScatterSim
</pre>
</li>
<li>
Then run the following two commands: 
<pre>
git checkout master
git pull origin master
</pre>
</li>
</ol>

NOTE : If you made any changes to ScatterSim, git will complain (this could happen by accidentally opening a file and adding in a whitespace for example). To resolve this, you delete all changes you may have made by typing:
<pre>
git reset --hard
</pre>
If you wanted to keep your changes, then one option is to create a new branch for them, such as:
may either need to add the changes:
<pre>
git checkout -b development-branch-name
git add <files...>
git commit -m "MY Commit message for these edits"
</pre>
Now your changes are saved and may always be accessed by running:
<pre>
git checkout development-branch-name
</pre>
This is likely unnecessary, unless you are digging into the code.

XAmp

2017-07-13T14:25:48Z

JulienLhermitte: /* References */

'''Coherent X-ray Amplification''' ('''XAmp''') is a method that can be used to boost the [[scattering]] signal of a weakly-scattering entity above some noisy contaminating [[background]]. The technique consists of bringing a specially-designed 'amplifier' nano-structure close to the sample of interest (within one coherence volume). The coherent interference between the sample of interest and the amplifier gives rise to an interference term in the scattering pattern seen on the detector. Even if the sample itself is too weak to be measured on its own (due to the background dominating), the interference term can be extremely strong (if the amplifier itself scatters strongly). As a result, the sample's scattering can be inferred from the measurable interference term.

The scattering from coherent interference involves three scattering terms :
# The scattering of the amplifier
# The scattering of the sample
# An interference term
This interference term encodes information about the sample, and may be amplified by increasing the amplifier signal strength (i.e. fabricating a more strongly scattering amplifier object). If a strong noisy background is present, then a sufficiently strong amplifier can actually increase the [[signal-to-noise]] of the measurement of the sample.

==References==
* Julien R. Lhermitte, Cheng Tian, Aaron Stein, Atikur Rahman, Yugang Zhang, Lutz Wiegart, Andrei Fluerasu, Oleg Gang, and [[Kevin G. Yager]] [http://journals.iucr.org/j/issues/2017/03/00/aj5285/index.html Robust X-ray angular correlations for the study of meso-structures] ''J. Appl. Cryst.'' '''2017''', 50(3). [https://doi.org/10.1107/S1600576717003946 doi: 10.1107/S1600576717003946]

* Julien R. Lhermitte, Aaron Stein, Cheng Tian, Yugang Zhang, Lutz Wiegart, Andrei Fluerasu, Oleg Gang, and [[Kevin G. Yager]] [http://journals.iucr.org/m/issues/2017/05/00/it5012/index.html Coherent Amplification of X-ray Scattering from Meso-structures] ''IUCrJ'' '''2017''' 4(5) [https://doi.org/10.1107/S2052252517008107 doi: 10.1107/S2052252517008107]

==See Also==
* [[Correlation methods]]

XAmp

2017-07-13T14:24:44Z

JulienLhermitte: /* References */

'''Coherent X-ray Amplification''' ('''XAmp''') is a method that can be used to boost the [[scattering]] signal of a weakly-scattering entity above some noisy contaminating [[background]]. The technique consists of bringing a specially-designed 'amplifier' nano-structure close to the sample of interest (within one coherence volume). The coherent interference between the sample of interest and the amplifier gives rise to an interference term in the scattering pattern seen on the detector. Even if the sample itself is too weak to be measured on its own (due to the background dominating), the interference term can be extremely strong (if the amplifier itself scatters strongly). As a result, the sample's scattering can be inferred from the measurable interference term.

The scattering from coherent interference involves three scattering terms :
# The scattering of the amplifier
# The scattering of the sample
# An interference term
This interference term encodes information about the sample, and may be amplified by increasing the amplifier signal strength (i.e. fabricating a more strongly scattering amplifier object). If a strong noisy background is present, then a sufficiently strong amplifier can actually increase the [[signal-to-noise]] of the measurement of the sample.

==References==
* Julien R. Lhermitte, Cheng Tian, Aaron Stein, Atikur Rahman, Yugang Zhang, Lutz Wiegart, Andrei Fluerasu, Oleg Gang, and [[Kevin G. Yager]] [http://journals.iucr.org/j/issues/2017/03/00/aj5285/index.html Robust X-ray angular correlations for the study of meso-structures] ''J. Appl. Cryst.'' '''2017''', 50(3). [https://doi.org/10.1107/S1600576717003946 doi: 10.1107/S1600576717003946]

* Julien R. Lhermitte, Aaron Stein, Cheng Tian, Yugang Zhang, Lutz Wiegart, Andrei Fluerasu, Oleg Gang, and [[Kevin G. Yager]] Coherent Amplification of X-ray Scattering from Meso-structures ''IUCrJ'' '''2017''' 4(5) [https://doi.org/10.1107/S2052252517008107]

==See Also==
* [[Correlation methods]]

ScatterSim:API

2017-07-10T20:29:20Z

JulienLhermitte:

ScatterSim:API

2017-07-10T20:29:09Z

JulienLhermitte: Created page with "== ScatterSim API == This page documents the general API for the ScatterSim code. === Structure === In general, the objects in the ScatterSim code used to generate simulation..."

== ScatterSim API ==
This page documents the general API for the ScatterSim code.

=== Structure ===
In general, the objects in the ScatterSim code used to generate simulations are either:

# NanoObject : the base object
# CompositeNanoObject : an arrangement of NanoObject objects
# Lattice objects : NanoObjects that are assembled into a lattice.

==== NanoObjects or Composite NanoObjects ====
Each of these elements is initialized by calling their initialization class.
To initialize a NanoObject or CompositeNanoObject, potential arguments must be supplied:
<source lang='python'>
from ScatterSim.NanoObjects import SphereNanoObject
pargs = {"radius" : 10}
sphere = SphereNanoObject(pargs=pargs)
</source>

where pargs is a dictionary containing the parameters that describe the system. Here, a SphereNanoObject only requires a radius as a parameter. Other more complex objects, like CylinderNanoObject may require more parameters (such as height in this case).

==== Creating a new CompositeNanoObject ====
Sometimes the objects available are not enough and a more complex objects is needed.
Objects may be compounded into more complex NanoObject objects by creating a new CompositeNanoObject.

=== Vectors ===

ScatterSim

2017-07-10T18:35:36Z

JulienLhermitte: /* See Also */

ScatterSim:Installing

2017-06-14T14:34:28Z

JulienLhermitte: /* Installing ScatterSim */

== Installing ScatterSim ==
Here are some rough guidelines into installing ScatterSim. There are a few ways to do it, but this is a recommended method.

<ol>
<li>
Download and install Anaconda 
https://www.continuum.io/downloads
</li>

<li>
Download and install git: 

https://git-scm.com/downloads

</li>
<li>
Download the ScatterSim library using git
<ol>
<li> Open a terminal and choose a directory where you want to install ScatterSim, for example:
<pre>
cd ~/
mkdir -p software
cd software
</pre>
</li>
<li>
Download and install ScatterSim using git:
<ol>
<li>Download using git: 

<pre>
git clone https://github.com/CFN-softbio/ScatterSim.git
</pre>
(For more information, you may also visit the [http://github.com/CFN-softbio/ScatterSim github page])
</li>
</li>
<li>
Now install ScatterSim
<pre>
cd ScatterSim
python setup.py develop
</pre>
It should now be installed.
</li>
</li>
</ol>
<li>
You should be able to now run ScatterSim in a python environment.
</ol>

== Testing ScatterSim ==
To test that ScatterSim was properly installed, let's make a folder where we can add code and test.
<ol>
<li>
Create a folder where you'll want to store your notebooks, for example, in a terminal, type:
<pre>
cd ~/software
mkdir -p ScatterSim-examples
cd ScatterSim-examples
</pre>
</li>
<li>
In this folder, in the terminal, type:
<pre>
jupyter notebook
</pre>
This will open your web browser to run jupyter notebooks.
</li>
<li>
Click "New" and select one of the entries under "Notebook". Likely it will say something like "Python 3" or something similar. You should only have one entry (unless you've manually created extra notebook kernels, or installed jupyter on its own).
</li>
<li>
To test that ScatterSim is installed, type in a cell:
<pre>
from ScatterSim.NanoObjects import SphereNanoObject
</pre>
and hit SHIFT + ENTER. If you do not receive an error, then it is installed. If you do receive an error, then try to use another kernel (the entries under notebook mentioned in the previous step).
</li>
</ol>

Troubleshooting If this was not successful, then here are some things you may try:
<ul>
<li> you have two instances of jupyter installed and you are not running the correct one. Try to find them and uninstall everything. The command (linux/mac) <pre>which jupyter</pre> can help hint where the jupyter version you're using is installed. </li>
<li> Another possibilty is that you are not in the right conda environment. Simply closing your terminal and opening it again could help. Else, you may need to find out the name of your conda environments by typing in a terminal:
<pre>
conda env list
</pre>
and finally selecting the correct environment by typing:
<pre>
source activate ENV
</pre>
where ENV is one of the names in the list you saw. (it should be one entry unless you've purposely added more environments)
</li>
</ul>

== Updating ScatterSim ==
If you installed using git, you can also update ScatterSim using git. When an update is pushed to the server, it may be retrieved as follows:

<ol>
<li>
Go into ScatterSim directory. Ex:
<pre>
cd ~/software/ScatterSim
</pre>
</li>
<li>
Then run the following two commands: 
<pre>
git checkout master
git pull origin master
</pre>
</li>
</ol>

NOTE : If you made any changes to ScatterSim, git will complain (this could happen by accidentally opening a file and adding in a whitespace for example). To resolve this, you delete all changes you may have made by typing:
<pre>
git reset --hard
</pre>
If you wanted to keep your changes, then one option is to create a new branch for them, such as:
may either need to add the changes:
<pre>
git checkout -b development-branch-name
git add <files...>
git commit -m "MY Commit message for these edits"
</pre>
Now your changes are saved and may always be accessed by running:
<pre>
git checkout development-branch-name
</pre>
This is likely unnecessary, unless you are digging into the code.

ScatterSim:Installing

2017-06-14T14:34:05Z

JulienLhermitte: /* Installing ScatterSim */

== Installing ScatterSim ==
Here are some rough guidelines into installing ScatterSim. There are a few ways to do it, but this is a recommended method.

<ol>
<li>
Download and install Anaconda 
https://www.continuum.io/downloads
</li>

<li>
Download and install git: 

https://git-scm.com/downloads

</li>
<li>
Download the ScatterSim library using git
<ol>
<li> Open a terminal and choose a directory where you want to install ScatterSim, for example:
<pre>
cd ~/
mkdir -p software
cd software
</pre>
</li>
<li>
Download and install ScatterSim using git:
<ol>
<li>Download using git: 

<pre>
git clone https://github.com/CFN-softbio/ScatterSim.git
</pre>
(For more information, you may also visit the [http://github.com/CFN-softbio/ScatterSim| github page])
</li>
</li>
<li>
Now install ScatterSim
<pre>
cd ScatterSim
python setup.py develop
</pre>
It should now be installed.
</li>
</li>
</ol>
<li>
You should be able to now run ScatterSim in a python environment.
</ol>

== Testing ScatterSim ==
To test that ScatterSim was properly installed, let's make a folder where we can add code and test.
<ol>
<li>
Create a folder where you'll want to store your notebooks, for example, in a terminal, type:
<pre>
cd ~/software
mkdir -p ScatterSim-examples
cd ScatterSim-examples
</pre>
</li>
<li>
In this folder, in the terminal, type:
<pre>
jupyter notebook
</pre>
This will open your web browser to run jupyter notebooks.
</li>
<li>
Click "New" and select one of the entries under "Notebook". Likely it will say something like "Python 3" or something similar. You should only have one entry (unless you've manually created extra notebook kernels, or installed jupyter on its own).
</li>
<li>
To test that ScatterSim is installed, type in a cell:
<pre>
from ScatterSim.NanoObjects import SphereNanoObject
</pre>
and hit SHIFT + ENTER. If you do not receive an error, then it is installed. If you do receive an error, then try to use another kernel (the entries under notebook mentioned in the previous step).
</li>
</ol>

Troubleshooting If this was not successful, then here are some things you may try:
<ul>
<li> you have two instances of jupyter installed and you are not running the correct one. Try to find them and uninstall everything. The command (linux/mac) <pre>which jupyter</pre> can help hint where the jupyter version you're using is installed. </li>
<li> Another possibilty is that you are not in the right conda environment. Simply closing your terminal and opening it again could help. Else, you may need to find out the name of your conda environments by typing in a terminal:
<pre>
conda env list
</pre>
and finally selecting the correct environment by typing:
<pre>
source activate ENV
</pre>
where ENV is one of the names in the list you saw. (it should be one entry unless you've purposely added more environments)
</li>
</ul>

== Updating ScatterSim ==
If you installed using git, you can also update ScatterSim using git. When an update is pushed to the server, it may be retrieved as follows:

<ol>
<li>
Go into ScatterSim directory. Ex:
<pre>
cd ~/software/ScatterSim
</pre>
</li>
<li>
Then run the following two commands: 
<pre>
git checkout master
git pull origin master
</pre>
</li>
</ol>

NOTE : If you made any changes to ScatterSim, git will complain (this could happen by accidentally opening a file and adding in a whitespace for example). To resolve this, you delete all changes you may have made by typing:
<pre>
git reset --hard
</pre>
If you wanted to keep your changes, then one option is to create a new branch for them, such as:
may either need to add the changes:
<pre>
git checkout -b development-branch-name
git add <files...>
git commit -m "MY Commit message for these edits"
</pre>
Now your changes are saved and may always be accessed by running:
<pre>
git checkout development-branch-name
</pre>
This is likely unnecessary, unless you are digging into the code.

ScatterSim

2017-06-14T14:16:09Z

JulienLhermitte: /* See Also */

ScatterSim:Installing

2017-06-14T14:15:19Z

JulienLhermitte: Created page with "== Installing ScatterSim == Here are some rough guidelines into installing ScatterSim. There are a few ways to do it, but this is a recommended method. <ol> <li> Download and..."

== Installing ScatterSim ==
Here are some rough guidelines into installing ScatterSim. There are a few ways to do it, but this is a recommended method.

<ol>
<li>
Download and install Anaconda 
https://www.continuum.io/downloads
</li>

<li>
Download and install git: 

https://git-scm.com/downloads

</li>
<li>
Download the ScatterSim library using git
<ol>
<li> Open a terminal and choose a directory where you want to install ScatterSim, for example:
<pre>
cd ~/
mkdir -p software
cd software
</pre>
</li>
<li>
Download and install ScatterSim using git:
<ol>
<li>Download using git: 

<pre>
git clone https://github.com/CFN-softbio/ScatterSim.git
</pre>
</li>
</li>
<li>
Now install ScatterSim
<pre>
cd ScatterSim
python setup.py develop
</pre>
It should now be installed.
</li>
</li>
</ol>
<li>
You should be able to now run ScatterSim in a python environment.
</ol>

== Testing ScatterSim ==
To test that ScatterSim was properly installed, let's make a folder where we can add code and test.
<ol>
<li>
Create a folder where you'll want to store your notebooks, for example, in a terminal, type:
<pre>
cd ~/software
mkdir -p ScatterSim-examples
cd ScatterSim-examples
</pre>
</li>
<li>
In this folder, in the terminal, type:
<pre>
jupyter notebook
</pre>
This will open your web browser to run jupyter notebooks.
</li>
<li>
Click "New" and select one of the entries under "Notebook". Likely it will say something like "Python 3" or something similar. You should only have one entry (unless you've manually created extra notebook kernels, or installed jupyter on its own).
</li>
<li>
To test that ScatterSim is installed, type in a cell:
<pre>
from ScatterSim.NanoObjects import SphereNanoObject
</pre>
and hit SHIFT + ENTER. If you do not receive an error, then it is installed. If you do receive an error, then try to use another kernel (the entries under notebook mentioned in the previous step).
</li>
</ol>

Troubleshooting If this was not successful, then here are some things you may try:
<ul>
<li> you have two instances of jupyter installed and you are not running the correct one. Try to find them and uninstall everything. The command (linux/mac) <pre>which jupyter</pre> can help hint where the jupyter version you're using is installed. </li>
<li> Another possibilty is that you are not in the right conda environment. Simply closing your terminal and opening it again could help. Else, you may need to find out the name of your conda environments by typing in a terminal:
<pre>
conda env list
</pre>
and finally selecting the correct environment by typing:
<pre>
source activate ENV
</pre>
where ENV is one of the names in the list you saw. (it should be one entry unless you've purposely added more environments)
</li>
</ul>

== Updating ScatterSim ==
If you installed using git, you can also update ScatterSim using git. When an update is pushed to the server, it may be retrieved as follows:

<ol>
<li>
Go into ScatterSim directory. Ex:
<pre>
cd ~/software/ScatterSim
</pre>
</li>
<li>
Then run the following two commands: 
<pre>
git checkout master
git pull origin master
</pre>
</li>
</ol>

NOTE : If you made any changes to ScatterSim, git will complain (this could happen by accidentally opening a file and adding in a whitespace for example). To resolve this, you delete all changes you may have made by typing:
<pre>
git reset --hard
</pre>
If you wanted to keep your changes, then one option is to create a new branch for them, such as:
may either need to add the changes:
<pre>
git checkout -b development-branch-name
git add <files...>
git commit -m "MY Commit message for these edits"
</pre>
Now your changes are saved and may always be accessed by running:
<pre>
git checkout development-branch-name
</pre>
This is likely unnecessary, unless you are digging into the code.

ScatterSim:Examples:002Lattice

2017-03-30T16:01:48Z

JulienLhermitte:

<source lang="python">
# The next step is creating a lattice

from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
# We'll import a few lattices, cubic, FCC, BCC and Diamond
from ScatterSim.LatticeObjects import SimpleCubic, FCCLattice, BCCLattice, DiamondTwoParticleLattice
# import the peak shape for the peaks, tunable
from ScatterSim.PeakShape import PeakShape

import numpy as np
import matplotlib.pyplot as plt

# Let's use our polydisperse sphere nanoobject since it's more realistic
# In general though, you'll want to start with simpler objects to reduce computation time
# but this one should be okay...
pargs_polysphere = dict(radius= 1, sigma_R=.04)

polysphere = PolydisperseNanoObject(SphereNanoObject, pargs_polysphere, argname='radius', argstdname='sigma_R')

# The peak shape
# delta is sigma of a Gaussian, and nu is FWHM of a Lorentzian
# Generally, you'll want to keep one zero and vary the other (to get a Gaussian or Lorentzian)
# but when finalizing a fit, you may want to play with intermediate values
peak = PeakShape(delta=0.03, nu=0.01)

# now define your lattices
# lattices, to first order are just defined by 6 parameters:
# lattice_spacing_a, lattice_spacing_b and lattice_spacing_c (the unit vector spacings)
# alpha, beta, gamma (the angles the unit vectors make with the axes)
# We'll deal with simple lattices, so all unit vectors are aligned with x, y and z axes, and same length
lattice_spacing = 10. # 10 times radius (1 nm)
sigma_D = .06 # add a Debye-Waller factor
lat_sc = SimpleCubic([polysphere], lattice_spacing_a=lattice_spacing, sigma_D=sigma_D)
lat_fcc = FCCLattice([polysphere], lattice_spacing_a=lattice_spacing, sigma_D=sigma_D)
lat_bcc = BCCLattice([polysphere], lattice_spacing_a=lattice_spacing, sigma_D=sigma_D)
lat_diamond = DiamondTwoParticleLattice([polysphere], lattice_spacing_a=lattice_spacing, sigma_D=sigma_D)

q = np.linspace(.4, 4, 1000)
# Now compute the intensity, it will take some time...
Z0_sc = lat_sc.intensity(q, peak)
Pq_sc = lat_sc.form_factor_squared_isotropic(q)

c_sc = .1

# note Gq is same for all three here (just depends on sigma_D, it's an exponential decay...)
Gq_sc = lat_sc.G_q(q)

Sq_sc = c_sc*Z0_sc/Pq_sc*Gq_sc + (1-Gq_sc)

print("Finished calculating Simple Cubic")

Z0_fcc = lat_fcc.intensity(q, peak)
Pq_fcc = lat_fcc.form_factor_squared_isotropic(q)
Gq_fcc = lat_fcc.G_q(q)

Sq_fcc = c_sc*Z0_fcc/Pq_fcc*Gq_fcc + (1-Gq_fcc)

print("Finished calculating Face Centered Cubic")

Z0_bcc = lat_bcc.intensity(q, peak)
Pq_bcc = lat_bcc.form_factor_squared_isotropic(q)
Gq_bcc = lat_bcc.G_q(q)

Sq_bcc = c_sc*Z0_bcc/Pq_bcc*Gq_bcc + (1-Gq_bcc)

print("Finished calculating Body Centered Cubic")
Z0_diamond = lat_diamond.intensity(q, peak)
Pq_diamond = lat_diamond.form_factor_squared_isotropic(q)
Gq_diamond = lat_diamond.G_q(q)

Sq_diamond = c_sc*Z0_diamond/Pq_diamond*Gq_diamond + (1-Gq_diamond)

print("Finished calculating Diamond")
plt.figure(0, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.plot(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.plot(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.plot(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.plot(q, Sq_diamond)

</source>
[[File:ScatterSimExamples-002-fig1.png]]
<source lang='python'>
# Same, but loglog plot (sometimes easier to see)

plt.figure(1, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.loglog(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.loglog(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.loglog(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.loglog(q, Sq_diamond)

</source>
[[File:ScatterSimExamples-002-fig2.png]]

ScatterSim:Examples

2017-03-30T15:56:13Z

JulienLhermitte:

These examples are typical use cases of the ScatterSim library to help get started using the library.



[[ScatterSim:Examples:001Sphere|Example 1]] : Creating a sphere and computing the form factor or viewing a projection. 
[[ScatterSim:Examples:002Lattice|Example 2]] : Creating a lattice and computing the powder diffraction.

ScatterSim:Examples

2017-03-30T15:55:55Z

JulienLhermitte:

These examples are typical use cases of the ScatterSim library to help get started using the library.



[[ScatterSim:Examples:001Sphere|Example 1]] : Creating a sphere and computing the form factor or viewing a projection. 
[[ScatterSim:Examples:002Lattice|Example 2]] : Creating a lattice and computing the powder diffraction. 
[[ScatterSim:Examples:003Poly|Example 3]] : Creating a polydisperse object (cylinder in this case) 
[[ScatterSim:Examples:004Composite|Example 4]] : Creating a composite nano object comprised of two cylinders.

ScatterSim:Examples:002Lattice

2017-03-29T16:06:10Z

JulienLhermitte:

<source lang="python">
# The next step is creating a lattice

from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
# We'll import a few lattices, cubic, FCC, BCC and Diamond
from ScatterSim.LatticeObjects import SimpleCubic, FCCLattice, BCCLattice, DiamondTwoParticleLattice
# import the peak shape for the peaks, tunable
from ScatterSim.PeakShape import PeakShape

import numpy as np
import matplotlib.pyplot as plt

</source>

TBA
<source lang="python">
# Let's use our polydisperse sphere nanoobject since it's more realistic
# In general though, you'll want to start with simpler objects to reduce computation time
# but this one should be okay...
pargs_polysphere = dict(radius= 1, sigma_R=.04)

polysphere = PolydisperseNanoObject(SphereNanoObject, pargs_polysphere, argname='radius', argstdname='sigma_R')

# The peak shape
# delta is sigma of a Gaussian, and nu is FWHM of a Lorentzian
# Generally, you'll want to keep one zero and vary the other (to get a Gaussian or Lorentzian)
# but when finalizing a fit, you may want to play with intermediate values
peak = PeakShape(delta=0.03, nu=0.01)

# now define your lattices
# lattices, to first order are just defined by 6 parameters:
# lattice_spacing_a, lattice_spacing_b and lattice_spacing_c (the unit vector spacings)
# alpha, beta, gamma (the angles the unit vectors make with the axes)
# We'll deal with simple lattices, so all unit vectors are aligned with x, y and z axes, and same length
lattice_spacing = 10. # 10 times radius (1 nm)
sigma_D = .06 # add a Debye-Waller factor
lat_sc = SimpleCubic([polysphere], lattice_spacing_a=lattice_spacing, sigma_D=sigma_D)
lat_fcc = FCCLattice([polysphere], lattice_spacing_a=lattice_spacing, sigma_D=sigma_D)
lat_bcc = BCCLattice([polysphere], lattice_spacing_a=lattice_spacing, sigma_D=sigma_D)
lat_diamond = DiamondTwoParticleLattice([polysphere], lattice_spacing_a=lattice_spacing, sigma_D=sigma_D)

q = np.linspace(.4, 4, 1000)
# Now compute the intensity, it will take some time...
Z0_sc = lat_sc.intensity(q, peak)
Pq_sc = lat_sc.form_factor_squared_isotropic(q)

c_sc = .1

# note Gq is same for all three here (just depends on sigma_D, it's an exponential decay...)
Gq_sc = lat_sc.G_q(q)

Sq_sc = c_sc*Z0_sc/Pq_sc*Gq_sc + (1-Gq_sc)

print("Finished calculating Simple Cubic")

Z0_fcc = lat_fcc.intensity(q, peak)
Pq_fcc = lat_fcc.form_factor_squared_isotropic(q)
Gq_fcc = lat_fcc.G_q(q)

Sq_fcc = c_sc*Z0_fcc/Pq_fcc*Gq_fcc + (1-Gq_fcc)

print("Finished calculating Face Centered Cubic")

Z0_bcc = lat_bcc.intensity(q, peak)
Pq_bcc = lat_bcc.form_factor_squared_isotropic(q)
Gq_bcc = lat_bcc.G_q(q)

Sq_bcc = c_sc*Z0_bcc/Pq_bcc*Gq_bcc + (1-Gq_bcc)

print("Finished calculating Body Centered Cubic")
Z0_diamond = lat_diamond.intensity(q, peak)
Pq_diamond = lat_diamond.form_factor_squared_isotropic(q)
Gq_diamond = lat_diamond.G_q(q)

Sq_diamond = c_sc*Z0_diamond/Pq_diamond*Gq_diamond + (1-Gq_diamond)

print("Finished calculating Diamond")
plt.figure(0, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.plot(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.plot(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.plot(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.plot(q, Sq_diamond)

</source>
[[File:ScatterSimExamples-002-fig1.png]]
<source lang='python'>
# Same, but loglog plot (sometimes easier to see)

plt.figure(1, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.loglog(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.loglog(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.loglog(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.loglog(q, Sq_diamond)

</source>
[[File:ScatterSimExamples-002-fig2.png]]

ScatterSim:Examples:002Lattice

2017-03-29T16:05:15Z

JulienLhermitte:

<source lang="python">
# The next step is creating a lattice

from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
# We'll import a few lattices, cubic, FCC, BCC and Diamond
from ScatterSim.LatticeObjects import SimpleCubic, FCCLattice, BCCLattice, DiamondTwoParticleLattice
# import the peak shape for the peaks, tunable
from ScatterSim.PeakShape import PeakShape

import numpy as np
import matplotlib.pyplot as plt

</source>

TBA
<source lang="python">
# Let's use our polydisperse sphere nanoobject since it's more realistic
# In general though, you'll want to start with simpler objects to reduce computation time
# but this one should be okay...
pargs_polysphere = dict(radius= 1, sigma_R=.04)

polysphere = PolydisperseNanoObject(SphereNanoObject, pargs_polysphere, argname='radius', argstdname='sigma_R')

# The peak shape
# delta is sigma of a Gaussian, and nu is FWHM of a Lorentzian
# Generally, you'll want to keep one zero and vary the other (to get a Gaussian or Lorentzian)
# but when finalizing a fit, you may want to play with intermediate values
peak = PeakShape(delta=0.03, nu=0.01)

# now define your lattices
# lattices, to first order are just defined by 6 parameters:
# lattice_spacing_a, lattice_spacing_b and lattice_spacing_c (the unit vector spacings)
# alpha, beta, gamma (the angles the unit vectors make with the axes)
# We'll deal with simple lattices, so all unit vectors are aligned with x, y and z axes, and same length
lattice_spacing = 10. # 10 times radius (1 nm)
lat_sc = SimpleCubic([polysphere], lattice_spacing_a=lattice_spacing)
lat_fcc = FCCLattice([polysphere], lattice_spacing_a=lattice_spacing)
lat_bcc = BCCLattice([polysphere], lattice_spacing_a=lattice_spacing)
lat_diamond = DiamondTwoParticleLattice([polysphere], lattice_spacing_a=lattice_spacing)

q = np.linspace(.4, 4, 1000)
# Now compute the intensity, it will take some time...
Z0_sc = lat_sc.intensity(q, peak)
Pq_sc = lat_sc.form_factor_squared_isotropic(q)

c_sc = .1

# note Gq is same for all three here (just depends on sigma_D, it's an exponential decay...)
Gq_sc = lat_sc.G_q(q)

Sq_sc = c_sc*Z0_sc/Pq_sc*Gq_sc + (1-Gq_sc)

print("Finished calculating Simple Cubic")

Z0_fcc = lat_fcc.intensity(q, peak)
Pq_fcc = lat_fcc.form_factor_squared_isotropic(q)
Gq_fcc = lat_fcc.G_q(q)

Sq_fcc = c_sc*Z0_fcc/Pq_fcc*Gq_fcc + (1-Gq_fcc)

print("Finished calculating Face Centered Cubic")

Z0_bcc = lat_bcc.intensity(q, peak)
Pq_bcc = lat_bcc.form_factor_squared_isotropic(q)
Gq_bcc = lat_bcc.G_q(q)

Sq_bcc = c_sc*Z0_bcc/Pq_bcc*Gq_bcc + (1-Gq_bcc)

print("Finished calculating Body Centered Cubic")
Z0_diamond = lat_diamond.intensity(q, peak)
Pq_diamond = lat_diamond.form_factor_squared_isotropic(q)
Gq_diamond = lat_diamond.G_q(q)

Sq_diamond = c_sc*Z0_diamond/Pq_diamond*Gq_diamond + (1-Gq_diamond)

print("Finished calculating Diamond")
plt.figure(0, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.plot(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.plot(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.plot(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.plot(q, Sq_diamond)

</source>
[[File:ScatterSimExamples-002-fig1.png]]
<source lang='python'>
# Same, but loglog plot (sometimes easier to see)

plt.figure(1, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.loglog(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.loglog(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.loglog(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.loglog(q, Sq_diamond)

</source>
[[File:ScatterSimExamples-002-fig2.png]]

ScatterSim:Examples:002Lattice

2017-03-29T16:04:55Z

JulienLhermitte:

<source lang="python">
# The next step is creating a lattice

from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
# We'll import a few lattices, cubic, FCC, BCC and Diamond
from ScatterSim.LatticeObjects import SimpleCubic, FCCLattice, BCCLattice, DiamondTwoParticleLattice
# import the peak shape for the peaks, tunable
from ScatterSim.PeakShape import PeakShape

import numpy as np
import matplotlib.pyplot as plt

</source>

TBA
<source lang="python">
# Let's use our polydisperse sphere nanoobject since it's more realistic
# In general though, you'll want to start with simpler objects to reduce computation time
# but this one should be okay...
pargs_polysphere = dict(radius= 1, sigma_R=.04)

polysphere = PolydisperseNanoObject(SphereNanoObject, pargs_polysphere, argname='radius', argstdname='sigma_R')

# The peak shape
# delta is sigma of a Gaussian, and nu is FWHM of a Lorentzian
# Generally, you'll want to keep one zero and vary the other (to get a Gaussian or Lorentzian)
# but when finalizing a fit, you may want to play with intermediate values
peak = PeakShape(delta=0.03, nu=0.01)

# now define your lattices
# lattices, to first order are just defined by 6 parameters:
# lattice_spacing_a, lattice_spacing_b and lattice_spacing_c (the unit vector spacings)
# alpha, beta, gamma (the angles the unit vectors make with the axes)
# We'll deal with simple lattices, so all unit vectors are aligned with x, y and z axes, and same length
lattice_spacing = 10. # 10 times radius (1 nm)
lat_sc = SimpleCubic([polysphere], lattice_spacing_a=lattice_spacing)
lat_fcc = FCCLattice([polysphere], lattice_spacing_a=lattice_spacing)
lat_bcc = BCCLattice([polysphere], lattice_spacing_a=lattice_spacing)
lat_diamond = DiamondTwoParticleLattice([polysphere], lattice_spacing_a=lattice_spacing)

q = np.linspace(.4, 4, 1000)
# Now compute the intensity, it will take some time...
Z0_sc = lat_sc.intensity(q, peak)
Pq_sc = lat_sc.form_factor_squared_isotropic(q)

c_sc = .1

# note Gq is same for all three here (just depends on sigma_D, it's an exponential decay...)
Gq_sc = lat_sc.G_q(q)

Sq_sc = c_sc*Z0_sc/Pq_sc*Gq_sc + (1-Gq_sc)

print("Finished calculating Simple Cubic")

Z0_fcc = lat_fcc.intensity(q, peak)
Pq_fcc = lat_fcc.form_factor_squared_isotropic(q)
Gq_fcc = lat_fcc.G_q(q)

Sq_fcc = c_sc*Z0_fcc/Pq_fcc*Gq_fcc + (1-Gq_fcc)

print("Finished calculating Face Centered Cubic")

Z0_bcc = lat_bcc.intensity(q, peak)
Pq_bcc = lat_bcc.form_factor_squared_isotropic(q)
Gq_bcc = lat_bcc.G_q(q)

Sq_bcc = c_sc*Z0_bcc/Pq_bcc*Gq_bcc + (1-Gq_bcc)

print("Finished calculating Body Centered Cubic")
Z0_diamond = lat_diamond.intensity(q, peak)
Pq_diamond = lat_diamond.form_factor_squared_isotropic(q)
Gq_diamond = lat_diamond.G_q(q)

Sq_diamond = c_sc*Z0_diamond/Pq_diamond*Gq_diamond + (1-Gq_diamond)

print("Finished calculating Diamond")
plt.figure(0, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.plot(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.plot(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.plot(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.plot(q, Sq_diamond)

</source>
[[File:ScatterSimExamples-001-fig2.png]]
<source lang='python'>
# Same, but loglog plot (sometimes easier to see)

plt.figure(1, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.loglog(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.loglog(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.loglog(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.loglog(q, Sq_diamond)

</source>
[[File:ScatterSimExamples-001-fig2.png]]

File:ScatterSimExamples-002-fig2.png

2017-03-29T16:04:16Z

JulienLhermitte: ScatterSim example # 2 figure 2

ScatterSim example # 2 figure 2

File:ScatterSimExamples-002-fig1.png

2017-03-29T16:04:00Z

JulienLhermitte: ScatterSim example # 2 figure 1

ScatterSim example # 2 figure 1

ScatterSim:Examples:002Lattice

2017-03-29T16:03:09Z

JulienLhermitte:

<source lang="python">
# The next step is creating a lattice

from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
# We'll import a few lattices, cubic, FCC, BCC and Diamond
from ScatterSim.LatticeObjects import SimpleCubic, FCCLattice, BCCLattice, DiamondTwoParticleLattice
# import the peak shape for the peaks, tunable
from ScatterSim.PeakShape import PeakShape

import numpy as np
import matplotlib.pyplot as plt

</source>

TBA
<source lang="python">
# Let's use our polydisperse sphere nanoobject since it's more realistic
# In general though, you'll want to start with simpler objects to reduce computation time
# but this one should be okay...
pargs_polysphere = dict(radius= 1, sigma_R=.04)

polysphere = PolydisperseNanoObject(SphereNanoObject, pargs_polysphere, argname='radius', argstdname='sigma_R')

# The peak shape
# delta is sigma of a Gaussian, and nu is FWHM of a Lorentzian
# Generally, you'll want to keep one zero and vary the other (to get a Gaussian or Lorentzian)
# but when finalizing a fit, you may want to play with intermediate values
peak = PeakShape(delta=0.03, nu=0.01)

# now define your lattices
# lattices, to first order are just defined by 6 parameters:
# lattice_spacing_a, lattice_spacing_b and lattice_spacing_c (the unit vector spacings)
# alpha, beta, gamma (the angles the unit vectors make with the axes)
# We'll deal with simple lattices, so all unit vectors are aligned with x, y and z axes, and same length
lattice_spacing = 10. # 10 times radius (1 nm)
lat_sc = SimpleCubic([polysphere], lattice_spacing_a=lattice_spacing)
lat_fcc = FCCLattice([polysphere], lattice_spacing_a=lattice_spacing)
lat_bcc = BCCLattice([polysphere], lattice_spacing_a=lattice_spacing)
lat_diamond = DiamondTwoParticleLattice([polysphere], lattice_spacing_a=lattice_spacing)

q = np.linspace(.4, 4, 1000)
# Now compute the intensity, it will take some time...
Z0_sc = lat_sc.intensity(q, peak)
Pq_sc = lat_sc.form_factor_squared_isotropic(q)

c_sc = .1

# note Gq is same for all three here (just depends on sigma_D, it's an exponential decay...)
Gq_sc = lat_sc.G_q(q)

Sq_sc = c_sc*Z0_sc/Pq_sc*Gq_sc + (1-Gq_sc)

print("Finished calculating Simple Cubic")

Z0_fcc = lat_fcc.intensity(q, peak)
Pq_fcc = lat_fcc.form_factor_squared_isotropic(q)
Gq_fcc = lat_fcc.G_q(q)

Sq_fcc = c_sc*Z0_fcc/Pq_fcc*Gq_fcc + (1-Gq_fcc)

print("Finished calculating Face Centered Cubic")

Z0_bcc = lat_bcc.intensity(q, peak)
Pq_bcc = lat_bcc.form_factor_squared_isotropic(q)
Gq_bcc = lat_bcc.G_q(q)

Sq_bcc = c_sc*Z0_bcc/Pq_bcc*Gq_bcc + (1-Gq_bcc)

print("Finished calculating Body Centered Cubic")
Z0_diamond = lat_diamond.intensity(q, peak)
Pq_diamond = lat_diamond.form_factor_squared_isotropic(q)
Gq_diamond = lat_diamond.G_q(q)

Sq_diamond = c_sc*Z0_diamond/Pq_diamond*Gq_diamond + (1-Gq_diamond)

print("Finished calculating Diamond")
plt.figure(0, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.plot(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.plot(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.plot(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.plot(q, Sq_diamond)

# Same, but loglog plot (sometimes easier to see)

plt.figure(1, figsize=(10,8));plt.clf()
plt.subplot(2,2,1)
plt.title("Simple Cubic Structure Factor")
plt.loglog(q, Sq_sc)
plt.subplot(2,2,2)
plt.title("Face Centered Cubic Structure Factor")
plt.loglog(q, Sq_fcc)
plt.subplot(2,2,3)
plt.title("Body Centered Cubic Structure Factor")
plt.loglog(q, Sq_bcc)
plt.subplot(2,2,4)
plt.title("Diamond Structure Factor")
plt.loglog(q, Sq_diamond)

ScatterSim

2017-03-29T15:07:51Z

JulienLhermitte:

ScatterSim:Examples:001Sphere

2017-03-28T20:44:12Z

JulienLhermitte:

This example shows you how to create a sphere NanoObject and view its 2D form factor, projection, as well as its isotropically averaged form factor.
It also shows you how to add polydispersity to your NanoObject.
Some code necessary for plotting is deferred at end of document for clarity. '''Be sure to first copy and paste that code before running the rest.'''

<source lang='python'>
from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

# Definining a sphere is simple
pargs_sphere = {'radius' : 1}
sphere = SphereNanoObject(pargs_sphere)

# You can also define a NanoObject with a stochastic parameter
# in this case, we'll make a polydisperse sphere
# The varied parameter will be the radius
pargs_polysphere = dict(radius= 1, sigma_R=.04) # (alternate way of defining dictionaries)
# Just give the object the class you're interested in, and tell it what the parameter it
# is you're varying
# The parameter is assumed to be sampled from a Gaussian distribution of mean 'argname'
# and standard deviation (sigma) 'sigma_R'
polysphere = PolydisperseNanoObject(SphereNanoObject, pargs_polysphere, argname='radius', argstdname='sigma_R')

# Now choose a q domain for the plotting. The units of q will be the inverse of units you supply
# as parameters to the object. For example, we used nanometers, so q will be in inverse nanometers
q = np.linspace(0, 10, 1000)

# finally, calculate
sq_sphere = sphere.form_factor_squared_isotropic(q)
# The polydisperse sphere should take roughly 21 times longer. This is because
# by default it computes the form factors of spheres of radii from 21 points in the distribution
# You can change this, and even change the distribution by reading more into the code
# of NanoObjects.PolydisperseNanoObject
sq_polysphere = polysphere.form_factor_squared_isotropic(q)

# plot using your favorite plotting library
plt.figure(0);
plt.clf()
plt.loglog(q, sq_sphere)
</source>
[[File:ScatterSimExamples-001-fig1.png]]
<source lang='python'>

# even with a small polydispersity (4%), polydisperse sphere scattering looks much different
plt.figure(1);
plt.clf()
plt.loglog(q, sq_polysphere)
</source>
[[File:ScatterSimExamples-001-fig2.png]]
<source lang='python'>
# For any object, you can compute the form factor or projection. See functions
# above on how to do it.
# P2 means |P|^2 (form factor squared)
qmax = 10
P2_xy, P2_yz, P2_xz = form_factor_slices(sphere, qmax)
rmax = 1.5
V_xy, V_yz, V_xz = sphere.projections(rmax)
</source>

<source lang='python'>
# remember this is a 3D Object. We can look at projections of the object in real space
# or slices of the scattering in Fourier (reciprocal) space

show_projections(V_xy, V_yz, V_xz, rmax, 3)
</source>
[[File:ScatterSimExamples-001-fig3.png]]
<source lang='python>
# Showing the form factor

show_qslices(P2_xy, P2_yz, P2_xz, qmax, 2, vmin=0, vmax=6e1)
</source>
[[File:ScatterSimExamples-001-fig4.png]]

Plotting code:
<source lang='python'>
def form_factor_slices(smod, qmax):
''' Compute the xy, xz, and yz projections.

'''
q = np.linspace(-qmax, qmax,100)
QROWS, QCOLS = np.meshgrid(q,q, indexing="ij")
Q0 = QROWS*0
P2_xy = smod.form_factor_squared(np.array([QCOLS, QROWS, Q0]))
P2_yz = smod.form_factor_squared(np.array([Q0, QCOLS, QROWS]))
P2_xz = smod.form_factor_squared(np.array([QROWS, QCOLS, Q0]))

return P2_xy, P2_yz, P2_xz

def show_qslices(F_xy, F_xz, F_yz, length, num=4, **kwargs):
'''plot the xy, xz, and yz projections with length used from
projections function, in figure num

slices go from -2pi/length to +2pi/length
'''
extent = 2*np.pi/length*np.array([-1, 1, -1, 1])
plt.figure(num);plt.clf();
plt.subplot(2,2,1)
plt.title("x-y plane")
plt.imshow(F_xy,extent=extent, **kwargs)
plt.subplot(2,2,2)
plt.title("x-z plane")
plt.imshow(F_xz,extent=extent, **kwargs)
plt.subplot(2,2,3)
plt.title("y-z plane")
plt.imshow(F_yz,extent=extent, **kwargs)

def show_projections(V_xy, V_xz, V_yz, length, num=4):
'''plot the xy, xz, and yz projections with length used from
projections function, in figure num
projections go from -length to +length
'''
extent = [-length, length, length, -length]
plt.figure(num);plt.clf();
plt.subplot(2,2,1)
plt.title("x-y plane")
plt.imshow(V_xy,extent=extent)
plt.subplot(2,2,2)
plt.title("x-z plane")
plt.imshow(V_xz,extent=extent)
plt.subplot(2,2,3)
plt.title("y-z plane")
plt.imshow(V_yz,extent=extent)
</source>

ScatterSim:Examples:001Sphere

2017-03-28T20:40:05Z

JulienLhermitte:

<source lang='python'>
from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

# Definining a sphere is simple
pargs_sphere = {'radius' : 1}
sphere = SphereNanoObject(pargs_sphere)

# You can also define a NanoObject with a stochastic parameter
# in this case, we'll make a polydisperse sphere
# The varied parameter will be the radius
pargs_polysphere = dict(radius= 1, sigma_R=.04) # (alternate way of defining dictionaries)
# Just give the object the class you're interested in, and tell it what the parameter it
# is you're varying
# The parameter is assumed to be sampled from a Gaussian distribution of mean 'argname'
# and standard deviation (sigma) 'sigma_R'
polysphere = PolydisperseNanoObject(SphereNanoObject, pargs_polysphere, argname='radius', argstdname='sigma_R')

# Now choose a q domain for the plotting. The units of q will be the inverse of units you supply
# as parameters to the object. For example, we used nanometers, so q will be in inverse nanometers
q = np.linspace(0, 10, 1000)

# finally, calculate
sq_sphere = sphere.form_factor_squared_isotropic(q)
# The polydisperse sphere should take roughly 21 times longer. This is because
# by default it computes the form factors of spheres of radii from 21 points in the distribution
# You can change this, and even change the distribution by reading more into the code
# of NanoObjects.PolydisperseNanoObject
sq_polysphere = polysphere.form_factor_squared_isotropic(q)

# plot using your favorite plotting library
plt.figure(0);
plt.clf()
plt.loglog(q, sq_sphere)
</source>
[[File:ScatterSimExamples-001-fig1.png]]
<source lang='python'>

# even with a small polydispersity (4%), polydisperse sphere scattering looks much different
plt.figure(1);
plt.clf()
plt.loglog(q, sq_polysphere)
</source>
[[File:ScatterSimExamples-001-fig2.png]]
<source lang='python'>
# For any object, you can compute the form factor or projection. See functions
# above on how to do it.
# P2 means |P|^2 (form factor squared)
qmax = 10
P2_xy, P2_yz, P2_xz = form_factor_slices(sphere, qmax)
rmax = 1.5
V_xy, V_yz, V_xz = sphere.projections(rmax)
</source>

<source lang='python'>
# remember this is a 3D Object. We can look at projections of the object in real space
# or slices of the scattering in Fourier (reciprocal) space

show_projections(V_xy, V_yz, V_xz, rmax, 3)
</source>
[[File:ScatterSimExamples-001-fig3.png]]
<source lang='python>
# Showing the form factor

show_qslices(P2_xy, P2_yz, P2_xz, qmax, 2, vmin=0, vmax=6e1)
</source>
[[File:ScatterSimExamples-001-fig4.png]]

ScatterSim:Examples:002Lattice

2017-03-28T20:39:21Z

JulienLhermitte: Created page with "<source lang="python> # The next step is creating a lattice from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject # We'll import a few lattices, cubic, ..."

<source lang="python>
# The next step is creating a lattice

from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
# We'll import a few lattices, cubic, FCC, BCC and Diamond
from ScatterSim.LatticeObjects import SimpleCubic, FCCLattice, BCCLattice, DiamondTwoParticleLattice
# import the peak shape for the peaks, tunable
from ScatterSim.PeakShape import PeakShape

import numpy as np
import matplotlib.pyplot as plt

</source>

TBA

ScatterSim:Examples

2017-03-28T20:38:06Z

JulienLhermitte:

These examples are typical use cases of the ScatterSim library to help get started using the library.

These examples may also be found on the [http://github.com/CFN-softbio/ScatterSim-examples| github page].

[[ScatterSim:Examples:001Sphere|Example 1]] : Creating a sphere and computing the form factor or viewing a projection. 
[[ScatterSim:Examples:002Lattice|Example 2]] : Creating a lattice and computing the powder diffraction. 
[[ScatterSim:Examples:003Poly|Example 3]] : Creating a polydisperse object (cylinder in this case) 
[[ScatterSim:Examples:004Composite|Example 4]] : Creating a composite nano object comprised of two cylinders.

ScatterSim:Examples

2017-03-28T20:35:23Z

JulienLhermitte:

[[ScatterSim:Examples:001Sphere|Example 1]] : Creating a sphere and computing the form factor or viewing a projection. 
[[ScatterSim:Examples:002Lattice|Example 2]] : Creating a lattice and computing the powder diffraction. 
[[ScatterSim:Examples:003Poly|Example 3]] : Creating a polydisperse object (cylinder in this case) 
[[ScatterSim:Examples:004Composite|Example 4]] : Creating a composite nano object comprised of two cylinders.

ScatterSim:Examples:001Sphere

2017-03-28T20:31:03Z

JulienLhermitte: Created page with "<source lang='python'> from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject import numpy as np import matplotlib.pyplot as plt %matplotlib inline # De..."

<source lang='python'>
from ScatterSim.NanoObjects import SphereNanoObject, PolydisperseNanoObject
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

# Definining a sphere is simple
pargs_sphere = {'radius' : 1}
sphere = SphereNanoObject(pargs_sphere)

# You can also define a NanoObject with a stochastic parameter
# in this case, we'll make a polydisperse sphere
# The varied parameter will be the radius
pargs_polysphere = dict(radius= 1, sigma_R=.04) # (alternate way of defining dictionaries)
# Just give the object the class you're interested in, and tell it what the parameter it
# is you're varying
# The parameter is assumed to be sampled from a Gaussian distribution of mean 'argname'
# and standard deviation (sigma) 'sigma_R'
polysphere = PolydisperseNanoObject(SphereNanoObject, pargs_polysphere, argname='radius', argstdname='sigma_R')

# Now choose a q domain for the plotting. The units of q will be the inverse of units you supply
# as parameters to the object. For example, we used nanometers, so q will be in inverse nanometers
q = np.linspace(0, 10, 1000)

# finally, calculate
sq_sphere = sphere.form_factor_squared_isotropic(q)
# The polydisperse sphere should take roughly 21 times longer. This is because
# by default it computes the form factors of spheres of radii from 21 points in the distribution
# You can change this, and even change the distribution by reading more into the code
# of NanoObjects.PolydisperseNanoObject
sq_polysphere = polysphere.form_factor_squared_isotropic(q)

# plot using your favorite plotting library
plt.figure(0);
plt.clf()
plt.loglog(q, sq_sphere)
</source>
[[File:ScatterSimExamples-001-fig1.png]]
<source lang='python'>

# even with a small polydispersity (4%), polydisperse sphere scattering looks much different
plt.figure(1);
plt.clf()
plt.loglog(q, sq_polysphere)
</source>
[[File:ScatterSimExamples-001-fig2.png]]
<source lang='python'>
# For any object, you can compute the form factor or projection. See functions
# above on how to do it.
# P2 means |P|^2 (form factor squared)
qmax = 10
P2_xy, P2_yz, P2_xz = form_factor_slices(sphere, qmax)
rmax = 1.5
V_xy, V_yz, V_xz = sphere.projections(rmax)
</source>
[[File:ScatterSimExamples-001-fig3.png]]
<source lang='python'>
# remember this is a 3D Object. We can look at projections of the object in real space
# or slices of the scattering in Fourier (reciprocal) space

show_projections(V_xy, V_yz, V_xz, rmax, 3)
</source>
[[File:ScatterSimExamples-001-fig4.png]]
<source lang='python>
# Showing the form factor

show_qslices(P2_xy, P2_yz, P2_xz, qmax, 2, vmin=0, vmax=6e1)
</source>

File:ScatterSimExamples-001-fig4.png

2017-03-28T20:30:09Z

JulienLhermitte: Fourth figure of example #1 of ScatterSim examples.

Fourth figure of example #1 of ScatterSim examples.

File:ScatterSimExamples-001-fig3.png

2017-03-28T20:29:56Z

JulienLhermitte: Third figure of example #1 of ScatterSim examples.

Third figure of example #1 of ScatterSim examples.

File:ScatterSimExamples-001-fig2.png

2017-03-28T20:29:36Z

JulienLhermitte: Second figure of Example #1 of ScatterSim examples.

Second figure of Example #1 of ScatterSim examples.

File:ScatterSimExamples-001-fig1.png

2017-03-28T20:29:03Z

JulienLhermitte: First figure of Example #1 of ScatterSim Examples.

First figure of Example #1 of ScatterSim Examples.

ScatterSim:Examples

2017-03-28T20:20:50Z

JulienLhermitte:

Example 1 : Creating a sphere and computing the form factor or viewing a projection. 
Example 2 : Creating a lattice and computing the powder diffraction. 
Example 3 : Creating a polydisperse object (cylinder in this case) 
Example 4 : Creating a composite nano object comprised of two cylinders.