Micro and Nano Mechanics Group - User contributions [en]

Computational XRD

2015-08-23T21:57:52Z

Alank2: /* Making Nanoparticles */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:
generate_particles.py
XRDsetup.py

and these can be run with the command:
<pre>
bin/eam generate_particles.py
</pre>
'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL and C++11 packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions written by generate_particles.py and the following C++ file which can be run as:

<pre>
g++ -o XRD.exe XRD.cpp -lgsl -lgslcblas -lm -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam

num_bins = 25000 # the number of bins in the histogram per division
# the background noise is quite dependent on this
# parameter so don't make it too small

N = 10000 # the number of Intensity points to calculate
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized (completely serial) and still runs very fast. A 4 nm nanoparticle calculation takes ~30 seconds with this code.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. As the particles get bigger and more heavily deformed, the number of bins may need to be increased, leading to a notable increase in the XRD time. Unless the number of bins necessary is outrageously large (even at the huge overkill of 100,000 bins for a 4 nm nanoparticle, the entire calculation of distances + XRD takes 75 seconds), the XRD time should not get too large from this contribution. One important note is that the cluster of GPUs need to have the GSL libraries available.

Computational XRD

2015-08-23T21:57:22Z

Alank2: /* Intensity Calculation in C++ */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:
generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL and C++11 packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions written by generate_particles.py and the following C++ file which can be run as:

<pre>
g++ -o XRD.exe XRD.cpp -lgsl -lgslcblas -lm -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam

num_bins = 25000 # the number of bins in the histogram per division
# the background noise is quite dependent on this
# parameter so don't make it too small

N = 10000 # the number of Intensity points to calculate
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized (completely serial) and still runs very fast. A 4 nm nanoparticle calculation takes ~30 seconds with this code.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. As the particles get bigger and more heavily deformed, the number of bins may need to be increased, leading to a notable increase in the XRD time. Unless the number of bins necessary is outrageously large (even at the huge overkill of 100,000 bins for a 4 nm nanoparticle, the entire calculation of distances + XRD takes 75 seconds), the XRD time should not get too large from this contribution. One important note is that the cluster of GPUs need to have the GSL libraries available.

Computational XRD

2015-08-23T21:56:37Z

Alank2: /* Making Nanoparticles */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:
generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL and C++11 packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD.cpp -lgsl -lgslcblas -lm -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam

num_bins = 25000 # the number of bins in the histogram per division
# the background noise is quite dependent on this
# parameter so don't make it too small

N = 10000 # the number of Intensity points to calculate
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized (completely serial) and still runs very fast. A 4 nm nanoparticle calculation takes ~30 seconds with this code.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. As the particles get bigger and more heavily deformed, the number of bins may need to be increased, leading to a notable increase in the XRD time. Unless the number of bins necessary is outrageously large (even at the huge overkill of 100,000 bins for a 4 nm nanoparticle, the entire calculation of distances + XRD takes 75 seconds), the XRD time should not get too large from this contribution. One important note is that the cluster of GPUs need to have the GSL libraries available.

Computational XRD

2015-08-23T21:54:23Z

Alank2: /* Making Nanoparticles */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:
[[media:generate_particles.py | generate_particles.py]]

XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL and C++11 packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD.cpp -lgsl -lgslcblas -lm -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam

num_bins = 25000 # the number of bins in the histogram per division
# the background noise is quite dependent on this
# parameter so don't make it too small

N = 10000 # the number of Intensity points to calculate
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized (completely serial) and still runs very fast. A 4 nm nanoparticle calculation takes ~30 seconds with this code.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. As the particles get bigger and more heavily deformed, the number of bins may need to be increased, leading to a notable increase in the XRD time. Unless the number of bins necessary is outrageously large (even at the huge overkill of 100,000 bins for a 4 nm nanoparticle, the entire calculation of distances + XRD takes 75 seconds), the XRD time should not get too large from this contribution. One important note is that the cluster of GPUs need to have the GSL libraries available.

Computational XRD

2015-08-23T21:50:55Z

Alank2: /* CUDA Code */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL and C++11 packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD.cpp -lgsl -lgslcblas -lm -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam

num_bins = 25000 # the number of bins in the histogram per division
# the background noise is quite dependent on this
# parameter so don't make it too small

N = 10000 # the number of Intensity points to calculate
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized (completely serial) and still runs very fast. A 4 nm nanoparticle calculation takes ~30 seconds with this code.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. As the particles get bigger and more heavily deformed, the number of bins may need to be increased, leading to a notable increase in the XRD time. Unless the number of bins necessary is outrageously large (even at the huge overkill of 100,000 bins for a 4 nm nanoparticle, the entire calculation of distances + XRD takes 75 seconds), the XRD time should not get too large from this contribution. One important note is that the cluster of GPUs need to have the GSL libraries available.

Computational XRD

2015-08-23T21:47:51Z

Alank2: /* CUDA Code */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL and C++11 packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD.cpp -lgsl -lgslcblas -lm -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam

num_bins = 25000 # the number of bins in the histogram per division
# the background noise is quite dependent on this
# parameter so don't make it too small

N = 10000 # the number of Intensity points to calculate
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized (completely serial) and still runs very fast. A 4 nm nanoparticle calculation takes ~30 seconds with this code.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. As the particles get bigger and more heavily deformed, the number of bins may need to be increased, leading to a notable increase in the XRD time. Unless the number of bins necessary is outrageously large (even at the huge overkill of 100,000 bins for a 4 nm nanoparticle, the entire calculation of distances + XRD takes ), the XRD time should not get too large from this contribution. One important note is that the cluster of GPUs need to have the gsl libraries available.

Computational XRD

2015-08-23T21:43:19Z

Alank2: /* Intensity Calculation in C++ */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL and C++11 packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD.cpp -lgsl -lgslcblas -lm -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam

num_bins = 25000 # the number of bins in the histogram per division
# the background noise is quite dependent on this
# parameter so don't make it too small

N = 10000 # the number of Intensity points to calculate
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized (completely serial) and still runs very fast. A 4 nm nanoparticle calculation takes ~30 seconds with this code.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. One important note is that the cluster of GPUs need to have the gsl libraries available.

Computational XRD

2015-08-23T21:39:20Z

Alank2: /* Intensity Calculation in C++ */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam
num_bins = 25000 # the number of bins in the histogram per division
N = 10000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized and still runs very fast.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. One important note is that the cluster of GPUs need to have the gsl libraries available.

Computational XRD

2015-08-23T20:35:40Z

Alank2: /* CUDA Code */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel. One important note is that the cluster of GPUs need to have the gsl libraries available.

Computational XRD

2015-08-23T19:03:10Z

Alank2: /* CUDA Code */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed. The vast majority of time is spent in the distances calculation so for now, only this section will be made into a CUDA kernel.

Computational XRD

2015-08-23T18:59:56Z

Alank2: /* Plotting and Interpolating */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = float(sys.argv[3]) # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed.

Computational XRD

2015-08-20T02:54:58Z

Alank2: /* Intensity Calculation in C++ */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40

wavelength = 0.67 # the wavelength of the incident monochromatic X-ray beam
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = 2e4 # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed.

Computational XRD

2015-08-20T02:52:50Z

Alank2: /* Plotting and Interpolating */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. The following file plots and interpolates the intensity and it should be run as:
<pre>
python MD++_plot.py Radius flag cutoff
</pre>
where Radius, flag, and cutoff are parameters. These are some important parameters to consider, especially in the interpolation.

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = 2e4 # Bragg peaks with maximum below this cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum.
# This really doesn't need to be changed
</pre>

Thus the cutoff must be chosen carefully if one wants to get the most number of peaks that have resolved half-widths. This gets more important with increased peak broadening.

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed.

Computational XRD

2015-08-20T02:47:59Z

Alank2: /* Intensity Calculation in C++ */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. There are some important parameters to consider, especially in the interpolation. These are:

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = 2e4 # Bragg peaks with maxima below cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum
</pre>

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed.

Computational XRD

2015-08-20T02:47:45Z

Alank2: /* Intensity Calculation in C++ */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
</pre>
followed simply by

<pre>
./XRD.exe.
</pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. There are some important parameters to consider, especially in the interpolation. These are:

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = 2e4 # Bragg peaks with maxima below cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum
</pre>

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed.

Computational XRD

2015-08-20T02:47:12Z

Alank2: /* Intensity Calculation in C++ */

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run

<pre>
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11

<pre>
followed simply by

<pre>
./XRD.exe.
<pre>

'''Parameters'''

<pre>
flag = 0
Radius = 40
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. There are some important parameters to consider, especially in the interpolation. These are:

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = 2e4 # Bragg peaks with maxima below cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum
</pre>

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed.

Computational XRD

2015-08-15T05:14:49Z

Alank2:

Computational XRD
<DIV>
 
</DIV>

===Making Nanoparticles===

Here we give an example of how to generate nanoparticles with different dislocations. One may have to play around a bit with the directories to make sure that the files get opened and written to the correct places. A python version of the MD++ code is necessary. The relevant python files are:

generate_particles.py
XRDsetup.py

and these can be run with the command:
bin/eam generate_particles.py

'''Notable Parameters'''

<pre>
# flag = 0 is no dislocations
# flag = 1 is only one dislocation
# flag = 2 is multiple randomly generated dislocations
flag = 0
start = 40 # Radius of the nanoparticle
numDisls = 6 # if flag == 2, the number of dislocations
</pre>

This generates a series of .cn, .cfg, and a file of atomic positions which will be read by the C++ code to calculate the Intensity.

===Intensity Calculation in C++===

First, make sure the required libraries are installed. The GSL, C++11, and OpenMP packages are required (the GSL library is for easily making histograms). The required files are the previous file of atomic positions and the attached C++ file:

Now we are ready to run
g++ -o XRD.exe XRD_OpenMP.cpp -lgsl -lgslcblas -lm -fopenmp -std=c++11
followed simply by ./XRD.exe.

'''Parameters'''

<pre>
flag = 0
Radius = 40
divs = 6 # the number of partial distance calculations to compute.
# this needs to be adjusted to larger values for large runs
# because of memory issues. If not set properly, the code will
# exit with a memory error.
num_bins = 5000 # the number of bins in the histogram per division
N = 1000 # the number of points for the Intensity and Q
</pre>

I plan to run several different sizes and compare the time taken for this calculation for a fixed num_bins, divs, and N to access the scalability. Currently the code is highly un-optimized. This code should be re-written with dynamic arrays instead of vectors in order to become much more parallel.

===Plotting and Interpolating===

The next step is to read the file of Intensities and Q values into the python script attached. The Intensity and Q values that are either background before the first real Bragg peak or are small values past Q~20 are gotten rid of. The interpolation is only done on the largest 5-10 peaks. The number of peaks that can be reasonably interpolated decreases with increasing number of dislocations as the peaks broaden. There are some important parameters to consider, especially in the interpolation. These are:

'''Parameters'''

<pre>
wavelength = 0.67
Radius = int(sys.argv[1])
flag = int(sys.argv[2])
cutoff = 2e4 # Bragg peaks with maxima below cutoff will be ignored
tol = 0.1 # The Q range around which the program searches for a half-maximum
</pre>

===CUDA Code===
The code is obviously parallel. The next step is to re-write the code in CUDA to improve speed.

Computational XRD

2015-08-15T05:12:29Z

Alank2:

Computational XRD

2015-08-15T05:11:51Z

Alank2:

Computational XRD

2015-08-15T04:57:24Z

Alank2: Created page with " Computational XRD <DIV> </DIV> ===Making Nanoparticle..."