Compare commits

..

268 commits

Author SHA1 Message Date
796176b4b4 Merge pull request 'issue/edgesVolume' (#59) from issue/edgesVolume into development
Reviewed-on: https://plasmalab.aero.upm.es/git/git/JGonzalez/fpakc/pulls/59
2026-02-26 19:21:52 +01:00
7208b2e0da Merge remote-tracking branch 'origin/issue/Maxwellian' into issue/edgesVolume 2026-02-04 19:59:59 +01:00
23bba31005 Fixed an issue with the random Maxwellian subroutines 2026-02-04 13:52:24 +01:00
159f2e7620 Trying partial reflection 2026-02-03 10:15:12 +01:00
34b5bdbb52 Merge pull request 'Wrong surface in edges' (#58) from issue/edgesVolume into development
Reviewed-on: https://plasmalab.aero.upm.es/git/git/JGonzalez/fpakc/pulls/58
2026-02-02 14:34:47 +01:00
8d5cb6a516 Wrong surface in edges
Some edges were calculating the area surface incorrectly, which was leading to wrong densities.
2026-02-02 14:31:58 +01:00
4747673d0a Bones of boundary 2026-01-28 14:56:38 +01:00
6a901a0cac Merge pull request 'feature/meshText' (#57) from feature/meshText into development
Reviewed-on: https://plasmalab.aero.upm.es/git/git/JGonzalez/fpakc/pulls/57
2026-01-23 15:27:27 +01:00
56a17300f3 Change in manual 2026-01-23 15:26:23 +01:00
0c0017b84a txs auto checkin 2026-01-23 15:21:26 +01:00
1b1a574edc Read initial
Now we can read an initial condition as we do with other formats.

Only documentation left.
2026-01-23 15:04:39 +01:00
d34e72d2e8 Collisions done
Thanks to the advance statement the output of collisions is done.
2026-01-23 14:51:49 +01:00
46b9f263ea Average done
Now we can output averages in this format.
2026-01-23 14:26:39 +01:00
8c8c6409f6 Output for EM
The output for the EM field properties is done.
2026-01-23 12:16:52 +01:00
27158c7c1d Output for species
First output done. Now it is mostly Copy Paste.

There are so many things I need to reform in other parts... Learning new things is awful.
2026-01-22 18:44:25 +01:00
3083e20ff7 Subroutine for reading mesh
It is now complete and working. I also added some minor improvements to moduleMesh.f90 using 'associate' to practice.

I noticed there are a lot of things (allocating K, for example) that are common for all meshes and should be moved to a general module.
2026-01-22 14:06:20 +01:00
7d4f4b98c3 Implementing input subroutines 2026-01-19 15:37:31 +01:00
9f9bacca7c Skeleton implementation of text mesh for simple 1D cases. 2026-01-19 14:48:06 +01:00
d5bcf8ce50 Merge branch 'issue/triangles' into 'development'
Fixed issue with volume in triangles

See merge request JorgeGonz/fpakc!56
2025-10-11 12:01:28 +00:00
55e062a9ef Fixed issue with volume in triangles
The right value in 2D Cartesian is used for calculating the volume.
2025-10-11 14:00:16 +02:00
c9b551458d Merge branch 'citationFile' into 'development'
Add citation file

See merge request JorgeGonz/fpakc!55
2025-09-24 17:34:24 +00:00
9d789ef7a6 Add citation file
I think it follows the standard.
2025-09-24 19:33:25 +02:00
b1f21a2c02 Merge branch 'IEPC2025' into 'development'
Merge IEPC2025

See merge request JorgeGonz/fpakc!54
2025-09-23 16:42:04 +00:00
dff9a87f0d Implemenint injecting particles without direction
I was almost sure this was implemented in the past, but it was not working.

Now, if n = 0 or if n is not provided, particles are injected with the normal to the surface.
2025-08-08 19:27:27 +02:00
5166a650d2 Data for Kr, just to test 2025-08-06 10:59:03 +02:00
3d7b1ce476 Fixed!
So it seems that rectangles and triangles are now working properly.

I have also checked the phy2log routine, now it seems a bit more complicated, but it is much clearer.
Maybe in the future is worth rethinking to improve speed (specially for quad elements)
2025-08-03 22:14:19 +02:00
102fd013f3 Issue with triangles fixed
Now they give the right electric field.

I have to change 2DCyl.

However, there was some insonsistency between the change of coordinates in phy2log and the Jacobian for the K matrix. I fixed it putting a transpose() in phy2log, but I don't like that solution.

I need to review the basic procedure of phy2log.
2025-08-03 20:46:12 +02:00
7e193b9fa8 Minor changes, no improvement made yet 2025-08-03 15:32:55 +02:00
d86c8480f3 Fixed issue with some velocities. Still, at some point I need to rething all the injection thing. 2025-08-02 16:51:00 +02:00
4b040c35c3 Fixes to random variables
After reading some works and reviewing what I had, I've done some
corrections to how the randomb velicities in Maxwellian distributions
are calculated. These should be correct now.
2025-08-02 13:25:48 +02:00
78cb9a2453 No reflection of particles at injection, that should be a boundary condition 2025-08-02 10:31:06 +02:00
d1e73297eb Adjust flux when no particlesPerEdge is used
This does not affects the cases of the IEPC, but I am also doing other
stuff.
2025-07-27 18:17:01 +02:00
8e531ede08 Vol_ref was the right answer 2025-07-27 17:16:57 +02:00
76c5af89b2 Merge branch 'IEPC2025' of gitlab.com:JorgeGonz/fpakc into IEPC2025 2025-07-27 17:15:36 +02:00
7f73b69dc2 Fix injection
Half-Maxwellian distribution should inject particles correctly
2025-07-27 17:14:38 +02:00
69215ef66d Change in calculating ionization
I don't know why I normalizing density n_0 by Vol_ref and not n_ref
2025-07-22 19:52:39 +02:00
a2f9957f32 I am dumb
The Poisson equation was not working because I didn't finish
implementing the new type of BCs. Dirichlet is probably untested. I
should stop doing shitty developments and no testing.
2025-07-18 16:31:52 +02:00
d28dd16c2e Average fix and data for Xe 2025-07-17 18:34:11 +02:00
221de46734 Merge branch 'development' into feature/BoltzmannElectrons 2024-10-13 14:54:34 +02:00
2268a97e23 Merge branch 'mergeDevleopment' into 'development'
Issue with injecting current

See merge request JorgeGonz/fpakc!53
2024-10-13 12:41:03 +00:00
3d8d912722 Merge branch 'development' of gitlab.com:JorgeGonz/fpakc into development 2024-10-13 13:35:34 +02:00
2af10acd70 Issue with injecting current
Values were not right in 1D geometry. Fixed.
2024-10-13 13:32:57 +02:00
98ee3e9c9c Still not working, but will be fixed
I have the solution in the plasma expansion code, but I need to do other
stuff.
2024-09-30 17:06:25 +02:00
0679fa58bc Merge branch 'feature/temporalDirichlet' into 'development'
Time variable Dirichlet condition

See merge request JorgeGonz/fpakc!52
2024-07-13 11:01:10 +00:00
6f185c4188 Organizing things
Move the array of pointers to the nodes to moduleMesh.
2024-07-13 12:35:42 +02:00
e4dfba45f8 Manual updated
New dirichletTime condition is documented.
2024-07-13 12:13:39 +02:00
2d4b405fb1 Functionality added
Now we have a new boundary condition that can change the value of the
potential in a surface based on a file.
2024-07-13 12:06:41 +02:00
10dee05922 NOT WORKING: Compilation okay, but not Dirichlet BC
The code compiles but the right BC is not being applied to the vectorF.

I'll check this tomorrow.
2024-07-12 23:30:35 +02:00
ac27725940 Big one...
I should've commited before, but I wanted to make things compile.

The big change is that I've added a global time step so the parameter
does not need to be passed in each function. This is useful as we are
moving towards using time profiles for boundary conditions and injection
of particles (not in this branch, but in the future and the procedure
will be quite similar)
2024-07-12 23:08:19 +02:00
49025a6965 Starting changes
Planning the new way to do BC in the EM field solver.
Probably I have to change how things are read, but I don't think this is
going to affect the input file.
2024-07-12 19:21:00 +02:00
f0a27c0529 More comments
So if the source vector is being updated every time step, it might be
"easy" to implement these things.
2024-07-12 13:17:02 +02:00
abedb79b16 Some comments
Just some comments on how I am going to make the desired changes (have a
Dirichlet boundary condition for the electric potential that changes
with time). This might be a good opportunity to rework the boundary
conditions in the electrostatic field and include other things like a
Newmann boundary condition. We will see.
2024-07-12 11:02:26 +02:00
065bb1d13e Merge branch 'issue/injection2DCyl' into 'development'
Rework of injection of particles with a special focus in 2DCyl to ensure an homogeneous distribution.

See merge request JorgeGonz/fpakc!51
2024-07-11 16:51:42 +00:00
fb9d1ad837 Update moduleMesh2DCyl.f90
This is not needed.
2024-07-11 16:44:29 +00:00
152ae6b097 No longer needed
The correction in the node volume is no longer needed as now things are
being calculated right with the last change.

Still, at some point I should review the calculation of the node volume
in 2DCyl.
2024-07-11 18:19:26 +02:00
72dd3c9073 I think I have it
So the radius for the volume integral in the nodes has to be set with a
1/4 3/4 ratio to match the change in volume as the radius changes along
the volume.

This has a bigger impact close to the edge.

Still unsure if this is the "right" thing to do, but at least it works
okay (it seems).
2024-07-11 17:40:57 +02:00
bc8f205287 Clean-up!
Trying to reduce warnings and unused variables in the code. This should
not be in this branch.
2024-07-11 15:55:02 +02:00
d710cc5e66 Probes fixed!
This should've been commited in another branch, but I am taking
advantage of this to clean up the code a bit.
2024-07-11 15:52:13 +02:00
03f3b81811 Manual updated
The manual has been modified to account for the new particlePerEdge
option and to indicate that now when the flux is giving by a flux like
in the Am2 units, the real surface of the inject is used to scale it.
2024-07-11 15:31:01 +02:00
6d62807fb4 Remove testing 'print' statements
2DCyl still seems to have some problems but waiting for simulation.
2024-07-11 14:50:14 +02:00
96c563c146 Finally, some progress
I rewrote how particles are injected. Now the particles per edge and its
weight are calculated in the initialization. There is the possibility
for the user to select the particles per edge.

TODO: Write documentation for new feature.
TODO: Test in 2DCyl
2024-07-11 14:39:56 +02:00
e23fc2fc2c Small progress
I made some small changes to how things are calculated.

I have also discovered that the issue with different density when
changing injection is not related with the node volume but with the way
injection is carried out. When loading particles from a file, all
provide the same density regardless the cell (node) volume.

I am doing testing in 2DCart as it is easier to set up.
2024-07-11 11:21:38 +02:00
9d961bb85f Removing weight from edges
This parameter is no longer needed.

Also removing the cumulative sum of weights from the injection.
2024-07-10 21:57:22 +02:00
cb92462f36 New injection based on surface to all geometries.
WARNING: 3DCart still not working (too tired to calculate things and I'm
    not ussing it...)
2024-07-10 21:55:45 +02:00
d608639e77 Forgot to save
Sorry.
2024-07-09 22:05:16 +02:00
667a2ecd93 So, no idea...
Basically things do not work. I've added a correction to the node volume
in the axis which gives okays results but still this is not perfect. I
need to find a better way to do things.

Also, I've noticed that the density changes with the size of the cells,
which should not happen! I'vw to check this issue.
2024-07-09 21:57:32 +02:00
11831a973d Still not working
Trying to have a very simple volume per node assuming a rectangle and
the density at the axis it higher than it should (kinda like when using
the more accurate volume calculation).

This is still weird. I also suspect that the size of the first cell in
the axis will also affect this...
2024-07-09 21:25:30 +02:00
b36f9c2615 Shifting towards constant number of particles per edge
So now each edge has the same number of particles and the weight of each
particle is calculated based on the surface of each edge compared to the
total one.

Only in 2DCyl, still to extend to other geometries.

Not perfect constant density, but the issue might be the node volume.
2024-07-09 17:49:42 +02:00
fa23f9481a Issue with bibliography
Backup files are properly ignored now.
2024-07-07 14:40:26 +02:00
1f2ec8d82f New option for initial distribution of species
The number of particles per cell can be defined when giving an initial
distribution fora species. If not, the typical method of using the
species weight is used. This is particularly useful for cylindrical
coordinates in which very little particles might end up in the axis if a
constant weight is used.
2024-07-07 14:37:34 +02:00
5bc064d018 Some parallel issues
Forgot to check Gmsh2 format with new changes.

Cartesian coordinates were not calculating things properly.
2024-07-07 11:53:56 +02:00
626e970d82 Some progress
Fixed an issue with random integer numbers.
Cylindrical coordinates are not perfect yet:
  - Box (cylinder) with initial constant density loses particles at r =
    0
  - Injection density still low in r = 0
2024-07-06 19:14:44 +02:00
6b5ac16e4b Still working on it
No uniform density yet...
2024-07-06 10:12:03 +02:00
b972120ed5 Switching to variable particle weight
I have to change the injection of particles. Each edge will receive a
similar number of particles and their weight will change to have a
constant density based on the geometry.

Still testing.
2024-07-04 10:56:13 +02:00
6b78ae3738 Added an adhoc factor to correct injection
I think that the volume of the nodes is not being well calculated, maybe
we need a better volume calculation for this, using multiple points (as
it is done for K)
2024-07-03 22:04:28 +02:00
0471517526 Merge branch 'issue/injection' into 'development'
Change in injection to achieve uniform density of particles.

See merge request JorgeGonz/fpakc!50
2024-06-30 08:50:25 +00:00
e277fe6ddb PI is no needed here 2024-06-30 08:48:51 +00:00
59a322a4c7 Clean up
Fixing calculation of node volumes.
2024-06-30 10:46:05 +02:00
cd7bf66bd8 A workaround
The random position for edges in the axis is corrected so that there is
a more uniform charge density in the axis.

Still, things are not perfect and this is something to really look into
in the future.
2024-06-30 10:36:36 +02:00
4cadfe5367 Seems are a bit better
There is still less density in the axis. I don't find a reason why.
There must be a modification to the weight...
2024-06-29 22:22:10 +02:00
5386114d15 Cylindrical injection working better
Seems things are a bit better. Still, more cases are needed and still
not perfectly uniform...
2024-06-29 14:58:48 +02:00
6389c8ba2d Quick because food
Cartesian fixed now
2024-06-27 12:08:08 +02:00
0ce921a48c Merge branch 'issue/quadLocation' into 'development'
Issue with calculating coordinates in quads

See merge request JorgeGonz/fpakc!49
2024-06-26 13:14:22 +00:00
c6470819e8 Issue with calculating coordinates in quads
The third coordinate (unused) was causing some errors when it was
becomming too large.
2024-06-26 15:11:01 +02:00
e4f7987f90 Trying to solve
Still I don't understand this basic thing...
2024-05-19 16:45:03 +02:00
a3bdf8230a Implementation of Boltzmann electrons
Still not working, just saving code.
2024-05-19 10:55:20 +02:00
62b8873786 Merge branch 'feature/Amps_per_m2' into 'development'
Implementing injection with current density

See merge request JorgeGonz/fpakc!48
2024-03-29 12:09:30 +00:00
d86b3a3417 Implementing injection with current density
WARNING: This current denstiy will be multiplied by the reference
length, no the surface area that is being used for injection!

New units in the injection of particles 'Am2' to inject a density
current. Manual has been modified accordingly.

Reference parameters are now also printed in the case folder.
2024-03-28 09:45:46 +01:00
a3d7b38e3b Merge branch 'improve/secondaryElectronIonization' into 'development'
Improve ionization

See merge request JorgeGonz/fpakc!47
2023-11-24 09:34:30 +00:00
e41b448ef8 Different species for secondary electrons
The option to have a different species than the impacting electron for
secondary electrons from ionization is introduced.
2023-11-24 10:30:50 +01:00
4585390b50 Fixing issue
Fixing an issue with reading tables led me to other issues with
collisions that I think are fixed right now. I am testing with the 1D
ionization model for ALPHIE and things seems to be working properly.
2023-11-21 09:53:36 +01:00
5df81a79e4 Merge branch 'feature/CoulombLinear' into 'development'
First attempt at Coulomb collisions

See merge request JorgeGonz/fpakc!46
2023-07-16 12:47:58 +00:00
2e4b3c3d20 Update of user-manual
The user manual has been updated with a simple explanation on how to use
Coulomb Scattering.
2023-07-16 14:44:38 +02:00
e05c0d4635 Coulomb Scattering fully conservative
Coulomb scattering is now fully conservative thanks to the method in
lemos2009small.

The trick was to conserve the momentum and energy of ALL particles
involved in the scattering in each cell.

The substeps in Coulomb collisions have been removed as they are no
longer necessary.

Still some issues with e-i, but I don't know right now.
2023-07-16 14:30:49 +02:00
c3a6f77ffc Combining ij - ji collisions
In an attempt to make the operator fully conservarive I have combined ij
and ji collisions (when i/=j).

Now the matter is to find a way that makes this conserve momentum and
energy for intraspecies.
2023-07-12 15:17:26 +02:00
28b2bf206a Added the possibility to have sub-steps
Now per each Coulomb collision process there is the possibility to do
sub-steps. This helps in improving accuracy without reducing the time
step of the problem.
2023-07-12 14:21:29 +02:00
a891360b7a Still unsure, but things fixed
There was an issue with the calculation of theta and phi for the
rotation from W to C. This was causing some velocities not being
correct.

Now the angles are properly computed. Still unsure about the e-i
collisions as they seem to be quite small. Probably a numerical issue
with the mass ratios still exists.
2023-07-12 11:38:12 +02:00
f63e34e266 Not fully conservative but works
The code is still not fully conservative in intra-species collisions
(small error) but at least now is working.

I have to test species with different weight.

I have to implement a fully conservation for intra-species.
2023-07-11 18:55:20 +02:00
63fc2842be Small changes
Just some small changes to the code to improve its quality.

Nothing regarding conservation was done yet.
2023-07-11 11:22:19 +02:00
c45ffa5380 Dear various gods, finally...
I had to go back to sherlock2008montecarlo to properly understand the
change in frame of reference and how to translate that into the code.
The language there is clear and understandable for a dumb person like
me.

Now I have a Coulomb linear operator that at least works.

However, still not fully 100% conservative, need to fix this with a
correction for intra-species collisions.

I skip gym today because I was unable to focus on other things than
this.
2023-07-11 09:58:50 +02:00
d75af4bda7 Trying to implement Lemos Coulomb Scatering
I was having tones of issues with the previous implementation. I think
the problem was the velocity vector and how it was returning to the
normal reference frame.

I hope this new implementation works better.
2023-07-11 07:51:49 +02:00
a26dc04051 I hate Coulomb and his Scattering
I found no way to ensure conservation in the linear Coulomb operator.
Thus, now two collisions have to be declared if sp_i /= sp_j: collision
ij and collision ji.

This does not conserve energy so please use under your own risk, like
everything else.

Still, I think something is wrong with this implementation and I'm
really tired.
2023-07-07 16:36:31 +02:00
8d35123508 First Coulomb implementation that works
After fixing all possible divisions by zero I was able to find in the
Coulomb collision I think that this is a first working implementation of
a Coulomb operator based on moments.

Still to test a few things, modify the manual but I would say that I'm
satisfiyed right now. This operator won't be used that often but maybe
improving efficiency is still needed.

In the future a binary operator is required to be able to study cases
out of Maxwellian equilibrium.
2023-07-04 17:01:02 +02:00
0bd90d02f9 Merge branch 'issue/injection' into 'feature/CoulombLinear'
Issue with injection of particles

See merge request JorgeGonz/fpakc!45
2023-05-22 15:51:28 +00:00
2505cbecf2 Half-Maxwellian distribution added to the user manual
The option to have half-Maxwellian distributions in the injection of
particles has been added to the user manual.
2023-05-22 15:20:11 +02:00
94a4864e6a Issue with injection of particles
I was having a lot of issues trying to get quasi-neutrality with the
injection of electrons and ions. Main issue was a definition of the
direction of injection. This should be fixed now (tested in 1D).

Added a definition for Half-Maxwellian velocity distribution.

WARNING: I'm still not happy at all about the definition of the
direction of injection and the velocity definition to be in that
direction so I might change it at some point (for example take into
account the sign of each direction in the thermal part of the velocity)
2023-05-22 15:14:33 +02:00
ed6c2c46e4 I'm a fucking idiot
The limit I set to avoid divisions by zero was wront and collisions were
being skipped. It is corrected now.
2023-03-29 10:08:11 +02:00
f4448d9e7a Fixed segmentation fault in Coulomb collisions
When the relative velocity between a charged particle and the background
for Coulomb collisions (W in the code) was low, there was a
segmentation fault. This is fixed now as if the norm of the relative
velocity (normW) in the code is too low, no collision is applied.
2023-03-12 17:02:12 +01:00
a70788b95d Fix an issue with compilation
Copy paste error. Now the code compiles.
2023-03-08 19:42:15 +01:00
fe94615a27 First conservative implementation of Coulomb
I am doing a trick in which I ensure that energy is conserved for
Coulomb collisions. This was not happening and what an issue for
different mass ratios. Still, this can cause an issue on getting the
right relaxation rates, still necessary to check it.
2023-03-08 16:37:45 +01:00
f8af7a8dae No progress in fixing Coulomb collisions with mass ratio
I am starting to think that the only fix is to reduce the time step, but
that is too harsh.
2023-03-07 10:10:54 +01:00
6113ac3305 Correction with conservation
Now the method is much better in conserving total energy.
However, still there is an issue with collisions between species of
dispaprate mass.
2023-03-06 16:16:17 +01:00
601103105f First attempt at Coulomb collisions
First attemp for Coulomb collisions based on the moments distribtuions.
Still the method is not done and far from being complete but input
options and basic math are implemented.
2023-02-24 21:46:01 +01:00
7579d165ad Merge branch 'improve/probes' into 'development'
Probes were not working properly

See merge request JorgeGonz/fpakc!44
2023-02-23 12:45:38 +00:00
386ddd82dd Probes in 0 iteration
Probes are now written at the 0 iteration.

Additionally, and this shouldn't be done, some small changes to the quad
elements. This should be done in a separate commit, but I'm lazy.
2023-02-23 13:36:31 +01:00
2ee6c1764e Probes were not working properly
Issue in the output of probes and in the detection of particles inside
the velocity grid.
2023-02-23 08:18:46 +01:00
e7ae4e13ff Merge branch 'issue/lapack' into 'development'
Issue with -llapack option

See merge request JorgeGonz/fpakc!43
2023-02-17 12:05:39 +00:00
acc8505485 Issue with -llapack option
Some versions of gfortran (in the foss framework) were having issues
with the -llpack flag, so it is disables as OpenBLAS takes the work.
2023-02-17 13:03:22 +01:00
ee16de3f86 Merge branch 'issue/gmsh2FileName' into 'development'
Incorrect file name in Gmsh2 output

See merge request JorgeGonz/fpakc!42
2023-02-17 11:54:13 +00:00
8237aa90e9 Incorrect file name in Gmsh2 output
The file with the EMField was being writteng with the wrong name.
Quantities inside were correct.
2023-02-17 12:48:23 +01:00
e51348ae41 Merge branch 'issue/findCell' into 'development'
Returning to previous version of moduleMesh.f90

See merge request JorgeGonz/fpakc!41
2023-02-10 17:54:49 +00:00
4e9a592982 Returning to previous version of moduleMesh.f90
Having initialization in some variables was causing issues in 1D
geometry, so I reverted the file to one working.
2023-02-10 18:53:19 +01:00
167e25e276 Merge branch 'feature/writeGitCommit' into 'development'
Adds the commit to the output folder

See merge request JorgeGonz/fpakc!40
2023-02-09 15:50:36 +00:00
60477481dd Adds the commit to the output folder
I thought it will be a good idea to write the commit into the output
folder to better track the code version responsible for the results.
2023-02-09 16:48:49 +01:00
f815c8f192 Merge branch 'issue/particlesStuck' into 'development'
Issue in connectivity between Quad elements

See merge request JorgeGonz/fpakc!39
2023-02-09 15:29:34 +00:00
de1d4567f3 Issue for particles in quad cell
Due to a high convergence value (1.0e-2) in phy2logQuad (variable conv),
    particles were being stuck in some elements, reaching a segmentation
    fault. The new limit (1.0e-4) should avoid this.
2023-02-09 15:32:04 +01:00
f86641110c Issue in connectivity between Quad elements
For unstructured meshes, the quad elements where not being propertly
connected as not all possibilities were tested. This should be fixed
now.
2023-02-09 12:15:18 +01:00
de2aad02d1 Merge branch 'feature/vtk' into 'development'
Implementation of vtu file format for mesh reading and output

See merge request JorgeGonz/fpakc!38
2023-02-07 15:11:16 +00:00
2c55913501 First version of vtu file format
After some testing and making things a bit better and more general, I am
quite happy with the implementation of vtu and it seems that it is
working (at least as good as Gmsh2).

There are some procedures that might be useful for other XML-like
formats that might be moved in the future to the common module (I am
    thinking right now in the implementation of a general format like
    XDMF3).
2023-02-07 16:02:36 +01:00
e9ac9bdd80 Finishing implementation of vtu mesh format
I have tested all geometries and cases and all seem to work perfectly
with .vtu meshes.

Input and output works great, starting from a previous case also works.
Everything I was able to test is okay.

Still, what I want to do is to change a few things in the output (e.g.,
    change OUTPUT prefix to Step) and try to improve reading gmsh meshes
to make them more compact as vtu is now.
2023-02-07 15:19:13 +01:00
ba2b5bc6f3 Fixed issue with initial velocity
The problem was that the number of values for velocity was numNodes and
not 3*numNodes.
2023-02-07 09:43:28 +01:00
515e5c7744 Fix an issue and starting to read information from .vtu initial files
For some reason the connectivity for collision meshes was not being
properly assigned.

Also, the first subroutine to read information from .vtu files as
initial states has been added.
It is currently giving wrong results.
2023-02-06 19:54:54 +01:00
a22099ee87 Improvement to vtu read subroutine
Some improvements to reduce code repetition when reading vtu mesh.
2023-02-06 19:18:04 +01:00
402dac9068 Update to the manual for .vtu
Manual has been updated to account for new vtu option in the mesh
format.
2023-02-05 21:44:09 +01:00
e3eeb97f48 First working version!
First complete implementation of .vtu format.
Still a lot of things to improve but right now fpakc can read a vtu mesh
and write the output in vtu.

Still to test:
  Multiple geometries.
  Double mesh.
2023-02-05 21:33:03 +01:00
43a7421795 Creating of nodes and edges in .vtu format
Moving forward making vtu an independent format.

Now fpakc can generate nodes and edges from vtu input.
Next step is cells.

Some minor corrections in gmsh2 format to unify statements.
The reading of meshes needs a good overhaul.

Testing all geometries with vtu is gonna be fun...
2023-02-05 19:35:49 +01:00
7b470b7f58 Subroutines to read .vtu information
All subroutines to read .vtu information is ready.

Now it is time to create the input and generate a mesh for fpakc.
2023-02-05 18:32:38 +01:00
63fd8fdb91 New functions to read VTU
Added a few functions to read .vtu meshes.

Output in .vtu changed to output data in 6 columns (seems to be the
    standard.)
2023-02-05 16:23:37 +01:00
f5be04587a First step towards reading .vtu mesh
Just setting up the required functions.
2023-02-04 15:41:13 +01:00
6706c5dd1c Average is written in .vtu
The average of the species properties can be written now in .vtu format.
No .pvd file is provided as no time series is generated.

Still to do:
  Read a .vtu mesh.
  Improve gmsh format to use more common functions.
2023-02-04 15:20:36 +01:00
f1c0c5755f Collisions and EM field in .vtu
The collisions and EM field information is now available in .vtu files.
A collection file .pvd is provided per dataset for time-dependent
plotting.

Still to do:
  Write average quantities in .vtu
  Read mesh from .vtu
2023-02-04 12:31:33 +01:00
ceab516a5b Correction on collection file
The extension of the collection file has to be .pvd so that ParaView
properly reads it.
2023-02-04 08:54:36 +01:00
aca84d6312 First output in VTU format
Testing new VTU format.

For now, species information is ALWAYS output in .vtu (to test, this will
    be an independent format in the future).
A .pvd file is produced to do time-series.

Still to implement other outputs (electromagnetic, average,
    collisions...)

Still to implement reading a mesh from .vtu file
2023-02-03 20:14:53 +01:00
318f686051 Merge branch 'issue/forgotPrint' into 'development'
Forgot to remove some print statements

See merge request JorgeGonz/fpakc!37
2023-02-03 14:12:30 +00:00
6c34dd8a05 Forgot to remove some print statements
It is okay now. Sorry.
2023-02-03 15:11:36 +01:00
e3e87eeb9f Merge branch 'feature/injectionNormal' into 'development'
Injection of particles from surfaces direction

See merge request JorgeGonz/fpakc!36
2023-02-03 14:07:32 +00:00
bc2c29092a Injection of particles from surfaces direction
Now, if no normal is provided to an injection in the input file, the
velocity direction of the particles is chosen to be the surface normal.

This allows to inject particles from curves, corners... without having
to provide a direction or declaring multiple injections.
2023-02-03 14:03:22 +01:00
3646474d3d Merge branch 'issue/ionizationBoundaryCell' into 'development'
Fix an issue in assigning cells in ionization Boundary

See merge request JorgeGonz/fpakc!35
2023-02-03 09:54:58 +00:00
a0dfc55a69 Fix an issue in assigning cells in ionization Boundary
This assigns the correct random cell when a particle is created from the
ionization boundary.

Also, the number of possible ionizations is reduced by one if there is a
suscesful ionization. This has no impact on the results.
2023-02-03 10:52:49 +01:00
d36b2db342 Merge branch 'issue/electricFieldGather' into 'development'
Incorrect tau in electrostatic pushers

See merge request JorgeGonz/fpakc!34
2023-01-13 14:38:09 +00:00
cca57d5ab0 Incorrect tau in electrostatic pushers
During the improve performant step, an error in the electrostatic
pushers was introduced, resulting in these using the minimum time step
and not the species time step when calculating the acceleration.
2023-01-13 15:32:25 +01:00
d8eb2c2c58 Merge branch 'improvement/performance' into 'development'
Performance improvement.

See merge request JorgeGonz/fpakc!33
2023-01-07 17:47:29 +00:00
7ce1b7a4dd Reducing overhead when no collisions are present
Particles are added to lists only if there are MCC collisions. Hopefully
this will reduce overhead when OpenMP is used and no collisions are
active.
2023-01-07 12:12:37 +01:00
1c5b887a6d Small bugfix when testing examples
While testing the examples distributed with the code, a few errors were
found and fixed, mostly related with the K matrix in 1D geometry and
reading values from initial conditions for species.
2023-01-07 10:47:18 +01:00
22dff9ed69 Small style correction 2023-01-06 22:36:55 +01:00
600480f5d5 Reduce overhead of probes
I noticed that doProbes was causing some overhead even if no probes were
being used. Now it should be fixed.
2023-01-06 21:37:26 +01:00
746c5bea09 First step of performance improvement
Finalysing first step of performance improvement focusing on reducing
iteration CPU time by improving calculation of basic element functions,
which took a lot of the CPU time
2023-01-06 21:02:54 +01:00
7b7a5c45ca Small improvement
Very small improvement in performance.

Still, partialDer takes too long to compute.
Trying to find ways to improve it.
2023-01-06 15:18:04 +01:00
ba272de4e3 DOES NOT COMPILE: Break
Small break of changing functions.
Still some geometries to change.
2023-01-06 12:16:54 +01:00
7f6afd6a87 Mark_1
First thing that I am kinda happy with.

Still some things to improve but at least push is good.
2023-01-05 22:43:51 +01:00
15d64f3e68 Passing nNodes as argument
It seems that this improves results as passing the size of the arrays as
an argument is better than getting it from self.
2023-01-05 21:22:13 +01:00
6f24b5f1f6 Small changes before trying something big
I think that creating arrays with self%nNodes takes a lot of time.
I'm trying now to pass the number of nodes as argument.
2023-01-05 20:32:45 +01:00
26bd73597d Small improvement for 2DCyl
Nothing important, but overhead in dPsi has been reduced.
2023-01-05 18:47:33 +01:00
2486ef6316 Reduction in pushing
Reduction in 10-20% of time spend in pushing in 2DCyl thanks to
rewriting fPsi and dPsi.
2023-01-05 16:47:13 +01:00
0db76083ec fPsi no longer allocates memory
I noticed that phy2logquad had a lot of overhead. Trying to reducing it
by simplifying calls to fPsi, dPsi and such.

The function for fPsi has been made so no memory is allocated and works
under the assumption that the input array has the right size (1:numNodes)
2023-01-01 12:12:06 +01:00
c82cd50cf9 Merge branch 'issue/collisionWeight' into 'development'
Adjusting weights for collisions

See merge request JorgeGonz/fpakc!32
2022-12-31 10:25:33 +00:00
8199a228c8 Locks for particle lists are now inside the type.
The lock of a particle list is no longer an external variable, it is now
part of the type.

New procedures have been added to set and unset the lock.
2022-12-31 11:22:02 +01:00
0677684f85 Adjusting weights for collisions
Ionization and recombination collisions have been modified to have the
right products accounting for the possibility that primary electron and
target particle have different weight.
2022-12-31 10:46:25 +01:00
061dcafafe Merge branch 'feature/weighting' into 'development'
Trying to fix weighting scheme

See merge request JorgeGonz/fpakc!31
2022-12-29 18:35:02 +00:00
905d3f94a5 Trying to fix weighting scheme
Now particles can be split to increase statistics when they enter a
smaller cell. However, this only has an effect for collisions.

Still, I have to rethink a lot about this feature.
2022-12-29 19:32:38 +01:00
7c2c4ae884 Merge branch 'issue/organizeSolvers' into 'development'
Reorganization of modules

See merge request JorgeGonz/fpakc!30
2022-12-24 12:27:47 +00:00
9484502d0b Most of modules organized
Most of the modules are organized in subfolders.

Maybe some big re-organization is needed in the future, but for now I am
happy.
2022-12-24 13:26:10 +01:00
d9a1869564 Reorganization of solver
I started grouping similar modules in subfolders to ease the expansion
process.
2022-12-24 12:59:23 +01:00
37dccb2d11 Merge branch 'feature/average' into 'development'
Average scheme

See merge request JorgeGonz/fpakc!29
2022-12-24 10:42:34 +00:00
a8bea6102f Final commit for volume nodes
1D Rad is fixed.

Still there might be an issue with the triangles in 2D Cyl.
2022-12-24 11:41:12 +01:00
78763bbd84 Merge branch 'issue/volumeNode' into 'feature/average'
Fix for node volume

See merge request JorgeGonz/fpakc!28
2022-12-24 10:32:08 +00:00
e9c86b4678 Modification of Weighting scheme
The weighting scheme has been modified so that particles are splitted
without modifying the weight.

I have to look a bit more into this.
2022-12-24 11:30:20 +01:00
dd1fca3fee Fix for node volume
An issue in the node volume calculation in cylindrical coordinates was
found. This was causing wrong conservation of current. Still to test
with ALPHIE_Grid case.

Still to check triangular element.
Still to theck 1D radial geometry
2022-12-20 15:51:43 +01:00
cab07447b5 Averge scheme documented
Documentation of the average scheme for species properties.
2022-12-16 19:27:10 +01:00
5509332980 Output of standard deviation
The output for the standard deviation (still Gmsh2 only) was added.

Change in the output routines to reduce code repetition.
2022-12-15 11:40:24 +01:00
38d28887ff Implementation of average scheme and testing
New input variables to activate the average scheme.
Still only computing the mean, no the standard deviation.

Output checked  with ALPHIE Grid example. Looks good.

No impact on CPU time, although testing is still required.
2022-12-15 08:35:00 +01:00
c5c4cbefbf Output ready
Output for Gmsh2 ready.

Unfortunatly, code repetition was required.
2022-12-14 18:30:14 +01:00
b2eb7c5622 First commit for average scheme
New module defined that will take care of averaging the output in the
nodes.
2022-12-14 16:22:59 +01:00
239552f715 Merge branch 'feature/electromagnetic' into 'development'
Restructuring pushsers and addition to first electromagnetic pusher

See merge request JorgeGonz/fpakc!27
2022-12-12 18:20:34 +00:00
c7d205e4dd fix possible issue in particle injection 2022-12-12 17:57:18 +01:00
2ee58b6b77 Small change to ionization boundary
Very small change in formats to better account the ionization processes.
Minimum impact in results.
2022-12-12 17:36:10 +01:00
924ba4e20e Alphie grid case and issues
Output for the example ALPHIE_Grid.

Found an issue when multiple injections were used with species with
different time steps.

Modification to the way to compute the ionization boundary:
  The maximum number of ionizations is computed by eRel/eThreshold
  (relative energy / threshold of ionization)
  For each possible ionization, the probability of ionization is
  computed based on the density of neutrals, cross section and effective
  time divided by the number of maximum ionizations.
  If an ionization takes place, the ionization energy is substracted
  from the relative energy.
2022-12-11 22:39:28 +01:00
1587d57cc7 Readme for ALPHIE_Grid example 2022-12-10 11:16:07 +01:00
2850f37551 Test of examples
As all pushers and geometries have change, I'm testing all examples,
   adding a README.txt and a reference output for each case.
2022-12-10 10:37:14 +01:00
8dd3023bc0 Documentation change and testing examples
Documentation adapted to the new way to define geometry and pushers.

Examples are currently being tested and small modifications are being
done to include a reference output.
2022-12-09 16:05:32 +01:00
ae8aa9075e Change in calculation of reduced mass and relative energy
Now reduced mass and relative energy are calculated on the fly per
collision.
2022-12-09 09:54:44 +01:00
50705292a7 Changes in Cross Sections
Changes in cross-sections for Ar, particularly e-Ar process.
2022-12-08 16:37:44 +01:00
23e2fe9bae I'm dying with hay fever but I have to commit
I'm feeling awful but I have work in my desktop that I need to commit so
I can work with my laptop while I'm at the IEPC 2022 in Boston.
2022-06-10 16:07:14 +02:00
cbb5fe0bf2 Merge branch 'feature/collisionPairs' into feature/electromagnetic
Merging branches and fixing a number of important issues:

- Initial particles were not being assigned to the list of particles.

- List of particles was being erased every iteration, even if species
  was not pushed.

These caused issues with the calculation of collisions when a species
was frozen.

Now, things should work properly. All particles are properly added to
the volume list and the list is erased ONLY if the species has been
updated.

I hope that collisions are now properly accounted for per species pair.
2022-04-23 20:48:34 +02:00
4e9514876e Number of collisions per collision pair
Now the number of collisions is calculated per species pair. This allows
that the randomly particles selected for collisions do not have
collisions assigned.
2022-04-23 19:00:33 +02:00
78a97ed7a0 Improve to collisions
Improvement into the collision model to better compute number of
particles collisions.
2022-04-23 18:57:27 +02:00
97718209cc Setting pushers as PURE
Pushers were not set to PURE after testing.
2022-04-09 09:00:40 +02:00
8006f9d768 First EM pusher
First implementation of Electromagnetic pusher.

Some testing is still required.

Documentation needs to be upgraded to match the changes in this branch.
2022-04-09 08:57:06 +02:00
771e336f87 Cart pusher combined
Now, all Cart pushers push particles in 3D, regardless the geometry.
2022-04-08 19:16:41 +02:00
5b5dadce39 Restructuring the geometry and pushers
The geometry and push structure has been reworked to allow eassy adding
new pushers.

Documentation not updated yet.

Baseline for merging Cartesian pushers into one.
2022-04-08 19:06:12 +02:00
562dba1694 Merge branch 'issue/makefile' into 'development'
Fixing issue with makefile

See merge request JorgeGonz/fpakc!26
2021-10-18 14:39:20 +00:00
90e667f0a5 Fixing issue with makefile
The dependencies of the modules have been streamlined.
2021-10-18 16:36:19 +02:00
4c7ffa946c Merge branch 'feature/probe' into 'development'
Modification to Probes to use all particles

See merge request JorgeGonz/fpakc!25
2021-10-18 14:07:50 +00:00
e683c66ff8 Modification to Probes to use all particles
Now, probes check all particles in the domain.
This is done only when probes are outputed to save CPU time.
However, still some issues and distribution functions are not properly
being calculated.
2021-10-18 16:00:28 +02:00
550f6e2d2e Merge branch 'issue/readEMBoundary' into 'development'
Issue reading EM field

See merge request JorgeGonz/fpakc!24
2021-10-18 08:32:44 +00:00
f9dcd181c8 Issue reading EM field
Fixed an issue reading the EM field from input file.
2021-10-18 10:29:45 +02:00
aa9dda76ca Small improvement.
Small change to probing system.
2021-08-26 11:21:08 +02:00
611fae8d82 Merge branch 'feature/probe' into 'development'
First implementation of probing method

See merge request JorgeGonz/fpakc!23
2021-06-29 08:40:54 +00:00
56967dd6c7 First implementation of probing method
The code nows offer the possibility to obtain the distribution function
for a specific species in a 3D velocity grid at a determined position.

This is a simple method that just scatter the particles in one cell into
the velocity grid.
2021-06-29 10:37:39 +02:00
2d3b163700 Merge branch 'feature/collisionTimeStep' into 'development'
Adding a time step for collisions

See merge request JorgeGonz/fpakc!22
2021-06-15 08:49:19 +00:00
b6a7eb9ced Adding a time step for collisions
A new option has been added in which MCC are computed with its own time
step.

If no time is provided, then the minimum time step of the simulation is
employed.
2021-06-15 10:40:13 +02:00
c6e3238810 Merge branch 'issue/triaInitial' into 'development'
Issue with random position in volumes

See merge request JorgeGonz/fpakc!21
2021-05-24 10:41:28 +00:00
9af3429395 Issue with random position in volumes
Fixed an issue in which  the position in triangular an thetrahedron
elements were not correctly being computed.

Other minor issues fixed:
  - Units in input file now do not use '/'.
  - Collisions accuratly conserve momentum.
  - Minor improvements in mass calculation in collisions.
2021-05-24 12:37:16 +02:00
cfe5616c8c Merge branch 'feature/combineScattering' into 'development'
Common scatter subroutine

See merge request JorgeGonz/fpakc!20
2021-04-21 21:44:58 +00:00
35bd61fda9 Common scatter subroutine
All subroutines of scattering particle properties to the nodes of a
volume have been converged into one in moduleMesh.
2021-04-21 23:40:58 +02:00
d613f80c0d Merge branch 'feature/copyInputFiles' into 'development'
Copy input files to output folder

See merge request JorgeGonz/fpakc!19
2021-04-21 14:03:27 +00:00
027b346a84 Copy input files to output folder
After reading the input, the code copies the JSON input file but the
mesh(es) to the output directory.
2021-04-21 16:01:01 +02:00
302e4ecc1a Merge branch 'issue/initialIteration' into 'development'
Implementation of initial iteration.

See merge request JorgeGonz/fpakc!18
2021-04-17 09:00:57 +00:00
dee860e37b Implementation of initial iteration.
An initial simulation time can be provided in the input file. This is
useful when restarting a simulation from a previous file. If no
initial time is provided, the value 0 is used.
2021-04-17 10:45:52 +02:00
0d2e62421d Merge branch 'issue/initialInput' into 'development'
Small modification in input for initial case.

See merge request JorgeGonz/fpakc!17
2021-04-15 07:49:04 +00:00
f20cb35fc5 Small modification in input for initial case.
Names have been simplified. User manual updated accordingly.
2021-04-15 09:47:19 +02:00
53827ec117 Merge branch 'issue/injectionNormal' into 'development'
The normal vector in an injection is now normalized to 1

See merge request JorgeGonz/fpakc!16
2021-04-14 19:00:08 +00:00
7dccba5906 The normal vector in an injection is now normalized to 1 and it is no
longer responsability of the user to ensure that the norm is 1.

This is a very simple fix and I do not why I did not implemented early.
2021-04-14 20:56:53 +02:00
fd148db2ee Merge branch 'feature/Coulomb' into 'development'
Implementation of 0D grid for analysis of collisional operators.

See merge request JorgeGonz/fpakc!15
2021-04-13 19:57:19 +00:00
b40d867d74 Removed innnecesary input from input file 2021-04-13 21:51:08 +02:00
a681b9f533 0D Grid geometry
Implementation of the 0D grid to test collisional processes.

An OMP_LOCK was added to the nodes to properly write perform the
scattering (it is weird that multiple threads work in the same node at
the same time, but in 0D happens everytime).

Added a new case to test the 0D geometry.

User Manual updated with the new options.
2021-04-13 21:48:44 +02:00
0ffdb8578a Merge branch 'development' into feature/0DGrid
Conflicts:
	src/modules/mesh/moduleMesh.f90
2021-04-13 17:46:20 +02:00
f1d74d954c Implementation of 0D dummy pusher and modifications to input parameters
to allow 0D runs.
2021-04-13 17:40:33 +02:00
8775bce11f Merge branch 'feature/initial' into 'development'
New format for initial state

See merge request JorgeGonz/fpakc!14
2021-04-13 15:06:10 +00:00
e25b567d36 Now the initial state has the same format as the mesh file, i.e., is
easy to use a file from a previous run without processing it into a
plain text file.

Although the previous method presented some updates for 1D small cases,
this is quite easy to do with any type of simulations and, in the
future, with different mesh formats.
2021-04-13 16:55:50 +02:00
d2b36632c9 Implementation of 0D grid for analysis of collisional operators.
Still need to add a 0D pusher and the corresponding input configuration
and documentation.
2021-04-12 18:54:33 +02:00
439a45efbf Merge branch 'feature/doubleMesh' into 'development'
Improvements to mesh and double mesh

See merge request JorgeGonz/fpakc!13
2021-04-05 07:49:26 +00:00
cbcefb06c8 Final implementation of a specific mesh for MCC, added a case for
cylFlow that used two meshes and the User Manual has been updated.
2021-04-05 09:45:57 +02:00
a2631f6b78 Impliementation of a collision mesh which is independent for the mesh
used to scatter particles and compute the EM field.
2021-04-03 09:20:46 +02:00
16b86542d4 Modified documentation to change input meshFormat from gmsh to gmsh2 in
preparation for supporting gmsh v4 in the future.
2021-03-29 09:49:19 +02:00
3f91d9e1ed Reading of mesh files has been made independent from geometry and
prepared to accept different formats.
2021-03-29 09:45:51 +02:00
46348c86ee Improved some general things using pointers. 2021-03-28 16:52:01 +02:00
ec128902ad The integer part%sp that referenced the species index has been
substituted for a pointer to the species.
2021-03-28 15:55:26 +02:00
bf4b8b41d3 Fixed an issue in the compilation caused by not included the
moduleRefCase when using m_ref in moduleInput.
2021-03-28 15:20:27 +02:00
d66add058d Merge branch 'improve/cases' into development 2021-03-28 15:17:45 +02:00
6431120734 Small modifications to the 1D Cathode case. 2021-03-28 15:17:10 +02:00
1f017bc5cc Merge branch 'feature/boundary' into 'development'
Testing of the ionization boundary and 3D geometry.

See merge request JorgeGonz/fpakc!12
2021-03-27 10:41:31 +00:00
2a843547b8 Ionization boundary condition fully tested.
Documentation updated properly.

3D Cartesian geometry also tested.
Documentation updated properly.

Added weighting probability in the injection of particles.
2021-03-27 11:38:18 +01:00
2b78c0a7da Merge branch 'feature/boundary' into 'development'
Ionization and symmetry axis fixin

See merge request JorgeGonz/fpakc!11
2021-03-23 15:50:21 +00:00
12e61731df Ionization boundary ready to testing.
Fixed an issue in which some particles in the corner were interacting
with the axis boundary. Now the axis acts as a reflective boundary in
case a particle is wrongly assigned to it.
2021-03-23 16:43:11 +01:00
9b1b0e4f0a Merge branch 'feature/3DCart' into 'development'
3D geometry and unification of boundary

See merge request JorgeGonz/fpakc!10
2021-03-22 11:43:17 +00:00
db6b0a2c03 Fixed an issue with reflection of particles in all geometries and also
assigning the normal vector in 2D and 3D.

3D Cartesian geometry is working properly, although it needs testing.

Still issue with ionization boundary.
2021-03-22 12:39:34 +01:00
3b01099aba Merge branch 'development' into feature/3DCart 2021-03-20 13:08:55 +01:00
8cf50cda68 First implementation of ionization boundary. Still some work to do. 2021-03-20 13:08:01 +01:00
c236c5e0e2 Fixing some issues in 3D Cartesian coordinates. Included 3D pusher.
Still there are issues linking a volume to an edge.
2021-03-15 10:00:34 +01:00
1e66110014 Merge branch 'development' into feature/3DCart 2021-03-11 18:43:44 +01:00
7e5b78f72f Implementation of 3D cartesian coordinates completed. Last commit before
testing.
2021-03-11 16:25:30 +01:00
61885b4a37 Merge branch 'issue/reflection' into 'development'
Normal of edges unitary

See merge request JorgeGonz/fpakc!8
2021-03-11 11:58:29 +00:00
ff0c09242d Fixed an issue with normal vector not being norm unit, which was causing
reflected particle velocities to increase.
2021-03-11 12:56:15 +01:00
95d5a1200d Included a new cases of 1D Cathode emission based on plasma background
previously computed.
2021-03-11 12:54:51 +01:00
682afaac0c Merge branch 'improve/cases' into 'development'
Structure for 3D Cartesian Grid created.

See merge request JorgeGonz/fpakc!7
2021-03-06 18:21:43 +00:00
1f077eeb91 Modifications to cases to fix minor issues. Work in having a 1D Cathode
model working
2021-03-06 19:19:46 +01:00
ac2965621a Structure for 3D Cartesian Grid created.
Unification of boundary conditions into one file.

Some changes to input file for reference cases. This should have been
done in another branch but I wanto to commit to save progress and I
don't want to deal with tswitching branches right now, I'm very busy
watching Futurama.
2021-02-27 16:24:44 +01:00
eb6b045734 Merge branch 'issue/stuck_injection' into 'development'
Issue/stuck injection

See merge request JorgeGonz/fpakc!6
2021-01-27 09:03:04 +00:00
9d146b9bcc Number of threads set to 24. 2021-01-27 10:01:19 +01:00
20bc1abc29 Fixed an issue in which the logical coordinates of the particle (xi)
were not being initialized and was causing particles to get stuck in
  the iteration loop.
2021-01-27 09:59:37 +01:00
2eae95002d Small modifications to 1D input files to make them start from a small
x/r position to avoid huge fields in Radial case when r -> 0 due to
charge accumulation.

Added a Gnuplot script to plot both potential profiles extracted from
Gmsh.
2021-01-23 10:58:39 +01:00
81e2202959 Merge branch 'feature/2DCart' into 'development'
First implementation of 2D Cartesian space.

See merge request JorgeGonz/fpakc!5
2021-01-21 11:07:31 +00:00
2ae4a6c785 First implementation of 2D Cartesian space.
Files and types with 'Cyl' have been changed to '2DCyl' to better
differentiate between the two types of 2D geometry.

Solvers for charged and neutral particles in 2D Cartesian space.

Added solveds for 1D neutral particles (this branch is not the place to
    do it, but it was a minor change).

User Manual updated with the new accepted options.
2021-01-21 12:03:10 +01:00
c378f8c3a2 Merge branch 'feature/output' into 'development'
Folder name

See merge request JorgeGonz/fpakc!4
2021-01-20 15:38:10 +00:00
2a6628d529 Added and option to include an output folder name. The date and time of
creation is still appended to the folder name provided.
2021-01-20 16:36:01 +01:00
95f81173f5 Merge branch 'improve/mesh' into 'development'
Improvements to Triangles

See merge request JorgeGonz/fpakc!3
2021-01-20 15:15:51 +00:00
978eb99f02 New way to deal with electric field in triangles. Some improvements but
rectangles are still recommended for regular grids.
2021-01-20 16:08:01 +01:00
135 changed files with 65731 additions and 30968 deletions

2
.gitignore vendored
View file

@ -4,3 +4,5 @@ obj/
doc/user_manual/ doc/user_manual/
doc/coding_style/ doc/coding_style/
json-fortran-8.2.0/ json-fortran-8.2.0/
json-fortran/
runs/

50
CITATION.cff Normal file
View file

@ -0,0 +1,50 @@
# This CITATION.cff file was generated with cffinit.
# Visit https://bit.ly/cffinit to generate yours today!
cff-version: 1.2.0
title: Finite element Particle Kinetic Code
message: >-
If you use this software, please cite it using the
metadata from this file.
type: software
authors:
- given-names: Jorge
family-names: Gonzalez
email: jorge.gonzalez@upm.es
affiliation: Universidad Politécnica de Madrid
orcid: 'https://orcid.org/0000-0001-7905-5001'
repository-code: 'https://gitlab.com/JorgeGonz/fpakc'
abstract: >-
Welcome to fpakc (Finite element PArticle Kinetic Code), a
modern object oriented Fortran open-source code for
particle simulations of plasma and gases. This code works
by simulating charged and neutral particles, following
their trajectories, collisions and boundary conditions
imposed by the user.
One of our aims is to make a code easy to maintain as well
as easy to use by a variety of reserchers and students.
This code is currenlty in very early steps of development.
The code aims to be easy to maintain and easy to use,
allowing its application from complex problems to easy
examples that can be used, for example, as teaching
exercises.
Parallelization techniques such as OpenMP, MPI will be
used to distribute the cpu load. We aim to make fpakc GPU
compatible in the future.
The codefpakc makes use of finite elements to generate
meshes in complex geometries. Particle properties are
deposited in the nodes and cells of the mesh. The
electromagnetic field, with the boundary conditions
imposed by the user, is solved also in this mesh.
keywords:
- particle-in-cell
- plasma
- finite elements
license: GPL-3.0
version: beta
date-released: '2025-10-01'

204
data/collisions/EL_e-Ar.dat Normal file
View file

@ -0,0 +1,204 @@
# EL cross sections extracted from PROGRAM MAGBOLTZ, VERSION 7.1 JUNE 2004 www.lxcat.net/Biagi-v7.1
# Relative energy (eV) cross section (m^2)
0.000000e+0 7.100000e-20
1.000000e-3 6.298400e-20
2.000000e-3 5.835000e-20
5.000000e-3 4.977500e-20
1.000000e-2 4.113000e-20
2.000000e-2 3.071300e-20
5.000000e-2 1.570900e-20
1.000000e-1 6.062200e-21
1.092000e-1 5.117000e-21
1.482000e-1 2.519100e-21
1.885000e-1 1.330700e-21
2.303000e-1 9.762900e-22
2.735000e-1 1.139000e-21
3.183000e-1 1.628900e-21
3.646000e-1 2.326700e-21
4.125000e-1 3.155200e-21
4.622000e-1 4.064500e-21
5.136000e-1 5.023100e-21
5.668000e-1 6.012300e-21
6.218000e-1 7.023300e-21
6.788000e-1 8.054600e-21
7.378000e-1 9.110500e-21
7.989000e-1 1.020000e-20
8.621000e-1 1.133700e-20
9.275000e-1 1.253700e-20
9.953000e-1 1.382100e-20
1.065400e+0 1.479100e-20
1.138000e+0 1.576700e-20
1.213100e+0 1.677000e-20
1.290900e+0 1.778100e-20
1.371400e+0 1.882800e-20
1.454700e+0 1.991100e-20
1.541000e+0 2.107400e-20
1.630300e+0 2.232400e-20
1.722700e+0 2.358000e-20
1.818400e+0 2.476000e-20
1.917400e+0 2.598200e-20
2.020000e+0 2.729100e-20
2.126100e+0 2.884100e-20
2.235900e+0 3.044500e-20
2.349700e+0 3.210500e-20
2.467400e+0 3.382400e-20
2.589200e+0 3.558500e-20
2.715400e+0 3.740100e-20
2.845900e+0 3.928100e-20
2.981100e+0 4.122700e-20
3.121000e+0 4.331500e-20
3.265800e+0 4.548700e-20
3.415700e+0 4.773600e-20
3.570900e+0 5.006300e-20
3.731500e+0 5.247300e-20
3.897800e+0 5.496700e-20
4.069900e+0 5.775100e-20
4.248100e+0 6.093800e-20
4.432500e+0 6.423700e-20
4.623400e+0 6.765200e-20
4.821000e+0 7.118700e-20
5.025600e+0 7.507600e-20
5.237300e+0 7.901500e-20
5.456500e+0 8.309200e-20
5.683400e+0 8.731200e-20
5.918300e+0 9.168100e-20
6.161400e+0 9.628400e-20
6.413100e+0 1.010900e-19
6.673600e+0 1.060800e-19
6.943300e+0 1.118000e-19
7.222400e+0 1.170000e-19
7.511400e+0 1.222000e-19
7.810500e+0 1.275900e-19
8.120100e+0 1.326900e-19
8.440600e+0 1.372100e-19
8.772400e+0 1.416500e-19
9.115800e+0 1.451600e-19
9.471300e+0 1.487100e-19
9.839300e+0 1.523900e-19
1.022020e+1 1.548800e-19
1.061450e+1 1.564600e-19
1.100000e+1 1.580000e-19
1.160000e+1 1.580000e-19
1.220000e+1 1.571000e-19
1.280380e+1 1.547800e-19
1.328890e+1 1.525600e-19
1.379110e+1 1.495700e-19
1.431090e+1 1.458200e-19
1.484890e+1 1.420600e-19
1.540590e+1 1.373500e-19
1.598240e+1 1.321600e-19
1.657920e+1 1.291500e-19
1.719700e+1 1.225700e-19
1.783650e+1 1.157400e-19
1.849840e+1 1.110100e-19
1.918370e+1 1.069000e-19
1.989300e+1 1.026400e-19
2.062720e+1 9.899000e-20
2.138720e+1 9.534100e-20
2.217390e+1 9.156500e-20
2.298830e+1 8.765600e-20
2.383130e+1 8.361000e-20
2.470400e+1 7.942100e-20
2.560730e+1 7.611800e-20
2.654230e+1 7.321900e-20
2.751020e+1 7.021800e-20
2.851210e+1 6.711300e-20
2.954920e+1 6.389700e-20
3.062280e+1 6.137900e-20
3.173410e+1 5.937900e-20
3.288440e+1 5.730800e-20
3.407520e+1 5.516500e-20
3.530780e+1 5.294600e-20
3.658370e+1 5.064900e-20
3.790450e+1 4.827200e-20
3.927170e+1 4.581100e-20
4.068690e+1 4.384700e-20
4.215190e+1 4.245600e-20
4.366840e+1 4.101500e-20
4.523810e+1 3.952400e-20
4.686300e+1 3.798000e-20
4.854500e+1 3.638200e-20
5.028610e+1 3.480000e-20
5.208840e+1 3.353800e-20
5.395410e+1 3.223200e-20
5.588530e+1 3.088000e-20
5.788440e+1 2.948100e-20
5.995370e+1 2.803200e-20
6.209570e+1 2.674300e-20
6.431310e+1 2.541200e-20
6.660830e+1 2.403500e-20
6.898420e+1 2.260900e-20
7.144360e+1 2.171100e-20
7.398940e+1 2.120200e-20
7.662470e+1 2.067500e-20
7.935260e+1 2.012900e-20
8.217640e+1 1.940100e-20
8.509940e+1 1.859800e-20
8.812510e+1 1.776600e-20
9.125710e+1 1.690400e-20
9.449930e+1 1.601300e-20
9.785530e+1 1.509000e-20
1.013293e+2 1.435400e-20
1.049254e+2 1.395800e-20
1.086478e+2 1.354900e-20
1.125011e+2 1.312500e-20
1.164898e+2 1.268600e-20
1.206186e+2 1.223200e-20
1.248925e+2 1.176200e-20
1.293167e+2 1.127500e-20
1.338963e+2 1.077100e-20
1.386368e+2 1.025000e-20
1.435440e+2 9.710200e-21
1.486236e+2 9.151400e-21
1.538817e+2 8.790400e-21
1.593245e+2 8.496500e-21
1.649587e+2 8.192200e-21
1.707908e+2 7.877300e-21
1.768279e+2 7.551300e-21
1.830772e+2 7.213800e-21
1.895461e+2 6.864500e-21
1.962423e+2 6.502900e-21
2.031738e+2 6.244500e-21
2.103489e+2 6.118900e-21
2.177762e+2 5.988900e-21
2.254644e+2 5.854400e-21
2.334229e+2 5.715100e-21
2.416610e+2 5.570900e-21
2.501886e+2 5.421700e-21
2.590160e+2 5.267200e-21
2.681535e+2 5.107300e-21
2.776121e+2 4.941800e-21
2.874032e+2 4.770400e-21
2.975383e+2 4.593100e-21
3.080295e+2 4.409500e-21
3.188895e+2 4.219400e-21
3.301311e+2 4.022700e-21
3.417678e+2 3.819100e-21
3.538134e+2 3.608300e-21
3.662823e+2 3.390100e-21
3.791894e+2 3.164200e-21
3.925501e+2 2.930400e-21
4.063803e+2 2.789400e-21
4.355158e+2 2.740800e-21
4.667351e+2 2.688800e-21
4.831724e+2 2.661400e-21
5.001872e+2 2.633000e-21
5.178000e+2 2.603700e-21
5.360318e+2 2.573300e-21
5.549043e+2 2.541800e-21
5.744399e+2 2.509300e-21
5.946621e+2 2.475600e-21
6.155950e+2 2.440700e-21
6.372635e+2 2.404600e-21
6.596934e+2 2.367200e-21
6.829116e+2 2.328500e-21
7.069458e+2 2.288400e-21
7.318245e+2 2.247000e-21
7.575776e+2 2.204000e-21
7.842356e+2 2.159600e-21
8.118305e+2 2.113600e-21
8.403951e+2 2.066000e-21
8.699636e+2 2.016700e-21
9.005711e+2 1.965700e-21
9.322543e+2 1.912900e-21
9.650509e+2 1.858200e-21

View file

@ -1,34 +1,203 @@
# H. C. Straub et. al, Physical Review A, 55,2(1995) # EL cross sections extracted from PROGRAM MAGBOLTZ, VERSION 7.1 JUNE 2004 www.lxcat.net/Biagi-v7.1
# Relative energy (eV) cross section (m^2) # Relative energy (eV) cross section (m^2)
17 1.700E-22 1.570000e+1 0.000000e+0
20 4.600E-21 1.571000e+1 1.033000e-25
25 1.240E-20 1.574000e+1 3.631000e-23
30 1.840E-20 1.577000e+1 7.390000e-23
35 2.260E-20 1.581000e+1 1.128000e-22
40 2.550E-20 1.585000e+1 1.531000e-22
45 2.660E-20 1.589000e+1 1.948000e-22
50 2.700E-20 1.593000e+1 2.379000e-22
55 2.690E-20 1.597000e+1 2.826000e-22
60 2.670E-20 1.602000e+1 3.330000e-22
65 2.670E-20 1.606000e+1 3.914000e-22
70 2.670E-20 1.611000e+1 4.518000e-22
75 2.660E-20 1.616000e+1 5.143000e-22
80 2.690E-20 1.621000e+1 5.791000e-22
85 2.700E-20 1.627000e+1 6.461000e-22
90 2.690E-20 1.632000e+1 7.155000e-22
95 2.670E-20 1.638000e+1 7.873000e-22
100 2.640E-20 1.644000e+1 8.616000e-22
110 2.610E-20 1.650000e+1 9.386000e-22
120 2.550E-20 1.656000e+1 1.026000e-21
140 2.450E-20 1.663000e+1 1.116000e-21
160 2.350E-20 1.670000e+1 1.209000e-21
180 2.270E-20 1.677000e+1 1.306000e-21
200 2.180E-20 1.684000e+1 1.406000e-21
225 2.100E-20 1.691000e+1 1.510000e-21
250 1.990E-20 1.699000e+1 1.617000e-21
275 1.870E-20 1.707000e+1 1.733000e-21
300 1.790E-20 1.715000e+1 1.853000e-21
350 1.630E-20 1.724000e+1 1.977000e-21
400 1.510E-20 1.733000e+1 2.106000e-21
450 1.390E-20 1.742000e+1 2.239000e-21
500 1.310E-20 1.752000e+1 2.378000e-21
1.762000e+1 2.526000e-21
1.772000e+1 2.680000e-21
1.783000e+1 2.839000e-21
1.794000e+1 3.004000e-21
1.805000e+1 3.175000e-21
1.817000e+1 3.354000e-21
1.829000e+1 3.540000e-21
1.842000e+1 3.731000e-21
1.855000e+1 3.933000e-21
1.868000e+1 4.146000e-21
1.882000e+1 4.367000e-21
1.897000e+1 4.596000e-21
1.912000e+1 4.837000e-21
1.927000e+1 5.089000e-21
1.943000e+1 5.349000e-21
1.960000e+1 5.618000e-21
1.977000e+1 5.897000e-21
1.995000e+1 6.186000e-21
2.013000e+1 6.498000e-21
2.032000e+1 6.826000e-21
2.052000e+1 7.161000e-21
2.073000e+1 7.464000e-21
2.094000e+1 7.777000e-21
2.116000e+1 8.092000e-21
2.138000e+1 8.414000e-21
2.162000e+1 8.757000e-21
2.186000e+1 9.122000e-21
2.211000e+1 9.468000e-21
2.237000e+1 9.786000e-21
2.264000e+1 1.013000e-20
2.292000e+1 1.050000e-20
2.321000e+1 1.085000e-20
2.351000e+1 1.121000e-20
2.382000e+1 1.158000e-20
2.414000e+1 1.197000e-20
2.447000e+1 1.237000e-20
2.482000e+1 1.278000e-20
2.517000e+1 1.317000e-20
2.554000e+1 1.355000e-20
2.592000e+1 1.400000e-20
2.631000e+1 1.440000e-20
2.672000e+1 1.479000e-20
2.715000e+1 1.519000e-20
2.758000e+1 1.560000e-20
2.804000e+1 1.604000e-20
2.850000e+1 1.650000e-20
2.899000e+1 1.699000e-20
2.949000e+1 1.749000e-20
3.001000e+1 1.801000e-20
3.055000e+1 1.844000e-20
3.111000e+1 1.888000e-20
3.168000e+1 1.935000e-20
3.228000e+1 1.981000e-20
3.290000e+1 2.027000e-20
3.354000e+1 2.075000e-20
3.420000e+1 2.123000e-20
3.488000e+1 2.167000e-20
3.559000e+1 2.214000e-20
3.633000e+1 2.255000e-20
3.709000e+1 2.289000e-20
3.787000e+1 2.324000e-20
3.869000e+1 2.351000e-20
3.953000e+1 2.376000e-20
4.040000e+1 2.398000e-20
4.131000e+1 2.416000e-20
4.224000e+1 2.435000e-20
4.321000e+1 2.454000e-20
4.421000e+1 2.474000e-20
4.525000e+1 2.492000e-20
4.632000e+1 2.501000e-20
4.743000e+1 2.509000e-20
4.858000e+1 2.519000e-20
4.978000e+1 2.528000e-20
5.101000e+1 2.544000e-20
5.228000e+1 2.562000e-20
5.360000e+1 2.580000e-20
5.497000e+1 2.600000e-20
5.639000e+1 2.617000e-20
5.785000e+1 2.634000e-20
5.937000e+1 2.652000e-20
6.094000e+1 2.673000e-20
6.256000e+1 2.696000e-20
6.425000e+1 2.719000e-20
6.599000e+1 2.738000e-20
6.779000e+1 2.752000e-20
6.965000e+1 2.767000e-20
7.159000e+1 2.786000e-20
7.358000e+1 2.806000e-20
7.565000e+1 2.823000e-20
7.780000e+1 2.831000e-20
8.001000e+1 2.840000e-20
8.231000e+1 2.845000e-20
8.468000e+1 2.849000e-20
8.714000e+1 2.854000e-20
8.969000e+1 2.859000e-20
9.232000e+1 2.860000e-20
9.505000e+1 2.860000e-20
9.788000e+1 2.854000e-20
1.008000e+2 2.848000e-20
1.038000e+2 2.842000e-20
1.070000e+2 2.836000e-20
1.102000e+2 2.830000e-20
1.136000e+2 2.823000e-20
1.170000e+2 2.816000e-20
1.206000e+2 2.807000e-20
1.243000e+2 2.788000e-20
1.282000e+2 2.769000e-20
1.322000e+2 2.753000e-20
1.363000e+2 2.741000e-20
1.406000e+2 2.727000e-20
1.450000e+2 2.705000e-20
1.496000e+2 2.682000e-20
1.543000e+2 2.654000e-20
1.592000e+2 2.625000e-20
1.643000e+2 2.598000e-20
1.696000e+2 2.572000e-20
1.750000e+2 2.545000e-20
1.807000e+2 2.516000e-20
1.865000e+2 2.478000e-20
1.925000e+2 2.439000e-20
1.988000e+2 2.398000e-20
2.052000e+2 2.367000e-20
2.119000e+2 2.337000e-20
2.189000e+2 2.307000e-20
2.260000e+2 2.275000e-20
2.335000e+2 2.243000e-20
2.412000e+2 2.209000e-20
2.491000e+2 2.174000e-20
2.574000e+2 2.142000e-20
2.659000e+2 2.110000e-20
2.747000e+2 2.076000e-20
2.839000e+2 2.041000e-20
2.933000e+2 2.005000e-20
3.031000e+2 1.969000e-20
3.132000e+2 1.935000e-20
3.237000e+2 1.899000e-20
3.346000e+2 1.862000e-20
3.458000e+2 1.824000e-20
3.575000e+2 1.791000e-20
3.695000e+2 1.759000e-20
3.820000e+2 1.727000e-20
3.949000e+2 1.693000e-20
4.083000e+2 1.659000e-20
4.221000e+2 1.623000e-20
4.364000e+2 1.585000e-20
4.512000e+2 1.548000e-20
4.666000e+2 1.520000e-20
4.824000e+2 1.492000e-20
4.989000e+2 1.462000e-20
5.159000e+2 1.435000e-20
5.335000e+2 1.406000e-20
5.517000e+2 1.377000e-20
5.706000e+2 1.347000e-20
5.901000e+2 1.316000e-20
6.104000e+2 1.285000e-20
6.313000e+2 1.256000e-20
6.530000e+2 1.226000e-20
6.754000e+2 1.194000e-20
6.986000e+2 1.162000e-20
7.226000e+2 1.137000e-20
7.475000e+2 1.112000e-20
7.733000e+2 1.087000e-20
7.999000e+2 1.060000e-20
8.275000e+2 1.039000e-20
8.561000e+2 1.018000e-20
8.857000e+2 9.958000e-21
9.163000e+2 9.736000e-21
9.480000e+2 9.514000e-21
9.808000e+2 9.285000e-21

View file

@ -0,0 +1,52 @@
# D108525 "refs": {"B56": {"note": "CLM-R294 (1989)"}}
# Relative energy (eV) cross section (m^2)
1.40E+01 0
1.62E+01 7.249E-21
1.88E+01 1.199E-20
2.18E+01 1.644E-20
2.53E+01 2.1E-20
2.94E+01 2.542E-20
3.41E+01 2.937E-20
3.95E+01 3.26E-20
4.58E+01 3.499E-20
5.32E+01 3.653E-20
6.17E+01 3.726E-20
7.15E+01 3.728E-20
8.29E+01 3.671E-20
9.62E+01 3.566E-20
1.12E+02 3.426E-20
1.29E+02 3.259E-20
1.50E+02 3.075E-20
1.74E+02 2.881E-20
2.02E+02 2.682E-20
2.34E+02 2.484E-20
2.72E+02 2.289E-20
3.15E+02 2.101E-20
3.65E+02 1.922E-20
4.24E+02 1.751E-20
4.91E+02 1.592E-20
5.70E+02 1.443E-20
6.61E+02 1.305E-20
7.67E+02 1.177E-20
8.89E+02 1.06E-20
1.03E+03 9.526E-21
1.20E+03 8.547E-21
1.39E+03 7.658E-21
1.61E+03 6.851E-21
1.87E+03 6.121E-21
2.16E+03 5.462E-21
2.51E+03 4.868E-21
2.91E+03 4.334E-21
3.38E+03 3.855E-21
3.92E+03 3.426E-21
4.54E+03 3.041E-21
5.27E+03 2.698E-21
6.11E+03 2.391E-21
7.09E+03 2.118E-21
8.22E+03 1.875E-21
9.53E+03 1.658E-21
1.11E+04 1.466E-21
1.28E+04 1.295E-21
1.49E+04 1.143E-21
1.72E+04 1.009E-21
2.00E+04 8.898E-22

148
data/collisions/IO_e-Li.dat Normal file
View file

@ -0,0 +1,148 @@
# Rusudan I., et al., Atoms 9(4):90 2021
# Relative energy (eV) cross section (m^2)
5.393 1.061E-23
6.000 5.885E-21
7.000 1.352E-20
8.000 1.927E-20
9.000 2.364E-20
10.000 2.698E-20
11.000 2.956E-20
12.000 3.156E-20
13.000 3.309E-20
14.000 3.427E-20
15.000 3.517E-20
16.000 3.585E-20
17.000 3.635E-20
18.000 3.670E-20
19.000 3.694E-20
20.000 3.708E-20
21.000 3.714E-20
22.000 3.714E-20
23.000 3.709E-20
24.000 3.700E-20
25.000 3.686E-20
26.000 3.671E-20
27.000 3.652E-20
28.000 3.632E-20
29.000 3.610E-20
30.000 3.588E-20
31.000 3.564E-20
32.000 3.539E-20
33.000 3.514E-20
34.000 3.488E-20
35.000 3.462E-20
36.000 3.435E-20
37.000 3.409E-20
38.000 3.383E-20
39.000 3.356E-20
40.000 3.330E-20
41.000 3.304E-20
42.000 3.277E-20
43.000 3.252E-20
44.000 3.226E-20
45.000 3.201E-20
46.000 3.175E-20
47.000 3.151E-20
48.000 3.126E-20
49.000 3.102E-20
50.000 3.078E-20
51.000 3.054E-20
52.000 3.031E-20
53.000 3.008E-20
54.000 2.985E-20
55.000 2.963E-20
56.000 2.941E-20
57.000 2.919E-20
58.000 2.898E-20
59.000 2.877E-20
60.000 2.856E-20
61.000 2.835E-20
62.000 2.815E-20
63.000 2.795E-20
64.000 2.776E-20
65.000 2.756E-20
66.000 2.737E-20
67.000 2.719E-20
68.000 2.700E-20
69.000 2.682E-20
70.000 2.664E-20
71.000 2.646E-20
72.000 2.629E-20
73.000 2.612E-20
74.000 2.595E-20
75.000 2.578E-20
76.000 2.562E-20
77.000 2.546E-20
78.000 2.530E-20
79.000 2.514E-20
80.000 2.499E-20
81.000 2.483E-20
82.000 2.468E-20
83.000 2.453E-20
84.000 2.439E-20
85.000 2.424E-20
86.000 2.410E-20
87.000 2.396E-20
88.000 2.382E-20
89.000 2.369E-20
90.000 2.355E-20
91.000 2.342E-20
92.000 2.329E-20
93.000 2.316E-20
94.000 2.303E-20
95.000 2.290E-20
96.000 2.278E-20
97.000 2.266E-20
98.000 2.253E-20
99.000 2.241E-20
100.000 2.230E-20
101.000 2.218E-20
102.000 2.206E-20
103.000 2.195E-20
104.000 2.184E-20
105.000 2.173E-20
106.000 2.162E-20
107.000 2.151E-20
108.000 2.140E-20
109.000 2.129E-20
110.000 2.119E-20
111.000 2.109E-20
112.000 2.098E-20
113.000 2.088E-20
114.000 2.078E-20
115.000 2.068E-20
116.000 2.059E-20
117.000 2.049E-20
118.000 2.039E-20
119.000 2.030E-20
120.000 2.021E-20
121.000 2.011E-20
122.000 2.002E-20
123.000 1.993E-20
124.000 1.984E-20
125.000 1.976E-20
126.000 1.967E-20
127.000 1.958E-20
128.000 1.950E-20
129.000 1.941E-20
130.000 1.933E-20
131.000 1.924E-20
132.000 1.916E-20
133.000 1.908E-20
134.000 1.900E-20
135.000 1.892E-20
136.000 1.884E-20
137.000 1.877E-20
138.000 1.869E-20
139.000 1.861E-20
140.000 1.854E-20
141.000 1.846E-20
142.000 1.839E-20
143.000 1.831E-20
144.000 1.824E-20
145.000 1.817E-20
146.000 1.810E-20
147.000 1.803E-20
148.000 1.796E-20
149.000 1.789E-20
150.000 1.782E-20

View file

@ -0,0 +1,52 @@
# EL cross sections extracted from PROGRAM MAGBOLTZ, VERSION 7.1 JUNE 2004 www.lxcat.net/Biagi-v7.1
# Relative energy (eV) cross section (m^2)
1.21E+01 0
1.41E+01 3.923E-21
1.64E+01 1.194E-20
1.91E+01 2.1E-20
2.22E+01 2.946E-20
2.58E+01 3.65E-20
3.00E+01 4.185E-20
3.49E+01 4.552E-20
4.06E+01 4.766E-20
4.72E+01 4.85E-20
5.49E+01 4.828E-20
6.39E+01 5.031E-20
7.43E+01 5.1E-20
8.64E+01 5.1E-20
1.01E+02 5.032E-20
1.17E+02 4.906E-20
1.36E+02 4.732E-20
1.58E+02 4.521E-20
1.84E+02 4.283E-20
2.14E+02 4.029E-20
2.49E+02 3.764E-20
2.90E+02 3.497E-20
3.37E+02 3.233E-20
3.92E+02 2.975E-20
4.56E+02 2.726E-20
5.31E+02 2.489E-20
6.17E+02 2.266E-20
7.18E+02 2.056E-20
8.35E+02 1.861E-20
9.72E+02 1.68E-20
1.13E+03 1.514E-20
1.32E+03 1.361E-20
1.53E+03 1.221E-20
1.78E+03 1.094E-20
2.07E+03 9.781E-21
2.41E+03 8.735E-21
2.80E+03 7.789E-21
3.26E+03 6.938E-21
3.79E+03 6.171E-21
4.41E+03 5.484E-21
5.13E+03 4.868E-21
5.97E+03 4.316E-21
6.94E+03 3.824E-21
8.07E+03 3.385E-21
9.39E+03 2.994E-21
1.09E+04 2.646E-21
1.27E+04 2.336E-21
1.48E+04 2.062E-21
1.72E+04 1.818E-21
2.00E+04 1.602E-21

BIN
doc/logos/fpakc.pdf Normal file

Binary file not shown.

View file

@ -6,6 +6,7 @@
*.aux *.aux
*.ps *.ps
bibliography.bib.bak bibliography.bib.bak
bibliography.bib.sav
*.bbl *.bbl
*.blg *.blg
*.out *.out

View file

@ -8,6 +8,16 @@
pages = {3--67}, pages = {3--67},
} }
@article{higginson2020corrected,
title={A corrected method for Coulomb scattering in arbitrarily weighted particle-in-cell plasma simulations},
author={Higginson, Drew Pitney and Holod, Ihor and Link, Anthony},
journal={Journal of Computational Physics},
volume={413},
pages={109450},
year={2020},
publisher={Elsevier}
}
@Misc{gfortranURL, @Misc{gfortranURL,
author = {GNU Project}, author = {GNU Project},
title = {gfortran - the GNU Fortran compiler}, title = {gfortran - the GNU Fortran compiler},
@ -41,4 +51,38 @@
howpublished = {\url{https://gmsh.info/}}, howpublished = {\url{https://gmsh.info/}},
} }
@Article{welford1962note,
author = {Welford, BP},
journal = {Technometrics},
title = {Note on a method for calculating corrected sums of squares and products},
year = {1962},
number = {3},
pages = {419--420},
volume = {4},
publisher = {Taylor \& Francis},
}
@Article{sherlock2008monte,
author = {Sherlock, Mark},
journal = {Journal of Computational Physics},
title = {A Monte-Carlo method for Coulomb collisions in hybrid plasma models},
year = {2008},
number = {4},
pages = {2286--2292},
volume = {227},
groups = {Particle-in-cell},
publisher = {Elsevier},
}
@article{lemons2009small,
title={Small-angle Coulomb collision model for particle-in-cell simulations},
author={Lemons, Don S and Winske, Dan and Daughton, William and Albright, Brian},
journal={Journal of Computational Physics},
volume={228},
number={5},
pages={1391--1403},
year={2009},
publisher={Elsevier}
}
@Comment{jabref-meta: databaseType:bibtex;} @Comment{jabref-meta: databaseType:bibtex;}

View file

@ -1,177 +0,0 @@
%!PS-Adobe-3.0 EPSF-3.0
%%Creator: cairo 1.16.0 (https://cairographics.org)
%%CreationDate: Wed Oct 07 12:01:13 2020
%%Pages: 1
%%DocumentData: Clean7Bit
%%LanguageLevel: 2
%%BoundingBox: 6 7 205 57
%%EndComments
%%BeginProlog
50 dict begin
/q { gsave } bind def
/Q { grestore } bind def
/cm { 6 array astore concat } bind def
/w { setlinewidth } bind def
/J { setlinecap } bind def
/j { setlinejoin } bind def
/M { setmiterlimit } bind def
/d { setdash } bind def
/m { moveto } bind def
/l { lineto } bind def
/c { curveto } bind def
/h { closepath } bind def
/re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto
0 exch rlineto 0 rlineto closepath } bind def
/S { stroke } bind def
/f { fill } bind def
/f* { eofill } bind def
/n { newpath } bind def
/W { clip } bind def
/W* { eoclip } bind def
/BT { } bind def
/ET { } bind def
/BDC { mark 3 1 roll /BDC pdfmark } bind def
/EMC { mark /EMC pdfmark } bind def
/cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def
/Tj { show currentpoint cairo_store_point } bind def
/TJ {
{
dup
type /stringtype eq
{ show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse
} forall
currentpoint cairo_store_point
} bind def
/cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore
cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def
/Tf { pop /cairo_font exch def /cairo_font_matrix where
{ pop cairo_selectfont } if } bind def
/Td { matrix translate cairo_font_matrix matrix concatmatrix dup
/cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point
/cairo_font where { pop cairo_selectfont } if } bind def
/Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def
cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def
/g { setgray } bind def
/rg { setrgbcolor } bind def
/d1 { setcachedevice } bind def
/cairo_data_source {
CairoDataIndex CairoData length lt
{ CairoData CairoDataIndex get /CairoDataIndex CairoDataIndex 1 add def }
{ () } ifelse
} def
/cairo_flush_ascii85_file { cairo_ascii85_file status { cairo_ascii85_file flushfile } if } def
/cairo_image { image cairo_flush_ascii85_file } def
/cairo_imagemask { imagemask cairo_flush_ascii85_file } def
%%EndProlog
%%BeginSetup
%%EndSetup
%%Page: 1 1
%%BeginPageSetup
%%PageBoundingBox: 6 7 205 57
%%EndPageSetup
q 6 7 199 50 rectclip
1 0 0 -1 0 71 cm q
0 g
49.766 27.305 m 49.766 29.898 49.078 31.813 47.703 33.039 c 46.328 34.27
44.297 34.883 41.609 34.883 c 36.625 34.883 l 36.625 47.945 l 32.438 47.945
l 32.438 14.352 l 41.516 14.352 l 44.234 14.352 46.285 14.953 47.672 16.148
c 49.066 17.348 49.766 19.242 49.766 21.836 c h
45.594 21.398 m 45.594 20.18 45.313 19.301 44.75 18.758 c 44.195 18.219
43.313 17.945 42.094 17.945 c 36.625 17.945 l 36.625 31.289 l 42.094 31.289
l 43.313 31.289 44.195 31.008 44.75 30.445 c 45.313 29.883 45.594 29 45.594
27.789 c h
45.594 21.398 m f
75.641 27.305 m 75.641 29.898 74.953 31.813 73.578 33.039 c 72.203 34.27
70.172 34.883 67.484 34.883 c 62.5 34.883 l 62.5 47.945 l 58.313 47.945
l 58.313 14.352 l 67.391 14.352 l 70.109 14.352 72.16 14.953 73.547 16.148
c 74.941 17.348 75.641 19.242 75.641 21.836 c h
71.469 21.398 m 71.469 20.18 71.188 19.301 70.625 18.758 c 70.07 18.219
69.188 17.945 67.969 17.945 c 62.5 17.945 l 62.5 31.289 l 67.969 31.289
l 69.188 31.289 70.07 31.008 70.625 30.445 c 71.188 29.883 71.469 29 71.469
27.789 c h
71.469 21.398 m f
99.891 47.945 m 99.473 47.945 99.016 47.82 98.516 47.57 c 98.023 47.313
97.602 46.957 97.25 46.508 c 96.508 47.469 95.535 47.945 94.328 47.945
c 90.047 47.945 l 87.617 47.945 85.852 47.461 84.75 46.492 c 83.645 45.516
83.094 43.836 83.094 41.461 c 83.094 40.508 l 83.094 35.551 85.426 33.07
90.094 33.07 c 96.047 33.07 l 96.047 30.664 l 96.047 29.676 95.742 28.91
95.141 28.367 c 94.535 27.816 93.641 27.539 92.453 27.539 c 85.016 27.539
l 85.016 23.945 l 91.969 23.945 l 94.75 23.945 96.801 24.555 98.125 25.773
c 99.457 26.984 100.125 28.938 100.125 31.633 c 100.125 43.148 l 100.125
43.629 100.305 43.988 100.672 44.227 c 101.047 44.469 101.664 44.586 102.531
44.586 c 102.531 47.945 l h
93.844 44.352 m 94.801 44.352 95.406 44.129 95.656 43.68 c 95.914 43.234
96.047 42.656 96.047 41.945 c 96.047 36.664 l 90.047 36.664 l 89.211 36.664
88.523 36.941 87.984 37.492 c 87.441 38.035 87.172 38.719 87.172 39.539
c 87.172 41.945 l 87.172 42.781 87.363 43.391 87.75 43.773 c 88.133 44.16
88.742 44.352 89.578 44.352 c h
93.844 44.352 m f
114.047 44.352 m 114.047 27.539 l 110.547 27.539 l 110.547 23.945 l 117.891
23.945 l 117.891 25.242 l 118.953 24.379 120.234 23.945 121.734 23.945
c 126.672 23.945 l 126.672 27.789 l 121.25 27.789 l 120.227 27.789 119.461
28.117 118.953 28.773 c 118.441 29.43 118.172 30.094 118.141 30.758 c 118.141
44.352 l 123.359 44.352 l 123.359 47.945 l 110.547 47.945 l 110.547 44.352
l h
114.047 44.352 m f
146.359 47.945 m 144.723 47.945 143.473 47.422 142.609 46.367 c 141.754
45.305 141.328 43.91 141.328 42.18 c 141.328 27.539 l 136.766 27.539 l
136.766 23.945 l 141.328 23.945 l 141.328 18.18 l 145.406 18.18 l 145.406
23.945 l 152.406 23.945 l 152.406 27.539 l 145.406 27.539 l 145.406 42.43
l 145.406 43.129 145.578 43.625 145.922 43.914 c 146.273 44.207 146.82
44.352 147.563 44.352 c 152.406 44.352 l 152.406 47.945 l h
146.359 47.945 m f
172.719 14.352 m 172.719 18.664 l 168.156 18.664 l 168.156 14.352 l h
161.344 27.539 m 161.344 23.945 l 172.469 23.945 l 172.469 44.352 l 179.578
44.352 l 179.578 47.945 l 168.391 47.945 l 168.391 27.539 l h
161.344 27.539 m f
197.25 47.945 m 194.469 47.945 192.332 47.27 190.844 45.914 c 189.352 44.551
188.609 42.508 188.609 39.789 c 188.609 22.508 l 188.609 19.789 189.352
17.754 190.844 16.398 c 192.332 15.035 194.469 14.352 197.25 14.352 c 204.063
14.352 l 204.063 17.992 l 196.766 17.992 l 195.578 17.992 194.613 18.348
193.875 19.055 c 193.145 19.754 192.781 20.598 192.781 21.586 c 192.781
40.695 l 192.781 41.688 193.145 42.535 193.875 43.242 c 194.613 43.953
195.578 44.305 196.766 44.305 c 204.063 44.305 l 204.063 47.945 l h
197.25 47.945 m f
0.831373 0 0 rg
17.277 53.707 m 17.277 56.629 14.91 58.996 11.988 58.996 c 9.066 58.996
6.695 56.629 6.695 53.707 c 6.695 50.785 9.066 48.414 11.988 48.414 c 14.91
48.414 17.277 50.785 17.277 53.707 c f
0 0 0.501961 rg
23.906 61.84 m 23.906 62.969 22.992 63.883 21.863 63.883 c 20.734 63.883
19.82 62.969 19.82 61.84 c 19.82 60.715 20.734 59.801 21.863 59.801 c 22.992
59.801 23.906 60.715 23.906 61.84 c f
0.596078 g
0.751181 w
0 J
0 j
[] 0.0 d
4 M q 1 0 0 1 0 0 cm
16.941 50.758 m 29.465 47.813 l S Q
27.848 47.258 m 30.453 47.578 l 28.262 49.023 l 28.523 48.41 28.355 47.699
27.848 47.258 c h
27.848 47.258 m f*
0.137102 w
1 j
q -1 0.235294 -0.235294 -1 0 0 cm
-15.851 -50.987 m -18.248 -51.872 l -15.849 -52.753 l -16.234 -52.23 -16.233
-51.519 -15.851 -50.987 c h
-15.851 -50.987 m S Q
0.6 g
0.751178 w
0 j
q 1 0 0 1 0 0 cm
23.234 59.613 m 30.398 49.301 l S Q
28.824 49.969 m 30.973 48.461 l 30.313 51 l 30.098 50.375 29.496 49.957
28.824 49.969 c h
28.824 49.969 m f*
0.115667 w
1 j
q -0.694805 1 -1 -0.694805 0 0 cm
20.193 -42.855 m 18.17 -43.597 l 20.191 -44.342 l 19.87 -43.904 19.87 -43.302
20.193 -42.855 c h
20.193 -42.855 m S Q
Q Q
showpage
%%Trailer
end
%%EOF

View file

@ -1,159 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="80mm"
height="25mm"
viewBox="0 0 80 25"
version="1.1"
id="svg8"
inkscape:version="1.0 (4035a4fb49, 2020-05-01)"
sodipodi:docname="PPartiC.svg">
<defs
id="defs2">
<marker
inkscape:stockid="Arrow2Mend"
orient="auto"
refY="0.0"
refX="0.0"
id="Arrow2Mend"
style="overflow:visible;"
inkscape:isstock="true">
<path
id="path881"
style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
transform="scale(0.6) rotate(180) translate(0,0)" />
</marker>
<marker
inkscape:stockid="Arrow2Send"
orient="auto"
refY="0.0"
refX="0.0"
id="Arrow2Send"
style="overflow:visible;"
inkscape:isstock="true">
<path
id="path887"
style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#989898;stroke-opacity:1;fill:#989898;fill-opacity:1"
d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
transform="scale(0.3) rotate(180) translate(-2.3,0)" />
</marker>
<marker
inkscape:stockid="Arrow1Mend"
orient="auto"
refY="0.0"
refX="0.0"
id="Arrow1Mend"
style="overflow:visible;"
inkscape:isstock="true">
<path
id="path863"
d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
transform="scale(0.4) rotate(180) translate(10,0)" />
</marker>
<marker
inkscape:stockid="Arrow1Lend"
orient="auto"
refY="0.0"
refX="0.0"
id="Arrow1Lend"
style="overflow:visible;"
inkscape:isstock="true">
<path
id="path857"
d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
transform="scale(0.8) rotate(180) translate(12.5,0)" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="Arrow2Send-8"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Send">
<path
transform="matrix(-0.3,0,0,-0.3,0.69,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#999999;fill-opacity:1;fill-rule:evenodd;stroke:#999999;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path887-3" />
</marker>
</defs>
<sodipodi:namedview
id="base"
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1.0"
inkscape:pageopacity="0.0"
inkscape:pageshadow="2"
inkscape:zoom="2.8"
inkscape:cx="-108.81501"
inkscape:cy="51.644646"
inkscape:document-units="mm"
inkscape:current-layer="layer1"
inkscape:document-rotation="0"
showgrid="false"
inkscape:window-width="2560"
inkscape:window-height="1378"
inkscape:window-x="-9"
inkscape:window-y="26"
inkscape:window-maximized="1" />
<metadata
id="metadata5">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<g
inkscape:label="Layer 1"
inkscape:groupmode="layer"
id="layer1">
<text
xml:space="preserve"
style="font-style:normal;font-weight:normal;font-size:16.9333px;line-height:1.25;font-family:sans-serif;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.264583"
x="9.921875"
y="16.914433"
id="text12"><tspan
sodipodi:role="line"
id="tspan10"
x="9.921875"
y="16.914433"
style="font-style:italic;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16.9333px;font-family:'Share Tech Mono';-inkscape-font-specification:'Share Tech Mono Italic';stroke-width:0.264583">PPartiC</tspan></text>
<circle
style="fill:#d40000;stroke-width:0.264583"
id="path14"
cx="4.2286086"
cy="18.946056"
r="1.8662573" />
<circle
style="fill:#000080;stroke-width:0.576413"
id="path16"
cx="7.7130766"
cy="21.816313"
r="0.7205171" />
<path
style="fill:none;fill-opacity:1;stroke:#989898;stroke-width:0.265;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow2Send)"
d="M 5.9767484,17.906622 10.394345,16.867188"
id="path18"
sodipodi:nodetypes="cc" />
<path
sodipodi:nodetypes="cc"
id="path18-6"
d="m 8.195956,21.029626 2.527716,-3.638021"
style="fill:none;stroke:#999999;stroke-width:0.264999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow2Send-8)" />
</g>
</svg>

Before

Width:  |  Height:  |  Size: 5.7 KiB

View file

@ -1,294 +0,0 @@
%!PS-Adobe-3.0 EPSF-3.0
%%Creator: cairo 1.16.0 (https://cairographics.org)
%%CreationDate: Sat Nov 21 21:23:19 2020
%%Pages: 1
%%DocumentData: Clean7Bit
%%LanguageLevel: 2
%%BoundingBox: 8 15 191 78
%%EndComments
%%BeginProlog
50 dict begin
/q { gsave } bind def
/Q { grestore } bind def
/cm { 6 array astore concat } bind def
/w { setlinewidth } bind def
/J { setlinecap } bind def
/j { setlinejoin } bind def
/M { setmiterlimit } bind def
/d { setdash } bind def
/m { moveto } bind def
/l { lineto } bind def
/c { curveto } bind def
/h { closepath } bind def
/re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto
0 exch rlineto 0 rlineto closepath } bind def
/S { stroke } bind def
/f { fill } bind def
/f* { eofill } bind def
/n { newpath } bind def
/W { clip } bind def
/W* { eoclip } bind def
/BT { } bind def
/ET { } bind def
/BDC { mark 3 1 roll /BDC pdfmark } bind def
/EMC { mark /EMC pdfmark } bind def
/cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def
/Tj { show currentpoint cairo_store_point } bind def
/TJ {
{
dup
type /stringtype eq
{ show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse
} forall
currentpoint cairo_store_point
} bind def
/cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore
cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def
/Tf { pop /cairo_font exch def /cairo_font_matrix where
{ pop cairo_selectfont } if } bind def
/Td { matrix translate cairo_font_matrix matrix concatmatrix dup
/cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point
/cairo_font where { pop cairo_selectfont } if } bind def
/Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def
cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def
/g { setgray } bind def
/rg { setrgbcolor } bind def
/d1 { setcachedevice } bind def
/cairo_data_source {
CairoDataIndex CairoData length lt
{ CairoData CairoDataIndex get /CairoDataIndex CairoDataIndex 1 add def }
{ () } ifelse
} def
/cairo_flush_ascii85_file { cairo_ascii85_file status { cairo_ascii85_file flushfile } if } def
/cairo_image { image cairo_flush_ascii85_file } def
/cairo_imagemask { imagemask cairo_flush_ascii85_file } def
%%EndProlog
%%BeginSetup
%%BeginResource: font f-0-0
%!FontType1-1.1 f-0-0 1.0
11 dict begin
/FontName /f-0-0 def
/PaintType 0 def
/FontType 1 def
/FontMatrix [0.001 0 0 0.001 0 0] readonly def
/FontBBox {30 -240 640 735 } readonly def
/Encoding 256 array
0 1 255 {1 index exch /.notdef put} for
dup 97 /a put
dup 99 /c put
dup 102 /f put
dup 107 /k put
dup 112 /p put
readonly def
currentdict end
currentfile eexec
f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467
b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de
800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f
2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b
9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799
69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5
8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251caad907dcd8c61e
23500065b1568be79a17d2379b63d656e8f7715cdfdf357f0e30d9ab91d113c88231d875d60897
1dee27eb5da34a09d2f1b1a2e7ab8be1036393cd6ae53eff0d77f452e9bf45eccc9e4836ae77c5
b74262fa43bfccfd9a147a18dcdae6e50cc518129a64f669a5fae69c8082dec571d7d01a4e9f05
6d3e52de0ea004acdbd1b3bf9b19aa17f839a75365a77b7275442a967093ffdf1694a72f9978a2
304ac331d401b48e3e62a3a92cd39516dd480f088980d1ad8993a1f6fefb07e0d86b6f0293bb41
68ac465726267cacb7516a0e910fe67c2dbfef06d8b64a9811506650d32fa182a0adcab8e2e21e
ca6d0dc81959c25ea2d3f7ccec13e0cb4a7ef88e97c36e74fa13010220d6835ebdcbabdb507d84
239e5483e8a8b7a52d6e1ea4ea1f5e6bef4534710c4055265aaa86fb445f3b2fc62cfdd9e283d8
8bd083d09f0971cde00f2031b58b304d5f647f02aabf7ba9062c33979cd391f692c72ee179b7a8
16f9c9e668d20021bd2b6a0f0114898729c6228be2895a696aaef0ebbcc842e64d5e72cc1d9b75
44314028987a238f8fc4c18a0db3546c9ea42194b6bbdc45587e36d605fe2b7608d9292ddc0c9b
be3e420b36fd52f9aef97f13533e101f34d4f882848f4845a7a824da815a710abe11a1ec8363c1
06daa18dffb5a451af7bf3b20d79a63c94e305050ea893b7a61cc8cfdb2e8a593a073c2021b298
40863c70742ab1734e1d6811cf1927832da10f562f6895575b50044179588ddd9ec4c413f68c3e
3063f9594dc94115af4d9d4d6259c2ebb5afa796131772de3d297a8cc04f7f10398acc9142b1aa
2da9741ad314918ff1553dafe4751b4c0efdc9d6a549acbf1b3d209f6ebe8f6561d627f37bbce1
7213b92bf332c27718ca9f868f1724cda0774ea4c3a5a2ba99509eb9128c456e5526f234dc3adc
37ac61ead9dafba1b5d58a9443ceb92474535cd3515e9ce357420b230fe927e81f06b2363c70aa
b6e00858a44972ad3f8759069235bba0b8ae2c65a59fe3ee5642f88a8550a765907eb4f9432ac4
9e896114d0bc969bc2c14acd9a50c31e2095133b6b4fc11a1136dbba4b515eaabf0cba23ffe795
3532a1fca89780a841f3a5fe2514d31fd6d41fbcb5b8caadd53c1fa7b06506963f37006269d0ae
fc1d5d6bd7f6788544e01a77bdf35aaacdd41dd4fc16237759516c60ee9b57e7b56606e0fb5a25
9e6cb3b2e22d3ac4db73c228fda1b327cace7cbe25594ea2a9445efeda7826604e3daf18ca977a
9a2788cddcea95b5460b648c12bebc3c39302a07481fe18ceed4c9e12ac7d51f8104bd589cf9f6
68371d3aa8510b5ff08c972b84fd4e48c356f9098b9d130085f59bc7e748ac59e9715060d29b38
d828e479d8a85e0aaaa7b4ab34b547643b9c3417305b29be240ba9514cd4656079f26f378a6af9
f7c694b1332a14baa203faa5c6745eea7c9cc0b3fc13f722ff941857d141db5665b32ada8b7831
06f5c01361bd4b161450546ad8812d364b394658c4d3e1e2cf1daba58315787fbe299a27a387f2
1545b5d4bc3022e6a6803e971698504ebc44c9f7c02256a5ae01c9fb3194baf05fb7c9cd862427
95ca9cfd57ba76d6697fc842ee19ff35ce8b9d3299a185a4d28537058b5ea471a818f521183ffa
4b171f078577707cfbb3b2c6de4659b6dbacb952a0213b0586bd5879096ec53540ad07463e5b25
1a38d715de6a0bb6f92d3e20e1b25be654fe7aad2e057428b68e2d6830f2ee0ca384fb862813ba
d48832ec89991fa5e6bf9d3135378f0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
cleartomark
%%EndResource
%%EndSetup
%%Page: 1 1
%%BeginPageSetup
%%PageBoundingBox: 8 15 191 78
%%EndPageSetup
q 8 15 183 63 rectclip
1 0 0 -1 0 86 cm q
0 g
BT
56.000126 0 0 -56.000126 52.419201 52.791732 Tm
/f-0-0 1 Tf
[(fpak)10(c)]TJ
ET
0.749999 w
0 J
0 j
[] 0.0 d
4 M q 1 0 0 1 0 0 cm
8.996 27.238 m 20.621 9.359 l 34.656 9.363 l 34.621 14.746 l 25.941 18.195
l 17.332 33.629 l 17.41 55.852 l 9.316 55.785 l h
8.996 27.238 m S Q
q 1 0 0 1 0 0 cm
21.156 69.262 m 21.156 38.387 l 40.305 38.387 l 40.305 53.027 l 27.457
53.027 l 27.457 69.52 l h
21.156 69.262 m S Q
q 1 0 0 1 0 0 cm
27.898 43.988 m 27.898 47.73 l 33.426 47.73 l 33.426 43.898 l h
27.898 43.988 m S Q
0.283465 w
q 1 0 0 1 0 0 cm
9.094 50.535 m 17.414 50.297 l S Q
q 1 0 0 1 0 0 cm
9.34 43.07 m 17.094 44.93 l S Q
q 1 0 0 1 0 0 cm
9.43 34.727 m 17.348 41.363 l S Q
q 1 0 0 1 0 0 cm
17.332 33.629 m 8.996 27.238 l S Q
q 1 0 0 1 0 0 cm
13.297 31.055 m 11.32 36.062 l 12.719 43.309 l 14.023 50.113 l 12.02 55.516
l S Q
q 1 0 0 1 0 0 cm
17.332 33.629 m 12.203 21.801 l S Q
q 1 0 0 1 0 0 cm
21.246 26.223 m 12.203 21.801 l S Q
q 1 0 0 1 0 0 cm
15.379 16.828 m 21.246 26.223 l S Q
q 1 0 0 1 0 0 cm
23.562 22.152 m 15.379 16.828 l S Q
q 1 0 0 1 0 0 cm
25.941 18.195 m 15.379 16.828 l S Q
q 1 0 0 1 0 0 cm
13.297 31.055 m 14.234 26.23 l S Q
q 1 0 0 1 0 0 cm
14.234 26.23 m 21.246 26.223 l S Q
q 1 0 0 1 0 0 cm
25.941 18.195 m 17.918 13.906 l S Q
q 1 0 0 1 0 0 cm
20.621 9.359 m 25.941 18.195 l S Q
q 1 0 0 1 0 0 cm
34.656 9.363 m 25.941 18.195 l S Q
q 1 0 0 1 0 0 cm
25.941 18.195 m 26.527 9.582 l S Q
1 0 0 rg
23.523 67.027 m 23.523 67.027 23.523 67.031 23.523 67.031 c 23.52 67.031
23.52 67.027 23.52 67.027 c 23.52 67.027 23.52 67.027 23.523 67.027 c h
23.523 67.027 m f
0 g
0.749999 w
q 1 0 0 1 0 0 cm
23.523 67.027 m 23.523 67.027 23.523 67.031 23.523 67.031 c 23.52 67.031
23.52 67.027 23.52 67.027 c 23.52 67.027 23.52 67.027 23.523 67.027 c h
23.523 67.027 m S Q
1 0 0 rg
24.66 63.297 m 24.66 63.297 24.656 63.297 24.656 63.297 c 24.656 63.293
24.66 63.293 24.66 63.293 c 24.66 63.293 24.66 63.293 24.66 63.297 c h
24.66 63.297 m f
0 g
q 1 0 0 1 0 0 cm
24.66 63.297 m 24.66 63.297 24.656 63.297 24.656 63.297 c 24.656 63.293
24.66 63.293 24.66 63.293 c 24.66 63.293 24.66 63.293 24.66 63.297 c h
24.66 63.297 m S Q
0 0 1 rg
23.797 64.039 m 23.797 64.273 23.609 64.465 23.371 64.465 c 23.137 64.465
22.949 64.273 22.949 64.039 c 22.949 63.805 23.137 63.613 23.371 63.613
c 23.609 63.613 23.797 63.805 23.797 64.039 c h
23.797 64.039 m f
1 0 0 rg
37.844 42.566 m 37.844 42.945 37.535 43.254 37.156 43.254 c 36.773 43.254
36.465 42.945 36.465 42.566 c 36.465 42.184 36.773 41.875 37.156 41.875
c 37.535 41.875 37.844 42.184 37.844 42.566 c h
37.844 42.566 m f
0 g
0.141732 w
q 1 0 0 1 0 0 cm
35.977 42.188 m 31.02 39.777 l S Q
31.531 40.027 m 31.91 39.895 l 30.895 39.715 l 31.66 40.406 l h
31.531 40.027 m f*
0.0679747 w
q 1 0.486446 -0.486446 1 0 0 cm
41.243 19.965 m 41.497 19.708 l 40.605 19.963 l 41.496 20.22 l h
41.243 19.965 m S Q
0.141732 w
q 1 0 0 1 0 0 cm
29.828 39.73 m 23.582 45.012 l S Q
24.016 44.645 m 24.047 44.246 l 23.473 45.102 l 24.414 44.68 l h
24.016 44.645 m f*
0.0577315 w
q 1 -0.845211 0.845211 1 0 0 cm
-8.002 37.881 m -7.787 37.664 l -8.544 37.88 l -7.787 38.098 l h
-8.002 37.881 m S Q
0.141732 w
q 1 0 0 1 0 0 cm
23.82 46.355 m 25.027 51.145 l S Q
24.887 50.594 m 24.543 50.387 l 25.059 51.281 l 25.094 50.25 l h
24.887 50.594 m f*
0.0732958 w
q -0.252177 -1 1 -0.252177 0 0 cm
-53.469 11.403 m -53.193 11.129 l -54.156 11.402 l -53.195 11.679 l h
-53.469 11.403 m S Q
0.141732 w
q 1 0 0 1 0 0 cm
23.453 63.156 m 26.16 58.465 l S Q
25.875 58.953 m 25.98 59.34 l 26.23 58.34 l 25.488 59.059 l h
25.875 58.953 m f*
0.0654792 w
q -0.576787 1 -1 -0.576787 0 0 cm
33.038 -44.931 m 33.282 -45.177 l 32.424 -44.932 l 33.284 -44.686 l h
33.038 -44.931 m S Q
0.141732 w
q 1 0 0 1 0 0 cm
26.215 57.066 m 26.281 52.215 l S Q
26.273 52.785 m 26.555 53.07 l 26.285 52.074 l 25.984 53.062 l h
26.273 52.785 m f*
0.0755832 w
q -0.0137977 1 -1 -0.0137977 0 0 cm
52.413 -26.997 m 52.694 -27.282 l 51.702 -26.999 l 52.694 -26.711 l h
52.413 -26.997 m S Q
0.141732 w
q 1 0 0 1 0 0 cm
26.5 50.707 m 34.664 48.957 l S Q
34.109 49.074 m 33.895 49.41 l 34.805 48.926 l 33.773 48.859 l h
34.109 49.074 m f*
0.0739077 w
q -1 0.214603 -0.214603 -1 0 0 cm
-22.54 -53.911 m -22.266 -54.188 l -23.235 -53.912 l -22.263 -53.637 l
h
-22.54 -53.911 m S Q
0.141732 w
q 1 0 0 1 0 0 cm
36.809 49.66 m 38.371 43.828 l S Q
38.223 44.379 m 38.426 44.727 l 38.406 43.691 l 37.879 44.578 l h
38.223 44.379 m f*
0.0730145 w
q -0.26796 1 -1 -0.26796 0 0 cm
31.85 -46.757 m 32.123 -47.034 l 31.163 -46.757 l 32.122 -46.486 l h
31.85 -46.757 m S Q
Q Q
showpage
%%Trailer
end
%%EOF

View file

@ -1,303 +0,0 @@
%!PS-Adobe-3.0 EPSF-3.0
%%Creator: cairo 1.16.0 (https://cairographics.org)
%%CreationDate: Thu Oct 08 15:41:58 2020
%%Pages: 1
%%DocumentData: Clean7Bit
%%LanguageLevel: 2
%%BoundingBox: 13 30 125 153
%%EndComments
%%BeginProlog
50 dict begin
/q { gsave } bind def
/Q { grestore } bind def
/cm { 6 array astore concat } bind def
/w { setlinewidth } bind def
/J { setlinecap } bind def
/j { setlinejoin } bind def
/M { setmiterlimit } bind def
/d { setdash } bind def
/m { moveto } bind def
/l { lineto } bind def
/c { curveto } bind def
/h { closepath } bind def
/re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto
0 exch rlineto 0 rlineto closepath } bind def
/S { stroke } bind def
/f { fill } bind def
/f* { eofill } bind def
/n { newpath } bind def
/W { clip } bind def
/W* { eoclip } bind def
/BT { } bind def
/ET { } bind def
/BDC { mark 3 1 roll /BDC pdfmark } bind def
/EMC { mark /EMC pdfmark } bind def
/cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def
/Tj { show currentpoint cairo_store_point } bind def
/TJ {
{
dup
type /stringtype eq
{ show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse
} forall
currentpoint cairo_store_point
} bind def
/cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore
cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def
/Tf { pop /cairo_font exch def /cairo_font_matrix where
{ pop cairo_selectfont } if } bind def
/Td { matrix translate cairo_font_matrix matrix concatmatrix dup
/cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point
/cairo_font where { pop cairo_selectfont } if } bind def
/Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def
cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def
/g { setgray } bind def
/rg { setrgbcolor } bind def
/d1 { setcachedevice } bind def
/cairo_data_source {
CairoDataIndex CairoData length lt
{ CairoData CairoDataIndex get /CairoDataIndex CairoDataIndex 1 add def }
{ () } ifelse
} def
/cairo_flush_ascii85_file { cairo_ascii85_file status { cairo_ascii85_file flushfile } if } def
/cairo_image { image cairo_flush_ascii85_file } def
/cairo_imagemask { imagemask cairo_flush_ascii85_file } def
%%EndProlog
%%BeginSetup
%%EndSetup
%%Page: 1 1
%%BeginPageSetup
%%PageBoundingBox: 13 30 125 153
%%EndPageSetup
q 13 30 112 123 rectclip
1 0 0 -1 0 171 cm q
0 0.784314 0 rg
20.836 84.285 52.273 43.371 re f
0 g
0.751178 w
0 J
0 j
[] 0.0 d
4 M q 1 0 0 1 0 0 cm
20.836 84.285 52.273 43.371 re S Q
1 0.627451 0 rg
73.109 84.285 43.184 43.371 re f
0 g
q 1 0 0 1 0 0 cm
73.109 84.285 43.184 43.371 re S Q
0.0431373 0 1 rg
73.109 32.199 43.184 52.086 re f
0 g
q 1 0 0 1 0 0 cm
73.109 32.199 43.184 52.086 re S Q
1 0 0 rg
20.836 32.199 52.273 52.086 re f
0 g
q 1 0 0 1 0 0 cm
20.836 32.199 52.273 52.086 re S Q
q 1 0 0 1 0 0 cm
20.836 32.199 95.457 95.457 re S Q
0 0 1 rg
22.902 127.77 m 22.902 128.914 21.973 129.844 20.824 129.844 c 19.68 129.844
18.75 128.914 18.75 127.77 c 18.75 126.621 19.68 125.691 20.824 125.691
c 21.973 125.691 22.902 126.621 22.902 127.77 c h
22.902 127.77 m f
q 1 0 0 1 0 0 cm
22.902 127.77 m 22.902 128.914 21.973 129.844 20.824 129.844 c 19.68 129.844
18.75 128.914 18.75 127.77 c 18.75 126.621 19.68 125.691 20.824 125.691
c 21.973 125.691 22.902 126.621 22.902 127.77 c h
22.902 127.77 m S Q
1 0 0 rg
118.059 127.23 m 118.059 128.379 117.129 129.309 115.98 129.309 c 114.836
129.309 113.906 128.379 113.906 127.23 c 113.906 126.086 114.836 125.156
115.98 125.156 c 117.129 125.156 118.059 126.086 118.059 127.23 c f
q 1 0 0 1 0 0 cm
118.059 127.23 m 118.059 128.379 117.129 129.309 115.98 129.309 c 114.836
129.309 113.906 128.379 113.906 127.23 c 113.906 126.086 114.836 125.156
115.98 125.156 c 117.129 125.156 118.059 126.086 118.059 127.23 c S Q
0 0.784314 0 rg
117.789 32.41 m 117.789 33.559 116.859 34.488 115.715 34.488 c 114.566
34.488 113.637 33.559 113.637 32.41 c 113.637 31.266 114.566 30.336 115.715
30.336 c 116.859 30.336 117.789 31.266 117.789 32.41 c f
q 1 0 0 1 0 0 cm
117.789 32.41 m 117.789 33.559 116.859 34.488 115.715 34.488 c 114.566
34.488 113.637 33.559 113.637 32.41 c 113.637 31.266 114.566 30.336 115.715
30.336 c 116.859 30.336 117.789 31.266 117.789 32.41 c S Q
1 0.627451 0 rg
23.238 32.41 m 23.238 33.559 22.309 34.488 21.16 34.488 c 20.016 34.488
19.086 33.559 19.086 32.41 c 19.086 31.266 20.016 30.336 21.16 30.336 c
22.309 30.336 23.238 31.266 23.238 32.41 c f
q 1 0 0 1 0 0 cm
23.238 32.41 m 23.238 33.559 22.309 34.488 21.16 34.488 c 20.016 34.488
19.086 33.559 19.086 32.41 c 19.086 31.266 20.016 30.336 21.16 30.336 c
22.309 30.336 23.238 31.266 23.238 32.41 c S Q
0 g
76.465 84.191 m 76.465 86.262 74.785 87.941 72.715 87.941 c 70.645 87.941
68.965 86.262 68.965 84.191 c 68.965 82.121 70.645 80.441 72.715 80.441
c 74.785 80.441 76.465 82.121 76.465 84.191 c h
76.465 84.191 m f
q 1 0 0 1 0 0 cm
76.465 84.191 m 76.465 86.262 74.785 87.941 72.715 87.941 c 70.645 87.941
68.965 86.262 68.965 84.191 c 68.965 82.121 70.645 80.441 72.715 80.441
c 74.785 80.441 76.465 82.121 76.465 84.191 c h
76.465 84.191 m S Q
0.749999 w
q 1 0 0 1 0 0 cm
20.355 84.105 m 115.98 84.105 l S Q
q 1 0 0 1 0 0 cm
72.922 127.277 m 72.922 32.008 l S Q
14.742 139.539 m 16.68 139.539 l 16.68 132.867 l 14.57 133.289 l 14.57
132.211 l 16.664 131.789 l 17.852 131.789 l 17.852 139.539 l 19.789 139.539
l 19.789 140.539 l 14.742 140.539 l h
14.742 139.539 m f
120.676 136.695 m 124.816 136.695 l 124.816 137.695 l 119.254 137.695 l
119.254 136.695 l 119.699 136.238 120.309 135.617 121.082 134.836 c 121.863
134.047 122.352 133.535 122.551 133.305 c 122.934 132.891 123.199 132.535
123.348 132.242 c 123.504 131.941 123.582 131.648 123.582 131.367 c 123.582
130.898 123.414 130.52 123.082 130.227 c 122.758 129.938 122.336 129.789
121.816 129.789 c 121.441 129.789 121.043 129.852 120.629 129.977 c 120.223
130.102 119.785 130.301 119.316 130.57 c 119.316 129.367 l 119.793 129.18
120.238 129.039 120.645 128.945 c 121.059 128.844 121.441 128.789 121.785
128.789 c 122.691 128.789 123.414 129.02 123.957 129.477 c 124.496 129.926
124.77 130.531 124.77 131.289 c 124.77 131.645 124.699 131.984 124.566
132.305 c 124.43 132.629 124.184 133.008 123.832 133.445 c 123.727 133.563
123.414 133.891 122.895 134.43 c 122.371 134.973 121.633 135.727 120.676
136.695 c h
120.676 136.695 m f
122.875 24.07 m 123.438 24.195 123.875 24.453 124.188 24.836 c 124.508
25.211 124.672 25.68 124.672 26.242 c 124.672 27.109 124.375 27.781 123.781
28.258 c 123.188 28.727 122.344 28.961 121.25 28.961 c 120.883 28.961 120.504
28.922 120.109 28.852 c 119.723 28.781 119.328 28.672 118.922 28.523 c
118.922 27.383 l 119.242 27.57 119.598 27.719 119.984 27.82 c 120.379 27.914
120.789 27.961 121.219 27.961 c 121.957 27.961 122.52 27.816 122.906 27.523
c 123.301 27.234 123.5 26.805 123.5 26.242 c 123.5 25.734 123.316 25.332
122.953 25.039 c 122.586 24.75 122.086 24.602 121.453 24.602 c 120.422
24.602 l 120.422 23.633 l 121.5 23.633 l 122.07 23.633 122.516 23.52 122.828
23.289 c 123.141 23.051 123.297 22.711 123.297 22.273 c 123.297 21.828
123.133 21.484 122.813 21.242 c 122.5 21.004 122.047 20.883 121.453 20.883
c 121.117 20.883 120.766 20.922 120.391 20.992 c 120.023 21.055 119.617
21.16 119.172 21.305 c 119.172 20.258 l 119.629 20.133 120.051 20.039 120.438
19.977 c 120.832 19.914 121.203 19.883 121.547 19.883 c 122.453 19.883
123.164 20.086 123.688 20.492 c 124.207 20.898 124.469 21.453 124.469 22.148
c 124.469 22.641 124.328 23.051 124.047 23.383 c 123.773 23.719 123.383
23.945 122.875 24.07 c h
122.875 24.07 m f
17.223 19.746 m 14.238 24.418 l 17.223 24.418 l h
16.91 18.715 m 18.41 18.715 l 18.41 24.418 l 19.66 24.418 l 19.66 25.402
l 18.41 25.402 l 18.41 27.465 l 17.223 27.465 l 17.223 25.402 l 13.285
25.402 l 13.285 24.262 l h
16.91 18.715 m f
39.906 47.727 m 38.297 52.07 l 41.516 52.07 l h
39.234 46.555 m 40.578 46.555 l 43.906 55.305 l 42.672 55.305 l 41.875
53.055 l 37.938 53.055 l 37.141 55.305 l 35.891 55.305 l h
39.234 46.555 m f
45.5 57.066 m 48.188 57.066 l 48.188 57.707 l 44.578 57.707 l 44.578 57.066
l 44.867 56.766 45.266 56.359 45.766 55.848 c 46.266 55.34 46.582 55.012
46.719 54.863 c 46.957 54.582 47.125 54.348 47.219 54.16 c 47.32 53.965
47.375 53.777 47.375 53.598 c 47.375 53.297 47.266 53.051 47.047 52.863
c 46.836 52.668 46.566 52.566 46.234 52.566 c 45.992 52.566 45.738 52.609
45.469 52.691 c 45.195 52.777 44.91 52.902 44.609 53.066 c 44.609 52.301
l 44.922 52.176 45.207 52.082 45.469 52.02 c 45.738 51.957 45.988 51.926
46.219 51.926 c 46.801 51.926 47.27 52.074 47.625 52.363 c 47.977 52.656
48.156 53.047 48.156 53.535 c 48.156 53.777 48.109 54 48.016 54.207 c 47.93
54.418 47.773 54.66 47.547 54.941 c 47.484 55.016 47.281 55.23 46.938 55.582
c 46.594 55.938 46.113 56.434 45.5 57.066 c h
45.5 57.066 m f
93.52 47.684 m 91.91 52.027 l 95.129 52.027 l h
92.848 46.512 m 94.191 46.512 l 97.52 55.262 l 96.285 55.262 l 95.488 53.012
l 91.551 53.012 l 90.754 55.262 l 89.504 55.262 l h
92.848 46.512 m f
98.582 57.02 m 99.832 57.02 l 99.832 52.676 l 98.473 52.957 l 98.473 52.254
l 99.832 51.973 l 100.598 51.973 l 100.598 57.02 l 101.848 57.02 l 101.848
57.66 l 98.582 57.66 l h
98.582 57.02 m f
45.98 98.063 m 44.371 102.406 l 47.59 102.406 l h
45.309 96.891 m 46.652 96.891 l 49.98 105.641 l 48.746 105.641 l 47.949
103.391 l 44.012 103.391 l 43.215 105.641 l 41.965 105.641 l h
45.309 96.891 m f
53.23 104.98 m 53.605 105.055 53.895 105.215 54.105 105.465 c 54.313 105.715
54.418 106.023 54.418 106.387 c 54.418 106.949 54.219 107.387 53.824 107.699
c 53.438 108.004 52.891 108.152 52.184 108.152 c 51.941 108.152 51.699
108.125 51.449 108.074 c 51.199 108.035 50.938 107.965 50.668 107.871 c
50.668 107.137 l 50.875 107.254 51.105 107.348 51.355 107.418 c 51.613 107.48
51.887 107.512 52.168 107.512 c 52.645 107.512 53.012 107.418 53.262 107.23
c 53.52 107.035 53.652 106.754 53.652 106.387 c 53.652 106.055 53.531 105.793
53.293 105.605 c 53.051 105.418 52.723 105.324 52.309 105.324 c 51.652
105.324 l 51.652 104.684 l 52.34 104.684 l 52.723 104.684 53.016 104.613
53.215 104.465 c 53.41 104.309 53.512 104.09 53.512 103.809 c 53.512 103.52
53.406 103.293 53.199 103.137 c 52.988 102.98 52.691 102.902 52.309 102.902
c 52.098 102.902 51.875 102.93 51.637 102.98 c 51.395 103.023 51.129 103.09
50.84 103.184 c 50.84 102.496 l 51.129 102.414 51.402 102.355 51.652 102.324
c 51.91 102.285 52.156 102.262 52.387 102.262 c 52.969 102.262 53.426 102.398
53.762 102.668 c 54.105 102.93 54.277 103.285 54.277 103.73 c 54.277 104.043
54.184 104.309 53.996 104.527 c 53.816 104.746 53.563 104.898 53.23 104.98
c h
53.23 104.98 m f
93.707 97.875 m 92.098 102.219 l 95.316 102.219 l h
93.035 96.703 m 94.379 96.703 l 97.707 105.453 l 96.473 105.453 l 95.676
103.203 l 91.738 103.203 l 90.941 105.453 l 89.691 105.453 l h
93.035 96.703 m f
100.754 102.836 m 98.801 105.867 l 100.754 105.867 l h
100.551 102.164 m 101.52 102.164 l 101.52 105.867 l 102.316 105.867 l 102.316
106.508 l 101.52 106.508 l 101.52 107.852 l 100.754 107.852 l 100.754 106.508
l 98.176 106.508 l 98.176 105.773 l h
100.551 102.164 m f
27.949 77.395 m 27.949 80.301 l 27.043 80.301 l 27.043 72.754 l 27.949
72.754 l 27.949 73.582 l 28.137 73.262 28.371 73.02 28.652 72.863 c 28.941
72.707 29.293 72.629 29.699 72.629 c 30.363 72.629 30.902 72.895 31.309
73.426 c 31.723 73.949 31.934 74.637 31.934 75.488 c 31.934 76.355 31.723
77.051 31.309 77.582 c 30.902 78.105 30.363 78.363 29.699 78.363 c 29.293
78.363 28.941 78.285 28.652 78.129 c 28.371 77.973 28.137 77.73 27.949
77.395 c h
31.012 75.488 m 31.012 74.832 30.871 74.316 30.59 73.941 c 30.316 73.566
29.949 73.379 29.48 73.379 c 29 73.379 28.625 73.566 28.355 73.941 c 28.082
74.316 27.949 74.832 27.949 75.488 c 27.949 76.156 28.082 76.676 28.355
77.051 c 28.625 77.426 29 77.613 29.48 77.613 c 29.949 77.613 30.316 77.426
30.59 77.051 c 30.871 76.676 31.012 76.156 31.012 75.488 c h
31.012 75.488 m f
35.578 70.629 m 35.148 71.379 34.828 72.125 34.609 72.863 c 34.398 73.594
34.297 74.332 34.297 75.082 c 34.297 75.832 34.398 76.578 34.609 77.316
c 34.828 78.059 35.148 78.793 35.578 79.535 c 34.797 79.535 l 34.316 78.773
33.953 78.027 33.703 77.285 c 33.461 76.547 33.344 75.813 33.344 75.082
c 33.344 74.355 33.461 73.625 33.703 72.895 c 33.941 72.156 34.305 71.402
34.797 70.629 c h
35.578 70.629 m f
41.875 72.754 m 39.906 75.41 l 41.984 78.223 l 40.922 78.223 l 39.328 76.066
l 37.734 78.223 l 36.672 78.223 l 38.797 75.363 l 36.859 72.754 l 37.922
72.754 l 39.375 74.707 l 40.813 72.754 l h
41.875 72.754 m f
43.121 79.676 m 44.168 79.676 l 44.168 76.066 l 43.027 76.301 l 43.027
75.707 l 44.152 75.488 l 44.793 75.488 l 44.793 79.676 l 45.84 79.676 l
45.84 80.223 l 43.121 80.223 l h
43.121 79.676 m f
47.621 76.988 m 48.652 76.988 l 48.652 77.816 l 47.855 79.379 l 47.215
79.379 l 47.621 77.816 l h
47.621 76.988 m f
55.117 72.754 m 53.148 75.41 l 55.227 78.223 l 54.164 78.223 l 52.57 76.066
l 50.977 78.223 l 49.914 78.223 l 52.039 75.363 l 50.102 72.754 l 51.164
72.754 l 52.617 74.707 l 54.055 72.754 l h
55.117 72.754 m f
56.801 79.676 m 59.035 79.676 l 59.035 80.223 l 56.02 80.223 l 56.02 79.676
l 56.27 79.426 56.602 79.094 57.02 78.676 c 57.434 78.25 57.699 77.973
57.816 77.848 c 58.023 77.621 58.164 77.426 58.238 77.27 c 58.32 77.105
58.363 76.941 58.363 76.785 c 58.363 76.535 58.273 76.332 58.098 76.176
c 57.918 76.02 57.691 75.941 57.41 75.941 c 57.211 75.941 56.996 75.98 56.77
76.051 c 56.551 76.113 56.316 76.219 56.066 76.363 c 56.066 75.707 l 56.316
75.605 56.551 75.527 56.77 75.473 c 56.996 75.422 57.207 75.395 57.395
75.395 c 57.883 75.395 58.273 75.52 58.566 75.77 c 58.855 76.012 59.004
76.34 59.004 76.754 c 59.004 76.941 58.965 77.125 58.895 77.301 c 58.82
77.48 58.691 77.688 58.504 77.926 c 58.449 77.988 58.277 78.168 57.988 78.457
c 57.707 78.75 57.309 79.156 56.801 79.676 c h
56.801 79.676 m f
60.484 70.629 m 61.266 70.629 l 61.754 71.402 62.117 72.156 62.359 72.895
c 62.609 73.625 62.734 74.355 62.734 75.082 c 62.734 75.813 62.609 76.547
62.359 77.285 c 62.117 78.027 61.754 78.773 61.266 79.535 c 60.484 79.535
l 60.922 78.793 61.242 78.059 61.453 77.316 c 61.672 76.578 61.781 75.832
61.781 75.082 c 61.781 74.332 61.672 73.594 61.453 72.863 c 61.242 72.125
60.922 71.379 60.484 70.629 c h
60.484 70.629 m f
Q Q
showpage
%%Trailer
end
%%EOF

Binary file not shown.

View file

@ -1,5 +1,5 @@
\documentclass[10pt,a4paper,oneside]{book} \documentclass[10pt,a4paper,twoside]{book}
\usepackage[latin1]{inputenc} %\usepackage[latin1]{inputenc}
\usepackage{amsmath} \usepackage{amsmath}
\usepackage{amsfonts} \usepackage{amsfonts}
\usepackage{amssymb} \usepackage{amssymb}
@ -10,6 +10,7 @@
\usepackage[block=ragged,backend=bibtex]{biblatex} \usepackage[block=ragged,backend=bibtex]{biblatex}
\usepackage[acronym,toc,automake]{glossaries} \usepackage[acronym,toc,automake]{glossaries}
\usepackage[hidelinks]{hyperref} \usepackage[hidelinks]{hyperref}
\usepackage[version=4]{mhchem}
\hypersetup{ \hypersetup{
breaklinks = true, % Allows break links in lines breaklinks = true, % Allows break links in lines
colorlinks = true, % Colours links instead of ugly boxes colorlinks = true, % Colours links instead of ugly boxes
@ -21,16 +22,23 @@
Author = {Jorge Gonzalez} Author = {Jorge Gonzalez}
} }
} }
\usepackage[margin=1in]{geometry} % Reduces margins of the document
% Allows breaking of URL in bibliography.
\setcounter{biburllcpenalty}{7000}
\setcounter{biburlucpenalty}{8000}
\makeglossaries \makeglossaries
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newacronym{fpakc}{fpakc}{Finite element PArticle Code}
\newacronym{fpakc}{fpakc}{Finite Element PArticle Code}
\newacronym{mpi}{MPI}{Message Passing Interface} \newacronym{mpi}{MPI}{Message Passing Interface}
\newacronym{gpu}{GPU}{Graphics Processing Unit} \newacronym{gpu}{GPU}{Graphics Processing Unit}
\newacronym{cpu}{CPU}{Central Processing Unit} \newacronym{cpu}{CPU}{Central Processing Unit}
\newacronym{json}{JSON}{JavaScript Object Notation} \newacronym{json}{JSON}{JavaScript Object Notation}
\newacronym{io}{I/O}{input/output} \newacronym{io}{I/O}{input/output}
\newacronym{mcc}{MCC}{Monte-Carlo Collisions}
\newacronym{cs}{CS}{Coulomb Scattering}
\newacronym{vtu}{VTU}{Visualization Toolkit for unstructured grids}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newglossaryentry{openmp}{name={OpenMP},description={Shared-memory parallelization}} \newglossaryentry{openmp}{name={OpenMP},description={Shared-memory parallelization}}
@ -41,6 +49,7 @@
\newglossaryentry{git}{name={Git},description={Git is a distributed version-control system for tracking changes in a set of files}} \newglossaryentry{git}{name={Git},description={Git is a distributed version-control system for tracking changes in a set of files}}
\newglossaryentry{gitlab}{name={GitLab},description={GitLab is a web-based lifecycle tool that provides a \Gls{git}-repository manager}} \newglossaryentry{gitlab}{name={GitLab},description={GitLab is a web-based lifecycle tool that provides a \Gls{git}-repository manager}}
\newglossaryentry{gmsh}{name={Gmsh},description={A three-dimensional finite element mesh generator with built-in pre- and post-processing facilities.}} \newglossaryentry{gmsh}{name={Gmsh},description={A three-dimensional finite element mesh generator with built-in pre- and post-processing facilities.}}
\newglossaryentry{gnuplot}{name={Gnuplot},description={A portable command-line driven graphing utility for Linux, OS/2, MS Windows, OSX, VMS, and many other platforms.}}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\bibliography{bibliography} \bibliography{bibliography}
@ -60,8 +69,10 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Introduction} \chapter{Introduction}
\section{About fpakc} \section{About fpakc}
The \Gls{fpakc} is a simulation tool that models species in plasmas (ions, electrons and neutrals) following the trajectories of macro-particles as they move and interact between them and the boundaries of the domain. The \Gls{fpakc} is a simulation tool that models species in plasma (ions, electrons and neutrals) following the trajectories of macro-particles as they move and interact between them and the boundaries of the domain.
The code is currently in very early steps of development and further improvements are expected very soon. Particles properties are scattered into a finite element mesh in 1, 2 or three dimensions, with the possibility to choose different geometries.
The official repository can be found at: \url{https://gitlab.com/JorgeGonz/fpakc.git}.
The code is currently in the very early steps of development and further refinements are expected very soon.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Main Guidelines} \section{Main Guidelines}
@ -75,14 +86,14 @@
\item \acrshort{fpakc} is coded in a \textit{understandable} way. \item \acrshort{fpakc} is coded in a \textit{understandable} way.
This means that the code is required to be written in a clear way that is easy to understand and maintain. This means that the code is required to be written in a clear way that is easy to understand and maintain.
Variables and procedure names need to be self-understanding. Variables and procedure names need to be self-understanding.
This ease the process of fixing bugs and improving the codes by a large team of developers. This eases the process of fixing bugs and improving the codes by a large team of developers.
For more information, please refer to the \acrshort{fpakc} Coding Style document. For more information, please refer to the \acrshort{fpakc} Coding Style document.
\item \acrshort{fpakc} requires to be ease to use. \item \acrshort{fpakc} requires being ease to use.
Input files are required to be in a \textit{human} format, meaning that the different options can be easily understander without constant reference to the user guide. Input files are required to be in a \textit{human} format, meaning that the different options can be easily understood without constant reference to the user guide.
\acrshort{fpakc} is aimed to be used in a wide range of applications and by a variety of scientist: from very established ones to newcomers to the field and students. \acrshort{fpakc} is aimed to be used in a wide range of applications and by various scientists: from well-established ones to newcomers to the field and also students.
\end{enumerate} \end{enumerate}
These are foundation stones of the code and code development and should always be followed, at least for the releases in the official repository. These are foundation stones of \acrshort{fpakc} and its development and should always be followed, at least for the releases in the official repository.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{How to collaborate} \section{How to collaborate}
@ -92,22 +103,32 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Operation Scheme} \chapter{Operation Scheme}
\section{The Particle Method} \section{The Particle Method}
\acrshort{fpakc} uses macro-particles to simulate the dynamics of different plasma species (mainly ions, electrons and neutrals). \Gls{fpakc} uses macro-particles to simulate the dynamics of different plasma species (mainly ions, electrons and neutrals).
These macro-particles represent a large amount of real particles. These macro-particles could represent a large amount of real particles.
For now own, macro-particles will be referred as just particles by abusing of language. For now own, macro-particles will be referred as just particles by abuse of language.
In the evolution of these particles, external forces (as the electromagnetic field), interaction between particles (as collisions) and interaction with the boundaries of the domain are included. During the initiation phase, the input and mesh file(s) are reading.
If an initial distribution for a species is specified in the input file, particles to match that distribution are loaded into the cells.
At each time step, particles are first pushed accounting for possible acceleration by external forces. The general steps performed in each iteration are:
Then, the cell in which the particle ends up is located. \begin{enumerate}
If a boundary is encountered, the interaction between the particle and the boundary is calculated. \item Firstly, new particles are introduced into the domain as specified in the input file.
Next, collisions for the particles in each cell are carried on. \item Particles are then pushed, accounting for possible acceleration by external forces.
During this process, if a particle changes cell, it is found using the connectivity between elements.
If a particle encounters a boundary instead a new cell, the interaction between the boundary and the wall are computed.
A particle may abandon the computational domain and is no longer accounted for.
\item Next, collisions for the particles inside each cell are carried out.
This may include different collision processes for each particle. This may include different collision processes for each particle.
Finally, the particles properties are scattered into the mesh nodes. Monte-Carlo collisions (elastic, ionization, charge-exchange$\ldots$) can be carried out in a specific mesh, to better adjust to the cell size required, similar to the mean-free path.
Although not yet implemented, Coulomb scattering will always be performed in the mesh used for scattering, which cell size should be in the order of the Debye length.
\item A new array containing all particles inside the numerical domain is obtained.
\item Finally, particle properties are scattered among the mesh nodes.
These properties are density, momentum and the stress tensor. These properties are density, momentum and the stress tensor.
Non-dimensional units are used for this, but output files are converted into dimensional units. \item If requested, the electromagnetic field is computed.
If requested, the electromagnetic field is computed. \item If the number of iteration requires writing output files, it is done after all steps for the particles are completed.
\end{enumerate}
More in depth explanation of the different steps are given in the following sections. \Gls{fpakc} has the capability to configure all the behaviour of the simulation via the input file.
Parameters as injection, the kind of pusher used for each species, boundary conditions or collisions are user-input parameters and will be described in Chap.~\ref{ch:input_file}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Injection of new particles} \section{Injection of new particles}
@ -122,100 +143,150 @@
Particles are pushed in the selected domain. Particles are pushed in the selected domain.
Velocity and position are updated according to the old particle values and the external forces. Velocity and position are updated according to the old particle values and the external forces.
All the push routines for the different geometries can be found in \lstinline|moduleSolver|. All the push routines for the different geometries can be found in \lstinline|moduleSolver|.
The pushers included in \Gls{fpakc} are:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \begin{itemize}
\subsection{2D Cylindrical} \item 3D Cartesian pusher.
Moving particles in a simple 3D Cartesian space.
\item 2D Cylindrical.
When a 2D cylindrical geometry is used ($z$, $r$), a Boris solver\cite{boris1970relativistic} is used to move particles accounting for the effect of the symmetry axis. When a 2D cylindrical geometry is used ($z$, $r$), a Boris solver\cite{boris1970relativistic} is used to move particles accounting for the effect of the symmetry axis.
This pusher removes the issue with particles going to infinite velocity when $r \rightarrow 0$ by pushing the particles in Cartesian space and then converting it to $r-z$ geometry. This pusher removes the issue with particles going to infinite velocity when $r \rightarrow 0$ by pushing the particles in Cartesian space and then converting it to $r-z$ geometry.
Velocity in the $\theta$ direction is updated for collision processes, although the dynamic in the angular direction is assumed as symmetric. Velocity in the $\theta$ direction is updated for collision processes, although the dynamic in the angular direction is assumed as symmetric.
Cross-sections are read from files. \item 2D Cartesian pusher.
These files contains two columns: one for the relative energy (in $\unit{eV}$) and another one for the cross-section (in $\unit{m^{-2}}$). Moving particles in a simple 2D Cartesian space.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \item 1D Radial pusher.
\subsection{1D Cartesian pusher} Same implementation as 2D cylindrical pusher but direction $z$ is ignored.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \item 1D Cartesian pusher.
\subsection{1D Radial pusher} Moving particles in a simple 1D Cartesian space. Same implementation as in 2D Cartesian but $y$ direction is ignored.
\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Find new cell} \section{Find new cell}
Once the position and velocity of the particle are updated, the new cell that contains the particle is searched. Once the position and velocity of the particle are updated, the new cell that contains the particle is searched.
This is done by a neighbor search, starting from the previous cell containing the particle. This is done by a neighbour search, starting from the previous cell containing the particle.
In the process of finding the new cell, it is possible that a particle encounters a boundary. In the process of finding the new cell, a particle might encounter a boundary.
When the particle interacts with the boundary, the particle may continue its life in the simulation (reflected) or might be eliminated from it (absorbed). When the particle interacts with the boundary, the particle may continue its life in the simulation or might be eliminated from it.
Once that the new cell is found or that the particle life has been terminated, the pushing is complete. Once that the new cell is found or that the particle life has been terminated, the pushing is complete.
If a secondary mesh is used for the Monte-Carlo Collision method, the new cell in that mesh in which the particle reside is also found by the same method, although no interaction with the boundaries is accounted for this step.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Variable Weighting Scheme\label{sec:weightingScheme}} \section{Variable Weighting Scheme\label{sec:weightingScheme}}
One of the issues in particle simulations, specially for axisymmetrical cases, is that due to the disparate volume of cells, specially close to the axis, the statistics in some cells is usually poor. One of the issues in particle simulations, specially for axial-symmetrical cases, is that due to the disparate volume of cells, specially close to the axis, the statistics in some cells is usually poor.
To try to fix that, the possibility to include a Variable Weighting Scheme in the simulations is available in \Gls{fpakc}. To try to fix that, the possibility to include a Variable Weighting Scheme in the simulations is available in \Gls{fpakc}.
This schemes detect when a particle change cells and modify its weight accordingly. These schemes detect when a particle changes cells and split it if necessary to improve statistics.
To avoid particles having a larger weight than the rest, particle can be split in multiple particles if weight become too large. The use of a Variable Weighting Scheme is defined by the user in the input file.
Beware that this can increase the number of particles in the simulation and increase computational time.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Interaction between species}\label{ssec:collisions}
For each cell, interaction among the particles in it are carried out.
\Gls{fpakc} distinguish between two types of interactions: \acrfull{mcc} and \acrfull{cs}.
\acrshort{mcc} refers to the process in which two particles interact in short range.
These processes include, but are not limited to: elastic collisions, ionization/recombination, charge-exchange, excitation/de-excitation\ldots
A secondary mesh, with cell sizes in the range of the mean-free path, can be used for this type of collision.
\acrshort{cs} refers to the large range interaction that a charged species suffer do to the charge of other particles.
The interactions between the different species is defined by the user.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{\acrlong{mcc}}
For each cell, the maximum number of collisions between particle is computed.
For each collision, a random pair of particles is chosen.
A loop over all possible collisions for the pair of particles chosen is performed.
If a random number is above the probability of collision for that specific type, the collision takes place.
If not, the next type for the particle pair is checked.
Below are described the type of collision process implemented in \acrshort{fpakc}:
\begin{itemize}
\item Elastic.
In this type of collision, particles exchange energy due to hard-sphere model.
Total energy is conserved.
Resulting velocity directions are chosen from Maxwellian distribution functions.
This interaction is useful for short-range collisions as neutral-neutral and charged-neutral elastic collisions.
\item Charge Exchange.
When an ion interacts with a neutral particle, an electron is exchanged between the two particles with no exchange of energy.
This is called a resonant charge-exchange.
\item Electron Impact Ionization.
When the relative energy between a neutral and an electron is above the ionization threshold, there is a probability that the neutral particle will become ionized.
This ionization emits and additional electron
\item Recombination.
When an electron and an ion interact, there is a possibility for them to be recombined into a neutral particle.
The photons emitted by this process are not modelled yet.
\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{\acrlong{cs}}
A simple linearization of the Coulomb operator based on Ref.~\cite{sherlock2008monte} is implemented.
This method assumes that the species involved in the scattering process have a Maxwellian distribution.
The method is made to conserve momentum and kinetic energy based on the approach in Ref.~\cite{lemons2009small} for self (same species) and intra (different species) collisions.
The user must specify the charged species that will interact together.
The Coulomb logarithm involved in these processes is currently set to a fix value of $10$.
This method is not valid for situations in which the distribution functions are far from Maxwellian.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Reset of particle array} \section{Reset of particle array}
Once that the pushing is complete, the array of particles that remain inside the domain is copied to a new array. Once that the pushing is complete, the array of particles that remain inside the domain is copied to a new array.
The new array containing only the particles inside the domain will be the one used in the next steps. The new array containing only the particles inside the domain will be the one used in the next steps.
In this section, particles are assigned to the list of particles inside each individual cell. In this section, particles are assigned to the list of particles inside each individual cell.
Unfortunately, this is done right now without parallelisation and is very CPU consuming. Unfortunately, this is done right now without parallelization and is very CPU consuming.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Interaction between species}\label{ssec:collisions} \section{Probing}\label{sec:probing}
For each cell, interaction among the particles in it are carried out. As default, \gls{fpakc} outputs information of macroscopic quantities (density, velocity, temperature\ldots) in the finite element mesh.
The type of interaction between the different particles is defined by the user. However, a lot of information can be extracted from the particle distribution function.
In general, the maximum number of interaction in a cell is computed. Thus, a probing method is provided to extract the distribution function in a specific position.
For each collision, a pair of particles is selected.
A loop over all possible collisions for the pair of particles is performed.
If a random number generated is above the probability of collision for the type divided by the maximum one, the collision take place.
Collisions can change the velocity of the particles involved (elastic), create new particles (ionization-recombination) or change the type of particle (charge-exchange). The particles inside a cell in which the input position is located are distributed into a 3D velocity grid.
The user can decide the grid width and the number of points in each direction.
The distribution function will be calculated and wrote with a time step decided by the user.
Below are described the type of collision process implemented between species. If a particle velocity resides outside the velocity grid (in any direction), it will not be added to the tally of the distribution function.
Due to the limitation of only considering particles in the cell, and not neighbour particles, two probes for the same species at different positions but in the same cell will output the same results.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% A more advance method considering distance between the particles and the probe position as well as particles in neighbour cells could be implemented to improve the statistics of the distribution function.
\subsection{Elastic collision}
In this type of collision, particles exchange energy due to hard-sphere model.
Total energy is conserved.
Resulting velocity directions are chosen from Maxwellian distribution functions.
This interaction is useful for short-range collisions as neutral-neutral and charged-neutral elastic collisions.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Charge Exchange}
When an ion interacts with a neutral particle, an electron is exchanged between the two particles with no exchange of energy.
This is called a resonant charge-exchange.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Electron Impact Ionization}
When the relative energy between a neutral and an electron is above the ionization threshold, there is a probability that the neutral particle will become ionized.
This ionization emits and additional electron
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Recombination}
When an electron and an ion interact, there is a possibility for them to be recombined into a neutral particle.
The photon emitted by this process is not modeled yet.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Scattering} \section{Scattering}
The properties of each particle are deposited in the nodes from the containing cell. The properties of each particle are deposited in the nodes from the containing cell.
This process depend on the cell type, but in general, each node receive a proportional part of the particle properties as a function of the particle position inside the cell. This process depends on the cell type, but in general, each node receives a proportional part of the particle properties as a function of the particle position inside the cell.
Figure \ref{fig:scatteringQuad} shows how a particle at a generic position $p(x_1, x_2)$ inside the cell is scattered to the four nodes. The figure \ref{fig:scatteringQuad} shows how a particle at a generic position $p(x_1, x_2)$ inside the cell is scattered to the four nodes.
\begin{wrapfigure}{l}{0.4\textwidth} \begin{wrapfigure}{l}{0.4\textwidth}
\centering \centering
\includegraphics{figures/scatteringQuad} \includegraphics{figures/scatteringQuad}
\caption{\label{fig:scatteringQuad}Example of how a particle is weighted in a quadrilateral cell.} \caption{\label{fig:scatteringQuad}Example of how a particle is weighted in a quadrilateral cell.}
\end{wrapfigure} \end{wrapfigure}
Each node receives a proportional part of the area formed by dividing the cell in for rectangles using as an additional vertex the particle position. Each node receives a proportional part of the area formed by dividing the cell in for rectangles, using as an additional vertex the particle position.
These properties are dimensionless, but they are converted to the correct units once the output is printed. These properties are dimensionless, but they are converted to the correct units once the output is printed.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Electromagnetic field} \section{Electromagnetic field}
WIP. WIP.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Average scheme}
Particle-in-cell codes have an intrinsic statistical noise associated with them.
Although this can be reduced by increasing the number of particles, this also increases the CPU requirements of the case.
It is quite common that most cases reach a quasi-steady state after a number of iterations and time-average results can be obtained after to improve analysis, plotting and restarting the case using these time-average results as new species backgrounds.
Although this is possible to do once the simulation is finished with post-processing tools, this is limited to the number of iterations printed.
\Gls{fpakc} implements a simple average scheme that, after a start time provided by the user, scores a mean and standard deviation of all the main species properties, and the electromagnetic field.
This scheme is based on the Welford's online algorithm~\cite{welford1962note}.
The averaged data is written in the same format as the input mesh at the end of the simulation.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Installation} \chapter{Installation}
\section{Required Packages} \section{Required Packages}
In order to properly compile \gls{fpakc}, the following packages are required. To properly compile \gls{fpakc}, the following packages are required.
\subsection{Gfortran} \subsection{Gfortran}
The \Gls{opensource} free compiler \Gls{gfortran}\cite{gfortranURL} from GCC is the basic way to compile \acrshort{fpakc}. The \Gls{opensource} free compiler \Gls{gfortran}\cite{gfortranURL} from GCC is the basic way to compile \acrshort{fpakc}.
It is distributed with all GNU/Linux distributions. It is distributed with all GNU/Linux distributions.
@ -239,7 +310,7 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Gmsh} \subsection{Gmsh}
Although \Gls{gmsh}\cite{gmshURL} is not required to compile and run \Gls{fpakc}, it is the default tool to generate finite element meshes and post-processing. Although \Gls{gmsh}\cite{gmshURL} is not required to compile and run \Gls{fpakc}, it is the default tool to generate finite element meshes and post-processing.
Right now, the only \acrshort{io} format available in \Gls{fpakc} is the v2.0 .msh format. Right now, the only \acrshort{io} format available in \Gls{fpakc} is the v2.0 \lstinline|.msh| format.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Installation steps} \section{Installation steps}
@ -274,7 +345,6 @@ make
\end{lstlisting} \end{lstlisting}
to compile the code. to compile the code.
If everything is correct, an executable named \textit{fpakc} will be generated. If everything is correct, an executable named \textit{fpakc} will be generated.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Running the code} \section{Running the code}
To run a case, simply execute: To run a case, simply execute:
@ -293,13 +363,13 @@ make
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Mesh file} \section{Mesh file}
\Gls{fpakc} accepts right now the version 2.0 of \Gls{gmsh} mesh format .msh in ASCII format. \Gls{fpakc} accepts right now the version 2.0 of \Gls{gmsh} mesh format \lstinline|.msh| in ASCII format.
This file contains information about the nodes, edges and volumes that define the finite element mesh used by \Gls{fpakc} to scatter particle properties and compute the self-consistent electromagnetic field. This file contains information about the nodes, edges and volumes that define the finite element mesh used by \Gls{fpakc} to scatter particle properties and compute the self-consistent electromagnetic field.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Case file} \section{Case file}
The required format for the case file is \Gls{json}. The required format for the case file is \Gls{json}.
\Gls{json} is a case-sensitive format, so input must be written with the correct capitalisation. \Gls{json} is a case-sensitive format, so input must be written with the correct capitalization.
The basic structure and options available for the case file are explained below. The basic structure and options available for the case file are explained below.
The order of the objects and variables is irrelevant, but the structure needs to be maintained. The order of the objects and variables is irrelevant, but the structure needs to be maintained.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -309,6 +379,10 @@ make
\begin{itemize} \begin{itemize}
\item \textbf{path}: Character. \item \textbf{path}: Character.
Path for the output files. This path is also used to locate the mesh input file. Path for the output files. This path is also used to locate the mesh input file.
\item \textbf{folder}: Character.
Base name of the folder in which output files are placed.
The date and time is appended to this name.
If none is provided, only the date and time is written as the folder name.
\item \textbf{triggerOutput}: Integer. \item \textbf{triggerOutput}: Integer.
Determines the number of iterations between writing output files for macroscopic quantities. Determines the number of iterations between writing output files for macroscopic quantities.
\item \textbf{cpuTime}: Logical. \item \textbf{cpuTime}: Logical.
@ -323,6 +397,30 @@ make
Trigger between writings is the same as in \textbf{triggerOutput}. Trigger between writings is the same as in \textbf{triggerOutput}.
\item \textbf{EMField}: Logical. \item \textbf{EMField}: Logical.
Determines if the electromagnetic field is printed. Determines if the electromagnetic field is printed.
\item \textbf{probes}: Array of objects.
Defines the probes employed for obtaining the distribution function at specific positions.
See Sec.~\ref{sec:probing} for more information.
The object is structured as follows:
\begin{itemize}
\item \textbf{species}: Character.
Species name as defined in \textbf{species} array.
\item \textbf{position}: Real.
Array of dimension $3$.
Units in $\unit{m}$.
Indicates the position of the probing.
\item \textbf{timeStep}: Real
Units in $\unit{s}$.
Optional.
Time step for output of the distribution function.
If none is provided, the minimum time step of the case is used.
\item \textbf{velocity\_1, velocity\_2, velocity\_3}: Real.
Array of dimension $2$.
Velocity range (minimum-maximum) in which the distribution function will be interpolated.
The subscripts 1, 2, 3 indicate the three directions of the case.
\item \textbf{points}: Integer.
Array of dimension $3$.
Number of points in each direction.
\end{itemize}
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -330,23 +428,50 @@ make
The object \textbf{geometry} contains information about the type of geometry, the mesh file format and the mesh filename. The object \textbf{geometry} contains information about the type of geometry, the mesh file format and the mesh filename.
The accepted parameters are: The accepted parameters are:
\begin{itemize} \begin{itemize}
\item \textbf{dimension}: Integer.
Number of spatial dimensions of the geometry.
Current values are: $0$, $1$, $2$ or $3$.
Zero dimension is a fictitious volume.
Geometry used mostly to test collisional effects.
No boundary or EM field is solved.
No injection can be implemented.
Initial state must be read from file.
No mesh file is required.
The optional argument \textbf{geometry.volume} can be used to set a value for the fictitious volume.
Otherwise, the volume is set to 1 in non-dimensional units.
\item \textbf{type}: Character. \item \textbf{type}: Character.
Type of geometry. Type of geometry.
Current accepted vaules are Current accepted vaules are
\begin{itemize} \begin{itemize}
\item \textbf{2DCyl}: Two-dimensional grid (z-r) with symmetry axis at $r = 0$. \item \textbf{Cart}: Cartesian coordinates.
For \Gls{gmsh} mesh format, the coordinates $x$ and $y$ correspond to $z$ and $r$ respectively. Available for \textbf{geometry.dimension} $1$, $2$ and $3$.
\item \textbf{1DCart}: One-dimensional grid (x) in Cartesian coordinates The coordinates $x$, $y$ and $z$ correspond to $x$, $y$ and $z$ respectively.
For \Gls{gmsh} mesh format, the coordinates $x$ corresponds to $x$. \item \textbf{Cyl}: Cylindrical coordinates ($z \hyphen r$) with symmetry axis at $r = 0$.
\item \textbf{1DRad}: One-dimensional grid (r) in radial coordinates Only available for \textbf{geometry.dimension} $2$.
For \Gls{gmsh} mesh format, the coordinates $x$ corresponds to $r$. The coordinates $x$ and $y$ correspond to $z$ and $r$ respectively.
\item \textbf{Rad}: One-dimensional radial space ($r$).
Only available for \textbf{geometry.dimension} $1$.
The coordinates $x$ corresponds to $r$.
\end{itemize} \end{itemize}
\item \textbf{meshType}: Character. \item \textbf{meshType}: Character.
Format of mesh file. Format of mesh file.
Currently, only the value \textbf{gmsh} is accepted, which makes reference to \Gls{gmsh} v2.0 output format. The output will be written in the same format as specified here.
Accepted formats are:
\begin{itemize}
\item \textbf{gmsh2}: \Gls{gmsh} file format in version 2.0. This has to be in ASCII format.
\item \textbf{vtu}: \Gls{vtu} file format. This has to be in ASCII format.
\item \textbf{text}: Plain text file format only intended for 1D cases.
This has to be in ASCII format and comma separated.
The first column represents the position and the second column the physical ID of the node.
Values have to be $1$ (left boundary), $2$ (right boundary), or $0$ (no boundary.)
\end{itemize}
\item \textbf{meshFile}: Character. \item \textbf{meshFile}: Character.
Mesh filename. Mesh filename.
This file is searched in the path \textbf{output.path} and must contain the file extension. This file is searched in the path \textbf{output.path} and must contain the file extension.
\item \textbf{volume}: Real.
Units of $\unit{m^{-3}}$.
Used to set a fictitious volume for the $0$ dimension.
Ignored in the other cases.
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -384,19 +509,72 @@ make
\begin{itemize} \begin{itemize}
\item \textbf{name}: Character. \item \textbf{name}: Character.
Name of the boundary. Name of the boundary.
\item \textbf{type}: Character. \item \textbf{physicalSurface}: Integer.
Type of boundary. Identification of the surface in the mesh file.
Accepted values are: \item \textbf{bType}: Array of objects of dimension 'number of species'.
Per each species defined in the case, a boundary \textbf{type} needs to be provided.
Accepted values for \textbf{type} are:
\begin{itemize} \begin{itemize}
\item \textbf{reflection}: Elastic reflection of particles. \item \textbf{reflection}: Elastic reflection of particles.
\item \textbf{absorption}: Particle is eliminated from the domain. \item \textbf{absorption}: Particle is eliminated from the domain.
The particle is first moved into the edge and its properties are scattered among the edge nodes. The particle is first moved into the edge and its properties are scattered among the edge nodes.
\item \textbf{transparent}: Particle abandon the numerical domain. \item \textbf{transparent}: Particle abandon the numerical domain.
\item \textbf{axis}: Identifies the symmetry axis for 2D cylindrical simulations. \item \textbf{wallTemperature}: Reflective wall with constant temperature that exchange heat with particles.
It has no actual function. Required parameters are:
\begin{itemize}
\item \textbf{temperature}: Real.
Units of $\unit{K}$.
Temperature wall.
\item \textbf{specificHeat}: Real.
Units of $\unit{J kg^{-1} K^{-1}}$.
Specific heat capacity of the material.
\end{itemize}
\item \textbf{ionization}: Per each particle crossing the surface with this type of boundary, a number of ionization events are calculated.
A pair of ion-electron is generated for each ionization event, taking as a reference a neutral background.
The secondary electron is taken as the same type as the incident particle.
The available input is:
\begin{itemize}
\item \textbf{neutral}: Object.
Information about the neutral background.
Required parameters are:
\begin{itemize}
\item \textbf{ion}: Character.
Species name of the ion generated as defined in object \textbf{species}.
Required parameter.
\item \textbf{mass}: Real.
Units in $\unit{kg}$.
Mass of neutral species.
If missing, the mass of the ion is used
\item \textbf{density}: Real.
Units in $\unit{m^{-3}}$.
Density of neutral background.
Required parameter.
\item \textbf{velocity}: Real.
Units in $\unit{m s^{-1}}$.
Array of dimension $3$.
Mean velocity of neutral background.
Required parameter.
\item \textbf{temperature}: Real.
Units in $\unit{K}$.
Temperature of neutral background.
Required parameter.
\end{itemize}
\item \textbf{effectiveTime}: Real.
Units in $\unit{s}$.
As the particle is no longer simulated once it crossed the boundary, this time represents the effective time in which the particle produces ionization processes in the neutral background.
Required parameter.
\item \textbf{energyThreashold}: Real.
Units in $\unit{eV}$.
Ionization energy threshold for the simulated process.
Required parameter.
\item \textbf{crossSection}: Character.
Complete path to the cross-section data for the ionization process.
\end{itemize}
\item \textbf{axis}: Identifies the symmetry axis for 2D cylindrical simulations.
If , for some reason, a particle interacts with this axis, it is reflected.
\end{itemize} \end{itemize}
\item \textbf{physicalSurface}: Integer.
Identification of the edge in the mesh file.
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -411,18 +589,26 @@ make
Type of boundary. Type of boundary.
Accepted values are: Accepted values are:
\begin{itemize} \begin{itemize}
\item \textbf{dirichlet}: Elastic reflection of particles. \item \textbf{dirichlet}: Constant value of electric potential on the surface.
\item \textbf{dirichletTime}: Constant value of the electric potential with a time variable profile.
The value of \textbf{boundaryEM.potential} will be multiplied for the corresponding value in the file \textbf{boundaryEM.temporalProfile}.
\end{itemize} \end{itemize}
\item \textbf{potential}: Real. \item \textbf{potential}: Real.
Fixed potential for Dirichlet boundary condition. Fixed potential for Dirichlet boundary condition.
\item \textbf{physicalSurface}: Integer. \item \textbf{physicalSurface}: Integer.
Identification of the edge in the mesh file. Identification of the edge in the mesh file.
\item \textbf{temporalProfile}: Character.
Filename of the 2 column file containing the time variable profile.
File must be located in \textbf{output.path}.
The first column is the time in $\unit{s}$.
The second column is the factor that will multiply the value of the boundary.
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{inject} \subsection{inject}
The array \textbf{inject} specifies the injection of particles from different surfaces. The array \textbf{inject} specifies the injection of particles from different surfaces.
The injection of particles need to be associated to a physicalSurface in the mesh file. The injection of particles needs to be associated to a physicalSurface in the mesh file.
Multiple injections can be associated to the same surface. Multiple injections can be associated to the same surface.
\begin{itemize} \begin{itemize}
\item \textbf{name}: Character. \item \textbf{name}: Character.
@ -436,26 +622,39 @@ make
Available values are: Available values are:
\begin{itemize} \begin{itemize}
\item \textbf{A}: Ampere. \item \textbf{A}: Ampere.
\item \textbf{sccm}: Standard cubic centimeter. \item \textbf{Am2}: Ampere per square meter.
This value will be multiplied by the area of injection.
\item \textbf{sccm}: Standard cubic centimetre.
\item \textbf{part/s}: Particles (real) per second.
\end{itemize} \end{itemize}
\item \textbf{v}: Real. \item \textbf{v}: Real.
Module of velocity vector, in $\unitfrac{m}{s}$. Units of $\unit{m s^{-1}}$.
Module of velocity vector.
\item \textbf{n}: Real. \item \textbf{n}: Real.
Array dimension $3$. Array dimension $3$.
Direction of injection. Direction of injection.
Norm of vector must be equal $1$. If no value is provided, the normal of the edge is used as the direction of injection.
This vector is normalized to $1$ by the code.
\item \textbf{velDist}: Character. \item \textbf{velDist}: Character.
Array dimension $3$. Array dimension $3$.
Type of distribution function used to obtain injected particle velocity: Type of distribution function used to obtain injected particle velocity:
\begin{itemize} \begin{itemize}
\item \textbf{Maxwellian}: Maxwellian distribution of temperature \textbf{T} and mean \textbf{v} times the value of \textbf{n} in the specified direction. \item \textbf{Maxwellian}: Maxwellian distribution of temperature \textbf{T} and mean \textbf{v} times the value of \textbf{n} in the specified direction.
\item \textbf{Half-Maxwellian}: Half-Maxwellian distribution of temperature \textbf{T} and mean \textbf{v} times the value of \textbf{n} in the specified direction.
Only considers the positive part of the half-Maxwellian.
\item \textbf{Delta}: Dirac's delta distribution function. All particles are injected with velocity \textbf{v} times the value of \textbf{n} in the specified direction. \item \textbf{Delta}: Dirac's delta distribution function. All particles are injected with velocity \textbf{v} times the value of \textbf{n} in the specified direction.
\end{itemize} \end{itemize}
\item \textbf{T}: Real. \item \textbf{T}: Real.
Units of $\unit{K}$
Array dimension $3$. Array dimension $3$.
Temperature in each direction. Temperature in each direction.
\item \textbf{physicalSurface}: Integer. \item \textbf{physicalSurface}: Integer.
Identification of the edge in the mesh file. Identification of the edge in the mesh file.
\item \textbf{particlesPerEdge}: Integer.
Optional.
Number of particles to be injected by each edge in the numerical domain.
The weight of the particles for each edge will modified by the surface of the edge to ensure the right flux is injected.
If no value is provided, the number of particles to inject per edge will be calculated with the species weight and the surface of the edge respect to the total one.
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{reference} \subsection{reference}
@ -471,29 +670,34 @@ make
\item \textbf{radius}: Real. \item \textbf{radius}: Real.
Reference atomic radius in $\unit{m}$. Reference atomic radius in $\unit{m}$.
\item \textbf{crossSection}: Real. \item \textbf{crossSection}: Real.
Reference cross section in $\unit{m^2}$. Reference cross-section in $\unit{m^2}$.
If this value is present, radius is ignored. If this value is present, radius is ignored.
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{case} \subsection{solver}
This object determines the simulation time, time step, pushers, weighting scheme and solver for the electromagnetic field. This object determines the input parameters for the solvers used in the case, both for particle pushers and electromagnetic field.
Accepted variables are: Accepted variables are:
\begin{itemize} \begin{itemize}
\item \textbf{tau}: Real. \item \textbf{tau}: Real.
Units of $\unit{s}$.
Array dimension 'number of species'. Array dimension 'number of species'.
Defines the different time steps for each species. Defines the different time steps for each species.
Even if all time steps are equal, they need to be defined as an array. Even if all time steps are equal, they need to be defined as an array.
\item \textbf{time}: Real. \item \textbf{finalTime}: Real.
Total simulation time in $\unit{s}$. Units of $\unit{s}$.
Final simulation time.
\item \textbf{initialTime}: Real.
Units of $\unit{s}$.
Initial simulation time.
If no value is provided, the initial time is set to $\unit[0.0]{s}$.
\item \textbf{pusher}: Character. \item \textbf{pusher}: Character.
Array dimension 'number of species'. Array dimension 'number of species'.
Indicates the type of pusher used for each species: Indicates the type of pusher used for each species:
\begin{itemize} \begin{itemize}
\item \textbf{2DCylNeutral}: Pushes particles in a 2D z-r space without any external force. \item \textbf{Neutral}: Pushes a particle without any external force.
\item \textbf{2DCylCharged}: Pushes particles in a 2D z-r space including the effect of the electrostatic field. \item \textbf{Electrostatic}: Pushes a particle, including the effect of the electrostatic field.
\item \textbf{1DCartCharged}: Pushes particles in a 1D Cartesian space accounting the the electrostatic field. \item \textbf{Electromagnetic}: Pushes a particle, accounting for the electromagnetic field.
\item \textbf{1DRadCharged}: Pushes particles in a 1D cylindrical space (r) accounting the the electrostatic field.
\end{itemize} \end{itemize}
\item \textbf{WeightingScheme}: Character. \item \textbf{WeightingScheme}: Character.
Indicates the variable weighting scheme to be used in the simulation. Indicates the variable weighting scheme to be used in the simulation.
@ -508,69 +712,98 @@ make
If no value is supplied, no field is solved. If no value is supplied, no field is solved.
\begin{itemize} \begin{itemize}
\item \textbf{Electrostatic}: Solves the Poison equation to obtain the self-consistent electrostatic potential. \item \textbf{Electrostatic}: Solves the Poison equation to obtain the self-consistent electrostatic potential.
\item \textbf{ConstantB}: Assumes a constant magnetic field in all the domain.
It solves the Poisson equation as in the \textbf{solver.EMSolver} option.
\end{itemize} \end{itemize}
\item \textbf{initial}: Object. \item \textbf{B}: Real.
Array. Units of $\unit{T}$.
Array of dimension $3$.
Provides the value of constant magnetic field for the option \textbf{solver.EMSolver} \textbf{ConstantB}.
\item \textbf{initial}: Array of objects.
Determines initial values for the species. Determines initial values for the species.
Required values are: Required values are:
\begin{itemize} \begin{itemize}
\item \textbf{speciesName}: Character. \item \textbf{species}: Character.
Name of species. Name of species as defined in the object \textbf{species}.
\item \textbf{initialState}: Character. \item \textbf{file}: Character.
Plain text file that contains the information about the species macroscopic properties in the grid. Output file from previous run used as an initial state for the species.
Initial particles are assumed to be Maxwellian. The file format must be the same as in \textbf{geometry.meshType}
File must be located at \textbf{output.path}. Initial particles are assumed to have a Maxwellian distribution.
The file must contain the following columns in this specific order: File must be located in \textbf{output.path}.
\begin{itemize} \item \textbf{particlesPerCell}: Integer.
\item \textit{Element}: Integer. Optional.
Identifier of the volume in the mesh. Initial number of particles per cell.
It is not required to specify empty volumes. If not, the number of particles per cell will be assigned based on the species weight and the cell volume.
\item \textit{Density}: Real.
Species density in $\unit{m^-3}$.
\item \textit{Velocity}: Real.
Three colums representing the initial velocity in each direction.
Units are $\unit{m s^-1}$.
\item \textit{Temperature}: Real.
One column that represents the initial temperature in $\unit{K}$.
\end{itemize}
\end{itemize} \end{itemize}
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{average}
This object determines the use of an average scheme.
If this object exists in the input file, average will be written at the end of the simulation.
Acceptable values are:
\begin{itemize}
\item \textbf{startTime}: Real.
Units in $\unit{s}$.
Simulation physical time in which average scheme will start to compute the mean and standard validation.
If no value is provided, the initial time is set to $\unit[0.0]{s}$.
\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{interactions}\label{ssec:input_interactions} \subsection{interactions}\label{ssec:input_interactions}
This object determine the different interactions among species. This object determines the different interactions among species.
Acceptable values are: Acceptable values are:
\begin{itemize} \begin{itemize}
\item \textbf{folderCollisions}: Character. \item \textbf{folderCollisions}: Character.
Indicates the path to in which the cross section tables are allocated. Indicates the path to in which the cross-section tables are allocated.
\item \textbf{collisions}: Object. \item \textbf{meshCollisions}: Character.
Array. Determines a specific mesh for \acrshort{mcc} processes.
Contains the different binary collisions. The file needs to be located in the folder \textbf{output.folder}.
If this value is not present, the mesh defined in \textbf{geometry.meshFile} is used for \acrshort{mcc}.
The format of this mesh needs to be the same as the one defined in \textbf{geometry.meshType}.
\item \textbf{timeStep}: Real.
Units of $\unit{s}$.
Time step to calculate MCC.
If no time is provided, the minimum time step is used.
\item \textbf{collisions}: Array of objects.
Contains the different short range interactions (\acrshort{mcc}).
Multiple collision types can be defined for each pair of species. Multiple collision types can be defined for each pair of species.
Each object in the array is defined by: Each object in the array is defined by:
\begin{itemize} \begin{itemize}
\item \textbf{species\_i}, \textbf{species\_j}: Character. \item \textbf{species\_i}, \textbf{species\_j}: Character.
Define the two species involved in the collision processes. Define the two species involved in the collision processes.
Order is indiferent. Order is indiferent.
\item \textbf{cTypes}: Object. \item \textbf{cTypes}: Array of objects.
Array.
Defines all the collisions between \textbf{species\_i} and \textbf{species\_j}. Defines all the collisions between \textbf{species\_i} and \textbf{species\_j}.
Required values are: Required values are:
\begin{itemize} \begin{itemize}
\item \textbf{type}: Character. \item \textbf{type}: Character.
Collision type. Collision type.
Accepted values are \textbf{elastic}, \textbf{chargeExchange}, \textbf{ionization} and \textbf{recombination}. Accepted values are \textbf{elastic}, \textbf{chargeExchange}, \textbf{ionization} and \textbf{recombination}.
Please refer to Sec. \ref{ssec:collisions} for a description of the different collision types. Please refer to Sec.~\ref{ssec:collisions} for a description of the different collision types.
\item \textbf{crossSection}: Character. \item \textbf{crossSection}: Character.
File in \textbf{interactions.folderCollisions} that contains the cross section data as a 1D table of relative energy (in $\unit{eV}$) and cross section (in $\unit{m^-2}$). File in \textbf{interactions.folderCollisions} that contains the cross-section data as a 1D table of relative energy (in $\unit{eV}$) and cross-section (in $\unit{m^-2}$).
\item \textbf{energyThreshold}: Real. \item \textbf{energyThreshold}: Real.
Energy threshold of the collisional process in $\unit{eV}$. Energy threshold of the collisional process in $\unit{eV}$.
Only valid for \textbf{ionization} and \textbf{recombination} processes. Only valid for \textbf{ionization} and \textbf{recombination} processes.
\item \textbf{electron}: Character. \item \textbf{electron}: Character.
Name of species designed as electrons. Name of species designed as electrons.
Only valid for \textbf{ionization} and \textbf{recombination} processes. Only valid for \textbf{ionization} and \textbf{recombination} processes.
\item \textbf{electronSecondary}: Character.
Optional.
Name of species designed as secondary electrons.
If none provided, \textbf{electron} is used.
Only valid for \textbf{ionization}.
\end{itemize} \end{itemize}
\end{itemize} \end{itemize}
\item \textbf{Coulomb}: Array of objects.
Contains the information about which species must use the Coulomb linear scattering.
This method assumes a Maxwellian distribution for all species involved.
Each object in the array is defined by:
\begin{itemize}
\item \textbf{species\_i}, \textbf{species\_j}: Character.
Define the two species involved in the collision processes.
Order is indifferent.
\end{itemize}
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{parallel} \subsection{parallel}
@ -587,22 +820,33 @@ make
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Example runs\label{ch:exampleRuns}} \chapter{Example runs}\label{ch:exampleRuns}
\section{1D Cathode} This chapter presents a description of the different example files distributed with \acrshort{fpakc}.
Emission from a 1D cathond in both, cartesian and radial coordinates. All examples in the repository have a \lstinline|README.txt| file and a reference output.
Both cases insert the same amount of electrons from the minimum coordinate and have the same boundary conditions for particles and the electrostatic field. Plotting of the output is done with \Gls{gnuplot} or \Gls{gmsh}.
This case is useful to ilustrate hoy \acrshort{fpakc} can deal with different geometries by just modifiying some parameters in the input file.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{1D Emissive Cathode (1D\_Cathode)}
Emission from a 1D cathode in both, Cartesian and radial coordinates.
Both cases insert the same number of electrons from the minimum coordinate and have the same boundary conditions for particles and the electrostatic field.
This case is useful to illustrate how \acrshort{fpakc} can deal with different geometries by just modifying some parameters in the input file.
The same mesh file (\lstinline|mesh.msh|) is used for both cases. The same mesh file (\lstinline|mesh.msh|) is used for both cases.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{ALPHIE Grid system} \section{0D \ce{Ar}-\ce{Ar+} Elastic Collision (0D\_Argon)}
Two-dimensional axialsymmetry case to study the counterflow of electrons and Argon ions going trhough the ALPHIE grid system. Test case to check the 0D geometry that includes the elastic collision between \ce{Ar} and \ce{Ar+}.
Initial states are read from the \lstinline|Argon_Initial.dat| and \lstinline|Argon+_Initial.dat|.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{ALPHIE Grid system (ALPHIE\_Grid)}
Two-dimensional axial-symmetry case to study the counterflow of electrons and Argon ions going through the ALPHIE grid system.
A \lstinline|mesh.geo| file is provided to easily modify the parameters of the grid system and generate a new mesh with \Gls{gmsh}. A \lstinline|mesh.geo| file is provided to easily modify the parameters of the grid system and generate a new mesh with \Gls{gmsh}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Flow around cylinder} \section{Flow around cylinder (cylFlow)}
Simple case of neutral Argon flow around a cylinder in a 2D axialsymmetry geometry. Simple case of neutral Argon flow around a cylinder in a 2D axial-symmetry geometry.
Elastic collisions between argon particles are included as default. Elastic collisions between argon particles are included.
Two cases are presented here: one in which the same mesh (\lstinline|meshSingle.msh|) for scattering and collisions is used (\lstinline|input.json|) and a second one (\lstinline|inputDualMesh.json|) in which a mesh is used for scattering (\lstinline|mesh.msh|) and a second one is used only for collisions (\lstinline|meshColl.msh|).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\printglossaries \printglossaries

View file

@ -6,7 +6,7 @@ SRCDIR := $(TOPDIR)/src# source folder
# compiler # compiler
# gfortran: # gfortran:
FC := gfortran FC := gfortran
JSONDIR := $(TOPDIR)/json-fortran-8.2.0/build-gfortran JSONDIR := $(TOPDIR)/json-fortran/build-gfortran
# ifort: # ifort:
# FC := ifort # FC := ifort
# JSONDIR := $(TOPDIR)/json-fortran-8.2.0/build-ifort # JSONDIR := $(TOPDIR)/json-fortran-8.2.0/build-ifort
@ -39,5 +39,6 @@ src.o:
clean: clean:
rm -f $(OUTPUT) rm -f $(OUTPUT)
rm -f $(MODDIR)/*.mod rm -f $(MODDIR)/*.mod
rm -f $(MODDIR)/*.smod
rm -f $(OBJDIR)/*.o rm -f $(OBJDIR)/*.o

View file

@ -0,0 +1,2 @@
# t density velocity pressure temperature
0 1.0E+16 0.0E+0 0.0E+0 0.0E+0 0 3000

View file

@ -0,0 +1,2 @@
# t density velocity pressure temperature
0 1.0E+16 0.0E+0 0.0E+0 0.0E+0 0 300

11
runs/0D_Argon/README.txt Normal file
View file

@ -0,0 +1,11 @@
Example of 0D geometry.
Mostly used to test collision processes.
This example includes Ar and Ar+ with self-collisions for Ar and elastic collisions for AR-Ar+.
Different starting temperatures for each species that end up in equilibrium.
The gnuplpot script 'plot_Temperature.gp' generates a plot of the species temperatures.
The result is provided in the output folder to compare if modifications to the code are made.

49
runs/0D_Argon/input.json Normal file
View file

@ -0,0 +1,49 @@
{
"output": {
"path": "./runs/0D_Argon/",
"triggerOutput": 1,
"numColl": true,
"folder": "test"
},
"reference": {
"density": 1.0e16,
"mass": 6.633e-26,
"temperature": 11604.0,
"radius": 1.88e-10
},
"geometry": {
"dimension": 0,
"volume": 1e-11
},
"species": [
{"name": "Argon+", "type": "charged", "mass": 6.633e-26, "charge": 1.0, "weight": 1.0e0},
{"name": "Argon", "type": "neutral", "mass": 6.633e-26, "weight": 1.0e0}
],
"solver": {
"tau": [1.0e-3, 1.0e-3],
"finalTime": 1.0e0,
"initial": [
{"species": "Argon+", "file": "Argon+_Initial.dat"},
{"species": "Argon", "file": "Argon_Initial.dat"}
]
},
"interactions": {
"folderCollisions": "./data/collisions/",
"collisions": [
{"species_i": "Argon", "species_j": "Argon",
"cTypes": [
{"type": "elastic", "crossSection": "EL_Ar-Ar.dat"}
]},
{"species_i": "Argon+", "species_j": "Argon",
"cTypes": [
{"type": "elastic", "crossSection": "EL_Ar-Ar.dat"}
]}
]
},
"parallel": {
"OpenMP":{
"nThreads": 4
}
}
}

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,65 @@
reset
set macros
term = 'postscript eps color enhanced'
font = 'font "CMUSerif-Roman,20"'
linew = 'lw 2.0'
times='"{/Symbol \264}"'
size_x=8.5
size_y=5.2
tmar=0.998
bmar=0.145
lmarLabel = 0.070
lmar=lmarLabel+0.085
rmar=0.97
space_x=(rmar-lmar)
xt_off_0=0.5
yt_off_0=0.6
set xtics nomirror offset 0.0,xt_off_0
set mxtics 2
set ytics nomirror offset yt_off_0,0.0
set mytics 2
set pointsize 1.5
set style line 1 pt 4 lc rgb "#B50427" #Squares red
set style line 2 pt 6 lc rgb "#3B4CC1" #Circles blue
set style line 3 pt 1 lc rgb "#2CA02C" #Crosses green
set style line 4 pt 2 lc rgb "#FE7F0E" #Exes orange
set style line 5 pt 8 lc rgb "#D6696B" #Triangles light red
set style line 10 lt 1 lw 2.0 lc rgb "black" #Black solid line
set terminal @term size size_x cm, size_y cm @linew @font
set output "comp_temp.eps"
#files
filename1 = "OUTPUT_Argon.dat"
filename2 = "OUTPUT_Argon+.dat"
folder = 'output/'
set lmargin at screen lmar
set rmargin at screen rmar
set xrange [-0.01:1.01]
set xtics 0.2
set xlabel "Time (s)" offset 0.0,1.2
set yrange [250:3550]
set format y "%3.0f"
set ytics 500
set ylabel "Temperature (K)" offset 1.4,0.0
set key width 0.5 height 0.1 spacing 1.3 samplen 0.2 box opaque font ",16"
set key at graph 0.95, graph 0.9 right top
plot folder.filename1 u ($1):($7) t "Ar" ls 1 with lines, \
folder.filename2 u ($1):($7) t "Ar^{+}" ls 2 with lines

View file

@ -0,0 +1,8 @@
This case is useful to explain how fpakc can work with different geometries (Cartisian and Radial in this case) using very similar input files and the same mesh.
From the position to the left, electrons are emitted at a constant rate.
The electric potential at the left is fixed at 0.
Depending on the geometry (which affects the symmetry) different distributions of the electron density and electric potential are achieved.
The last iteration obtained for these cases is in the output folder.

View file

@ -5,16 +5,18 @@
"triggerOutput": 100, "triggerOutput": 100,
"cpuTime": false, "cpuTime": false,
"numColl": false, "numColl": false,
"EMField": true "EMField": true,
"folder": "Cartesian_Emision"
}, },
"reference": { "reference": {
"density": 1.0e16, "density": 1.0e16,
"mass": 9.109e-31, "mass": 9.109e-31,
"temperature": 2500.0 "temperature": 11604.0
}, },
"geometry": { "geometry": {
"type": "1DCart", "dimension": 1,
"meshType": "gmsh", "type": "Cart",
"meshType": "gmsh2",
"meshFile": "mesh.msh" "meshFile": "mesh.msh"
}, },
"species": [ "species": [
@ -29,22 +31,21 @@
]} ]}
], ],
"boundaryEM": [ "boundaryEM": [
{"name": "Cathode", "type": "dirichlet", "potential": -10.0, "physicalSurface": 1}, {"name": "Cathode", "type": "dirichlet", "potential": 0.0, "physicalSurface": 1}
{"name": "Infinite", "type": "dirichlet", "potential": 0.0, "physicalSurface": 2}
], ],
"inject": [ "inject": [
{"name": "Cathode Electron", "species": "Electron", "flow": 9.0e-5, "units": "A", "v": 27500.0, "T": [2500.0, 2500.0, 2500.0], {"name": "Plasma Cat e", "species": "Electron", "flow": 2.64e-5, "units": "A", "v": 180000.0, "T": [ 2300.0, 2300.0, 2300.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1} "velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1}
], ],
"case": { "solver": {
"tau": [1.0e-11], "tau": [1.0e-11],
"time": 1.0e-6, "finalTime": 1.0e-8,
"pusher": ["1DCartCharged"], "pusher": ["Electrostatic"],
"EMSolver": "Electrostatic" "EMSolver": "Electrostatic"
}, },
"parallel": { "parallel": {
"OpenMP":{ "OpenMP":{
"nThreads": 1 "nThreads": 24
} }
} }
} }

View file

@ -5,16 +5,18 @@
"triggerOutput": 100, "triggerOutput": 100,
"cpuTime": false, "cpuTime": false,
"numColl": false, "numColl": false,
"EMField": true "EMField": true,
"folder": "Radial_Emission"
}, },
"reference": { "reference": {
"density": 1.0e16, "density": 1.0e16,
"mass": 9.109e-31, "mass": 9.109e-31,
"temperature": 2500.0 "temperature": 11604.0
}, },
"geometry": { "geometry": {
"type": "1DRad", "dimension": 1,
"meshType": "gmsh", "type": "Rad",
"meshType": "gmsh2",
"meshFile": "mesh.msh" "meshFile": "mesh.msh"
}, },
"species": [ "species": [
@ -29,22 +31,21 @@
]} ]}
], ],
"boundaryEM": [ "boundaryEM": [
{"name": "Cathode", "type": "dirichlet", "potential": -10.0, "physicalSurface": 1}, {"name": "Cathode", "type": "dirichlet", "potential": 0.0, "physicalSurface": 1}
{"name": "Infinite", "type": "dirichlet", "potential": 0.0, "physicalSurface": 2}
], ],
"inject": [ "inject": [
{"name": "Cathode Electron", "species": "Electron", "flow": 9.0e-5, "units": "A", "v": 27500.0, "T": [2500.0, 2500.0, 2500.0], {"name": "Plasma Cat e", "species": "Electron", "flow": 2.64e-5, "units": "A", "v": 180000.0, "T": [ 2300.0, 2300.0, 2300.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1} "velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1}
], ],
"case": { "solver": {
"tau": [1.0e-11], "tau": [1.0e-11],
"time": 1.0e-6, "finalTime": 1.0e-8,
"pusher": ["1DRadCharged"], "pusher": ["Electrostatic"],
"EMSolver": "Electrostatic" "EMSolver": "Electrostatic"
}, },
"parallel": { "parallel": {
"OpenMP":{ "OpenMP":{
"nThreads": 1 "nThreads": 24
} }
} }
} }

16
runs/1D_Cathode/mesh.geo Normal file
View file

@ -0,0 +1,16 @@
Lcell = 4e-5;
x0 = 0.001;
xf = x0 + 50.0*Lcell;
Point(1) = {x0, 0, 0, 1};
Point(2) = {xf, 0, 0, 1};
Line(1) = {1, 2};
Physical Point(1) = {1};
Physical Point(2) = {2};
Physical Line(1) = {1};
Transfinite Line {1} = (xf-x0)/Lcell + 1 Using Progression 1;

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,185 @@
$MeshFormat
2.2 0 8
$EndMeshFormat
$NodeData
1
"Potential (V)"
1
1.0000000000000000E-008
3
1000
1
51
1 -7.2180834934653183E-012
2 -1.6164415181357834
3 -0.36980461527280883
4 -0.57492573345192088
5 -0.71403100967357258
6 -0.82100545766928923
7 -0.90752842743341133
8 -0.97972921034487059
9 -1.0411791818607907
10 -1.0939318279574932
11 -1.1399404313046071
12 -1.1807139724083482
13 -1.2174163304531369
14 -1.2504990809463861
15 -1.2803540949915220
16 -1.3073500616819811
17 -1.3316282169084139
18 -1.3537385275137412
19 -1.3739696197563589
20 -1.3927592194128697
21 -1.4103076231740377
22 -1.4266496533259061
23 -1.4418485519615323
24 -1.4562354448986332
25 -1.4697852468324024
26 -1.4825221356246889
27 -1.4946048104025964
28 -1.5059524644639768
29 -1.5166545901603037
30 -1.5269837565446036
31 -1.5366931422515575
32 -1.5457467079858906
33 -1.5541298965687140
34 -1.5618551829370724
35 -1.5689172611267244
36 -1.5752150587183313
37 -1.5808462624732060
38 -1.5860612571248669
39 -1.5910404498436017
40 -1.5957279636246224
41 -1.5998828959091791
42 -1.6032394878414955
43 -1.6059267946667977
44 -1.6082423003097928
45 -1.6102897646308323
46 -1.6120678175170864
47 -1.6134998424675298
48 -1.6146588662864141
49 -1.6155317189248377
50 -1.6160774066120194
51 -1.6163242439958503
$EndNodeData
$ElementData
1
"Electric Field (V m^-1)"
1
1.0000000000000000E-008
3
1000
3
50
3 9245.1153816612405 0.0000000000000000 0.0000000000000000
4 5128.0279544843424 0.0000000000000000 0.0000000000000000
5 3477.6319055457411 0.0000000000000000 0.0000000000000000
6 2674.3611998963270 0.0000000000000000 0.0000000000000000
7 2163.0742441058046 0.0000000000000000 0.0000000000000000
8 1805.0195727920382 0.0000000000000000 0.0000000000000000
9 1536.2492879082888 0.0000000000000000 0.0000000000000000
10 1318.8161524257080 0.0000000000000000 0.0000000000000000
11 1150.2150836799428 0.0000000000000000 0.0000000000000000
12 1019.3385275948289 0.0000000000000000 0.0000000000000000
13 917.55895112089058 0.0000000000000000 0.0000000000000000
14 827.06876233228445 0.0000000000000000 0.0000000000000000
15 746.37535112673595 0.0000000000000000 0.0000000000000000
16 674.89916726183060 0.0000000000000000 0.0000000000000000
17 606.95388066159535 0.0000000000000000 0.0000000000000000
18 552.75776513387154 0.0000000000000000 0.0000000000000000
19 505.77730606825133 0.0000000000000000 0.0000000000000000
20 469.73999141591514 0.0000000000000000 0.0000000000000000
21 438.71009403214083 0.0000000000000000 0.0000000000000000
22 408.55075379944572 0.0000000000000000 0.0000000000000000
23 379.97246589319053 0.0000000000000000 0.0000000000000000
24 359.67232342854714 0.0000000000000000 0.0000000000000000
25 338.74504834466700 0.0000000000000000 0.0000000000000000
26 318.42221980693205 0.0000000000000000 0.0000000000000000
27 302.06686944643235 0.0000000000000000 0.0000000000000000
28 283.69135153333235 0.0000000000000000 0.0000000000000000
29 267.55314240706213 0.0000000000000000 0.0000000000000000
30 258.22915960642655 0.0000000000000000 0.0000000000000000
31 242.73464267283171 0.0000000000000000 0.0000000000000000
32 226.33914335739505 0.0000000000000000 0.0000000000000000
33 209.57971456971421 0.0000000000000000 0.0000000000000000
34 193.13215920815529 0.0000000000000000 0.0000000000000000
35 176.55195474056683 0.0000000000000000 0.0000000000000000
36 157.44493979054459 0.0000000000000000 0.0000000000000000
37 140.78009387281193 0.0000000000000000 0.0000000000000000
38 130.37486629147924 0.0000000000000000 0.0000000000000000
39 124.47981796785177 0.0000000000000000 0.0000000000000000
40 117.18784452503036 0.0000000000000000 0.0000000000000000
41 103.87330711348883 0.0000000000000000 0.0000000000000000
42 83.914798307876424 0.0000000000000000 0.0000000000000000
43 67.182670633004349 0.0000000000000000 0.0000000000000000
44 57.887641075013939 0.0000000000000000 0.0000000000000000
45 51.186608025777616 0.0000000000000000 0.0000000000000000
46 44.451322156171258 0.0000000000000000 0.0000000000000000
47 35.800623760933746 0.0000000000000000 0.0000000000000000
48 28.975595471990374 0.0000000000000000 0.0000000000000000
49 21.821315960497699 0.0000000000000000 0.0000000000000000
50 13.642192179482622 0.0000000000000000 0.0000000000000000
51 6.1709345957464548 0.0000000000000000 0.0000000000000000
52 2.9318534983186093 0.0000000000000000 0.0000000000000000
$EndElementData
$NodeData
1
"Magnetic Field (T)"
1
1.0000000000000000E-008
3
1000
3
51
1 0.0000000000000000 0.0000000000000000 0.0000000000000000
2 0.0000000000000000 0.0000000000000000 0.0000000000000000
3 0.0000000000000000 0.0000000000000000 0.0000000000000000
4 0.0000000000000000 0.0000000000000000 0.0000000000000000
5 0.0000000000000000 0.0000000000000000 0.0000000000000000
6 0.0000000000000000 0.0000000000000000 0.0000000000000000
7 0.0000000000000000 0.0000000000000000 0.0000000000000000
8 0.0000000000000000 0.0000000000000000 0.0000000000000000
9 0.0000000000000000 0.0000000000000000 0.0000000000000000
10 0.0000000000000000 0.0000000000000000 0.0000000000000000
11 0.0000000000000000 0.0000000000000000 0.0000000000000000
12 0.0000000000000000 0.0000000000000000 0.0000000000000000
13 0.0000000000000000 0.0000000000000000 0.0000000000000000
14 0.0000000000000000 0.0000000000000000 0.0000000000000000
15 0.0000000000000000 0.0000000000000000 0.0000000000000000
16 0.0000000000000000 0.0000000000000000 0.0000000000000000
17 0.0000000000000000 0.0000000000000000 0.0000000000000000
18 0.0000000000000000 0.0000000000000000 0.0000000000000000
19 0.0000000000000000 0.0000000000000000 0.0000000000000000
20 0.0000000000000000 0.0000000000000000 0.0000000000000000
21 0.0000000000000000 0.0000000000000000 0.0000000000000000
22 0.0000000000000000 0.0000000000000000 0.0000000000000000
23 0.0000000000000000 0.0000000000000000 0.0000000000000000
24 0.0000000000000000 0.0000000000000000 0.0000000000000000
25 0.0000000000000000 0.0000000000000000 0.0000000000000000
26 0.0000000000000000 0.0000000000000000 0.0000000000000000
27 0.0000000000000000 0.0000000000000000 0.0000000000000000
28 0.0000000000000000 0.0000000000000000 0.0000000000000000
29 0.0000000000000000 0.0000000000000000 0.0000000000000000
30 0.0000000000000000 0.0000000000000000 0.0000000000000000
31 0.0000000000000000 0.0000000000000000 0.0000000000000000
32 0.0000000000000000 0.0000000000000000 0.0000000000000000
33 0.0000000000000000 0.0000000000000000 0.0000000000000000
34 0.0000000000000000 0.0000000000000000 0.0000000000000000
35 0.0000000000000000 0.0000000000000000 0.0000000000000000
36 0.0000000000000000 0.0000000000000000 0.0000000000000000
37 0.0000000000000000 0.0000000000000000 0.0000000000000000
38 0.0000000000000000 0.0000000000000000 0.0000000000000000
39 0.0000000000000000 0.0000000000000000 0.0000000000000000
40 0.0000000000000000 0.0000000000000000 0.0000000000000000
41 0.0000000000000000 0.0000000000000000 0.0000000000000000
42 0.0000000000000000 0.0000000000000000 0.0000000000000000
43 0.0000000000000000 0.0000000000000000 0.0000000000000000
44 0.0000000000000000 0.0000000000000000 0.0000000000000000
45 0.0000000000000000 0.0000000000000000 0.0000000000000000
46 0.0000000000000000 0.0000000000000000 0.0000000000000000
47 0.0000000000000000 0.0000000000000000 0.0000000000000000
48 0.0000000000000000 0.0000000000000000 0.0000000000000000
49 0.0000000000000000 0.0000000000000000 0.0000000000000000
50 0.0000000000000000 0.0000000000000000 0.0000000000000000
51 0.0000000000000000 0.0000000000000000 0.0000000000000000
$EndNodeData

View file

@ -0,0 +1,247 @@
$MeshFormat
2.2 0 8
$EndMeshFormat
$NodeData
1
"Electron density (m^-3)"
1
1.0000000000000000E-008
3
1000
1
51
1 1.663355E+017
2 1.635218E+014
3 6.971311E+016
4 2.630990E+016
5 1.405426E+016
6 9.465391E+015
7 6.637877E+015
8 4.988303E+015
9 4.189069E+015
10 3.156337E+015
11 2.494143E+015
12 1.855358E+015
13 1.740443E+015
14 1.546003E+015
15 1.316731E+015
16 1.372680E+015
17 9.737899E+014
18 9.388176E+014
19 6.512445E+014
20 5.832764E+014
21 5.692614E+014
22 5.935914E+014
23 3.292208E+014
24 4.143419E+014
25 4.100487E+014
26 2.728780E+014
27 3.714897E+014
28 3.455677E+014
29 9.442239E+013
30 3.445456E+014
31 3.018612E+014
32 3.256579E+014
33 3.148337E+014
34 2.986174E+014
35 3.894979E+014
36 3.315681E+014
37 1.927240E+014
38 8.916509E+013
39 1.257294E+014
40 2.430101E+014
41 4.270402E+014
42 3.345209E+014
43 1.510759E+014
44 1.256626E+014
45 1.136905E+014
46 1.909151E+014
47 1.133460E+014
48 1.373180E+014
49 1.567058E+014
50 1.725501E+014
51 8.718697E+012
$EndNodeData
$NodeData
1
"Electron velocity (m s^-1)"
1
1.0000000000000000E-008
3
1000
3
51
1 6.822573E+002 7.341184E+002 -1.294679E+003
2 2.275900E+005 -1.156323E+005 -3.994264E+004
3 6.011992E+003 -2.085702E+003 -6.955356E+003
4 2.674256E+003 -1.413909E+003 1.028663E+003
5 -6.262168E+003 -5.034055E+003 1.381887E+004
6 1.057957E+003 8.436700E+002 -1.017065E+004
7 1.182090E+004 1.797951E+004 6.390618E+003
8 1.868273E+004 1.131158E+004 1.107675E+004
9 1.821590E+004 5.287286E+003 9.958486E+003
10 5.545844E+003 -1.134700E+003 -1.747390E+004
11 4.595683E+004 1.909957E+004 4.055354E+004
12 5.242670E+004 -1.209486E+003 1.046959E+004
13 -6.508610E+003 4.362341E+004 -8.868030E+003
14 -5.779804E+003 7.888582E+003 -1.190795E+004
15 -3.256102E+003 -2.423327E+004 1.680404E+004
16 2.026515E+004 5.900866E+003 4.573129E+004
17 1.881938E+004 -5.907004E+004 4.787712E+003
18 2.471440E+004 3.126628E+004 3.276285E+004
19 1.927866E+004 -1.774386E+004 1.728677E+004
20 4.357578E+004 -1.754746E+004 2.441953E+004
21 -2.293113E+004 5.501146E+003 3.536741E+004
22 2.289073E+004 2.308340E+004 5.214795E+004
23 1.380393E+005 8.134296E+004 6.839466E+004
24 1.059159E+005 7.461802E+003 -9.633646E+003
25 1.093199E+004 -1.991657E+004 -1.139848E+005
26 2.642203E+004 -2.481740E+004 3.143777E+004
27 9.005040E+004 8.070628E+003 -3.359234E+004
28 1.241325E+005 5.096109E+004 7.419358E+002
29 1.346489E+005 -1.573873E+005 6.203455E+003
30 5.610495E+004 -3.368553E+004 1.507073E+005
31 3.535163E+004 1.988632E+004 6.165400E+004
32 9.376597E+004 1.073849E+004 1.451017E+004
33 1.084345E+005 3.421118E+004 2.083726E+004
34 7.746595E+004 3.203130E+004 6.852780E+003
35 1.133766E+005 2.337750E+003 -4.867282E+004
36 1.025276E+005 1.014552E+005 -8.405875E+004
37 7.241202E+004 2.972254E+002 1.876103E+004
38 4.204461E+004 9.161183E+004 -8.625228E+004
39 2.000094E+004 1.616608E+005 -4.124777E+004
40 1.065082E+005 1.060744E+005 -9.625557E+004
41 2.353957E+005 -3.660256E+003 -6.119245E+003
42 2.043649E+005 1.172239E+003 -2.283045E+004
43 1.632956E+005 -3.766183E+004 -5.714495E+004
44 2.139853E+005 -1.091968E+005 -7.473445E+004
45 6.523701E+004 -5.437454E+004 2.092413E+005
46 6.804248E+004 2.190917E+004 -3.051095E+004
47 1.247063E+005 9.312863E+004 -2.110944E+004
48 1.488446E+005 4.703577E+003 1.162251E+005
49 1.444633E+005 2.511461E+004 7.188944E+004
50 1.343558E+005 -1.246722E+004 2.197029E+005
51 1.789699E+005 -1.338478E+005 -5.783810E+004
$EndNodeData
$NodeData
1
"Electron pressure (Pa)"
1
1.0000000000000000E-008
3
1000
1
51
1 5.385580E-003
2 1.002571E-006
3 2.356496E-003
4 8.962727E-004
5 4.794124E-004
6 3.503273E-004
7 2.442948E-004
8 1.546660E-004
9 1.322598E-004
10 9.957574E-005
11 8.063749E-005
12 5.468381E-005
13 5.120468E-005
14 4.099773E-005
15 4.147335E-005
16 4.439409E-005
17 3.060211E-005
18 3.239301E-005
19 1.928871E-005
20 1.720661E-005
21 1.615443E-005
22 2.301910E-005
23 9.019928E-006
24 8.246059E-006
25 9.022171E-006
26 5.090623E-006
27 1.430550E-005
28 1.078930E-005
29 2.237441E-006
30 8.720790E-006
31 7.185960E-006
32 1.040168E-005
33 8.947370E-006
34 8.505472E-006
35 1.011847E-005
36 1.009116E-005
37 6.487404E-006
38 9.794017E-007
39 1.137051E-006
40 4.115733E-006
41 1.110521E-005
42 5.195716E-006
43 2.249886E-006
44 2.702675E-006
45 1.909427E-006
46 4.939937E-006
47 1.983386E-006
48 2.345377E-006
49 4.284590E-006
50 4.071858E-006
51 4.700991E-008
$EndNodeData
$NodeData
1
"Electron temperature (K)"
1
1.0000000000000000E-008
3
1000
1
51
1 2.345117E+003
2 4.440750E+002
3 2.448325E+003
4 2.467391E+003
5 2.470690E+003
6 2.680725E+003
7 2.665642E+003
8 2.245737E+003
9 2.286795E+003
10 2.285004E+003
11 2.341707E+003
12 2.134754E+003
13 2.130918E+003
14 1.920730E+003
15 2.281334E+003
16 2.342463E+003
17 2.276161E+003
18 2.499120E+003
19 2.145241E+003
20 2.136672E+003
21 2.055403E+003
22 2.808779E+003
23 1.984416E+003
24 1.441466E+003
25 1.593648E+003
26 1.351199E+003
27 2.789158E+003
28 2.261399E+003
29 1.716301E+003
30 1.833268E+003
31 1.724227E+003
32 2.313443E+003
33 2.058406E+003
34 2.063004E+003
35 1.881598E+003
36 2.204374E+003
37 2.438102E+003
38 7.955782E+002
39 6.550284E+002
40 1.226704E+003
41 1.883539E+003
42 1.124965E+003
43 1.078654E+003
44 1.557774E+003
45 1.216454E+003
46 1.874123E+003
47 1.267412E+003
48 1.237093E+003
49 1.980347E+003
50 1.709206E+003
51 3.905303E+002
$EndNodeData

View file

@ -0,0 +1,185 @@
$MeshFormat
2.2 0 8
$EndMeshFormat
$NodeData
1
"Potential (V)"
1
1.0000000000000000E-008
3
1000
1
51
1 -2.0125602360500233E-012
2 -2.1476540511245403
3 -0.92254600934286035
4 -1.1693722452494442
5 -1.3055892978798838
6 -1.4090596211031350
7 -1.4933143808451328
8 -1.5638362561671308
9 -1.6231896643635058
10 -1.6740175110100952
11 -1.7185366931231973
12 -1.7583784348355216
13 -1.7946512154913346
14 -1.8278278087327231
15 -1.8580164245432433
16 -1.8852831251773992
17 -1.9099218127680115
18 -1.9323133093677307
19 -1.9527025003199079
20 -1.9712632206620335
21 -1.9881621423695754
22 -2.0035781018067564
23 -2.0176479044718039
24 -2.0305087603061467
25 -2.0422748378993707
26 -2.0530348175074842
27 -2.0628746022811000
28 -2.0718874967016756
29 -2.0801381491382527
30 -2.0876833658364853
31 -2.0945891263065528
32 -2.1008985562257543
33 -2.1066381420356524
34 -2.1118556546612779
35 -2.1165897969031175
36 -2.1208699819402956
37 -2.1247303076336199
38 -2.1281989125689238
39 -2.1312983972494055
40 -2.1340576795392843
41 -2.1364955581097296
42 -2.1386339190704353
43 -2.1405011196666606
44 -2.1421213004925956
45 -2.1435109859394803
46 -2.1446785599633511
47 -2.1456400594108116
48 -2.1464001968748745
49 -2.1469649987104309
50 -2.1473539773488697
51 -2.1475805166422961
$EndNodeData
$ElementData
1
"Electric Field (V m^-1)"
1
1.0000000000000000E-008
3
1000
3
50
3 23063.650233574754 0.0000000000000000 0.0000000000000000
4 6170.6558976724700 0.0000000000000000 0.0000000000000000
5 3405.4263157653404 0.0000000000000000 0.0000000000000000
6 2586.7580805845814 0.0000000000000000 0.0000000000000000
7 2106.3689935526277 0.0000000000000000 0.0000000000000000
8 1763.0468830553750 0.0000000000000000 0.0000000000000000
9 1483.8352049193140 0.0000000000000000 0.0000000000000000
10 1270.6961661725816 0.0000000000000000 0.0000000000000000
11 1112.9795528295804 0.0000000000000000 0.0000000000000000
12 996.04354280937548 0.0000000000000000 0.0000000000000000
13 906.81951639648162 0.0000000000000000 0.0000000000000000
14 829.41483103577525 0.0000000000000000 0.0000000000000000
15 754.71539526132392 0.0000000000000000 0.0000000000000000
16 681.66751585425504 0.0000000000000000 0.0000000000000000
17 615.96718976609407 0.0000000000000000 0.0000000000000000
18 559.78741499368221 0.0000000000000000 0.0000000000000000
19 509.72977380725575 0.0000000000000000 0.0000000000000000
20 464.01800855624742 0.0000000000000000 0.0000000000000000
21 422.47304269137754 0.0000000000000000 0.0000000000000000
22 385.39898593210717 0.0000000000000000 0.0000000000000000
23 351.74506662853850 0.0000000000000000 0.0000000000000000
24 321.52139585948811 0.0000000000000000 0.0000000000000000
25 294.15193983097186 0.0000000000000000 0.0000000000000000
26 268.99949020263892 0.0000000000000000 0.0000000000000000
27 245.99461933938235 0.0000000000000000 0.0000000000000000
28 225.32236051344728 0.0000000000000000 0.0000000000000000
29 206.26631091357709 0.0000000000000000 0.0000000000000000
30 188.63041745502420 0.0000000000000000 0.0000000000000000
31 172.64401175097743 0.0000000000000000 0.0000000000000000
32 157.73574797938116 0.0000000000000000 0.0000000000000000
33 143.48964524685633 0.0000000000000000 0.0000000000000000
34 130.43781564009393 0.0000000000000000 0.0000000000000000
35 118.35355604550293 0.0000000000000000 0.0000000000000000
36 107.00462592970442 0.0000000000000000 0.0000000000000000
37 96.508142333755885 0.0000000000000000 0.0000000000000000
38 86.715123382567057 0.0000000000000000 0.0000000000000000
39 77.487117011718453 0.0000000000000000 0.0000000000000000
40 68.982057246684732 0.0000000000000000 0.0000000000000000
41 60.946964260881018 0.0000000000000000 0.0000000000000000
42 53.459024017616187 0.0000000000000000 0.0000000000000000
43 46.680014905952270 0.0000000000000000 0.0000000000000000
44 40.504520648464592 0.0000000000000000 0.0000000000000000
45 34.742136171983248 0.0000000000000000 0.0000000000000000
46 29.189350596637517 0.0000000000000000 0.0000000000000000
47 24.037486186421319 0.0000000000000000 0.0000000000000000
48 19.003436601487543 0.0000000000000000 0.0000000000000000
49 14.120045888854746 0.0000000000000000 0.0000000000000000
50 9.7244659609280415 0.0000000000000000 0.0000000000000000
51 5.6634823356386530 0.0000000000000000 0.0000000000000000
52 1.8383620561016323 0.0000000000000000 0.0000000000000000
$EndElementData
$NodeData
1
"Magnetic Field (T)"
1
1.0000000000000000E-008
3
1000
3
51
1 0.0000000000000000 0.0000000000000000 0.0000000000000000
2 0.0000000000000000 0.0000000000000000 0.0000000000000000
3 0.0000000000000000 0.0000000000000000 0.0000000000000000
4 0.0000000000000000 0.0000000000000000 0.0000000000000000
5 0.0000000000000000 0.0000000000000000 0.0000000000000000
6 0.0000000000000000 0.0000000000000000 0.0000000000000000
7 0.0000000000000000 0.0000000000000000 0.0000000000000000
8 0.0000000000000000 0.0000000000000000 0.0000000000000000
9 0.0000000000000000 0.0000000000000000 0.0000000000000000
10 0.0000000000000000 0.0000000000000000 0.0000000000000000
11 0.0000000000000000 0.0000000000000000 0.0000000000000000
12 0.0000000000000000 0.0000000000000000 0.0000000000000000
13 0.0000000000000000 0.0000000000000000 0.0000000000000000
14 0.0000000000000000 0.0000000000000000 0.0000000000000000
15 0.0000000000000000 0.0000000000000000 0.0000000000000000
16 0.0000000000000000 0.0000000000000000 0.0000000000000000
17 0.0000000000000000 0.0000000000000000 0.0000000000000000
18 0.0000000000000000 0.0000000000000000 0.0000000000000000
19 0.0000000000000000 0.0000000000000000 0.0000000000000000
20 0.0000000000000000 0.0000000000000000 0.0000000000000000
21 0.0000000000000000 0.0000000000000000 0.0000000000000000
22 0.0000000000000000 0.0000000000000000 0.0000000000000000
23 0.0000000000000000 0.0000000000000000 0.0000000000000000
24 0.0000000000000000 0.0000000000000000 0.0000000000000000
25 0.0000000000000000 0.0000000000000000 0.0000000000000000
26 0.0000000000000000 0.0000000000000000 0.0000000000000000
27 0.0000000000000000 0.0000000000000000 0.0000000000000000
28 0.0000000000000000 0.0000000000000000 0.0000000000000000
29 0.0000000000000000 0.0000000000000000 0.0000000000000000
30 0.0000000000000000 0.0000000000000000 0.0000000000000000
31 0.0000000000000000 0.0000000000000000 0.0000000000000000
32 0.0000000000000000 0.0000000000000000 0.0000000000000000
33 0.0000000000000000 0.0000000000000000 0.0000000000000000
34 0.0000000000000000 0.0000000000000000 0.0000000000000000
35 0.0000000000000000 0.0000000000000000 0.0000000000000000
36 0.0000000000000000 0.0000000000000000 0.0000000000000000
37 0.0000000000000000 0.0000000000000000 0.0000000000000000
38 0.0000000000000000 0.0000000000000000 0.0000000000000000
39 0.0000000000000000 0.0000000000000000 0.0000000000000000
40 0.0000000000000000 0.0000000000000000 0.0000000000000000
41 0.0000000000000000 0.0000000000000000 0.0000000000000000
42 0.0000000000000000 0.0000000000000000 0.0000000000000000
43 0.0000000000000000 0.0000000000000000 0.0000000000000000
44 0.0000000000000000 0.0000000000000000 0.0000000000000000
45 0.0000000000000000 0.0000000000000000 0.0000000000000000
46 0.0000000000000000 0.0000000000000000 0.0000000000000000
47 0.0000000000000000 0.0000000000000000 0.0000000000000000
48 0.0000000000000000 0.0000000000000000 0.0000000000000000
49 0.0000000000000000 0.0000000000000000 0.0000000000000000
50 0.0000000000000000 0.0000000000000000 0.0000000000000000
51 0.0000000000000000 0.0000000000000000 0.0000000000000000
$EndNodeData

View file

@ -0,0 +1,247 @@
$MeshFormat
2.2 0 8
$EndMeshFormat
$NodeData
1
"Electron density (m^-3)"
1
1.0000000000000000E-008
3
1000
1
51
1 6.926728E+018
2 4.338487E+014
3 1.201033E+018
4 1.505055E+017
5 7.986344E+016
6 4.403063E+016
7 3.228092E+016
8 2.775434E+016
9 2.012556E+016
10 1.435034E+016
11 1.012383E+016
12 7.086783E+015
13 6.226656E+015
14 6.362452E+015
15 6.664819E+015
16 5.946772E+015
17 4.875712E+015
18 4.419041E+015
19 4.092162E+015
20 3.771210E+015
21 3.309077E+015
22 3.071732E+015
23 2.732966E+015
24 2.484798E+015
25 2.313440E+015
26 2.142727E+015
27 1.892093E+015
28 1.776155E+015
29 1.672823E+015
30 1.493186E+015
31 1.407724E+015
32 1.403006E+015
33 1.262097E+015
34 1.182309E+015
35 1.134819E+015
36 1.047928E+015
37 9.865986E+014
38 9.544875E+014
39 8.680888E+014
40 8.440321E+014
41 7.961164E+014
42 7.174005E+014
43 6.589875E+014
44 6.158189E+014
45 6.203645E+014
46 5.604593E+014
47 5.677392E+014
48 5.696204E+014
49 5.003183E+014
50 4.735248E+014
51 4.522101E+014
$EndNodeData
$NodeData
1
"Electron velocity (m s^-1)"
1
1.0000000000000000E-008
3
1000
3
51
1 6.755624E+003 2.474633E+002 2.390054E+002
2 2.054354E+005 -5.163376E+003 -9.846850E+003
3 1.851665E+004 5.899050E+001 2.941097E+002
4 5.874981E+003 -2.544408E+001 3.338329E+002
5 5.745724E+003 -2.992103E+002 -1.562428E+002
6 9.042765E+003 5.755962E+002 -7.509840E+002
7 1.189973E+004 1.251817E+003 -1.278355E+003
8 1.171915E+004 2.483533E+002 -1.798212E+003
9 1.539467E+004 -4.794788E+002 -1.578985E+002
10 1.749366E+004 -2.133315E+003 2.884641E+003
11 3.073569E+004 -1.813877E+003 2.015157E+002
12 4.338021E+004 4.080113E+003 -1.903833E+002
13 4.108799E+004 1.245391E+003 -1.163594E+003
14 3.541737E+004 2.090477E+003 2.419701E+002
15 3.427041E+004 2.013895E+003 -2.234277E+003
16 4.230007E+004 -2.398689E+003 1.371723E+002
17 4.749322E+004 1.597246E+003 -3.628288E+003
18 4.997666E+004 1.160104E+003 -8.401792E+003
19 5.195058E+004 -8.364161E+002 -1.802101E+003
20 5.591312E+004 -3.939060E+003 2.388800E+003
21 6.333098E+004 -6.945454E+002 2.258530E+002
22 6.525072E+004 -3.210740E+003 1.801044E+003
23 7.399242E+004 -1.986068E+003 2.887907E+002
24 7.895156E+004 3.349907E+003 -2.339613E+003
25 8.100325E+004 3.214988E+003 9.916669E+002
26 8.973728E+004 7.594115E+002 -3.305504E+003
27 9.309609E+004 1.417677E+003 -1.436153E+002
28 9.726401E+004 -3.383752E+003 2.393699E+003
29 1.004495E+005 -2.281003E+003 3.209291E+003
30 1.107262E+005 -1.404186E+003 7.470032E+002
31 1.202574E+005 -2.703508E+003 4.930279E+003
32 1.224420E+005 -3.973287E+002 -7.416719E+003
33 1.312544E+005 -5.905453E+003 -9.093921E+002
34 1.347764E+005 -3.491930E+003 -4.010455E+003
35 1.376741E+005 1.357565E+003 2.096097E+003
36 1.419675E+005 1.982650E+003 6.535850E+002
37 1.437177E+005 9.484341E+002 -1.187650E+004
38 1.468643E+005 2.894937E+003 -5.271059E+002
39 1.559764E+005 2.200720E+003 -6.344991E+003
40 1.599147E+005 -2.663692E+003 5.719357E+003
41 1.567097E+005 -7.359025E+000 -4.033384E+003
42 1.690415E+005 -6.956095E+002 3.022908E+003
43 1.814588E+005 -9.615306E+001 6.917210E+003
44 1.863152E+005 -7.990127E+002 1.523384E+004
45 1.886311E+005 4.934329E+003 4.438134E+002
46 1.938832E+005 -3.121504E+002 -3.067774E+003
47 1.900862E+005 -1.160531E+003 -4.620352E+003
48 1.923784E+005 -3.210640E+003 2.151672E+003
49 2.043583E+005 2.368308E+003 1.749902E+002
50 2.054704E+005 4.364283E+003 1.393513E+003
51 2.125792E+005 -4.749345E+003 -2.018864E+003
$EndNodeData
$NodeData
1
"Electron pressure (Pa)"
1
1.0000000000000000E-008
3
1000
1
51
1 2.252567E-001
2 7.546705E-006
3 4.045878E-002
4 5.008147E-003
5 2.551765E-003
6 1.488666E-003
7 1.021884E-003
8 7.937038E-004
9 5.788516E-004
10 4.290930E-004
11 3.263161E-004
12 2.445814E-004
13 2.004129E-004
14 1.799644E-004
15 1.711394E-004
16 1.505493E-004
17 1.238843E-004
18 1.124456E-004
19 9.851639E-005
20 8.889251E-005
21 7.626551E-005
22 6.799265E-005
23 5.942787E-005
24 5.395244E-005
25 4.992406E-005
26 4.474483E-005
27 4.103992E-005
28 3.826699E-005
29 3.404848E-005
30 3.038250E-005
31 2.882086E-005
32 2.844685E-005
33 2.486692E-005
34 2.305064E-005
35 2.204186E-005
36 2.045655E-005
37 1.912248E-005
38 1.817270E-005
39 1.663693E-005
40 1.616886E-005
41 1.470869E-005
42 1.249547E-005
43 1.189200E-005
44 1.112158E-005
45 1.148139E-005
46 1.015354E-005
47 9.973794E-006
48 9.467041E-006
49 8.605269E-006
50 8.068109E-006
51 8.336811E-006
$EndNodeData
$NodeData
1
"Electron temperature (K)"
1
1.0000000000000000E-008
3
1000
1
51
1 2.355409E+003
2 1.259899E+003
3 2.439915E+003
4 2.410136E+003
5 2.314246E+003
6 2.448833E+003
7 2.292833E+003
8 2.071307E+003
9 2.083225E+003
10 2.165738E+003
11 2.334589E+003
12 2.499719E+003
13 2.331244E+003
14 2.048702E+003
15 1.859852E+003
16 1.833641E+003
17 1.840328E+003
18 1.843025E+003
19 1.743703E+003
20 1.707266E+003
21 1.669315E+003
22 1.603229E+003
23 1.574972E+003
24 1.572667E+003
25 1.563034E+003
26 1.512492E+003
27 1.571017E+003
28 1.560488E+003
29 1.474228E+003
30 1.473759E+003
31 1.482881E+003
32 1.468559E+003
33 1.427073E+003
34 1.412111E+003
35 1.406820E+003
36 1.413897E+003
37 1.403850E+003
38 1.379006E+003
39 1.388116E+003
40 1.387513E+003
41 1.338179E+003
42 1.261559E+003
43 1.307058E+003
44 1.308069E+003
45 1.340493E+003
46 1.312170E+003
47 1.272414E+003
48 1.203776E+003
49 1.245762E+003
50 1.234087E+003
51 1.335293E+003
$EndNodeData

View file

@ -0,0 +1,7 @@
Alphie grid system.
The file mesh.geo can be easily modified to generate new grids to test different configurations.
Two cases are provided:
Clasical case in which ions and electrons are input from the ionization chamber.
Ionization case in which ion-electron pairs are generated due to the influx of electrons using the Ionization boundary condition.

View file

@ -2,19 +2,20 @@
"output": { "output": {
"path": "./runs/ALPHIE_Grid/", "path": "./runs/ALPHIE_Grid/",
"triggerOutput": 500, "triggerOutput": 500,
"triggerCPUTime": 1, "cpuTime": false,
"cpuTime": true,
"numColl": false, "numColl": false,
"EMField": true "EMField": true,
"folder": "base_case"
}, },
"geometry": { "geometry": {
"type": "2DCyl", "dimension": 2,
"meshType": "gmsh", "type": "Cyl",
"meshType": "gmsh2",
"meshFile": "mesh.msh" "meshFile": "mesh.msh"
}, },
"species": [ "species": [
{"name": "Argon+", "type": "charged", "mass": 6.633e-26, "charge": 1.0, "weight": 1.0e1}, {"name": "Argon+", "type": "charged", "mass": 6.633e-26, "charge": 1.0, "weight": 1.0e1},
{"name": "Electron", "type": "charged", "mass": 9.109e-31, "charge":-1.0, "weight": 1.0e1} {"name": "Electron", "type": "charged", "mass": 9.109e-31, "charge":-1.0, "weight": 1.0e2}
], ],
"boundary": [ "boundary": [
{"name": "Ionization Chanber", "physicalSurface": 1, "bTypes": [ {"name": "Ionization Chanber", "physicalSurface": 1, "bTypes": [
@ -44,30 +45,34 @@
], ],
"boundaryEM": [ "boundaryEM": [
{"name": "Extraction Grid", "type": "dirichlet", "potential": -150.0, "physicalSurface": 4}, {"name": "Extraction Grid", "type": "dirichlet", "potential": -150.0, "physicalSurface": 4},
{"name": "Acceleration Grid", "type": "dirichlet", "potential": -600.0, "physicalSurface": 5} {"name": "Acceleration Grid", "type": "dirichlet", "potential": -600.0, "physicalSurface": 5},
{"name": "Ionization Chamber", "type": "dirichlet", "potential": 0.0, "physicalSurface": 1},
{"name": "Infinite", "type": "dirichlet", "potential": -600.0, "physicalSurface": 2}
], ],
"inject": [ "inject": [
{"name": "Ionization Argon+", "species": "Argon+", "flow": 27.0e-6, "units": "A", "v": 322.0, "T": [ 500.0, 500.0, 500.0], {"name": "Ionization Argon+", "species": "Argon+", "flow": 1.0e-5, "units": "A", "v": 2500.0, "T": [ 500.0, 500.0, 500.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1}, "velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1},
{"name": "Ionization Electron", "species": "Electron", "flow": 27.0e-6, "units": "A", "v": 87000.0, "T": [ 500.0, 500.0, 500.0], {"name": "Ionization Electron", "species": "Electron", "flow": 1.0e-5, "units": "A", "v": 87000.0, "T": [30000.0, 30000.0, 30000.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1}, "velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1},
{"name": "Cathode Electron", "species": "Electron", "flow": 9.0e-5, "units": "A", "v": 87000.0, "T": [2500.0, 2500.0, 2500.0], {"name": "Cathode Electron", "species": "Electron", "flow": 1.0e-4, "units": "A", "v": 87000.0, "T": [30000.0, 30000.0, 30000.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [-1, 0, 0], "physicalSurface": 2} "velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [-1, 0, 0], "physicalSurface": 2}
], ],
"reference": { "reference": {
"density": 1.0e16, "density": 1.0e16,
"mass": 9.109e-31, "mass": 9.109e-31,
"temperature": 2500.0 "temperature": 2500.0,
"radius": 1.88e-10
}, },
"case": { "solver": {
"tau": [1.0e-9, 1.0e-11], "tau": [1.0e-9, 1.0e-11],
"time": 2.0e-6, "finalTime": 1.0e-6,
"pusher": ["2DCylCharged", "2DCylCharged"], "pusher": ["Electrostatic", "Electrostatic"],
"WeightingScheme": "Volume",
"EMSolver": "Electrostatic" "EMSolver": "Electrostatic"
}, },
"parallel": { "parallel": {
"OpenMP":{ "OpenMP":{
"nThreads": 8 "nThreads": 24
} }
} }
} }

View file

@ -2,24 +2,26 @@
"output": { "output": {
"path": "./runs/ALPHIE_Grid/", "path": "./runs/ALPHIE_Grid/",
"triggerOutput": 500, "triggerOutput": 500,
"triggerCPUTime": 1, "cpuTime": false,
"cpuTime": true,
"numColl": false, "numColl": false,
"EMField": true "EMField": true,
"folder": "ionization_0.10mA"
}, },
"geometry": { "geometry": {
"type": "2DCyl", "dimension": 2,
"meshType": "gmsh", "type": "Cyl",
"meshType": "gmsh2",
"meshFile": "mesh.msh" "meshFile": "mesh.msh"
}, },
"species": [ "species": [
{"name": "Argon+", "type": "charged", "mass": 6.633e-26, "charge": 1.0, "weight": 1.0e1}, {"name": "Argon+", "type": "charged", "mass": 6.633e-26, "charge": 1.0, "weight": 1.0e1},
{"name": "Electron", "type": "charged", "mass": 9.109e-31, "charge":-1.0, "weight": 1.0e1} {"name": "Electron", "type": "charged", "mass": 9.109e-31, "charge":-1.0, "weight": 1.0e2}
], ],
"boundary": [ "boundary": [
{"name": "Ionization Chanber", "physicalSurface": 1, "bTypes": [ {"name": "Ionization Chanber", "physicalSurface": 1, "bTypes": [
{"type": "transparent"}, {"type": "transparent"},
{"type": "transparent"} {"type": "ionization", "neutral": {"ion": "Argon+", "mass": 6.633e-26, "density": 5.0e16, "velocity": [2500, 0, 0], "temperature": 300},
"effectiveTime": 5.0e-6,"energyThreshold": 15.76, "crossSection": "./data/collisions/IO_e-Ar.dat"}
]}, ]},
{"name": "Vacuum Chamber", "physicalSurface": 2, "bTypes": [ {"name": "Vacuum Chamber", "physicalSurface": 2, "bTypes": [
{"type": "transparent"}, {"type": "transparent"},
@ -44,30 +46,30 @@
], ],
"boundaryEM": [ "boundaryEM": [
{"name": "Extraction Grid", "type": "dirichlet", "potential": -150.0, "physicalSurface": 4}, {"name": "Extraction Grid", "type": "dirichlet", "potential": -150.0, "physicalSurface": 4},
{"name": "Acceleration Grid", "type": "dirichlet", "potential": -600.0, "physicalSurface": 5} {"name": "Acceleration Grid", "type": "dirichlet", "potential": -600.0, "physicalSurface": 5},
{"name": "Ionization Chamber", "type": "dirichlet", "potential": 0.0, "physicalSurface": 1},
{"name": "Infinite", "type": "dirichlet", "potential": -600.0, "physicalSurface": 2}
], ],
"inject": [ "inject": [
{"name": "Ionization Argon+", "species": "Argon+", "flow": 27.0e-6, "units": "A", "v": 322.0, "T": [ 500.0, 500.0, 500.0], {"name": "Cathode Electron", "species": "Electron", "flow": 1.0e-4, "units": "A", "v": 87000.0, "T": [30000.0, 30000.0, 30000.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1},
{"name": "Ionization Electron", "species": "Electron", "flow": 27.0e-6, "units": "A", "v": 87000.0, "T": [ 500.0, 500.0, 500.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [ 1, 0, 0], "physicalSurface": 1},
{"name": "Cathode Electron", "species": "Electron", "flow": 9.0e-5, "units": "A", "v": 87000.0, "T": [2500.0, 2500.0, 2500.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [-1, 0, 0], "physicalSurface": 2} "velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [-1, 0, 0], "physicalSurface": 2}
], ],
"reference": { "reference": {
"density": 1.0e16, "density": 1.0e16,
"mass": 9.109e-31, "mass": 9.109e-31,
"temperature": 2500.0 "temperature": 2500.0,
"radius": 1.88e-10
}, },
"case": { "solver": {
"tau": [1.0e-11, 1.0e-11], "tau": [1.0e-9, 1.0e-11],
"time": 2.0e-6, "finalTime": 1.0e-6,
"pusher": ["2DCylCharged", "2DCylCharged"], "pusher": ["Electrostatic", "Electrostatic"],
"WeightingScheme": "Volume",
"EMSolver": "Electrostatic" "EMSolver": "Electrostatic"
}, },
"parallel": { "parallel": {
"OpenMP":{ "OpenMP":{
"nThreads": 8 "nThreads": 24
} }
} }
} }

View file

@ -1,12 +1,13 @@
Lz = 0.0100; zg1 = 0.0020;
Lr = 0.0006; tg1 = 0.0003;
zg1 = 0.0025;
tg1 = 0.0004;
rg1 = 0.0005; rg1 = 0.0005;
dg = 0.0025; dg = 0.0020;
zg2 = zg1 + tg1 + dg; zg2 = zg1 + tg1 + dg;
tg2 = tg1; tg2 = tg1;
rg2 = rg1; rg2 = rg1;
zEnd = 0.0050;
Lz = zg2 + tg2 + zEnd;
Lr = rg1 + 0.0001;
Lcell = 0.0001; Lcell = 0.0001;
@ -96,19 +97,19 @@ Transfinite Line {18, 19, 20, 21, 22, 6} = rg1/Lcell + 1 Using Progression 1;
Transfinite Line {17, 15, 13, 11, 9, 7} = (Lr-rg1)/Lcell + 1 Using Progression 1; Transfinite Line {17, 15, 13, 11, 9, 7} = (Lr-rg1)/Lcell + 1 Using Progression 1;
#Transfinite Surface{1}; Transfinite Surface{1};
#Recombine Surface {1}; Recombine Surface {1};
#Transfinite Surface{2}; Transfinite Surface{2};
#Recombine Surface {2}; Recombine Surface {2};
#Transfinite Surface{3}; Transfinite Surface{3};
#Recombine Surface {3}; Recombine Surface {3};
#Transfinite Surface{4}; Transfinite Surface{4};
#Recombine Surface {4}; Recombine Surface {4};
#Transfinite Surface{5}; Transfinite Surface{5};
#Recombine Surface {5}; Recombine Surface {5};
#Transfinite Surface{6}; Transfinite Surface{6};
#Recombine Surface {6}; Recombine Surface {6};
#Transfinite Surface{7}; Transfinite Surface{7};
#Recombine Surface {7}; Recombine Surface {7};
#Transfinite Surface{8}; Transfinite Surface{8};
#Recombine Surface {8}; Recombine Surface {8};

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -3,11 +3,13 @@
"path": "./runs/Argon_Expansion/", "path": "./runs/Argon_Expansion/",
"triggerOutput": 10, "triggerOutput": 10,
"cpuTime": false, "cpuTime": false,
"numColl": true "numColl": true,
"folder": "CX_case"
}, },
"geometry": { "geometry": {
"type": "2DCyl", "dimension": 2,
"meshType": "gmsh", "type": "Cyl",
"meshType": "gmsh2",
"meshFile": "mesh.msh" "meshFile": "mesh.msh"
}, },
"species": [ "species": [
@ -40,10 +42,10 @@
"temperature": 300.0, "temperature": 300.0,
"radius": 1.88e-10 "radius": 1.88e-10
}, },
"case": { "solver": {
"tau": [1.0e-6, 1.0e-6], "tau": [1.0e-6, 1.0e-6],
"time": 4.0e-3, "finalTime": 4.0e-3,
"pusher": ["2DCylNeutral", "2DCylNeutral"], "pusher": ["Neutral", "Neutral"],
"WeightingScheme": "Volume" "WeightingScheme": "Volume"
}, },
"interactions": { "interactions": {

View file

@ -3,11 +3,13 @@
"path": "./runs/Argon_Expansion/", "path": "./runs/Argon_Expansion/",
"triggerOutput": 10, "triggerOutput": 10,
"cpuTime": false, "cpuTime": false,
"numColl": false "numColl": false,
"folder": "Elastic_case"
}, },
"geometry": { "geometry": {
"type": "2DCyl", "dimension": 2,
"meshType": "gmsh", "type": "Cyl",
"meshType": "gmsh2",
"meshFile": "mesh.msh" "meshFile": "mesh.msh"
}, },
"species": [ "species": [
@ -40,10 +42,10 @@
"temperature": 300.0, "temperature": 300.0,
"radius": 1.88e-10 "radius": 1.88e-10
}, },
"case": { "solver": {
"tau": [1.0e-6, 1.0e-6], "tau": [1.0e-6, 1.0e-6],
"time": 4.0e-3, "finalTime": 4.0e-3,
"pusher": ["2DCylNeutral", "2DCylNeutral"], "pusher": ["Neutral", "Neutral"],
"WeightingScheme": "Volume" "WeightingScheme": "Volume"
}, },
"interactions": { "interactions": {

View file

@ -0,0 +1,56 @@
{
"output": {
"path": "./runs/Argon_Expansion/",
"triggerOutput": 10,
"cpuTime": false,
"numColl": false,
"folder": "Nocoll_case"
},
"geometry": {
"dimension": 2,
"type": "Cyl",
"meshType": "gmsh2",
"meshFile": "mesh.msh"
},
"species": [
{"name": "Argon", "type": "neutral", "mass": 6.633e-26, "weight": 1.0e8, "ion": "Argon+"},
{"name": "Argon+", "type": "charged", "mass": 6.633e-26, "weight": 1.0e8, "charge": 1.0, "neutral": "Argon"}
],
"boundary": [
{"name": "Injection", "physicalSurface": 1, "bTypes": [
{"type": "transparent"},
{"type": "transparent"}
]},
{"name": "Exterior", "physicalSurface": 2, "bTypes": [
{"type": "transparent"},
{"type": "transparent"}
]},
{"name": "Axis", "physicalSurface": 3, "bTypes": [
{"type": "axis"},
{"type": "axis"}
]}
],
"inject": [
{"name": "Exhausts Ar", "species": "Argon", "flow": 0.7, "units": "sccm", "v": 300.0, "T": [300.0, 300.0, 300.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [1, 0, 0], "physicalSurface": 1},
{"name": "Exhausts Ar+", "species": "Argon+", "flow": 0.3, "units": "sccm", "v": 40000.0, "T": [300.0, 300.0, 300.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [1, 0, 0], "physicalSurface": 1}
],
"reference": {
"density": 1.0e19,
"mass": 6.633e-26,
"temperature": 300.0,
"radius": 1.88e-10
},
"solver": {
"tau": [1.0e-6, 1.0e-6],
"finalTime": 4.0e-3,
"pusher": ["Neutral", "Neutral"],
"WeightingScheme": "Volume"
},
"parallel": {
"OpenMP":{
"nThreads": 24
}
}
}

7
runs/cylFlow/README.txt Normal file
View file

@ -0,0 +1,7 @@
Neutral flow around a cylinder with elastic collisions.
Case with the same mesh for particle weighting and collisions and another case using the dual mesh mode, with a more refined mesh around the cylinder.
This demostrates the capacity of fpakc to work with independent meshes for particles and collisions.
CPU time is outputed.
Gnuplot scripts for plotting the CPU time are provided.

View file

@ -3,12 +3,13 @@
"path": "./runs/cylFlow/", "path": "./runs/cylFlow/",
"triggerOutput": 10, "triggerOutput": 10,
"cpuTime": true, "cpuTime": true,
"numColl": false "numColl": true
}, },
"geometry": { "geometry": {
"type": "2DCyl", "dimension": 2,
"meshType": "gmsh", "type": "Cyl",
"meshFile": "mesh.msh" "meshType": "gmsh2",
"meshFile": "meshSingle.msh"
}, },
"species": [ "species": [
{"name": "Argon", "type": "neutral", "mass": 6.633e-26, "weight": 5.0e8} {"name": "Argon", "type": "neutral", "mass": 6.633e-26, "weight": 5.0e8}
@ -40,11 +41,10 @@
"temperature": 300.0, "temperature": 300.0,
"radius": 1.88e-10 "radius": 1.88e-10
}, },
"case": { "solver": {
"tau": [5.0e-7], "tau": [5.0e-7],
"time": 1.0e-3, "finalTime": 5.0e-4,
"pusher": ["2DCylNeutral"], "pusher": ["Neutral"],
"WeightingScheme": "Volume"
}, },
"interactions": { "interactions": {
"folderCollisions": "./data/collisions/", "folderCollisions": "./data/collisions/",
@ -57,7 +57,7 @@
}, },
"parallel": { "parallel": {
"OpenMP":{ "OpenMP":{
"nThreads": 8 "nThreads": 24
} }
} }
} }

View file

@ -0,0 +1,65 @@
{
"output": {
"path": "./runs/cylFlow/",
"triggerOutput": 10,
"cpuTime": true,
"numColl": true
},
"geometry": {
"dimension": 2,
"type": "Cyl",
"meshType": "gmsh2",
"meshFile": "mesh.msh",
"meshCollisions": "meshColl.msh"
},
"species": [
{"name": "Argon", "type": "neutral", "mass": 6.633e-26, "weight": 5.0e8}
],
"boundary": [
{"name": "Injection", "physicalSurface": 1, "bTypes": [
{"type": "transparent"}
]},
{"name": "Chamber Walls", "physicalSurface": 2, "bTypes": [
{"type": "reflection"}
]},
{"name": "Exterior", "physicalSurface": 3, "bTypes": [
{"type": "transparent"}
]},
{"name": "Cylinder Walls", "physicalSurface": 4, "bTypes": [
{"type": "reflection"}
]},
{"name": "Axis", "physicalSurface": 5, "bTypes": [
{"type": "axis"}
]}
],
"inject": [
{"name": "Nozzle", "species": "Argon", "flow": 10.0, "units": "sccm", "v": 300.0, "T": [300.0, 300.0, 300.0],
"velDist": ["Maxwellian", "Maxwellian", "Maxwellian"], "n": [1, 0, 0], "physicalSurface": 1}
],
"reference": {
"density": 1.0e20,
"mass": 6.633e-26,
"temperature": 300.0,
"radius": 1.88e-10
},
"solver": {
"tau": [5.0e-7],
"finalTime": 5.0e-4,
"pusher": ["Neutral"],
"WeightingScheme": "Volume"
},
"interactions": {
"folderCollisions": "./data/collisions/",
"collisions": [
{"species_i": "Argon", "species_j": "Argon",
"cTypes": [
{"type": "elastic", "crossSection": "EL_Ar-Ar.dat"}
]}
]
},
"parallel": {
"OpenMP":{
"nThreads": 24
}
}
}

View file

@ -62,10 +62,13 @@ Physical Surface(4) = {4};
Physical Surface(5) = {5}; Physical Surface(5) = {5};
Transfinite Line {12, 2, 4, 6} = cyl_h/Lcell + 1 Using Progression 1; Transfinite Line {12, 2, 4, 6} = cyl_h/Lcell + 1 Using Progression 1;
Transfinite Line {1, 13, 10} = cyl_s/Lcell + 1 Using Progression 1; Transfinite Line {10} = cyl_s/Lcell + 1 Using Progression 1;
Transfinite Line {11, 16, 15, 7} = (dom_h - cyl_h)/Lcell + 1 Using Progression 1; Transfinite Line {1, 13} = cyl_s/Lcell + 1 Using Progression 0.95;
Transfinite Line {11, 7} = (dom_h - cyl_h)/Lcell + 1 Using Progression 1;
Transfinite Line {16,-15} = (dom_h - cyl_h)/Lcell + 1 Using Progression 0.95;
Transfinite Line {3, 9} = cyl_l/Lcell + 1 Using Progression 1; Transfinite Line {3, 9} = cyl_l/Lcell + 1 Using Progression 1;
Transfinite Line {5, 14, 8} = (dom_l - cyl_e)/Lcell + 1 Using Progression 1; Transfinite Line {8} = (dom_l - cyl_e)/Lcell + 1 Using Progression 1;
Transfinite Line {-5, -14} = (dom_l - cyl_e)/Lcell + 1 Using Progression 0.95;
Transfinite Surface{1}; Transfinite Surface{1};
Recombine Surface {1}; Recombine Surface {1};

File diff suppressed because it is too large Load diff

View file

@ -1,629 +0,0 @@
General.AxesFormatX = "%.3g";
General.AxesFormatY = "%.3g";
General.AxesFormatZ = "%.3g";
General.AxesLabelX = "z (m)";
General.AxesLabelY = "r (m)";
General.AxesLabelZ = "";
General.BackgroundImageFileName = "";
General.BuildOptions = " 64Bit ALGLIB Bamg Blas Blossom DIntegration Dlopen DomHex Fltk GMP Gmm[system] Hxt Hxt3D Jpeg Kbipack Lapack LinuxJoystick MathEx Mesh Metis[system] Mmg3d Mpeg NativeFileChooser Netgen ONELAB ONELABMetamodel OpenCASCADE OpenCASCADE-CAF OpenGL OpenMP OptHom Parser Plugins Png Post QuadTri Solver TetGen/BR Zlib";
General.DefaultFileName = "untitled.geo";
General.Display = "";
General.ErrorFileName = ".gmsh-errors";
General.ExecutableFileName = "/usr/bin/gmsh";
General.FileName = "/home/jorge/PPartiC/runs/cylFlow/mesh.msh";
General.FltkTheme = "";
General.GraphicsFont = "Helvetica";
General.GraphicsFontEngine = "Native";
General.GraphicsFontTitle = "Helvetica";
General.OptionsFileName = ".gmsh-options";
General.RecentFile0 = "/home/jorge/PPartiC/runs/cylFlow/mesh.msh";
General.RecentFile1 = "untitled.geo";
General.RecentFile2 = "mesh/Neutral_Expansion_Div.geo";
General.RecentFile3 = "mesh/Neutral_Expansion_Div.msh";
General.RecentFile4 = "Neutral_Expansion_Div.msh";
General.RecentFile5 = "Neutral_Expansion.geo";
General.RecentFile6 = "Neutral_Expansion_Div.geo";
General.RecentFile7 = "/home/jorge/Dropbox/UPMPlasmaLab/Post-Doc/Codes/PICCIL2D/PIC-FEM/Neutral_Expansion_Div.msh";
General.RecentFile8 = "Neutral_Expansion.msh";
General.RecentFile9 = "/home/jorge/Dropbox/UPMPlasmaLab/Post-Doc/Codes/PICCIL2D/PIC-FEM/Neutral_Expansion.msh";
General.TextEditor = "gedit '%s'";
General.TmpFileName = ".gmsh-tmp";
General.Version = "4.4.1";
General.WatchFilePattern = "";
General.AlphaBlending = 1;
General.Antialiasing = 0;
General.ArrowHeadRadius = 0.12;
General.ArrowStemLength = 0.5600000000000001;
General.ArrowStemRadius = 0.02;
General.Axes = 1;
General.AxesMikado = 0;
General.AxesAutoPosition = 1;
General.AxesForceValue = 0;
General.AxesMaxX = 1;
General.AxesMaxY = 1;
General.AxesMaxZ = 1;
General.AxesMinX = 0;
General.AxesMinY = 0;
General.AxesMinZ = 0;
General.AxesTicsX = 8;
General.AxesTicsY = 4;
General.AxesTicsZ = 5;
General.AxesValueMaxX = 1;
General.AxesValueMaxY = 1;
General.AxesValueMaxZ = 1;
General.AxesValueMinX = 0;
General.AxesValueMinY = 0;
General.AxesValueMinZ = 0;
General.BackgroundGradient = 1;
General.BackgroundImage3D = 0;
General.BackgroundImagePage = 0;
General.BackgroundImagePositionX = 0;
General.BackgroundImagePositionY = 0;
General.BackgroundImageWidth = -1;
General.BackgroundImageHeight = -1;
General.BoundingBoxSize = 0.07615773105863909;
General.Camera = 0;
General.CameraAperture = 40;
General.CameraEyeSeparationRatio = 1.5;
General.CameraFocalLengthRatio = 1;
General.Clip0A = 1;
General.Clip0B = 0;
General.Clip0C = 0;
General.Clip0D = 0;
General.Clip1A = 0;
General.Clip1B = 1;
General.Clip1C = 0;
General.Clip1D = 0;
General.Clip2A = 0;
General.Clip2B = 0;
General.Clip2C = 1;
General.Clip2D = 0;
General.Clip3A = -1;
General.Clip3B = 0;
General.Clip3C = 0;
General.Clip3D = 1;
General.Clip4A = 0;
General.Clip4B = -1;
General.Clip4C = 0;
General.Clip4D = 1;
General.Clip5A = 0;
General.Clip5B = 0;
General.Clip5C = -1;
General.Clip5D = 1;
General.ClipFactor = 5;
General.ClipOnlyDrawIntersectingVolume = 0;
General.ClipOnlyVolume = 0;
General.ClipPositionX = 650;
General.ClipPositionY = 150;
General.ClipWholeElements = 0;
General.ColorScheme = 1;
General.ConfirmOverwrite = 1;
General.ContextPositionX = 235;
General.ContextPositionY = 962;
General.DetachedMenu = 0;
General.DisplayBorderFactor = 0.2;
General.DoubleBuffer = 1;
General.DrawBoundingBoxes = 0;
General.ExpertMode = 0;
General.ExtraPositionX = 650;
General.ExtraPositionY = 350;
General.ExtraHeight = 100;
General.ExtraWidth = 100;
General.FastRedraw = 0;
General.FieldPositionX = 650;
General.FieldPositionY = 550;
General.FieldHeight = 488;
General.FieldWidth = 651;
General.FileChooserPositionX = 200;
General.FileChooserPositionY = 200;
General.FltkColorScheme = 0;
General.FontSize = -1;
General.GraphicsFontSize = 15;
General.GraphicsFontSizeTitle = 18;
General.GraphicsHeight = 1003;
General.GraphicsPositionX = 274;
General.GraphicsPositionY = 263;
General.GraphicsWidth = 1920;
General.HighOrderToolsPositionX = 650;
General.HighOrderToolsPositionY = 150;
General.HighResolutionGraphics = 1;
General.HighResolutionPointSizeFactor = 2;
General.InitialModule = 0;
General.InputScrolling = 1;
General.Light0 = 1;
General.Light0X = 0.65;
General.Light0Y = 0.65;
General.Light0Z = 1;
General.Light0W = 0;
General.Light1 = 0;
General.Light1X = 0.5;
General.Light1Y = 0.3;
General.Light1Z = 1;
General.Light1W = 0;
General.Light2 = 0;
General.Light2X = 0.5;
General.Light2Y = 0.3;
General.Light2Z = 1;
General.Light2W = 0;
General.Light3 = 0;
General.Light3X = 0.5;
General.Light3Y = 0.3;
General.Light3Z = 1;
General.Light3W = 0;
General.Light4 = 0;
General.Light4X = 0.5;
General.Light4Y = 0.3;
General.Light4Z = 1;
General.Light4W = 0;
General.Light5 = 0;
General.Light5X = 0.5;
General.Light5Y = 0.3;
General.Light5Z = 1;
General.Light5W = 0;
General.LineWidth = 1;
General.ManipulatorPositionX = 650;
General.ManipulatorPositionY = 150;
General.MaxX = 0.07000000000000001;
General.MaxY = 0.03;
General.MaxZ = 0;
General.MenuWidth = 219;
General.MenuHeight = 200;
General.MenuPositionX = 400;
General.MenuPositionY = 400;
General.MessageFontSize = -1;
General.MessageHeight = 300;
General.MinX = 0;
General.MinY = 0;
General.MinZ = 0;
General.MouseHoverMeshes = 0;
General.MouseSelection = 1;
General.MouseInvertZoom = 0;
General.NonModalWindows = 1;
General.NoPopup = 0;
General.NumThreads = 1;
General.OptionsPositionX = 827;
General.OptionsPositionY = 541;
General.Orthographic = 1;
General.PluginPositionX = 58;
General.PluginPositionY = 658;
General.PluginHeight = 488;
General.PluginWidth = 708;
General.PointSize = 3;
General.PolygonOffsetAlwaysOn = 0;
General.PolygonOffsetFactor = 1;
General.PolygonOffsetUnits = 1;
General.ProgressMeterStep = 20;
General.QuadricSubdivisions = 6;
General.RotationX = -0;
General.RotationY = 0;
General.RotationZ = -0;
General.RotationCenterGravity = 1;
General.RotationCenterX = 0;
General.RotationCenterY = 0;
General.RotationCenterZ = 0;
General.SaveOptions = 0;
General.SaveSession = 1;
General.ScaleX = 1;
General.ScaleY = 1;
General.ScaleZ = 1;
General.Shininess = 0.4;
General.ShininessExponent = 40;
General.ShowModuleMenu = 1;
General.ShowOptionsOnStartup = 0;
General.ShowMessagesOnStartup = 0;
General.SmallAxes = 1;
General.SmallAxesPositionX = -60;
General.SmallAxesPositionY = -40;
General.SmallAxesSize = 30;
General.StatisticsPositionX = 650;
General.StatisticsPositionY = 150;
General.Stereo = 0;
General.SystemMenuBar = 1;
General.Terminal = 0;
General.Tooltips = 1;
General.Trackball = 1;
General.TrackballHyperbolicSheet = 1;
General.TrackballQuaternion0 = 0;
General.TrackballQuaternion1 = 0;
General.TrackballQuaternion2 = 0;
General.TrackballQuaternion3 = 1;
General.TranslationX = 0;
General.TranslationY = 0;
General.TranslationZ = 0;
General.VectorType = 4;
General.Verbosity = 5;
General.VisibilityPositionX = 1118;
General.VisibilityPositionY = 464;
General.ZoomFactor = 4;
General.Color.Background = {255,255,255};
General.Color.BackgroundGradient = {208,215,255};
General.Color.Foreground = {85,85,85};
General.Color.Text = {0,0,0};
General.Color.Axes = {0,0,0};
General.Color.SmallAxes = {0,0,0};
General.Color.AmbientLight = {25,25,25};
General.Color.DiffuseLight = {255,255,255};
General.Color.SpecularLight = {255,255,255};
Geometry.DoubleClickedPointCommand = "";
Geometry.DoubleClickedLineCommand = "";
Geometry.DoubleClickedSurfaceCommand = "";
Geometry.DoubleClickedVolumeCommand = "";
Geometry.OCCTargetUnit = "";
Geometry.AutoCoherence = 1;
Geometry.Clip = 0;
Geometry.CopyMeshingMethod = 0;
Geometry.DoubleClickedEntityTag = 0;
Geometry.ExactExtrusion = 1;
Geometry.ExtrudeReturnLateralEntities = 1;
Geometry.ExtrudeSplinePoints = 5;
Geometry.HighlightOrphans = 0;
Geometry.LabelType = 0;
Geometry.Light = 1;
Geometry.LightTwoSide = 1;
Geometry.Lines = 1;
Geometry.LineNumbers = 0;
Geometry.LineSelectWidth = 3;
Geometry.LineType = 0;
Geometry.LineWidth = 2;
Geometry.MatchGeomAndMesh = 0;
Geometry.MatchMeshScaleFactor = 1;
Geometry.MatchMeshTolerance = 1e-06;
Geometry.Normals = 0;
Geometry.NumSubEdges = 40;
Geometry.OCCAutoFix = 1;
Geometry.OCCBooleanPreserveNumbering = 1;
Geometry.OCCDisableSTL = 0;
Geometry.OCCFixDegenerated = 0;
Geometry.OCCFixSmallEdges = 0;
Geometry.OCCFixSmallFaces = 0;
Geometry.OCCImportLabels = 1;
Geometry.OCCParallel = 0;
Geometry.OCCScaling = 1;
Geometry.OCCSewFaces = 0;
Geometry.OffsetX = 0;
Geometry.OffsetY = 0;
Geometry.OffsetZ = 0;
Geometry.OldCircle = 0;
Geometry.OldRuledSurface = 0;
Geometry.OldNewReg = 1;
Geometry.Points = 1;
Geometry.PointNumbers = 0;
Geometry.PointSelectSize = 6;
Geometry.PointSize = 4;
Geometry.PointType = 0;
Geometry.ReparamOnFaceRobust = 0;
Geometry.ScalingFactor = 1;
Geometry.OrientedPhysicals = 1;
Geometry.SnapX = 0.1;
Geometry.SnapY = 0.1;
Geometry.SnapZ = 0.1;
Geometry.Surfaces = 0;
Geometry.SurfaceNumbers = 0;
Geometry.SurfaceType = 0;
Geometry.Tangents = 0;
Geometry.Tolerance = 1e-08;
Geometry.ToleranceBoolean = 0;
Geometry.Transform = 0;
Geometry.TransformXX = 1;
Geometry.TransformXY = 0;
Geometry.TransformXZ = 0;
Geometry.TransformYX = 0;
Geometry.TransformYY = 1;
Geometry.TransformYZ = 0;
Geometry.TransformZX = 0;
Geometry.TransformZY = 0;
Geometry.TransformZZ = 1;
Geometry.Volumes = 0;
Geometry.VolumeNumbers = 0;
Geometry.Color.Points = {90,90,90};
Geometry.Color.Lines = {0,0,255};
Geometry.Color.Surfaces = {128,128,128};
Geometry.Color.Volumes = {255,255,0};
Geometry.Color.Selection = {255,0,0};
Geometry.Color.HighlightZero = {255,0,0};
Geometry.Color.HighlightOne = {255,150,0};
Geometry.Color.HighlightTwo = {255,255,0};
Geometry.Color.Tangents = {255,255,0};
Geometry.Color.Normals = {255,0,0};
Geometry.Color.Projection = {0,255,0};
Mesh.Algorithm = 2;
Mesh.Algorithm3D = 1;
Mesh.AngleSmoothNormals = 30;
Mesh.AngleToleranceFacetOverlap = 0.1;
Mesh.AnisoMax = 9.999999999999999e+32;
Mesh.AllowSwapAngle = 10;
Mesh.BdfFieldFormat = 1;
Mesh.Binary = 0;
Mesh.BoundaryLayerFanPoints = 5;
Mesh.CgnsImportOrder = 1;
Mesh.CgnsConstructTopology = 0;
Mesh.CharacteristicLengthExtendFromBoundary = 1;
Mesh.CharacteristicLengthFactor = 1;
Mesh.CharacteristicLengthMin = 0;
Mesh.CharacteristicLengthMax = 1e+22;
Mesh.CharacteristicLengthFromCurvature = 0;
Mesh.CharacteristicLengthFromPoints = 1;
Mesh.Clip = 0;
Mesh.ColorCarousel = 0;
Mesh.CompoundClassify = 1;
Mesh.CompoundCharacteristicLengthFactor = 0.5;
Mesh.CpuTime = 0;
Mesh.DrawSkinOnly = 0;
Mesh.Dual = 0;
Mesh.ElementOrder = 1;
Mesh.Explode = 1;
Mesh.FlexibleTransfinite = 0;
Mesh.NewtonConvergenceTestXYZ = 0;
Mesh.Format = 10;
Mesh.Hexahedra = 1;
Mesh.HighOrderIterMax = 100;
Mesh.HighOrderNumLayers = 6;
Mesh.HighOrderOptimize = 0;
Mesh.HighOrderPassMax = 25;
Mesh.HighOrderPeriodic = 0;
Mesh.HighOrderPoissonRatio = 0.33;
Mesh.HighOrderPrimSurfMesh = 0;
Mesh.HighOrderDistCAD = 0;
Mesh.HighOrderThresholdMin = 0.1;
Mesh.HighOrderThresholdMax = 2;
Mesh.LabelSampling = 1;
Mesh.LabelType = 0;
Mesh.LcIntegrationPrecision = 1e-09;
Mesh.Light = 1;
Mesh.LightLines = 2;
Mesh.LightTwoSide = 1;
Mesh.Lines = 1;
Mesh.LineNumbers = 0;
Mesh.LineWidth = 1;
Mesh.MaxNumThreads1D = 0;
Mesh.MaxNumThreads2D = 0;
Mesh.MaxNumThreads3D = 0;
Mesh.MeshOnlyVisible = 0;
Mesh.MetisAlgorithm = 1;
Mesh.MetisEdgeMatching = 2;
Mesh.MetisMaxLoadImbalance = -1;
Mesh.MetisObjective = 1;
Mesh.MetisMinConn = -1;
Mesh.MetisRefinementAlgorithm = 2;
Mesh.MinimumCirclePoints = 7;
Mesh.MinimumCurvePoints = 3;
Mesh.MshFileVersion = 4.1;
Mesh.MedFileMinorVersion = -1;
Mesh.MedImportGroupsOfNodes = 0;
Mesh.MedSingleModel = 0;
Mesh.PartitionHexWeight = -1;
Mesh.PartitionLineWeight = -1;
Mesh.PartitionPrismWeight = -1;
Mesh.PartitionPyramidWeight = -1;
Mesh.PartitionQuadWeight = -1;
Mesh.PartitionTrihedronWeight = 0;
Mesh.PartitionTetWeight = -1;
Mesh.PartitionTriWeight = -1;
Mesh.PartitionCreateTopology = 1;
Mesh.PartitionCreatePhysicals = 1;
Mesh.PartitionCreateGhostCells = 0;
Mesh.PartitionSplitMeshFiles = 0;
Mesh.PartitionTopologyFile = 0;
Mesh.PartitionOldStyleMsh2 = 1;
Mesh.NbHexahedra = 0;
Mesh.NbNodes = 27248;
Mesh.NbPartitions = 0;
Mesh.NbPrisms = 0;
Mesh.NbPyramids = 0;
Mesh.NbTrihedra = 0;
Mesh.NbQuadrangles = 26877;
Mesh.NbTetrahedra = 0;
Mesh.NbTriangles = 0;
Mesh.Normals = 0;
Mesh.NumSubEdges = 2;
Mesh.Optimize = 1;
Mesh.OptimizeThreshold = 0.3;
Mesh.OptimizeNetgen = 0;
Mesh.Points = 0;
Mesh.PointNumbers = 0;
Mesh.PointSize = 4;
Mesh.PointType = 0;
Mesh.Prisms = 1;
Mesh.Pyramids = 1;
Mesh.Trihedra = 1;
Mesh.Quadrangles = 1;
Mesh.QualityInf = 0;
Mesh.QualitySup = 0;
Mesh.QualityType = 2;
Mesh.RadiusInf = 0;
Mesh.RadiusSup = 0;
Mesh.RandomFactor = 1e-09;
Mesh.RandomFactor3D = 1e-12;
Mesh.RandomSeed = 1;
Mesh.PreserveNumberingMsh2 = 0;
Mesh.IgnorePeriodicity = 0;
Mesh.RecombinationAlgorithm = 1;
Mesh.RecombineAll = 0;
Mesh.RecombineOptimizeTopology = 5;
Mesh.Recombine3DAll = 0;
Mesh.Recombine3DLevel = 0;
Mesh.Recombine3DConformity = 0;
Mesh.RefineSteps = 10;
Mesh.Renumber = 1;
Mesh.SaveAll = 0;
Mesh.SaveElementTagType = 1;
Mesh.SaveTopology = 0;
Mesh.SaveParametric = 0;
Mesh.SaveGroupsOfNodes = 0;
Mesh.ScalingFactor = 1;
Mesh.SecondOrderExperimental = 0;
Mesh.SecondOrderIncomplete = 0;
Mesh.SecondOrderLinear = 0;
Mesh.Smoothing = 1;
Mesh.SmoothCrossField = 0;
Mesh.CrossFieldClosestPoint = 1;
Mesh.SmoothNormals = 0;
Mesh.SmoothRatio = 1.8;
Mesh.StlOneSolidPerSurface = 0;
Mesh.StlRemoveDuplicateTriangles = 0;
Mesh.SubdivisionAlgorithm = 0;
Mesh.SurfaceEdges = 0;
Mesh.SurfaceFaces = 0;
Mesh.SurfaceNumbers = 0;
Mesh.SwitchElementTags = 0;
Mesh.Tangents = 0;
Mesh.Tetrahedra = 1;
Mesh.ToleranceEdgeLength = 0;
Mesh.ToleranceInitialDelaunay = 1e-08;
Mesh.Triangles = 1;
Mesh.UnvStrictFormat = 1;
Mesh.VolumeEdges = 1;
Mesh.VolumeFaces = 0;
Mesh.VolumeNumbers = 0;
Mesh.Voronoi = 0;
Mesh.ZoneDefinition = 0;
Mesh.Color.Points = {0,0,255};
Mesh.Color.PointsSup = {255,0,255};
Mesh.Color.Lines = {0,0,0};
Mesh.Color.Triangles = {160,150,255};
Mesh.Color.Quadrangles = {130,120,225};
Mesh.Color.Tetrahedra = {160,150,255};
Mesh.Color.Hexahedra = {130,120,225};
Mesh.Color.Prisms = {232,210,23};
Mesh.Color.Pyramids = {217,113,38};
Mesh.Color.Trihedra = {20,255,0};
Mesh.Color.Tangents = {255,255,0};
Mesh.Color.Normals = {255,0,0};
Mesh.Color.Zero = {255,120,0};
Mesh.Color.One = {0,255,132};
Mesh.Color.Two = {255,160,0};
Mesh.Color.Three = {0,255,192};
Mesh.Color.Four = {255,200,0};
Mesh.Color.Five = {0,216,255};
Mesh.Color.Six = {255,240,0};
Mesh.Color.Seven = {0,176,255};
Mesh.Color.Eight = {228,255,0};
Mesh.Color.Nine = {0,116,255};
Mesh.Color.Ten = {188,255,0};
Mesh.Color.Eleven = {0,76,255};
Mesh.Color.Twelve = {148,255,0};
Mesh.Color.Thirteen = {24,0,255};
Mesh.Color.Fourteen = {108,255,0};
Mesh.Color.Fifteen = {84,0,255};
Mesh.Color.Sixteen = {68,255,0};
Mesh.Color.Seventeen = {104,0,255};
Mesh.Color.Eighteen = {0,255,52};
Mesh.Color.Nineteen = {184,0,255};
Solver.Executable0 = "";
Solver.Executable1 = "";
Solver.Executable2 = "";
Solver.Executable3 = "";
Solver.Executable4 = "";
Solver.Executable5 = "";
Solver.Executable6 = "";
Solver.Executable7 = "";
Solver.Executable8 = "";
Solver.Executable9 = "";
Solver.Name0 = "GetDP";
Solver.Name1 = "";
Solver.Name2 = "";
Solver.Name3 = "";
Solver.Name4 = "";
Solver.Name5 = "";
Solver.Name6 = "";
Solver.Name7 = "";
Solver.Name8 = "";
Solver.Name9 = "";
Solver.Extension0 = ".pro";
Solver.Extension1 = "";
Solver.Extension2 = "";
Solver.Extension3 = "";
Solver.Extension4 = "";
Solver.Extension5 = "";
Solver.Extension6 = "";
Solver.Extension7 = "";
Solver.Extension8 = "";
Solver.Extension9 = "";
Solver.OctaveInterpreter = "octave";
Solver.PythonInterpreter = "python";
Solver.RemoteLogin0 = "";
Solver.RemoteLogin1 = "";
Solver.RemoteLogin2 = "";
Solver.RemoteLogin3 = "";
Solver.RemoteLogin4 = "";
Solver.RemoteLogin5 = "";
Solver.RemoteLogin6 = "";
Solver.RemoteLogin7 = "";
Solver.RemoteLogin8 = "";
Solver.RemoteLogin9 = "";
Solver.SocketName = ".gmshsock";
Solver.AlwaysListen = 0;
Solver.AutoArchiveOutputFiles = 0;
Solver.AutoCheck = 1;
Solver.AutoLoadDatabase = 0;
Solver.AutoSaveDatabase = 1;
Solver.AutoMesh = 2;
Solver.AutoMergeFile = 1;
Solver.AutoShowViews = 2;
Solver.AutoShowLastStep = 1;
Solver.Plugins = 0;
Solver.ShowInvisibleParameters = 0;
Solver.Timeout = 5;
PostProcessing.DoubleClickedGraphPointCommand = "";
PostProcessing.GraphPointCommand = "";
PostProcessing.AnimationDelay = 0.1;
PostProcessing.AnimationCycle = 0;
PostProcessing.AnimationStep = 1;
PostProcessing.CombineRemoveOriginal = 1;
PostProcessing.DoubleClickedGraphPointX = 0;
PostProcessing.DoubleClickedGraphPointY = 0;
PostProcessing.DoubleClickedView = 0;
PostProcessing.ForceElementData = 0;
PostProcessing.ForceNodeData = 0;
PostProcessing.Format = 10;
PostProcessing.GraphPointX = 0;
PostProcessing.GraphPointY = 0;
PostProcessing.HorizontalScales = 1;
PostProcessing.Link = 0;
PostProcessing.NbViews = 0;
PostProcessing.Plugins = 1;
PostProcessing.SaveInterpolationMatrices = 1;
PostProcessing.SaveMesh = 1;
PostProcessing.Smoothing = 0;
Print.ParameterCommand = "Mesh.Clip=1; View.Clip=1; General.ClipWholeElements=1; General.Clip0D=Print.Parameter; SetChanged;";
Print.Parameter = 0;
Print.ParameterFirst = -1;
Print.ParameterLast = 1;
Print.ParameterSteps = 10;
Print.Background = 0;
Print.CompositeWindows = 0;
Print.PgfTwoDim = 1;
Print.PgfExportAxis = 0;
Print.PgfHorizontalBar = 0;
Print.DeleteTemporaryFiles = 1;
Print.EpsBestRoot = 1;
Print.EpsCompress = 0;
Print.EpsLineWidthFactor = 1;
Print.EpsOcclusionCulling = 1;
Print.EpsPointSizeFactor = 1;
Print.EpsPS3Shading = 0;
Print.EpsQuality = 1;
Print.Format = 10;
Print.GeoLabels = 1;
Print.GeoOnlyPhysicals = 0;
Print.GifDither = 0;
Print.GifInterlace = 0;
Print.GifSort = 1;
Print.GifTransparent = 0;
Print.Height = -1;
Print.JpegQuality = 100;
Print.JpegSmoothing = 0;
Print.PostElementary = 1;
Print.PostElement = 0;
Print.PostGamma = 0;
Print.PostEta = 0;
Print.PostSICN = 0;
Print.PostSIGE = 0;
Print.PostDisto = 0;
Print.TexAsEquation = 0;
Print.Text = 1;
Print.X3dCompatibility = 0;
Print.X3dPrecision = 1e-09;
Print.X3dRemoveInnerBorders = 0;
Print.X3dTransparency = 0;
Print.Width = -1;

73
runs/cylFlow/meshColl.geo Normal file
View file

@ -0,0 +1,73 @@
cl__1 = 1;
cyl_h = 0.005;
cyl_l = 0.02;
cyl_s = 0.03;
cyl_e = cyl_s + cyl_l;
dom_h = 0.03;
dom_l = 0.07;
Lcell = 0.001;
Point(1) = {0, 0, 0, cl__1};
Point(2) = {cyl_s, 0, 0, cl__1};
Point(3) = {cyl_s, cyl_h, 0, cl__1};
Point(4) = {cyl_e, cyl_h, 0, cl__1};
Point(5) = {cyl_e, 0, 0, cl__1};
Point(6) = {dom_l, 0, 0, cl__1};
Point(7) = {dom_l, cyl_h, 0, cl__1};
Point(8) = {dom_l, dom_h, 0, cl__1};
Point(9) = {cyl_e, dom_h, 0, cl__1};
Point(10) = {cyl_s, dom_h, 0, cl__1};
Point(11) = {0, dom_h, 0, cl__1};
Point(12) = {0, cyl_h, 0, cl__1};
Line(1) = {1, 2};
Line(2) = {2, 3};
Line(3) = {3, 4};
Line(4) = {4, 5};
Line(5) = {5, 6};
Line(6) = {6, 7};
Line(7) = {7, 8};
Line(8) = {8, 9};
Line(9) = {9, 10};
Line(10) = {10, 11};
Line(11) = {11, 12};
Line(12) = {12, 1};
Line(13) = {12, 3};
Line(14) = {4, 7};
Line(15) = {4, 9};
Line(16) = {10, 3};
Line Loop(1) = {1, 2, -13, 12};
Plane Surface(1) = {1};
Line Loop(2) = {13, -16, 10, 11};
Plane Surface(2) = {2};
Line Loop(3) = {3, 15, 9, 16};
Plane Surface(3) = {3};
Line Loop(4) = {5, 6, -14, 4};
Plane Surface(4) = {4};
Line Loop(5) = {14, 7, 8, -15};
Plane Surface(5) = {5};
Physical Surface(1) = {1};
Physical Surface(2) = {2};
Physical Surface(3) = {3};
Physical Surface(4) = {4};
Physical Surface(5) = {5};
Transfinite Line {12, 2, 4, 6} = cyl_h/Lcell + 1 Using Progression 1;
Transfinite Line {1, 13, 10} = cyl_s/Lcell + 1 Using Progression 1;
Transfinite Line {11, 16, 15, 7} = (dom_h - cyl_h)/Lcell + 1 Using Progression 1;
Transfinite Line {3, 9} = cyl_l/Lcell + 1 Using Progression 1;
Transfinite Line {5, 14, 8} = (dom_l - cyl_e)/Lcell + 1 Using Progression 1;
Transfinite Surface{1};
Recombine Surface {1};
Transfinite Surface{2};
Recombine Surface {2};
Transfinite Surface{3};
Recombine Surface {3};
Transfinite Surface{4};
Recombine Surface {4};
Transfinite Surface{5};
Recombine Surface {5};

3974
runs/cylFlow/meshColl.msh Normal file

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,79 @@
cl__1 = 1;
cyl_h = 0.005;
cyl_l = 0.02;
cyl_s = 0.03;
cyl_e = cyl_s + cyl_l;
dom_h = 0.03;
dom_l = 0.07;
Lcell = 0.001;
Point(1) = {0, 0, 0, cl__1};
Point(2) = {cyl_s, 0, 0, cl__1};
Point(3) = {cyl_s, cyl_h, 0, cl__1};
Point(4) = {cyl_e, cyl_h, 0, cl__1};
Point(5) = {cyl_e, 0, 0, cl__1};
Point(6) = {dom_l, 0, 0, cl__1};
Point(7) = {dom_l, cyl_h, 0, cl__1};
Point(8) = {dom_l, dom_h, 0, cl__1};
Point(9) = {cyl_e, dom_h, 0, cl__1};
Point(10) = {cyl_s, dom_h, 0, cl__1};
Point(11) = {0, dom_h, 0, cl__1};
Point(12) = {0, cyl_h, 0, cl__1};
Line(1) = {1, 2};
Line(2) = {2, 3};
Line(3) = {3, 4};
Line(4) = {4, 5};
Line(5) = {5, 6};
Line(6) = {6, 7};
Line(7) = {7, 8};
Line(8) = {8, 9};
Line(9) = {9, 10};
Line(10) = {10, 11};
Line(11) = {11, 12};
Line(12) = {12, 1};
Line(13) = {12, 3};
Line(14) = {4, 7};
Line(15) = {4, 9};
Line(16) = {10, 3};
Line Loop(1) = {1, 2, -13, 12};
Plane Surface(1) = {1};
Line Loop(2) = {13, -16, 10, 11};
Plane Surface(2) = {2};
Line Loop(3) = {3, 15, 9, 16};
Plane Surface(3) = {3};
Line Loop(4) = {5, 6, -14, 4};
Plane Surface(4) = {4};
Line Loop(5) = {14, 7, 8, -15};
Plane Surface(5) = {5};
Physical Line(1) = {12, 11};
Physical Line(2) = {10, 9, 8};
Physical Line(3) = {7, 6};
Physical Line(4) = {2, 3, 4};
Physical Line(5) = {1, 5};
Physical Surface(1) = {1};
Physical Surface(2) = {2};
Physical Surface(3) = {3};
Physical Surface(4) = {4};
Physical Surface(5) = {5};
Transfinite Line {12, 2, 4, 6} = cyl_h/Lcell + 1 Using Progression 1;
Transfinite Line {1, 13, 10} = cyl_s/Lcell + 1 Using Progression 1;
Transfinite Line {11, 16, 15, 7} = (dom_h - cyl_h)/Lcell + 1 Using Progression 1;
Transfinite Line {3, 9} = cyl_l/Lcell + 1 Using Progression 1;
Transfinite Line {5, 14, 8} = (dom_l - cyl_e)/Lcell + 1 Using Progression 1;
Transfinite Surface{1};
Recombine Surface {1};
Transfinite Surface{2};
Recombine Surface {2};
Transfinite Surface{3};
Recombine Surface {3};
Transfinite Surface{4};
Recombine Surface {4};
Transfinite Surface{5};
Recombine Surface {5};

4182
runs/cylFlow/meshSingle.msh Normal file

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -1,20 +1,22 @@
! FPAKC main program ! FPAKC main program
PROGRAM fpakc PROGRAM fpakc
USE moduleInput
USE moduleErrors
USE moduleInject
USE moduleSolver
USE moduleCompTime USE moduleCompTime
USE moduleCaseParam USE moduleCaseParam
USE moduleInput
USE moduleInject
USE moduleSolver
USE moduleMesh
USE moduleProbe
USE moduleErrors
USE OMP_LIB USE OMP_LIB
IMPLICIT NONE IMPLICIT NONE
! t = time step
INTEGER:: t = 0
! arg1 = Input argument 1 (input file) ! arg1 = Input argument 1 (input file)
CHARACTER(200):: arg1 CHARACTER(200):: arg1
! inputFile = path+name of input file ! inputFile = path+name of input file
CHARACTER(:), ALLOCATABLE:: inputFile CHARACTER(:), ALLOCATABLE:: inputFile
! generic integer for time step
INTEGER:: t
tStep = omp_get_wtime() tStep = omp_get_wtime()
!Gets the input file !Gets the input file
@ -26,8 +28,17 @@ PROGRAM fpakc
!Reads the json configuration file !Reads the json configuration file
CALL readConfig(inputFile) CALL readConfig(inputFile)
!Create output folder and initial files
CALL initOutput(inputFile)
!Do '0' iteration
timeStep = tInitial
!$OMP PARALLEL DEFAULT(SHARED) !$OMP PARALLEL DEFAULT(SHARED)
!$OMP SINGLE !$OMP SINGLE
! Initial reset of probes
CALL resetProbes()
CALL verboseError("Initial scatter of particles...") CALL verboseError("Initial scatter of particles...")
!$OMP END SINGLE !$OMP END SINGLE
CALL doScatter() CALL doScatter()
@ -41,16 +52,21 @@ PROGRAM fpakc
tStep = omp_get_wtime() - tStep tStep = omp_get_wtime() - tStep
!Output initial state !Output initial state
CALL doOutput(t) CALL doOutput()
CALL verboseError('Starting main loop...') CALL verboseError('Starting main loop...')
!$OMP PARALLEL DEFAULT(SHARED) !$OMP PARALLEL DEFAULT(SHARED)
DO t = 1, tmax DO t = tInitial + 1, tFinal
!Insert new particles and push them
!$OMP SINGLE !$OMP SINGLE
tStep = omp_get_wtime() tStep = omp_get_wtime()
! Update global time step index
timeStep = t
!Checks if a species needs to me moved in this iteration !Checks if a species needs to me moved in this iteration
CALL solver%updatePushSpecies(t) CALL solver%updatePushSpecies()
!Checks if probes need to be calculated this iteration
CALL resetProbes()
tPush = omp_get_wtime() tPush = omp_get_wtime()
!$OMP END SINGLE !$OMP END SINGLE
@ -67,11 +83,26 @@ PROGRAM fpakc
tColl = omp_get_wtime() tColl = omp_get_wtime()
!$OMP END SINGLE !$OMP END SINGLE
CALL doCollisions() IF (doMCCollisions) THEN
CALL meshForMCC%doCollisions()
END IF
!$OMP SINGLE !$OMP SINGLE
tColl = omp_get_wtime() - tColl tColl = omp_get_wtime() - tColl
!Coulomb scattering
tCoul = omp_get_wTime()
!$OMP END SINGLE
IF (doCoulombScattering) THEN
CALL mesh%doCoulomb()
END IF
!$OMP SINGLE
tCoul = omp_get_wTime() - tCoul
!Reset particles !Reset particles
tReset = omp_get_wtime() tReset = omp_get_wtime()
!$OMP END SINGLE !$OMP END SINGLE
@ -98,10 +129,12 @@ PROGRAM fpakc
!$OMP SINGLE !$OMP SINGLE
tEMField = omp_get_wtime() - tEMField tEMField = omp_get_wtime() - tEMField
CALL doAverage()
tStep = omp_get_wtime() - tStep tStep = omp_get_wtime() - tStep
!Output data !Output data
CALL doOutput(t) CALL doOutput()
!$OMP END SINGLE !$OMP END SINGLE
END DO END DO

View file

@ -1,18 +1,30 @@
OBJECTS = $(OBJDIR)/moduleMesh.o $(OBJDIR)/moduleCompTime.o $(OBJDIR)/moduleSolver.o \ OBJECTS = $(OBJDIR)/moduleMesh.o $(OBJDIR)/moduleMeshBoundary.o $(OBJDIR)/moduleCompTime.o \
$(OBJDIR)/moduleSpecies.o $(OBJDIR)/moduleInject.o $(OBJDIR)/moduleInput.o \ $(OBJDIR)/moduleSpecies.o $(OBJDIR)/moduleInject.o $(OBJDIR)/moduleInput.o \
$(OBJDIR)/moduleErrors.o $(OBJDIR)/moduleList.o $(OBJDIR)/moduleOutput.o \ $(OBJDIR)/moduleErrors.o $(OBJDIR)/moduleList.o $(OBJDIR)/moduleOutput.o \
$(OBJDIR)/moduleBoundary.o $(OBJDIR)/moduleCaseParam.o $(OBJDIR)/moduleRefParam.o \ $(OBJDIR)/moduleBoundary.o $(OBJDIR)/moduleCaseParam.o $(OBJDIR)/moduleRefParam.o \
$(OBJDIR)/moduleCollisions.o $(OBJDIR)/moduleTable.o $(OBJDIR)/moduleParallel.o \ $(OBJDIR)/moduleCollisions.o $(OBJDIR)/moduleTable.o $(OBJDIR)/moduleParallel.o \
$(OBJDIR)/moduleEM.o $(OBJDIR)/moduleRandom.o \ $(OBJDIR)/moduleEM.o $(OBJDIR)/moduleRandom.o $(OBJDIR)/moduleMath.o \
$(OBJDIR)/moduleMeshCyl.o $(OBJDIR)/moduleMeshCylRead.o $(OBJDIR)/moduleMeshCylBoundary.o \ $(OBJDIR)/moduleProbe.o $(OBJDIR)/moduleAverage.o $(OBJDIR)/moduleCoulomb.o \
$(OBJDIR)/moduleMesh1DCart.o $(OBJDIR)/moduleMesh1DCartRead.o $(OBJDIR)/moduleMesh1DCartBoundary.o \ $(OBJDIR)/moduleMeshInoutCommon.o \
$(OBJDIR)/moduleMesh1DRad.o $(OBJDIR)/moduleMesh1DRadRead.o $(OBJDIR)/moduleMesh1DRadBoundary.o $(OBJDIR)/moduleMeshInputVTU.o $(OBJDIR)/moduleMeshOutputVTU.o \
$(OBJDIR)/moduleMeshInputGmsh2.o $(OBJDIR)/moduleMeshOutputGmsh2.o \
$(OBJDIR)/moduleMeshInput0D.o $(OBJDIR)/moduleMeshOutput0D.o \
$(OBJDIR)/moduleMeshInputText.o $(OBJDIR)/moduleMeshOutputText.o \
$(OBJDIR)/moduleMesh3DCart.o \
$(OBJDIR)/moduleMesh2DCyl.o \
$(OBJDIR)/moduleMesh2DCart.o \
$(OBJDIR)/moduleMesh1DRad.o \
$(OBJDIR)/moduleMesh1DCart.o \
$(OBJDIR)/moduleMesh0D.o \
$(OBJDIR)/moduleSolver.o \
$(OBJDIR)/modulePusher.o
all: $(OUTPUT) all: $(OUTPUT)
$(OUTPUT): modules.o $(OUTPUT).f90 $(OUTPUT): modules.o $(OUTPUT).f90
$(FC) $(FCFLAGS) -o $(OBJDIR)/$(OUTPUT).o -c $(OUTPUT).f90 $(FC) $(FCFLAGS) -o $(OBJDIR)/$(OUTPUT).o -c $(OUTPUT).f90
$(FC) $(FCFLAGS) -o $(TOPDIR)/$(OUTPUT) $(OBJECTS) $(OBJDIR)/$(OUTPUT).o $(JSONLIB) -L/usr/local/lib -llapack -lopenblas $(FC) $(FCFLAGS) -o $(TOPDIR)/$(OUTPUT) $(OBJECTS) $(OBJDIR)/$(OUTPUT).o $(JSONLIB) -L/usr/local/lib -lopenblas
modules.o: modules.o:
$(MAKE) -C modules all $(MAKE) -C modules all

View file

@ -0,0 +1,11 @@
OBJS = moduleCompTime.o moduleCaseParam.o moduleConstParam.o \
moduleErrors.o moduleMath.o moduleParallel.o \
moduleRandom.o moduleRefParam.o moduleTable.o
all: $(OBJS)
moduleTable.o: moduleErrors.o moduleTable.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
%.o: %.f90
$(FC) $(FCFLAGS) -c $< -o $(OBJDIR)/$@

View file

@ -0,0 +1,15 @@
!Problems of the case
MODULE moduleCaseParam
!Final and initial iterations
INTEGER:: tFinal, tInitial = 0
! Global index of current iteration
INTEGER:: timeStep
! Time step for all species
REAL(8), ALLOCATABLE:: tau(:)
! Minimum time step
REAL(8):: tauMin
! Time step for Monte-Carlo Collisions
REAL(8):: tauColl
END MODULE moduleCaseParam

View file

@ -0,0 +1,16 @@
!Information to calculate computation time
MODULE moduleCompTime
IMPLICIT NONE
PUBLIC
REAL(8):: tStep = 0.D0
REAL(8):: tPush = 0.D0
REAL(8):: tReset = 0.D0
REAL(8):: tColl = 0.D0
REAL(8):: tCoul = 0.D0
REAL(8):: tWeight = 0.D0
REAL(8):: tEMField = 0.D0
END MODULE moduleCompTime

View file

@ -6,7 +6,8 @@ MODULE moduleConstParam
REAL(8), PARAMETER:: PI = 4.D0*DATAN(1.D0) !number pi REAL(8), PARAMETER:: PI = 4.D0*DATAN(1.D0) !number pi
REAL(8), PARAMETER:: PI2 = 2.D0*PI !2*pi REAL(8), PARAMETER:: PI2 = 2.D0*PI !2*pi
REAL(8), PARAMETER:: PI8 = 8.D0*PI !2*pi REAL(8), PARAMETER:: PI4 = 4.D0*PI !4*pi
REAL(8), PARAMETER:: PI8 = 8.D0*PI !8*pi
REAL(8), PARAMETER:: sccm2atomPerS = 4.5D17 !sccm to atom s^-1 REAL(8), PARAMETER:: sccm2atomPerS = 4.5D17 !sccm to atom s^-1
REAL(8), PARAMETER:: qe = 1.60217662D-19 !Elementary charge REAL(8), PARAMETER:: qe = 1.60217662D-19 !Elementary charge
REAL(8), PARAMETER:: kb = 1.38064852D-23 !Boltzmann constants SI REAL(8), PARAMETER:: kb = 1.38064852D-23 !Boltzmann constants SI

View file

@ -0,0 +1,73 @@
MODULE moduleMath
IMPLICIT NONE
CONTAINS
!Outer product of two tensors
PURE FUNCTION outerProduct(a,b) RESULT(s)
IMPLICIT NONE
REAL(8), DIMENSION(1:3), INTENT(in):: a, b
REAL(8):: s(1:3,1:3)
s = SPREAD(a, dim = 2, ncopies = 3)*SPREAD(b, dim = 1, ncopies = 3)
END FUNCTION outerProduct
!Cross product of two 3D vectors
PURE FUNCTION crossProduct(a, b) RESULT(c)
IMPLICIT NONE
REAL(8), DIMENSION(1:3), INTENT(in):: a, b
REAL(8), DIMENSION(1:3):: c
c = 0.D0
c(1) = a(2)*b(3) - a(3)*b(2)
c(2) = -(a(1)*b(3) - a(3)*b(1))
c(3) = a(1)*b(2) - a(2)*b(1)
END FUNCTION crossProduct
!Normalizes a 3D vector
PURE FUNCTION normalize(a) RESULT(b)
IMPLICIT NONE
REAL(8), DIMENSION(1:3), INTENT(in):: a
REAL(8), DIMENSION(1:3):: b
b = a / NORM2(a)
END FUNCTION normalize
!Norm 1 of vector
PURE FUNCTION norm1(a) RESULT(b)
IMPLICIT NONE
REAL(8), DIMENSION(:), INTENT(in):: a
REAL(8):: b
b = SUM(DABS(a))
END FUNCTION norm1
PURE FUNCTION reducedMass(m_i, m_j) RESULT(rMass)
IMPLICIT NONE
REAL(8), INTENT(in):: m_i, m_j
REAL(8):: rMass
rMass = (m_i * m_j) / (m_i + m_j)
END FUNCTION
FUNCTION tensorTrace(a) RESULT(t)
IMPLICIT NONE
REAL(8), DIMENSION(1:3,1:3):: a
REAL(8):: t
t = 0.D0
t = a(1,1)+a(2,2)+a(3,3)
END FUNCTION tensorTrace
END MODULE moduleMath

View file

@ -40,30 +40,72 @@ MODULE moduleRandom
INTEGER:: rnd INTEGER:: rnd
REAL(8):: rnd01 REAL(8):: rnd01
rnd = 0.D0 rnd = 0
CALL RANDOM_NUMBER(rnd01) CALL RANDOM_NUMBER(rnd01)
rnd = INT(REAL(b - a) * rnd01) + 1 rnd = a + FLOOR((b+1-a)*rnd01)
END FUNCTION randomIntAB END FUNCTION randomIntAB
!Returns a random number in a Maxwellian distribution of mean 0 and width 1 with the Box-Muller Method
function randomMaxwellian() result(rnd)
USE moduleConstParam, only: pi
implicit none
real(8):: rnd
real(8):: v1, v2, Rsquare
v1 = 0.d0
do while (v1 <= 0.d0)
v1 = random()
end do
v2 = random()
rnd = sqrt(-2.d0*log(v1))*cos(2*pi*v2)
end function randomMaxwellian
!Returns a random number in a Maxwellian distribution of mean 0 and width 1 !Returns a random number in a Maxwellian distribution of mean 0 and width 1
FUNCTION randomMaxwellian() RESULT(rnd) FUNCTION randomHalfMaxwellian() RESULT(rnd)
USE moduleConstParam, ONLY: PI
IMPLICIT NONE IMPLICIT NONE
REAL(8):: rnd REAL(8):: rnd
REAL(8):: x, y REAL(8):: x
rnd = 0.D0 rnd = 0.D0
x = 0.D0 x = 0.D0
DO WHILE (x == 0.D0) DO WHILE (x == 0.D0)
CALL RANDOM_NUMBER(x) CALL RANDOM_NUMBER(x)
END DO END DO
CALL RANDOM_NUMBER(y)
rnd = DSQRT(-2.D0*DLOG(x))*DCOS(2.D0*PI*y) rnd = DSQRT(-DLOG(x))
END FUNCTION randomMaxwellian END FUNCTION randomHalfMaxwellian
!Returns a random number weighted with the cumWeight array
FUNCTION randomWeighted(cumWeight, sumWeight) RESULT(rnd)
IMPLICIT NONE
REAL(8), INTENT(in):: cumWeight(1:)
REAL(8), INTENT(in):: sumWeight
REAL(8):: rnd0b
INTEGER:: rnd, i
rnd0b = random()
i = 1
DO
IF (rnd0b <= cumWeight(i)/sumWeight) THEN
rnd = i
EXIT
ELSE
i = i +1
END IF
END DO
! rnd = MINLOC(DABS(rnd0b - cumWeight), 1)
END FUNCTION randomWeighted
END MODULE moduleRandom END MODULE moduleRandom

View file

@ -1,9 +1,9 @@
!Reference parameters !Reference parameters
MODULE moduleRefParam MODULE moduleRefParam
!Parameters that define the problem (inputs) !Parameters that define the problem (inputs)
REAL(8):: n_ref, m_ref, T_ref, r_ref, debye_ref, sigma_ref REAL(8):: n_ref, m_ref, T_ref, r_ref, debye_ref, sigmaVrel_ref
!Reference parameters for non-dimensional problem !Reference parameters for non-dimensional problem
REAL(8):: L_ref, v_ref, ti_ref, Vol_ref, EF_ref, Volt_ref REAL(8):: L_ref, v_ref, ti_ref, Vol_ref, EF_ref, Volt_ref, B_ref
END MODULE moduleRefParam END MODULE moduleRefParam

View file

@ -93,7 +93,7 @@ MODULE moduleTable
f = self%fMax f = self%fMax
ELSE ELSE
i = MINLOC(x - self%x, 1) i = MINLOC(ABS(x - self%x), 1)
deltaX = x - self%x(i) deltaX = x - self%x(i)
IF (deltaX < 0 ) THEN IF (deltaX < 0 ) THEN
i = i - 1 i = i - 1

View file

@ -0,0 +1,5 @@
all: moduleInput.o
%.o: %.f90
$(FC) $(FCFLAGS) -c $< -o $(OBJDIR)/$@

File diff suppressed because it is too large Load diff

View file

@ -1,46 +1,43 @@
OBJS = common.o output.o mesh.o solver.o init.o \
moduleBoundary.o moduleCollisions.o moduleInject.o \
moduleList.o moduleProbe.o moduleCoulomb.o \
moduleSpecies.o
OBJS = moduleCaseParam.o moduleCompTime.o moduleList.o \ all: $(OBJS)
moduleOutput.o moduleInput.o moduleSolver.o \
moduleCollisions.o moduleTable.o moduleParallel.o \
moduleEM.o moduleRandom.o
all: $(OBJS) mesh.o common.o:
$(MAKE) -C common all
mesh.o: moduleCollisions.o moduleBoundary.o output.o: moduleSpecies.o common.o
$(MAKE) -C output all
mesh.o: moduleCollisions.o moduleCoulomb.o moduleBoundary.o output.o common.o
$(MAKE) -C mesh all $(MAKE) -C mesh all
moduleCollisions.o: moduleRandom.o moduleTable.o moduleSpecies.o moduleRefParam.o moduleConstParam.o moduleCollisions.f90 solver.o: moduleSpecies.o moduleProbe.o common.o output.o mesh.o
$(MAKE) -C solver all
init.o: common.o solver.o moduleInject.o
$(MAKE) -C init all
moduleBoundary.o: common.o moduleBoundary.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleInput.o: moduleParallel.o moduleRefParam.o moduleCaseParam.o moduleSolver.o moduleInject.o moduleBoundary.o moduleErrors.o moduleSpecies.o moduleInput.f90 moduleCollisions.o: moduleList.o moduleSpecies.o common.o moduleCollisions.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleInject.o: moduleRandom.o moduleSpecies.o moduleSolver.o moduleInject.f90 moduleCoulomb.o: moduleSpecies.o common.o moduleCoulomb.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleList.o: moduleSpecies.o moduleErrors.o moduleList.f90 moduleList.o: common.o moduleSpecies.o moduleList.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleOutput.o: moduleSpecies.o moduleRefParam.o moduleOutput.f90 moduleProbe.o: mesh.o moduleProbe.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleRandom.o: moduleConstParam.o moduleRandom.f90 moduleSpecies.o: common.o moduleSpecies.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleRefParam.o: moduleConstParam.o moduleRefParam.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleSpecies.o: moduleErrors.o moduleCaseParam.o moduleSpecies.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleSolver.o: mesh.o moduleList.o moduleEM.o moduleSpecies.o moduleRefParam.o moduleOutput.o moduleSolver.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleTable.o: moduleErrors.o moduleTable.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleEM.o: mesh.o moduleSpecies.o moduleEM.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
%.o: %.f90 %.o: %.f90
$(FC) $(FCFLAGS) -c $< -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $< -o $(OBJDIR)/$@

View file

@ -0,0 +1,5 @@
all: moduleMesh0D.o
moduleMesh0D.o: moduleMesh0D.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@

View file

@ -0,0 +1,257 @@
!moduleMesh1D: 0D mesh. No coordinates are relevant. No edges are used
MODULE moduleMesh0D
USE moduleMesh
IMPLICIT NONE
TYPE, PUBLIC, EXTENDS(meshNode):: meshNode0D
INTEGER:: n1
CONTAINS
!meshNode DEFERRED PROCEDURES
PROCEDURE, PASS:: init => initNode0D
PROCEDURE, PASS:: getCoordinates => getCoord0D
END TYPE meshNode0D
TYPE, PUBLIC, EXTENDS(meshCell):: meshCell0D
CLASS(meshNode), POINTER:: n1
CONTAINS
PROCEDURE, PASS:: init => initCell0D
PROCEDURE, PASS:: getNodes => getNodes0D
PROCEDURE, PASS:: randPos => randPos0D
PROCEDURE, NOPASS:: fPsi => fPsi0D
PROCEDURE, NOPASS:: dPsi => dPsi0D
PROCEDURE, PASS:: partialDer => partialDer0D
PROCEDURE, NOPASS:: detJac => detJ0D
PROCEDURE, NOPASS:: invJac => invJ0D
PROCEDURE, PASS:: gatherElectricField => gatherEF0D
PROCEDURE, PASS:: gatherMagneticField => gatherMF0D
PROCEDURE, PASS:: elemK => elemK0D
PROCEDURE, PASS:: elemF => elemF0D
PROCEDURE, PASS:: phy2log => phy2log0D
PROCEDURE, NOPASS:: inside => inside0D
PROCEDURE, PASS:: neighbourElement => neighbourElement0D
END TYPE meshCell0D
CONTAINS
!NODE FUNCTIONS
!Init node
SUBROUTINE initNode0D(self, n, r)
USE moduleSpecies
USE OMP_LIB
IMPLICIT NONE
CLASS(meshNode0D), INTENT(out):: self
INTEGER, INTENT(in):: n
REAL(8), INTENT(in):: r(1:3) !Unused variable
self%n = n
ALLOCATE(self%output(1:nSpecies))
CALL OMP_INIT_LOCK(self%lock)
END SUBROUTINE initNode0D
!Get node coordinates
PURE FUNCTION getCoord0D(self) RESULT(r)
IMPLICIT NONE
CLASS(meshNode0D), INTENT(in):: self
REAL(8):: r(1:3)
r = 0.D0
END FUNCTION
!VOLUME FUNCTIONS
!Inits dummy 0D volume
SUBROUTINE initCell0D(self, n, p, nodes)
USE moduleRefParam
USE moduleSpecies
IMPLICIT NONE
CLASS(meshCell0D), INTENT(out):: self
INTEGER, INTENT(in):: n
INTEGER, INTENT(in):: p(:)
TYPE(meshNodeCont), INTENT(in), TARGET:: nodes(:)
self%n = n
self%nNodes = SIZE(p)
self%n1 => nodes(p(1))%obj
self%volume = 1.D0
self%n1%v = 1.D0
CALL OMP_INIT_LOCK(self%lock)
ALLOCATE(self%listPart_in(1:nSpecies))
ALLOCATE(self%totalWeight(1:nSpecies))
END SUBROUTINE initCell0D
!Get the nodes of the volume
PURE FUNCTION getNodes0D(self, nNodes) RESULT(n)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
INTEGER:: n(1:nNodes)
n = self%n1%n
END FUNCTION getNodes0D
!Calculate random position inside the volume
FUNCTION randPos0D(self) RESULT(r)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
REAL(8):: r(1:3)
r = 0.D0
END FUNCTION randPos0D
PURE FUNCTION fPsi0D(Xi, nNodes) RESULT(fPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
INTEGER, INTENT(in):: nNodes
REAL(8):: fPsi(1:nNodes)
fPsi = 1.D0
END FUNCTION fPsi0D
PURE FUNCTION dPsi0D(Xi, nNodes) RESULT(dPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
INTEGER, INTENT(in):: nNodes
REAL(8):: dPsi(1:3,1:nNodes)
dPsi = 0.D0
END FUNCTION dPsi0D
PURE FUNCTION partialDer0D(self, nNodes, dPsi) RESULT(pDer)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8), INTENT(in):: dPsi(1:3,1:nNodes)
REAL(8):: pDer(1:3, 1:3)
pDer = 0.D0
END FUNCTION partialDer0D
PURE FUNCTION elemK0D(self, nNodes) RESULT(localK)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8):: localK(1:nNodes,1:nNodes)
localK = 0.D0
END FUNCTION elemK0D
PURE FUNCTION elemF0D(self, nNodes, source) RESULT(localF)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8), INTENT(in):: source(1:nNodes)
REAL(8):: localF(1:nNodes)
localF = 0.D0
END FUNCTION elemF0D
PURE FUNCTION gatherEF0D(self, Xi) RESULT(array)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: array(1:3)
REAL(8):: phi(1:1)
phi = (/ self%n1%emData%phi /)
array = -self%gatherDF(Xi, 1, phi)
END FUNCTION gatherEF0D
PURE FUNCTION gatherMF0D(self, Xi) RESULT(array)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: array(1:3)
REAL(8):: B(1:1,1:3)
B(:,1) = (/ self%n1%emData%B(1) /)
B(:,2) = (/ self%n1%emData%B(2) /)
B(:,3) = (/ self%n1%emData%B(3) /)
array = self%gatherF(Xi, 1, B)
END FUNCTION gatherMF0D
PURE FUNCTION phy2log0D(self,r) RESULT(xN)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
REAL(8), INTENT(in):: r(1:3)
REAL(8):: xN(1:3)
xN = 0.D0
END FUNCTION phy2log0D
PURE FUNCTION inside0D(Xi) RESULT(ins)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
LOGICAL:: ins
ins = .TRUE.
END FUNCTION inside0D
SUBROUTINE neighbourElement0D(self, Xi, neighbourElement)
IMPLICIT NONE
CLASS(meshCell0D), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
CLASS(meshElement), POINTER, INTENT(out):: neighbourElement
neighbourElement => NULL()
END SUBROUTINE neighbourElement0D
!COMMON FUNCTIONS
PURE FUNCTION detJ0D(pDer) RESULT(dJ)
IMPLICIT NONE
REAL(8), INTENT(in):: pDer(1:3, 1:3)
REAL(8):: dJ
dJ = 0.D0
END FUNCTION detJ0D
PURE FUNCTION invJ0D(pDer) RESULT(invJ)
IMPLICIT NONE
REAL(8), INTENT(in):: pDer(1:3, 1:3)
REAL(8):: invJ(1:3,1:3)
invJ = 0.D0
END FUNCTION invJ0D
END MODULE moduleMesh0D

View file

@ -1,11 +1,5 @@
all: moduleMesh1DCart.o moduleMesh1DCartBoundary.o moduleMesh1DCartRead.o all: moduleMesh1DCart.o
moduleMesh1DCart.o: moduleMesh1DCart.f90 moduleMesh1DCart.o: moduleMesh1DCart.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleMesh1DCartBoundary.o: moduleMesh1DCart.o moduleMesh1DCartBoundary.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleMesh1DCartRead.o: moduleMesh1DCart.o moduleMesh1DCartBoundary.o moduleMesh1DCartRead.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@

View file

@ -4,12 +4,17 @@
! z == unused ! z == unused
MODULE moduleMesh1DCart MODULE moduleMesh1DCart
USE moduleMesh USE moduleMesh
USE moduleMeshBoundary
IMPLICIT NONE IMPLICIT NONE
REAL(8), PARAMETER:: corSeg(1:3) = (/ -DSQRT(3.D0/5.D0), 0.D0, DSQRT(3.D0/5.D0) /)
REAL(8), PARAMETER:: wSeg(1:3) = (/ 5.D0/9.D0 , 8.D0/9.D0, 5.D0/9.D0 /)
TYPE, PUBLIC, EXTENDS(meshNode):: meshNode1DCart TYPE, PUBLIC, EXTENDS(meshNode):: meshNode1DCart
!Element coordinates !Element coordinates
REAL(8):: x = 0.D0 REAL(8):: x = 0.D0
CONTAINS CONTAINS
!meshNode DEFERRED PROCEDURES
PROCEDURE, PASS:: init => initNode1DCart PROCEDURE, PASS:: init => initNode1DCart
PROCEDURE, PASS:: getCoordinates => getCoord1DCart PROCEDURE, PASS:: getCoordinates => getCoord1DCart
@ -21,111 +26,42 @@ MODULE moduleMesh1DCart
!Connectivity to nodes !Connectivity to nodes
CLASS(meshNode), POINTER:: n1 => NULL() CLASS(meshNode), POINTER:: n1 => NULL()
CONTAINS CONTAINS
!meshEdge DEFERRED PROCEDURES
PROCEDURE, PASS:: init => initEdge1DCart PROCEDURE, PASS:: init => initEdge1DCart
PROCEDURE, PASS:: getNodes => getNodes1DCart PROCEDURE, PASS:: getNodes => getNodes1DCart
PROCEDURE, PASS:: intersection => intersection1DCart
PROCEDURE, PASS:: randPos => randPosEdge PROCEDURE, PASS:: randPos => randPosEdge
END TYPE meshEdge1DCart END TYPE meshEdge1DCart
!Boundary functions defined in the submodule Boundary TYPE, PUBLIC, EXTENDS(meshCell):: meshCell1DCartSegm
INTERFACE
MODULE SUBROUTINE reflection(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE reflection
MODULE SUBROUTINE absorption(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE absorption
MODULE SUBROUTINE transparent(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE transparent
MODULE SUBROUTINE wallTemperature(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE wallTemperature
END INTERFACE
TYPE, PUBLIC, ABSTRACT, EXTENDS(meshVol):: meshVol1DCart
CONTAINS
PROCEDURE, PASS:: detJac => detJ1DCart
PROCEDURE, PASS:: invJac => invJ1DCart
PROCEDURE(fPsi_interface), DEFERRED, NOPASS:: fPsi
PROCEDURE(dPsi_interface), DEFERRED, NOPASS:: dPsi
PROCEDURE(partialDer_interface), DEFERRED, PASS:: partialDer
END TYPE meshVol1DCart
ABSTRACT INTERFACE
PURE FUNCTION fPsi_interface(xi) RESULT(fPsi)
REAL(8), INTENT(in):: xi(1:3)
REAL(8), ALLOCATABLE:: fPsi(:)
END FUNCTION fPsi_interface
PURE FUNCTION dPsi_interface(xi) RESULT(dPsi)
REAL(8), INTENT(in):: xi(1:3)
REAL(8), ALLOCATABLE:: dPsi(:,:)
END FUNCTION dPsi_interface
PURE SUBROUTINE partialDer_interface(self, dPsi, dx)
IMPORT meshVol1DCart
CLASS(meshVol1DCart), INTENT(in):: self
REAL(8), INTENT(in):: dPsi(1:,1:)
REAL(8), INTENT(out), DIMENSION(1):: dx
END SUBROUTINE partialDer_interface
END INTERFACE
TYPE, PUBLIC, EXTENDS(meshVol1DCart):: meshVol1DCartSegm
!Element coordinates !Element coordinates
REAL(8):: x(1:2) REAL(8):: x(1:2)
!Connectivity to nodes !Connectivity to nodes
CLASS(meshNode), POINTER:: n1 => NULL(), n2 => NULL() CLASS(meshNode), POINTER:: n1 => NULL(), n2 => NULL()
!Connectivity to adjacent elements !Connectivity to adjacent elements
CLASS(*), POINTER:: e1 => NULL(), e2 => NULL() CLASS(meshElement), POINTER:: e1 => NULL(), e2 => NULL()
REAL(8):: arNodes(1:2)
CONTAINS CONTAINS
PROCEDURE, PASS:: init => initVol1DCartSegm !meshCell DEFERRED PROCEDURES
PROCEDURE, PASS:: randPos => randPos1DCartSeg PROCEDURE, PASS:: init => initCell1DCartSegm
PROCEDURE, PASS:: area => areaSegm PROCEDURE, PASS:: getNodes => getNodesSegm
PROCEDURE, PASS:: randPos => randPos1DCartSegm
PROCEDURE, NOPASS:: fPsi => fPsiSegm PROCEDURE, NOPASS:: fPsi => fPsiSegm
PROCEDURE, NOPASS:: dPsi => dPsiSegm PROCEDURE, NOPASS:: dPsi => dPsiSegm
PROCEDURE, PASS:: partialDer => partialDerSegm PROCEDURE, PASS:: partialDer => partialDerSegm
PROCEDURE, NOPASS:: detJac => detJ1DCart
PROCEDURE, NOPASS:: invJac => invJ1DCart
PROCEDURE, PASS:: gatherElectricField => gatherEFSegm
PROCEDURE, PASS:: gatherMagneticField => gatherMFSegm
PROCEDURE, PASS:: elemK => elemKSegm PROCEDURE, PASS:: elemK => elemKSegm
PROCEDURE, PASS:: elemF => elemFSegm PROCEDURE, PASS:: elemF => elemFSegm
PROCEDURE, NOPASS:: weight => weightSegm
PROCEDURE, NOPASS:: inside => insideSegm PROCEDURE, NOPASS:: inside => insideSegm
PROCEDURE, PASS:: scatter => scatterSegm
PROCEDURE, PASS:: gatherEF => gatherEFSegm
PROCEDURE, PASS:: getNodes => getNodesSegm
PROCEDURE, PASS:: phy2log => phy2logSegm PROCEDURE, PASS:: phy2log => phy2logSegm
PROCEDURE, PASS:: nextElement => nextElementSegm PROCEDURE, PASS:: neighbourElement => neighbourElementSegm
!PARTICLUAR PROCEDURES
PROCEDURE, PASS, PRIVATE:: calculateVolume => volumeSegm
END TYPE meshVol1DCartSegm END TYPE meshCell1DCartSegm
CONTAINS CONTAINS
!NODE FUNCTIONS !NODE FUNCTIONS
@ -133,6 +69,7 @@ MODULE moduleMesh1DCart
SUBROUTINE initNode1DCart(self, n, r) SUBROUTINE initNode1DCart(self, n, r)
USE moduleSpecies USE moduleSpecies
USE moduleRefParam USE moduleRefParam
USE OMP_LIB
IMPLICIT NONE IMPLICIT NONE
CLASS(meshNode1DCart), INTENT(out):: self CLASS(meshNode1DCart), INTENT(out):: self
@ -147,6 +84,8 @@ MODULE moduleMesh1DCart
!Allocates output !Allocates output
ALLOCATE(self%output(1:nSpecies)) ALLOCATE(self%output(1:nSpecies))
CALL OMP_INIT_LOCK(self%lock)
END SUBROUTINE initNode1DCart END SUBROUTINE initNode1DCart
PURE FUNCTION getCoord1DCart(self) RESULT(r) PURE FUNCTION getCoord1DCart(self) RESULT(r)
@ -160,7 +99,7 @@ MODULE moduleMesh1DCart
END FUNCTION getCoord1DCart END FUNCTION getCoord1DCart
!EDGE FUNCTIONS !EDGE FUNCTIONS
!Inits edge element !Init edge element
SUBROUTINE initEdge1DCart(self, n, p, bt, physicalSurface) SUBROUTINE initEdge1DCart(self, n, p, bt, physicalSurface)
USE moduleSpecies USE moduleSpecies
USE moduleBoundary USE moduleBoundary
@ -176,12 +115,15 @@ MODULE moduleMesh1DCart
INTEGER:: s INTEGER:: s
self%n = n self%n = n
self%nNodes = SIZE(p)
self%n1 => mesh%nodes(p(1))%obj self%n1 => mesh%nodes(p(1))%obj
!Get element coordinates !Get element coordinates
r1 = self%n1%getCoordinates() r1 = self%n1%getCoordinates()
self%x = r1(1) self%x = r1(1)
self%surface = 1.D0
self%normal = (/ 1.D0, 0.D0, 0.D0 /) self%normal = (/ 1.D0, 0.D0, 0.D0 /)
!Boundary index !Boundary index
@ -189,23 +131,7 @@ MODULE moduleMesh1DCart
ALLOCATE(self%fboundary(1:nSpecies)) ALLOCATE(self%fboundary(1:nSpecies))
!Assign functions to boundary !Assign functions to boundary
DO s = 1, nSpecies DO s = 1, nSpecies
SELECT TYPE(obj => self%boundary%bTypes(s)%obj) CALL pointBoundaryFunction(self, s)
TYPE IS(boundaryAbsorption)
self%fBoundary(s)%apply => absorption
TYPE IS(boundaryReflection)
self%fBoundary(s)%apply => reflection
TYPE IS(boundaryTransparent)
self%fBoundary(s)%apply => transparent
TYPE IS(boundaryWallTemperature)
self%fBoundary(s)%apply => wallTemperature
CLASS DEFAULT
CALL criticalError("Boundary type not defined in this geometry", 'initEdge1DCart')
END SELECT
END DO END DO
@ -215,18 +141,29 @@ MODULE moduleMesh1DCart
END SUBROUTINE initEdge1DCart END SUBROUTINE initEdge1DCart
!Get nodes from edge !Get nodes from edge
PURE FUNCTION getNodes1DCart(self) RESULT(n) PURE FUNCTION getNodes1DCart(self, nNodes) RESULT(n)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshEdge1DCart), INTENT(in):: self CLASS(meshEdge1DCart), INTENT(in):: self
INTEGER, ALLOCATABLE:: n(:) INTEGER, INTENT(in):: nNodes
INTEGER:: n(1:nNodes)
ALLOCATE(n(1))
n = (/ self%n1%n /) n = (/ self%n1%n /)
END FUNCTION getNodes1DCart END FUNCTION getNodes1DCart
!Calculates a 'random' position in edge PURE FUNCTION intersection1DCart(self, r0) RESULT(r)
IMPLICIT NONE
CLASS(meshEdge1DCart), INTENT(in):: self
REAL(8), DIMENSION(1:3), INTENT(in):: r0
REAL(8), DIMENSION(1:3):: r
r = (/ self%x, 0.D0, 0.D0 /)
END FUNCTION intersection1DCart
!Calculate a 'random' position in edge
FUNCTION randPosEdge(self) RESULT(r) FUNCTION randPosEdge(self) RESULT(r)
CLASS(meshEdge1DCart), INTENT(in):: self CLASS(meshEdge1DCart), INTENT(in):: self
REAL(8):: r(1:3) REAL(8):: r(1:3)
@ -237,316 +174,420 @@ MODULE moduleMesh1DCart
!VOLUME FUNCTIONS !VOLUME FUNCTIONS
!SEGMENT FUNCTIONS !SEGMENT FUNCTIONS
!Init segment element !Init element
SUBROUTINE initVol1DCartSegm(self, n, p) SUBROUTINE initCell1DCartSegm(self, n, p, nodes)
USE moduleRefParam USE moduleRefParam
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(out):: self CLASS(meshCell1DCartSegm), INTENT(out):: self
INTEGER, INTENT(in):: n INTEGER, INTENT(in):: n
INTEGER, INTENT(in):: p(:) INTEGER, INTENT(in):: p(:)
TYPE(meshNodeCont), INTENT(in), TARGET:: nodes(:)
REAL(8), DIMENSION(1:3):: r1, r2 REAL(8), DIMENSION(1:3):: r1, r2
self%n = n self%n = n
self%n1 => mesh%nodes(p(1))%obj self%nNodes = SIZE(p)
self%n2 => mesh%nodes(p(2))%obj self%n1 => nodes(p(1))%obj
self%n2 => nodes(p(2))%obj
!Get element coordinates !Get element coordinates
r1 = self%n1%getCoordinates() r1 = self%n1%getCoordinates()
r2 = self%n2%getCoordinates() r2 = self%n2%getCoordinates()
self%x = (/ r1(1), r2(1) /) self%x = (/ r1(1), r2(1) /)
!Assign node volume !Assign node volume
CALL self%area() CALL self%calculateVolume()
self%n1%v = self%n1%v + self%arNodes(1)
self%n2%v = self%n2%v + self%arNodes(2)
self%sigmaVrelMax = sigma_ref/L_ref**2
CALL OMP_INIT_LOCK(self%lock) CALL OMP_INIT_LOCK(self%lock)
END SUBROUTINE initVol1DCartSegm ALLOCATE(self%listPart_in(1:nSpecies))
ALLOCATE(self%totalWeight(1:nSpecies))
!Calculates a random position in 1D volume END SUBROUTINE initCell1DCartSegm
FUNCTION randPos1DCartSeg(self) RESULT(r)
USE moduleRandom
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self
REAL(8):: r(1:3)
REAL(8):: xii(1:3)
REAL(8), ALLOCATABLE:: fPsi(:)
xii(1) = random(-1.D0, 1.D0)
xii(2:3) = 0.D0
fPsi = self%fPsi(xii)
r(1) = DOT_PRODUCT(fPsi, self%x)
END FUNCTION randPos1DCartSeg
!Computes element area
PURE SUBROUTINE areaSegm(self)
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(inout):: self
REAL(8):: l !element length
REAL(8):: fPsi(1:2)
REAL(8):: detJ
REAL(8):: Xii(1:3)
self%volume = 0.D0
self%arNodes = 0.D0
!1 point Gauss integral
Xii = 0.D0
fPsi = self%fPsi(Xii)
detJ = self%detJac(Xii)
l = 2.D0*detJ
self%volume = l
self%arNodes = fPsi*l
END SUBROUTINE areaSegm
!Computes element functions at point xii
PURE FUNCTION fPsiSegm(xi) RESULT(fPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: xi(1:3)
REAL(8), ALLOCATABLE:: fPsi(:)
ALLOCATE(fPsi(1:2))
fPsi(1) = 1.D0 - xi(1)
fPsi(2) = 1.D0 + xi(1)
fPsi = fPsi * 5.D-1
END FUNCTION fPsiSegm
!Computes element derivative shape function at Xii
PURE FUNCTION dPsiSegm(xi) RESULT(dPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: xi(1:3)
REAL(8), ALLOCATABLE:: dPsi(:,:)
ALLOCATE(dPsi(1:1, 1:2))
dPsi(1, 1) = -5.D-1
dPsi(1, 2) = 5.D-1
END FUNCTION dPsiSegm
!Computes partial derivatives of coordinates
PURE SUBROUTINE partialDerSegm(self, dPsi, dx)
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self
REAL(8), INTENT(in):: dPsi(1:,1:)
REAL(8), INTENT(out), DIMENSION(1):: dx
dx(1) = DOT_PRODUCT(dPsi(1,:), self%x)
END SUBROUTINE partialDerSegm
!Computes local stiffness matrix
PURE FUNCTION elemKSegm(self) RESULT(ke)
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self
REAL(8):: ke(1:2,1:2)
REAL(8):: Xii(1:3)
REAL(8):: dPsi(1:1, 1:2)
REAL(8):: invJ
ke = 0.D0
Xii = (/ 0.D0, 0.D0, 0.D0 /)
dPsi = self%dPsi(Xii)
invJ = self%invJac(Xii, dPsi)
ke(1,:) = (/ dPsi(1,1)*dPsi(1,1), dPsi(1,1)*dPsi(1,2) /)
ke(2,:) = (/ dPsi(1,2)*dPsi(1,1), dPsi(1,2)*dPsi(1,2) /)
ke = 2.D0*ke*invJ
END FUNCTION elemKSegm
PURE FUNCTION elemFSegm(self, source) RESULT(localF)
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self
REAL(8), INTENT(in):: source(1:)
REAL(8), ALLOCATABLE:: localF(:)
REAL(8):: fPsi(1:2)
REAL(8):: detJ
REAL(8):: Xii(1:3)
Xii = 0.D0
fPsi = self%fPsi(Xii)
detJ = self%detJac(Xii)
ALLOCATE(localF(1:2))
localF = 2.D0*DOT_PRODUCT(fPsi, source)*detJ
END FUNCTION elemFSegm
PURE FUNCTION weightSegm(xi) RESULT(w)
IMPLICIT NONE
REAL(8), INTENT(in):: xi(1:3)
REAL(8):: w(1:2)
w = fPsiSegm(xi)
END FUNCTION weightSegm
PURE FUNCTION insideSegm(xi) RESULT(ins)
IMPLICIT NONE
REAL(8), INTENT(in):: xi(1:3)
LOGICAL:: ins
ins = xi(1) >=-1.D0 .AND. &
xi(1) <= 1.D0
END FUNCTION insideSegm
SUBROUTINE scatterSegm(self, part)
USE moduleOutput
USE moduleSpecies
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self
CLASS(particle), INTENT(in):: part
TYPE(outputNode), POINTER:: vertex
REAL(8):: w_p(1:2)
REAL(8):: tensorS(1:3,1:3)
w_p = self%weight(part%xi)
tensorS = outerProduct(part%v, part%v)
vertex => self%n1%output(part%sp)
vertex%den = vertex%den + part%weight*w_p(1)
vertex%mom(:) = vertex%mom(:) + part%weight*w_p(1)*part%v(:)
vertex%tensorS(:,:) = vertex%tensorS(:,:) + part%weight*w_p(1)*tensorS
vertex => self%n2%output(part%sp)
vertex%den = vertex%den + part%weight*w_p(2)
vertex%mom(:) = vertex%mom(:) + part%weight*w_p(2)*part%v(:)
vertex%tensorS(:,:) = vertex%tensorS(:,:) + part%weight*w_p(2)*tensorS
END SUBROUTINE scatterSegm
!Gathers EF at position Xii
PURE FUNCTION gatherEFSegm(self, xi) RESULT(EF)
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self
REAL(8), INTENT(in):: xi(1:3)
REAL(8):: dPsi(1, 1:2)
REAL(8):: phi(1:2)
REAL(8):: EF(1:3)
REAL(8):: invJ
phi = (/ self%n1%emData%phi, &
self%n2%emData%phi /)
dPsi = self%dPsi(xi)
invJ = self%invJac(xi, dPsi)
EF(1) = -DOT_PRODUCT(dPsi(1, :), phi)*invJ
EF(2) = 0.D0
EF(3) = 0.D0
END FUNCTION gatherEFSegm
!Get nodes from 1D volume !Get nodes from 1D volume
PURE FUNCTION getNodesSegm(self) RESULT(n) PURE FUNCTION getNodesSegm(self, nNodes) RESULT(n)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self CLASS(meshCell1DCartSegm), INTENT(in):: self
INTEGER, ALLOCATABLE:: n(:) INTEGER, INTENT(in):: nNodes
INTEGER:: n(1:nNodes)
ALLOCATE(n(1:2))
n = (/ self%n1%n, self%n2%n /) n = (/ self%n1%n, self%n2%n /)
END FUNCTION getNodesSegm END FUNCTION getNodesSegm
PURE FUNCTION phy2logSegm(self, r) RESULT(xN) !Random position in 1D volume
FUNCTION randPos1DCartSegm(self) RESULT(r)
USE moduleRandom
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self CLASS(meshCell1DCartSegm), INTENT(in):: self
REAL(8), INTENT(in):: r(1:3) REAL(8):: r(1:3)
REAL(8):: xN(1:3) REAL(8):: Xi(1:3)
REAL(8):: fPsi(1:2)
xN = 0.D0 Xi = 0.D0
xN(1) = 2.D0*(r(1) - self%x(1))/(self%x(2) - self%x(1)) - 1.D0 Xi(1) = random(-1.D0, 1.D0)
fPsi = self%fPsi(Xi, 2)
r = 0.D0
r(1) = DOT_PRODUCT(fPsi, self%x)
END FUNCTION randPos1DCartSegm
!Compute element functions at point Xi
PURE FUNCTION fPsiSegm(Xi, nNodes) RESULT(fPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
INTEGER, INTENT(in):: nNodes
REAL(8):: fPsi(1:nNodes)
fPsi = (/ 1.D0 - Xi(1), &
1.D0 + Xi(1) /)
fPsi = fPsi * 0.50D0
END FUNCTION fPsiSegm
!Derivative element function at coordinates Xi
PURE FUNCTION dPsiSegm(Xi, nNodes) RESULT(dPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
INTEGER, INTENT(in):: nNodes
REAL(8):: dPsi(1:3,1:nNodes)
dPsi = 0.D0
dPsi(1, 1:2) = (/ -5.D-1, 5.D-1 /)
END FUNCTION dPsiSegm
!Partial derivative in global coordinates
PURE FUNCTION partialDerSegm(self, nNodes, dPsi) RESULT(pDer)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8), INTENT(in):: dPsi(1:3,1:nNodes)
REAL(8):: pDer(1:3, 1:3)
pDer = 0.D0
pDer(1,1) = DOT_PRODUCT(dPsi(1,1:2), self%x(1:2))
pDer(2,2) = 1.D0
pDer(3,3) = 1.D0
END FUNCTION partialDerSegm
PURE FUNCTION gatherEFSegm(self, Xi) RESULT(array)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: array(1:3)
REAL(8):: phi(1:2)
phi = (/ self%n1%emData%phi, &
self%n2%emData%phi /)
array = -self%gatherDF(Xi, 2, phi)
END FUNCTION gatherEFSegm
PURE FUNCTION gatherMFSegm(self, Xi) RESULT(array)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: array(1:3)
REAL(8):: B(1:2,1:3)
B(:,1) = (/ self%n1%emData%B(1), &
self%n2%emData%B(1) /)
B(:,2) = (/ self%n1%emData%B(2), &
self%n2%emData%B(2) /)
B(:,3) = (/ self%n1%emData%B(3), &
self%n2%emData%B(3) /)
array = self%gatherF(Xi, 2, B)
END FUNCTION gatherMFSegm
!Compute element local stiffness matrix
PURE FUNCTION elemKSegm(self, nNodes) RESULT(localK)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8):: localK(1:nNodes,1:nNodes)
REAL(8):: Xi(1:3)
REAL(8):: dPsi(1:3, 1:2)
REAL(8):: pDer(1:3, 1:3)
REAL(8):: invJ(1:3, 1:3), detJ
INTEGER:: l
localK = 0.D0
Xi = 0.D0
!Start 1D Gauss Quad Integral
DO l = 1, 3
Xi(1) = corSeg(l)
dPsi = self%dPsi(Xi, 2)
pDer = self%partialDer(2, dPsi)
detJ = self%detJac(pDer)
invJ = self%invJac(pDer)
localK = localK + MATMUL(TRANSPOSE(MATMUL(invJ,dPsi)), &
MATMUL(invJ,dPsi))* &
wSeg(l)/detJ
END DO
END FUNCTION elemKSegm
!Compute the local source vector for a force f
PURE FUNCTION elemFSegm(self, nNodes, source) RESULT(localF)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8), INTENT(in):: source(1:nNodes)
REAL(8):: localF(1:nNodes)
REAL(8):: fPsi(1:2)
REAL(8):: dPsi(1:3, 1:2), pDer(1:3, 1:3)
REAL(8):: Xi(1:3)
REAL(8):: detJ, f
INTEGER:: l
localF = 0.D0
Xi = 0.D0
!Start 1D Gauss Quad Integral
DO l = 1, 3
Xi(1) = corSeg(l)
dPsi = self%dPsi(Xi, 2)
pDer = self%partialDer(2, dPsi)
detJ = self%detJac(pDer)
fPsi = self%fPsi(Xi, 2)
f = DOT_PRODUCT(fPsi, source)
localF = localF + f*fPsi*wSeg(l)*detJ
END DO
END FUNCTION elemFSegm
PURE FUNCTION insideSegm(Xi) RESULT(ins)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
LOGICAL:: ins
ins = Xi(1) >=-1.D0 .AND. &
Xi(1) <= 1.D0
END FUNCTION insideSegm
PURE FUNCTION phy2logSegm(self, r) RESULT(Xi)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(in):: self
REAL(8), INTENT(in):: r(1:3)
REAL(8):: Xi(1:3)
Xi = 0.D0
Xi(1) = 2.D0*(r(1) - self%x(1))/(self%x(2) - self%x(1)) - 1.D0
END FUNCTION phy2logSegm END FUNCTION phy2logSegm
!Get next element for a logical position xi !Get the next element for a logical position Xi
SUBROUTINE nextElementSegm(self, xi, nextElement) SUBROUTINE neighbourElementSegm(self, Xi, neighbourElement)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(in):: self CLASS(meshCell1DCartSegm), INTENT(in):: self
REAL(8), INTENT(in):: xi(1:3) REAL(8), INTENT(in):: Xi(1:3)
CLASS(*), POINTER, INTENT(out):: nextElement CLASS(meshElement), POINTER, INTENT(out):: neighbourElement
NULLIFY(nextElement) NULLIFY(neighbourElement)
IF (xi(1) < -1.D0) THEN IF (Xi(1) < -1.D0) THEN
nextElement => self%e2 neighbourElement => self%e2
ELSEIF (xi(1) > 1.D0) THEN ELSEIF (Xi(1) > 1.D0) THEN
nextElement => self%e1 neighbourElement => self%e1
END IF END IF
END SUBROUTINE nextElementSegm END SUBROUTINE neighbourElementSegm
!Compute element volume
PURE SUBROUTINE volumeSegm(self)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(inout):: self
REAL(8):: Xi(1:3)
REAL(8):: dPsi(1:3, 1:2), pDer(1:3, 1:3)
REAL(8):: detJ
REAL(8):: fPsi(1:2)
self%volume = 0.D0
!1D 1 point Gauss Quad Integral
Xi = 0.D0
dPsi = self%dPsi(Xi, 2)
pDer = self%partialDer(2, dPsi)
detJ = self%detJac(pDer)
fPsi = self%fPsi(Xi, 2)
!Compute total volume of the cell
self%volume = detJ*2.D0
!Compute volume per node
self%n1%v = self%n1%v + fPsi(1)*self%volume
self%n2%v = self%n2%v + fPsi(2)*self%volume
END SUBROUTINE volumeSegm
!COMMON FUNCTIONS FOR 1D VOLUME ELEMENTS !COMMON FUNCTIONS FOR 1D VOLUME ELEMENTS
!Calculates a random position in 1D volume !Compute element Jacobian determinant
!Computes the element Jacobian determinant PURE FUNCTION detJ1DCart(pDer) RESULT(dJ)
PURE FUNCTION detJ1DCart(self, xi, dPsi_in) RESULT(dJ)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DCart), INTENT(in):: self REAL(8), INTENT(in):: pDer(1:3, 1:3)
REAL(8), INTENT(in):: xi(1:3)
REAL(8), INTENT(in), OPTIONAL:: dPsi_in(1:,1:)
REAL(8), ALLOCATABLE:: dPsi(:,:)
REAL(8):: dJ REAL(8):: dJ
REAL(8):: dx(1)
IF (PRESENT(dPsi_in)) THEN dJ = pDer(1, 1)
dPsi = dPsi_in
ELSE
dPsi = self%dPsi(xi)
END IF
CALL self%partialDer(dPsi, dx)
dJ = dx(1)
END FUNCTION detJ1DCart END FUNCTION detJ1DCart
!Computes the invers Jacobian !Compute element Jacobian inverse matrix (without determinant)
PURE FUNCTION invJ1DCart(self, xi, dPsi_in) RESULT(invJ) PURE FUNCTION invJ1DCart(pDer) RESULT(invJ)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DCart), INTENT(in):: self REAL(8), INTENT(in):: pDer(1:3, 1:3)
REAL(8), INTENT(in):: xi(1:3) REAL(8):: invJ(1:3,1:3)
REAL(8), INTENT(in), OPTIONAL:: dPsi_in(1:,1:)
REAL(8), ALLOCATABLE:: dPsi(:,:)
REAL(8):: dx(1)
REAL(8):: invJ
IF (PRESENT(dPsi_in)) THEN invJ = 0.D0
dPsi = dPsi_in
ELSE invJ(1, 1) = 1.D0/pDer(1, 1)
dPsi = self%dPsi(xi) invJ(2, 2) = 1.D0
invJ(3, 3) = 1.D0
END IF
CALL self%partialDer(dPsi, dx)
invJ = 1.D0/dx(1)
END FUNCTION invJ1DCart END FUNCTION invJ1DCart
SUBROUTINE connectMesh1DCart(self)
IMPLICIT NONE
CLASS(meshGeneric), INTENT(inout):: self
INTEGER:: e, et
DO e = 1, self%numCells
!Connect Cell-Cell
DO et = 1, self%numCells
IF (e /= et) THEN
CALL connectCellCell(self%cells(e)%obj, self%cells(et)%obj)
END IF
END DO
SELECT TYPE(self)
TYPE IS(meshParticles)
!Connect Cell-Edge
DO et = 1, self%numEdges
CALL connectCellEdge(self%cells(e)%obj, self%edges(et)%obj)
END DO
END SELECT
END DO
END SUBROUTINE connectMesh1DCart
SUBROUTINE connectCellCell(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell), INTENT(inout):: elemA
CLASS(meshCell), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS(meshCell1DCartSegm)
SELECT TYPE(elemB)
TYPE IS(meshCell1DCartSegm)
CALL connectSegmSegm(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectCellCell
SUBROUTINE connectSegmSegm(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(inout), TARGET:: elemA
CLASS(meshCell1DCartSegm), INTENT(inout), TARGET:: elemB
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
END IF
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END SUBROUTINE connectSegmSegm
SUBROUTINE connectCellEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell), INTENT(inout):: elemA
CLASS(meshEdge), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS (meshCell1DCartSegm)
SELECT TYPE(elemB)
CLASS IS(meshEdge1DCart)
CALL connectSegmEdge(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectCellEdge
SUBROUTINE connectSegmEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell1DCartSegm), INTENT(inout), TARGET:: elemA
CLASS(meshEdge1DCart), INTENT(inout), TARGET:: elemB
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
!Rever the normal to point inside the domain
elemB%normal = - elemB%normal
END IF
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n1%n == elemB%n1%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END SUBROUTINE connectSegmEdge
END MODULE moduleMesh1DCart END MODULE moduleMesh1DCart

View file

@ -1,91 +0,0 @@
SUBMODULE (moduleMesh1DCart) moduleMesh1DCartBoundary
USE moduleMesh1DCart
CONTAINS
SUBROUTINE reflection(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
SELECT TYPE(edge)
TYPE IS(meshEdge1DCart)
part%v(1) = -part%v(1)
part%r(1) = 2.D0*edge%x - part%r(1)
END SELECT
END SUBROUTINE reflection
SUBROUTINE absorption(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
REAL(8):: rEdge(1) !Position of particle in the edge
REAL(8):: d !Distance from particle to edge
SELECT TYPE(edge)
TYPE IS(meshEdge1DCart)
rEdge(1) = edge%x
d = DABS(part%r(1) - rEdge(1))
IF (d > 0.D0) THEN
part%weight = part%weight / d
part%r(1) = rEdge(1)
END IF
IF (ASSOCIATED(edge%e1)) THEN
CALL edge%e1%scatter(part)
ELSE
CALL edge%e2%scatter(part)
END IF
END SELECT
part%n_in = .FALSE.
END SUBROUTINE absorption
SUBROUTINE transparent(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
part%n_in = .FALSE.
END SUBROUTINE transparent
SUBROUTINE wallTemperature(edge, part)
USE moduleSpecies
USE moduleBoundary
USE moduleRandom
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
!Modifies particle velocity according to wall temperature
SELECT TYPE(bound => edge%boundary%bTypes(part%sp)%obj)
TYPE IS(boundaryWallTemperature)
part%v(1) = part%v(1) + bound%vTh*randomMaxwellian()
END SELECT
SELECT TYPE(edge)
TYPE IS(meshEdge1DCart)
part%v(1) = -part%v(1)
part%r(1) = 2.D0*edge%x - part%r(1)
END SELECT
END SUBROUTINE wallTemperature
END SUBMODULE moduleMesh1DCartBoundary

View file

@ -1,261 +0,0 @@
MODULE moduleMesh1DCartRead
USE moduleMesh
USE moduleMesh1DCart
!TODO: make this abstract to allow different mesh formats
TYPE, EXTENDS(meshGeneric):: mesh1DCartGeneric
CONTAINS
PROCEDURE, PASS:: init => init1DCartMesh
PROCEDURE, PASS:: readMesh => readMesh1DCart
END TYPE
INTERFACE connected
MODULE PROCEDURE connectedVolVol, connectedVolEdge
END INTERFACE connected
CONTAINS
!Init 1D mesh
SUBROUTINE init1DCartMesh(self, meshFormat)
USE moduleMesh
USE moduleErrors
IMPLICIT NONE
CLASS(mesh1DCartGeneric), INTENT(out):: self
CHARACTER(:), ALLOCATABLE, INTENT(in):: meshFormat
SELECT CASE(meshFormat)
CASE ("gmsh")
self%printOutput => printOutputGmsh
self%printColl => printCollGmsh
self%printEM => printEMGmsh
CASE DEFAULT
CALL criticalError("Mesh type " // meshFormat // " not supported.", "init1DCart")
END SELECT
END SUBROUTINE init1DCartMesh
!Reads 1D mesh
SUBROUTINE readMesh1DCart(self, filename)
USE moduleBoundary
IMPLICIT NONE
CLASS(mesh1DCartGeneric), INTENT(inout):: self
CHARACTER(:), ALLOCATABLE, INTENT(in):: filename
REAL(8):: x
INTEGER:: p(1:2)
INTEGER:: e, et, n, eTemp, elemType, bt
INTEGER:: totalNumElem
INTEGER:: boundaryType
!Open file mesh
OPEN(10, FILE=TRIM(filename))
!Skip header
READ(10, *)
READ(10, *)
READ(10, *)
READ(10, *)
!Read number of nodes
READ(10, *) self%numNodes
!Allocate required matrices and vectors
ALLOCATE(self%nodes(1:self%numNodes))
ALLOCATE(self%K(1:self%numNodes, 1:self%numNodes))
ALLOCATE(self%IPIV(1:self%numNodes, 1:self%numNodes))
self%K = 0.D0
self%IPIV = 0
!Read nodes coordinates. Only relevant for x
DO e = 1, self%numNodes
READ(10, *) n, x
ALLOCATE(meshNode1DCart:: self%nodes(n)%obj)
CALL self%nodes(n)%obj%init(n, (/ x, 0.D0, 0.D0 /))
END DO
!Skips comments
READ(10, *)
READ(10, *)
!Reads the total number of elements (edges+vol)
READ(10, *) totalNumElem
self%numEdges = 0
DO e = 1, totalNumElem
READ(10, *) eTemp, elemType
IF (elemType == 15) THEN !15 is physical node in GMSH
self%numEdges = e
END IF
END DO
!Substract the number of edges to the total number of elements
!to obtain the number of volume elements
self%numVols = totalNumelem - self%numEdges
!Allocates arrays
ALLOCATE(self%edges(1:self%numEdges))
ALLOCATE(self%vols(1:self%numVols))
!Go back to the beginning of reading elements
DO e = 1, totalNumelem
BACKSPACE(10)
END DO
!Reads edges
DO e = 1, self%numEdges
READ(10, *) n, elemType, eTemp, boundaryType, eTemp, p(1)
!Associate boundary condition
bt = getBoundaryId(boundaryType)
ALLOCATE(meshEdge1DCart:: self%edges(e)%obj)
CALL self%edges(e)%obj%init(n, p(1:1), bt, boundaryType)
END DO
!Read and initialize volumes
DO e = 1, self%numVols
READ(10, *) n, elemType, eTemp, eTemp, eTemp, p(1:2)
ALLOCATE(meshVol1DCartSegm:: self%vols(e)%obj)
CALL self%vols(e)%obj%init(n - self%numEdges, p(1:2))
END DO
CLOSE(10)
!Build connectivity between elements
DO e = 1, self%numVols
!Connectivity between volumes
DO et = 1, self%numVols
IF (e /= et) THEN
CALL connected(self%vols(e)%obj, self%vols(et)%obj)
END IF
END DO
!Connectivity betwen vols and edges
DO et = 1, self%numEdges
CALL connected(self%vols(e)%obj, self%edges(et)%obj)
END DO
!Constructs the global K matrix
CALL constructGlobalK(self%K, self%vols(e)%obj)
END DO
END SUBROUTINE readMesh1DCart
SUBROUTINE connectedVolVol(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol), INTENT(inout):: elemA
CLASS(meshVol), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS(meshVol1DCartSegm)
SELECT TYPE(elemB)
TYPE IS(meshVol1DCartSegm)
CALL connectedSegmSegm(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectedVolVol
SUBROUTINE connectedSegmSegm(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(inout), TARGET:: elemA
CLASS(meshVol1DCartSegm), INTENT(inout), TARGET:: elemB
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
END IF
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END SUBROUTINE connectedSegmSegm
SUBROUTINE connectedVolEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol), INTENT(inout):: elemA
CLASS(meshEdge), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS (meshVol1DCartSegm)
SELECT TYPE(elemB)
CLASS IS(meshEdge1DCart)
CALL connectedSegmEdge(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectedVolEdge
SUBROUTINE connectedSegmEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol1DCartSegm), INTENT(inout), TARGET:: elemA
CLASS(meshEdge1DCart), INTENT(inout), TARGET:: elemB
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
END IF
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n1%n == elemB%n1%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END SUBROUTINE connectedSegmEdge
SUBROUTINE constructGlobalK(K, elem)
IMPLICIT NONE
REAL(8), INTENT(inout):: K(1:,1:)
CLASS(meshVol), INTENT(in):: elem
REAL(8):: localK(1:2,1:2)
INTEGER:: i, j
INTEGER:: n(1:2)
SELECT TYPE(elem)
TYPE IS(meshVol1DCartSegm)
localK = elem%elemK()
n = (/ elem%n1%n, elem%n2%n /)
CLASS DEFAULT
n = 0
localK = 0.D0
END SELECT
DO i = 1, 2
DO j = 1, 2
K(n(i), n(j)) = K(n(i), n(j)) + localK(i, j)
END DO
END DO
END SUBROUTINE constructGlobalK
END MODULE moduleMesh1DCartRead

View file

@ -1,11 +1,5 @@
all: moduleMesh1DRad.o moduleMesh1DRadBoundary.o moduleMesh1DRadRead.o all: moduleMesh1DRad.o
moduleMesh1DRad.o: moduleMesh1DRad.f90 moduleMesh1DRad.o: moduleMesh1DRad.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleMesh1DRadBoundary.o: moduleMesh1DRad.o moduleMesh1DRadBoundary.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleMesh1DRadRead.o: moduleMesh1DRad.o moduleMesh1DRadBoundary.o moduleMesh1DRadRead.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@

View file

@ -4,12 +4,17 @@
! z == unused ! z == unused
MODULE moduleMesh1DRad MODULE moduleMesh1DRad
USE moduleMesh USE moduleMesh
USE moduleMeshBoundary
IMPLICIT NONE IMPLICIT NONE
REAL(8), PARAMETER:: corSeg(1:3) = (/ -DSQRT(3.D0/5.D0), 0.D0, DSQRT(3.D0/5.D0) /)
REAL(8), PARAMETER:: wSeg(1:3) = (/ 5.D0/9.D0 , 8.D0/9.D0, 5.D0/9.D0 /)
TYPE, PUBLIC, EXTENDS(meshNode):: meshNode1DRad TYPE, PUBLIC, EXTENDS(meshNode):: meshNode1DRad
!Element coordinates !Element coordinates
REAL(8):: r = 0.D0 REAL(8):: r = 0.D0
CONTAINS CONTAINS
!meshNode DEFERRED PROCEDURES
PROCEDURE, PASS:: init => initNode1DRad PROCEDURE, PASS:: init => initNode1DRad
PROCEDURE, PASS:: getCoordinates => getCoord1DRad PROCEDURE, PASS:: getCoordinates => getCoord1DRad
@ -21,112 +26,42 @@ MODULE moduleMesh1DRad
!Connectivity to nodes !Connectivity to nodes
CLASS(meshNode), POINTER:: n1 => NULL() CLASS(meshNode), POINTER:: n1 => NULL()
CONTAINS CONTAINS
!meshEdge DEFERRED PROCEDURES
PROCEDURE, PASS:: init => initEdge1DRad PROCEDURE, PASS:: init => initEdge1DRad
PROCEDURE, PASS:: getNodes => getNodes1DRad PROCEDURE, PASS:: getNodes => getNodes1DRad
PROCEDURE, PASS:: intersection => intersection1DRad
PROCEDURE, PASS:: randPos => randPos1DRad PROCEDURE, PASS:: randPos => randPos1DRad
END TYPE meshEdge1DRad END TYPE meshEdge1DRad
!Boundary functions defined in the submodule Boundary TYPE, PUBLIC, EXTENDS(meshCell):: meshCell1DRadSegm
INTERFACE
MODULE SUBROUTINE reflection(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE reflection
MODULE SUBROUTINE absorption(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE absorption
MODULE SUBROUTINE transparent(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE transparent
MODULE SUBROUTINE wallTemperature(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE wallTemperature
END INTERFACE
TYPE, PUBLIC, ABSTRACT, EXTENDS(meshVol):: meshVol1DRad
CONTAINS
PROCEDURE, PASS:: detJac => detJ1DRad
PROCEDURE, PASS:: invJac => invJ1DRad
PROCEDURE(fPsi_interface), DEFERRED, NOPASS:: fPsi
PROCEDURE(dPsi_interface), DEFERRED, NOPASS:: dPsi
PROCEDURE(partialDer_interface), DEFERRED, PASS:: partialDer
END TYPE meshVol1DRad
ABSTRACT INTERFACE
PURE FUNCTION fPsi_interface(xi) RESULT(fPsi)
REAL(8), INTENT(in):: xi(1:3)
REAL(8), ALLOCATABLE:: fPsi(:)
END FUNCTION fPsi_interface
PURE FUNCTION dPsi_interface(xi) RESULT(dPsi)
REAL(8), INTENT(in):: xi(1:3)
REAL(8), ALLOCATABLE:: dPsi(:,:)
END FUNCTION dPsi_interface
PURE SUBROUTINE partialDer_interface(self, dPsi, dx)
IMPORT meshVol1DRad
CLASS(meshVol1DRad), INTENT(in):: self
REAL(8), INTENT(in):: dPsi(1:,1:)
REAL(8), INTENT(out), DIMENSION(1):: dx
END SUBROUTINE partialDer_interface
END INTERFACE
TYPE, PUBLIC, EXTENDS(meshVol1DRad):: meshVol1DRadSegm
!Element coordinates !Element coordinates
REAL(8):: r(1:2) REAL(8):: r(1:2)
!Connectivity to nodes !Connectivity to nodes
CLASS(meshNode), POINTER:: n1 => NULL(), n2 => NULL() CLASS(meshNode), POINTER:: n1 => NULL(), n2 => NULL()
!Connectivity to adjacent elements !Connectivity to adjacent elements
CLASS(*), POINTER:: e1 => NULL(), e2 => NULL() CLASS(meshElement), POINTER:: e1 => NULL(), e2 => NULL()
REAL(8):: arNodes(1:2)
CONTAINS CONTAINS
PROCEDURE, PASS:: init => initVol1DRadSegm !meshCell DEFERRED PROCEDURES
PROCEDURE, PASS:: randPos => randPos1DRadSeg PROCEDURE, PASS:: init => initCell1DRadSegm
PROCEDURE, PASS:: area => areaRad PROCEDURE, PASS:: getNodes => getNodesSegm
PROCEDURE, NOPASS:: fPsi => fPsiRad PROCEDURE, PASS:: randPos => randPos1DRadSegm
PROCEDURE, NOPASS:: dPsi => dPsiRad PROCEDURE, NOPASS:: fPsi => fPsiSegm
PROCEDURE, PASS:: partialDer => partialDerRad PROCEDURE, NOPASS:: dPsi => dPsiSegm
PROCEDURE, PASS:: elemK => elemKRad PROCEDURE, PASS:: partialDer => partialDerSegm
PROCEDURE, PASS:: elemF => elemFRad PROCEDURE, NOPASS:: detJac => detJ1DRad
PROCEDURE, NOPASS:: weight => weightRad PROCEDURE, NOPASS:: invJac => invJ1DRad
PROCEDURE, NOPASS:: inside => insideRad PROCEDURE, PASS:: gatherElectricField => gatherEFSegm
PROCEDURE, PASS:: scatter => scatterRad PROCEDURE, PASS:: gatherMagneticField => gatherMFSegm
PROCEDURE, PASS:: gatherEF => gatherEFRad PROCEDURE, PASS:: elemK => elemKSegm
PROCEDURE, PASS:: getNodes => getNodesRad PROCEDURE, PASS:: elemF => elemFSegm
PROCEDURE, PASS:: phy2log => phy2logRad PROCEDURE, NOPASS:: inside => insideSegm
PROCEDURE, PASS:: nextElement => nextElementRad PROCEDURE, PASS:: phy2log => phy2logSegm
PROCEDURE, PASS:: neighbourElement => neighbourElementSegm
!PARTICLUAR PROCEDURES
PROCEDURE, PASS, PRIVATE:: calculateVolume => volumeSegm
END TYPE meshVol1DRadSegm END TYPE meshCell1DRadSegm
CONTAINS CONTAINS
!NODE FUNCTIONS !NODE FUNCTIONS
@ -134,6 +69,7 @@ MODULE moduleMesh1DRad
SUBROUTINE initNode1DRad(self, n, r) SUBROUTINE initNode1DRad(self, n, r)
USE moduleSpecies USE moduleSpecies
USE moduleRefParam USE moduleRefParam
USE OMP_LIB
IMPLICIT NONE IMPLICIT NONE
CLASS(meshNode1DRad), INTENT(out):: self CLASS(meshNode1DRad), INTENT(out):: self
@ -145,9 +81,11 @@ MODULE moduleMesh1DRad
!Node volume, to be determined in mesh !Node volume, to be determined in mesh
self%v = 0.D0 self%v = 0.D0
!Allocates output !Allocate output
ALLOCATE(self%output(1:nSpecies)) ALLOCATE(self%output(1:nSpecies))
CALL OMP_INIT_LOCK(self%lock)
END SUBROUTINE initNode1DRad END SUBROUTINE initNode1DRad
PURE FUNCTION getCoord1DRad(self) RESULT(r) PURE FUNCTION getCoord1DRad(self) RESULT(r)
@ -161,7 +99,7 @@ MODULE moduleMesh1DRad
END FUNCTION getCoord1DRad END FUNCTION getCoord1DRad
!EDGE FUNCTIONS !EDGE FUNCTIONS
!Inits edge element !Init edge element
SUBROUTINE initEdge1DRad(self, n, p, bt, physicalSurface) SUBROUTINE initEdge1DRad(self, n, p, bt, physicalSurface)
USE moduleSpecies USE moduleSpecies
USE moduleBoundary USE moduleBoundary
@ -177,12 +115,15 @@ MODULE moduleMesh1DRad
INTEGER:: s INTEGER:: s
self%n = n self%n = n
self%nNodes = SIZE(p)
self%n1 => mesh%nodes(p(1))%obj self%n1 => mesh%nodes(p(1))%obj
!Get element coordinates !Get element coordinates
r1 = self%n1%getCoordinates() r1 = self%n1%getCoordinates()
self%r = r1(1) self%r = r1(1)
self%surface = 1.D0
self%normal = (/ 1.D0, 0.D0, 0.D0 /) self%normal = (/ 1.D0, 0.D0, 0.D0 /)
!Boundary index !Boundary index
@ -190,23 +131,7 @@ MODULE moduleMesh1DRad
ALLOCATE(self%fboundary(1:nSpecies)) ALLOCATE(self%fboundary(1:nSpecies))
!Assign functions to boundary !Assign functions to boundary
DO s = 1, nSpecies DO s = 1, nSpecies
SELECT TYPE(obj => self%boundary%bTypes(s)%obj) CALL pointBoundaryFunction(self, s)
TYPE IS(boundaryAbsorption)
self%fBoundary(s)%apply => absorption
TYPE IS(boundaryReflection)
self%fBoundary(s)%apply => reflection
TYPE IS(boundaryTransparent)
self%fBoundary(s)%apply => transparent
TYPE IS(boundaryWallTemperature)
self%fBoundary(s)%apply => wallTemperature
CLASS DEFAULT
CALL criticalError("Boundary type not defined in this geometry", 'initEdge1DRad')
END SELECT
END DO END DO
@ -216,18 +141,29 @@ MODULE moduleMesh1DRad
END SUBROUTINE initEdge1DRad END SUBROUTINE initEdge1DRad
!Get nodes from edge !Get nodes from edge
PURE FUNCTION getNodes1DRad(self) RESULT(n) PURE FUNCTION getNodes1DRad(self, nNodes) RESULT(n)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshEdge1DRad), INTENT(in):: self CLASS(meshEdge1DRad), INTENT(in):: self
INTEGER, ALLOCATABLE:: n(:) INTEGER, INTENT(in):: nNodes
INTEGER:: n(1:nNodes)
ALLOCATE(n(1))
n = (/ self%n1%n /) n = (/ self%n1%n /)
END FUNCTION getNodes1DRad END FUNCTION getNodes1DRad
!Calculates a 'random' position in edge PURE FUNCTION intersection1DRad(self, r0) RESULT(r)
IMPLICIT NONE
CLASS(meshEdge1DRad), INTENT(in):: self
REAL(8), DIMENSION(1:3), INTENT(in):: r0
REAL(8), DIMENSION(1:3):: r
r = (/ self%r, 0.D0, 0.D0 /)
END FUNCTION intersection1DRad
!Calculate a 'random' position in edge
FUNCTION randPos1DRad(self) RESULT(r) FUNCTION randPos1DRad(self) RESULT(r)
CLASS(meshEdge1DRad), INTENT(in):: self CLASS(meshEdge1DRad), INTENT(in):: self
REAL(8):: r(1:3) REAL(8):: r(1:3)
@ -238,325 +174,435 @@ MODULE moduleMesh1DRad
!VOLUME FUNCTIONS !VOLUME FUNCTIONS
!SEGMENT FUNCTIONS !SEGMENT FUNCTIONS
!Init segment element !Init element
SUBROUTINE initVol1DRadSegm(self, n, p) SUBROUTINE initCell1DRadSegm(self, n, p, nodes)
USE moduleRefParam USE moduleRefParam
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(out):: self CLASS(meshCell1DRadSegm), INTENT(out):: self
INTEGER, INTENT(in):: n INTEGER, INTENT(in):: n
INTEGER, INTENT(in):: p(:) INTEGER, INTENT(in):: p(:)
TYPE(meshNodeCont), INTENT(in), TARGET:: nodes(:)
REAL(8), DIMENSION(1:3):: r1, r2 REAL(8), DIMENSION(1:3):: r1, r2
self%n = n self%n = n
self%n1 => mesh%nodes(p(1))%obj self%nNodes = SIZE(p)
self%n2 => mesh%nodes(p(2))%obj self%n1 => nodes(p(1))%obj
self%n2 => nodes(p(2))%obj
!Get element coordinates !Get element coordinates
r1 = self%n1%getCoordinates() r1 = self%n1%getCoordinates()
r2 = self%n2%getCoordinates() r2 = self%n2%getCoordinates()
self%r = (/ r1(1), r2(1) /) self%r = (/ r1(1), r2(1) /)
!Assign node volume !Assign node volume
CALL self%area() CALL self%calculateVolume()
self%n1%v = self%n1%v + self%arNodes(1)
self%n2%v = self%n2%v + self%arNodes(2)
self%sigmaVrelMax = sigma_ref/L_ref**2
CALL OMP_INIT_LOCK(self%lock) CALL OMP_INIT_LOCK(self%lock)
END SUBROUTINE initVol1DRadSegm ALLOCATE(self%listPart_in(1:nSpecies))
ALLOCATE(self%totalWeight(1:nSpecies))
!Calculates a random position in 1D volume END SUBROUTINE initCell1DRadSegm
FUNCTION randPos1DRadSeg(self) RESULT(r)
!Get nodes from 1D volume
PURE FUNCTION getNodesSegm(self, nNodes) RESULT(n)
IMPLICIT NONE
CLASS(meshCell1DRadSegm), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
INTEGER:: n(1:nNodes)
n = (/ self%n1%n, self%n2%n /)
END FUNCTION getNodesSegm
!Random position in 1D volume
FUNCTION randPos1DRadSegm(self) RESULT(r)
USE moduleRandom USE moduleRandom
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(in):: self CLASS(meshCell1DRadSegm), INTENT(in):: self
REAL(8):: r(1:3) REAL(8):: r(1:3)
REAL(8):: xii(1:3) REAL(8):: Xi(1:3)
REAL(8), ALLOCATABLE:: fPsi(:) REAL(8):: fPsi(1:2)
xii(1) = random(-1.D0, 1.D0) Xi = 0.D0
xii(2:3) = 0.D0 Xi(1) = random(-1.D0, 1.D0)
fPsi = self%fPsi(xii) fPsi = self%fPsi(Xi, 2)
r = 0.D0
r(1) = DOT_PRODUCT(fPsi, self%r) r(1) = DOT_PRODUCT(fPsi, self%r)
END FUNCTION randPos1DRadSeg END FUNCTION randPos1DRadSegm
!Computes element area !Compute element functions at point Xi
PURE SUBROUTINE areaRad(self) PURE FUNCTION fPsiSegm(Xi, nNodes) RESULT(fPsi)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(inout):: self REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: l !element length INTEGER, INTENT(in):: nNodes
REAL(8):: fPsi(1:2) REAL(8):: fPsi(1:nNodes)
REAL(8):: r
REAL(8):: detJ
REAL(8):: Xii(1:3)
self%volume = 0.D0 fPsi = (/ 1.D0 - Xi(1), &
self%arNodes = 0.D0 1.D0 + Xi(1) /)
!1 point Gauss integral
Xii = 0.D0
fPsi = self%fPsi(Xii)
detJ = self%detJac(Xii)
r = DOT_PRODUCT(fPsi, self%r)
l = 2.D0*detJ
self%volume = r*l
self%arNodes = fPsi*r*l
END SUBROUTINE areaRad fPsi = fPsi * 0.50D0
!Computes element functions at point xii END FUNCTION fPsiSegm
PURE FUNCTION fPsiRad(xi) RESULT(fPsi)
!Derivative element function at coordinates Xi
PURE FUNCTION dPsiSegm(Xi, nNodes) RESULT(dPsi)
IMPLICIT NONE IMPLICIT NONE
REAL(8), INTENT(in):: xi(1:3) REAL(8), INTENT(in):: Xi(1:3)
REAL(8), ALLOCATABLE:: fPsi(:) INTEGER, INTENT(in):: nNodes
REAL(8):: dPsi(1:3,1:nNodes)
ALLOCATE(fPsi(1:2)) dPsi = 0.D0
fPsi(1) = 1.D0 - xi(1) dPsi(1, 1:2) = (/ -5.D-1, 5.D-1 /)
fPsi(2) = 1.D0 + xi(1)
fPsi = fPsi * 5.D-1
END FUNCTION fPsiRad END FUNCTION dPsiSegm
!Computes element derivative shape function at Xii !Partial derivative in global coordinates
PURE FUNCTION dPsiRad(xi) RESULT(dPsi) PURE FUNCTION partialDerSegm(self, nNodes, dPsi) RESULT(pDer)
IMPLICIT NONE IMPLICIT NONE
REAL(8), INTENT(in):: xi(1:3) CLASS(meshCell1DRadSegm), INTENT(in):: self
REAL(8), ALLOCATABLE:: dPsi(:,:) INTEGER, INTENT(in):: nNodes
REAL(8), INTENT(in):: dPsi(1:3,1:nNodes)
REAL(8):: pDer(1:3, 1:3)
ALLOCATE(dPsi(1:1, 1:2)) pDer = 0.D0
dPsi(1, 1) = -5.D-1 pDer(1,1) = DOT_PRODUCT(dPsi(1,1:2), self%r(1:2))
dPsi(1, 2) = 5.D-1 pDer(2,2) = 1.D0
pDer(3,3) = 1.D0
END FUNCTION dPsiRad END FUNCTION partialDerSegm
!Computes partial derivatives of coordinates PURE FUNCTION gatherEFSegm(self, Xi) RESULT(array)
PURE SUBROUTINE partialDerRad(self, dPsi, dx)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshCell1DRadSegm), INTENT(in):: self
CLASS(meshVol1DRadSegm), INTENT(in):: self REAL(8), INTENT(in):: Xi(1:3)
REAL(8), INTENT(in):: dPsi(1:,1:) REAL(8):: array(1:3)
REAL(8), INTENT(out), DIMENSION(1):: dx
dx(1) = DOT_PRODUCT(dPsi(1,:), self%r)
END SUBROUTINE partialDerRad
!Computes local stiffness matrix
PURE FUNCTION elemKRad(self) RESULT(ke)
USE moduleConstParam, ONLY: PI2
IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(in):: self
REAL(8):: ke(1:2,1:2)
REAL(8):: Xii(1:3)
REAL(8):: dPsi(1:1, 1:2)
REAL(8):: invJ
REAL(8):: r, fPsi(1:2)
ke = 0.D0
Xii = 0.D0
dPsi = self%dPsi(Xii)
invJ = self%invJac(Xii, dPsi)
fPsi = self%fPsi(Xii)
r = DOT_PRODUCT(fPsi, self%r)
ke(1,:) = (/ dPsi(1,1)*dPsi(1,1), dPsi(1,1)*dPsi(1,2) /)
ke(2,:) = (/ dPsi(1,2)*dPsi(1,1), dPsi(1,2)*dPsi(1,2) /)
ke = 2.D0*ke*invJ
ke = ke*r*PI2
END FUNCTION elemKRad
PURE FUNCTION elemFRad(self, source) RESULT(localF)
USE moduleConstParam, ONLY: PI2
IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(in):: self
REAL(8), INTENT(in):: source(1:)
REAL(8), ALLOCATABLE:: localF(:)
REAL(8):: fPsi(1:2)
REAL(8):: r
REAL(8):: detJ
REAL(8):: Xii(1:3)
Xii = 0.D0
fPsi = self%fPsi(Xii)
detJ = self%detJac(Xii)
r = DOT_PRODUCT(fPsi,self%r)
ALLOCATE(localF(1:2))
localF = 2.D0*DOT_PRODUCT(fPsi, source)*detJ
localF = localF*r*PI2
END FUNCTION elemFRad
PURE FUNCTION weightRad(xi) RESULT(w)
IMPLICIT NONE
REAL(8), INTENT(in):: xi(1:3)
REAL(8):: w(1:2)
w = fPsiRad(xi)
END FUNCTION weightRad
PURE FUNCTION insideRad(xi) RESULT(ins)
IMPLICIT NONE
REAL(8), INTENT(in):: xi(1:3)
LOGICAL:: ins
ins = xi(1) >=-1.D0 .AND. &
xi(1) <= 1.D0
END FUNCTION insideRad
SUBROUTINE scatterRad(self, part)
USE moduleOutput
USE moduleSpecies
IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(in):: self
CLASS(particle), INTENT(in):: part
TYPE(outputNode), POINTER:: vertex
REAL(8):: w_p(1:2)
REAL(8):: tensorS(1:3,1:3)
w_p = self%weight(part%xi)
tensorS = outerProduct(part%v, part%v)
vertex => self%n1%output(part%sp)
vertex%den = vertex%den + part%weight*w_p(1)
vertex%mom(:) = vertex%mom(:) + part%weight*w_p(1)*part%v(:)
vertex%tensorS(:,:) = vertex%tensorS(:,:) + part%weight*w_p(1)*tensorS
vertex => self%n2%output(part%sp)
vertex%den = vertex%den + part%weight*w_p(2)
vertex%mom(:) = vertex%mom(:) + part%weight*w_p(2)*part%v(:)
vertex%tensorS(:,:) = vertex%tensorS(:,:) + part%weight*w_p(2)*tensorS
END SUBROUTINE scatterRad
!Gathers EF at position Xii
PURE FUNCTION gatherEFRad(self, xi) RESULT(EF)
IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(in):: self
REAL(8), INTENT(in):: xi(1:3)
REAL(8):: dPsi(1, 1:2)
REAL(8):: phi(1:2) REAL(8):: phi(1:2)
REAL(8):: EF(1:3)
REAL(8):: invJ
phi = (/ self%n1%emData%phi, & phi = (/ self%n1%emData%phi, &
self%n2%emData%phi /) self%n2%emData%phi /)
dPsi = self%dPsi(xi) array = -self%gatherDF(Xi, 2, phi)
invJ = self%invJac(xi, dPsi)
EF(1) = -DOT_PRODUCT(dPsi(1, :), phi)*invJ
EF(2) = 0.D0
EF(3) = 0.D0
END FUNCTION gatherEFRad END FUNCTION gatherEFSegm
!Get nodes from 1D volume PURE FUNCTION gatherMFSegm(self, Xi) RESULT(array)
PURE FUNCTION getNodesRad(self) RESULT(n) IMPLICIT NONE
CLASS(meshCell1DRadSegm), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: array(1:3)
REAL(8):: B(1:2,1:3)
B(:,1) = (/ self%n1%emData%B(1), &
self%n2%emData%B(1) /)
B(:,2) = (/ self%n1%emData%B(2), &
self%n2%emData%B(2) /)
B(:,3) = (/ self%n1%emData%B(3), &
self%n2%emData%B(3) /)
array = self%gatherF(Xi, 2, B)
END FUNCTION gatherMFSegm
!Compute element local stiffness matrix
PURE FUNCTION elemKSegm(self, nNodes) RESULT(localK)
USE moduleConstParam, ONLY: PI2
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(in):: self CLASS(meshCell1DRadSegm), INTENT(in):: self
INTEGER, ALLOCATABLE:: n(:) INTEGER, INTENT(in):: nNodes
REAL(8):: localK(1:nNodes,1:nNodes)
REAL(8):: Xi(1:3)
REAL(8):: dPsi(1:3, 1:2)
REAL(8):: pDer(1:3, 1:3)
REAL(8):: r
REAL(8):: invJ(1:3, 1:3), detJ
INTEGER:: l
ALLOCATE(n(1:2)) localK = 0.D0
n = (/ self%n1%n, self%n2%n /)
END FUNCTION getNodesRad Xi = 0.D0
!Start 1D Gauss Quad Integral
DO l = 1, 3
Xi(1) = corSeg(l)
dPsi = self%dPsi(Xi, 2)
pDer = self%partialDer(2, dPsi)
detJ = self%detJac(pDer)
invJ = self%invJac(pDer)
r = self%gatherF(Xi, 2, self%r)
localK = localK + MATMUL(TRANSPOSE(MATMUL(invJ,dPsi)), &
MATMUL(invJ,dPsi))* &
r*wSeg(l)/detJ
PURE FUNCTION phy2logRad(self, r) RESULT(xN) END DO
localK = localK*PI2
END FUNCTION elemKSegm
!Compute the local source vector for a force f
PURE FUNCTION elemFSegm(self, nNodes, source) RESULT(localF)
USE moduleConstParam, ONLY: PI2
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(in):: self CLASS(meshCell1DRadSegm), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8), INTENT(in):: source(1:nNodes)
REAL(8):: localF(1:nNodes)
REAL(8):: fPsi(1:2)
REAL(8):: dPsi(1:3, 1:2), pDer(1:3, 1:3)
REAL(8):: Xi(1:3)
REAL(8):: detJ, f
REAL(8):: r
INTEGER:: l
localF = 0.D0
Xi = 0.D0
!Start 1D Gauss Quad Integral
DO l = 1, 3
Xi(1) = corSeg(l)
dPsi = self%dPsi(Xi, 2)
pDer = self%partialDer(2, dPsi)
detJ = self%detJac(pDer)
fPsi = self%fPsi(Xi, 2)
r = DOT_PRODUCT(fPsi, self%r)
f = DOT_PRODUCT(fPsi, source)
localF = localF + r*f*fPsi*wSeg(l)*detJ
END DO
localF = localF*PI2
END FUNCTION elemFSegm
PURE FUNCTION insideSegm(Xi) RESULT(ins)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
LOGICAL:: ins
ins = Xi(1) >=-1.D0 .AND. &
Xi(1) <= 1.D0
END FUNCTION insideSegm
PURE FUNCTION phy2logSegm(self, r) RESULT(Xi)
IMPLICIT NONE
CLASS(meshCell1DRadSegm), INTENT(in):: self
REAL(8), INTENT(in):: r(1:3) REAL(8), INTENT(in):: r(1:3)
REAL(8):: xN(1:3) REAL(8):: Xi(1:3)
xN = 0.D0 Xi = 0.D0
xN(1) = 2.D0*(r(1) - self%r(1))/(self%r(2) - self%r(1)) - 1.D0
END FUNCTION phy2logRad Xi(1) = 2.D0*(r(1) - self%r(1))/(self%r(2) - self%r(1)) - 1.D0
!Get next element for a logical position xi END FUNCTION phy2logSegm
SUBROUTINE nextElementRad(self, xi, nextElement)
!Get the next element for a logical position Xi
SUBROUTINE neighbourElementSegm(self, Xi, neighbourElement)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(in):: self CLASS(meshCell1DRadSegm), INTENT(in):: self
REAL(8), INTENT(in):: xi(1:3) REAL(8), INTENT(in):: Xi(1:3)
CLASS(*), POINTER, INTENT(out):: nextElement CLASS(meshElement), POINTER, INTENT(out):: neighbourElement
NULLIFY(nextElement) NULLIFY(neighbourElement)
IF (xi(1) < -1.D0) THEN IF (Xi(1) < -1.D0) THEN
nextElement => self%e2 neighbourElement => self%e2
ELSEIF (xi(1) > 1.D0) THEN ELSEIF (Xi(1) > 1.D0) THEN
nextElement => self%e1 neighbourElement => self%e1
END IF END IF
END SUBROUTINE nextElementRad END SUBROUTINE neighbourElementSegm
!Compute element volume
PURE SUBROUTINE volumeSegm(self)
USE moduleConstParam, ONLY: PI4
IMPLICIT NONE
CLASS(meshCell1DRadSegm), INTENT(inout):: self
REAL(8):: Xi(1:3)
REAL(8):: dPsi(1:3, 1:2), pDer(1:3, 1:3)
REAL(8):: detJ
REAL(8):: fPsi(1:2)
REAL(8):: r
self%volume = 0.D0
!1D 1 point Gauss Quad Integral
Xi = 0.D0
dPsi = self%dPsi(Xi, 2)
pDer = self%partialDer(2, dPsi)
detJ = self%detJac(pDer)
fPsi = self%fPsi(Xi, 2)
r = DOT_PRODUCT(fPsi, self%r)
!Compute total volume of the cell
self%volume = r*detJ*PI4 !2*2PI
!Compute volume per node
Xi = (/-5.D-1, 0.D0, 0.D0/)
r = self%gatherF(Xi, 2, self%r)
self%n1%v = self%n1%v + fPsi(1)*r*detJ*PI4
Xi = (/ 5.D-1, 0.D0, 0.D0/)
r = self%gatherF(Xi, 2, self%r)
self%n2%v = self%n2%v + fPsi(2)*r*detJ*PI4
END SUBROUTINE volumeSegm
!COMMON FUNCTIONS FOR 1D VOLUME ELEMENTS !COMMON FUNCTIONS FOR 1D VOLUME ELEMENTS
!Computes the element Jacobian determinant !Compute element Jacobian determinant
PURE FUNCTION detJ1DRad(self, xi, dPsi_in) RESULT(dJ) PURE FUNCTION detJ1DRad(pDer) RESULT(dJ)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DRad), INTENT(in):: self REAL(8), INTENT(in):: pDer(1:3, 1:3)
REAL(8), INTENT(in):: xi(1:3)
REAL(8), INTENT(in), OPTIONAL:: dPsi_in(1:,1:)
REAL(8), ALLOCATABLE:: dPsi(:,:)
REAL(8):: dJ REAL(8):: dJ
REAL(8):: dx(1)
IF (PRESENT(dPsi_in)) THEN dJ = pDer(1, 1)
dPsi = dPsi_in
ELSE
dPsi = self%dPsi(xi)
END IF
CALL self%partialDer(dPsi, dx)
dJ = dx(1)
END FUNCTION detJ1DRad END FUNCTION detJ1DRad
!Computes the invers Jacobian !Compute element Jacobian inverse matrix (without determinant)
PURE FUNCTION invJ1DRad(self, xi, dPsi_in) RESULT(invJ) PURE FUNCTION invJ1DRad(pDer) RESULT(invJ)
IMPLICIT NONE IMPLICIT NONE
CLASS(meshVol1DRad), INTENT(in):: self REAL(8), INTENT(in):: pDer(1:3, 1:3)
REAL(8), INTENT(in):: xi(1:3) REAL(8):: invJ(1:3,1:3)
REAL(8), INTENT(in), OPTIONAL:: dPsi_in(1:,1:)
REAL(8), ALLOCATABLE:: dPsi(:,:)
REAL(8):: dx(1)
REAL(8):: invJ
IF (PRESENT(dPsi_in)) THEN invJ = 0.D0
dPsi = dPsi_in
ELSE invJ(1, 1) = 1.D0/pDer(1, 1)
dPsi = self%dPsi(xi) invJ(2, 2) = 1.D0
invJ(3, 3) = 1.D0
END IF
CALL self%partialDer(dPsi, dx)
invJ = 1.D0/dx(1)
END FUNCTION invJ1DRad END FUNCTION invJ1DRad
SUBROUTINE connectMesh1DRad(self)
IMPLICIT NONE
CLASS(meshGeneric), INTENT(inout):: self
INTEGER:: e, et
DO e = 1, self%numCells
!Connect Cell-Cell
DO et = 1, self%numCells
IF (e /= et) THEN
CALL connectCellCell(self%cells(e)%obj, self%cells(et)%obj)
END IF
END DO
SELECT TYPE(self)
TYPE IS(meshParticles)
!Connect Cell-Edge
DO et = 1, self%numEdges
CALL connectCellEdge(self%cells(e)%obj, self%edges(et)%obj)
END DO
END SELECT
END DO
END SUBROUTINE connectMesh1DRad
SUBROUTINE connectCellCell(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell), INTENT(inout):: elemA
CLASS(meshCell), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS(meshCell1DRadSegm)
SELECT TYPE(elemB)
TYPE IS(meshCell1DRadSegm)
CALL connectSegmSegm(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectCellCell
SUBROUTINE connectSegmSegm(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell1DRadSegm), INTENT(inout), TARGET:: elemA
CLASS(meshCell1DRadSegm), INTENT(inout), TARGET:: elemB
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
END IF
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END SUBROUTINE connectSegmSegm
SUBROUTINE connectCellEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell), INTENT(inout):: elemA
CLASS(meshEdge), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS (meshCell1DRadSegm)
SELECT TYPE(elemB)
CLASS IS(meshEdge1DRad)
CALL connectSegmEdge(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectCellEdge
SUBROUTINE connectSegmEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell1DRadSegm), INTENT(inout), TARGET:: elemA
CLASS(meshEdge1DRad), INTENT(inout), TARGET:: elemB
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
!Rever the normal to point inside the domain
elemB%normal = - elemB%normal
END IF
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n1%n == elemB%n1%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END SUBROUTINE connectSegmEdge
END MODULE moduleMesh1DRad END MODULE moduleMesh1DRad

View file

@ -1,93 +0,0 @@
SUBMODULE (moduleMesh1DRad) moduleMesh1DRadBoundary
USE moduleMesh1DRad
CONTAINS
SUBROUTINE reflection(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
SELECT TYPE(edge)
TYPE IS(meshEdge1DRad)
part%v(1) = -part%v(1)
part%r(1) = 2.D0*edge%r - part%r(1)
END SELECT
part%n_in = .TRUE.
END SUBROUTINE reflection
SUBROUTINE absorption(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
REAL(8):: rEdge(1) !Position of particle in the edge
REAL(8):: d !Distance from particle to edge
SELECT TYPE(edge)
TYPE IS(meshEdge1DRad)
rEdge(1) = edge%r
d = DABS(part%r(1) - rEdge(1))
IF (d > 0.D0) THEN
part%weight = part%weight / d
part%r(1) = rEdge(1)
END IF
IF (ASSOCIATED(edge%e1)) THEN
CALL edge%e1%scatter(part)
ELSE
CALL edge%e2%scatter(part)
END IF
END SELECT
part%n_in = .FALSE.
END SUBROUTINE absorption
SUBROUTINE transparent(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
part%n_in = .FALSE.
END SUBROUTINE transparent
SUBROUTINE wallTemperature(edge, part)
USE moduleSpecies
USE moduleBoundary
USE moduleRandom
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
!Modifies particle velocity according to wall temperature
SELECT TYPE(bound => edge%boundary%bTypes(part%sp)%obj)
TYPE IS(boundaryWallTemperature)
part%v(1) = part%v(1) + bound%vTh*randomMaxwellian()
END SELECT
SELECT TYPE(edge)
TYPE IS(meshEdge1DRad)
part%v(1) = -part%v(1)
part%r(1) = 2.D0*edge%r - part%r(1)
END SELECT
END SUBROUTINE wallTemperature
END SUBMODULE moduleMesh1DRadBoundary

View file

@ -1,261 +0,0 @@
MODULE moduleMesh1DRadRead
USE moduleMesh
USE moduleMesh1DRad
!TODO: make this abstract to allow different mesh formats
TYPE, EXTENDS(meshGeneric):: mesh1DRadGeneric
CONTAINS
PROCEDURE, PASS:: init => init1DRadMesh
PROCEDURE, PASS:: readMesh => readMesh1DRad
END TYPE
INTERFACE connected
MODULE PROCEDURE connectedVolVol, connectedVolEdge
END INTERFACE connected
CONTAINS
!Init 1D mesh
SUBROUTINE init1DRadMesh(self, meshFormat)
USE moduleMesh
USE moduleErrors
IMPLICIT NONE
CLASS(mesh1DRadGeneric), INTENT(out):: self
CHARACTER(:), ALLOCATABLE, INTENT(in):: meshFormat
SELECT CASE(meshFormat)
CASE ("gmsh")
self%printOutput => printOutputGmsh
self%printColl => printCollGmsh
self%printEM => printEMGmsh
CASE DEFAULT
CALL criticalError("Mesh type " // meshFormat // " not supported.", "init1DRad")
END SELECT
END SUBROUTINE init1DRadMesh
!Reads 1D mesh
SUBROUTINE readMesh1DRad(self, filename)
USE moduleBoundary
IMPLICIT NONE
CLASS(mesh1DRadGeneric), INTENT(inout):: self
CHARACTER(:), ALLOCATABLE, INTENT(in):: filename
REAL(8):: x
INTEGER:: p(1:2)
INTEGER:: e, et, n, eTemp, elemType, bt
INTEGER:: totalNumElem
INTEGER:: boundaryType
!Open file mesh
OPEN(10, FILE=TRIM(filename))
!Skip header
READ(10, *)
READ(10, *)
READ(10, *)
READ(10, *)
!Read number of nodes
READ(10, *) self%numNodes
!Allocate required matrices and vectors
ALLOCATE(self%nodes(1:self%numNodes))
ALLOCATE(self%K(1:self%numNodes, 1:self%numNodes))
ALLOCATE(self%IPIV(1:self%numNodes, 1:self%numNodes))
self%K = 0.D0
self%IPIV = 0
!Read nodes coordinates. Only relevant for x
DO e = 1, self%numNodes
READ(10, *) n, x
ALLOCATE(meshNode1DRad:: self%nodes(n)%obj)
CALL self%nodes(n)%obj%init(n, (/ x, 0.D0, 0.D0 /))
END DO
!Skips comments
READ(10, *)
READ(10, *)
!Reads the total number of elements (edges+vol)
READ(10, *) totalNumElem
self%numEdges = 0
DO e = 1, totalNumElem
READ(10, *) eTemp, elemType
IF (elemType == 15) THEN !15 is physical node in GMSH
self%numEdges = e
END IF
END DO
!Substract the number of edges to the total number of elements
!to obtain the number of volume elements
self%numVols = totalNumelem - self%numEdges
!Allocates arrays
ALLOCATE(self%edges(1:self%numEdges))
ALLOCATE(self%vols(1:self%numVols))
!Go back to the beginning of reading elements
DO e = 1, totalNumelem
BACKSPACE(10)
END DO
!Reads edges
DO e = 1, self%numEdges
READ(10, *) n, elemType, eTemp, boundaryType, eTemp, p(1)
!Associate boundary condition
bt = getBoundaryId(boundaryType)
ALLOCATE(meshEdge1DRad:: self%edges(e)%obj)
CALL self%edges(e)%obj%init(n, p(1:1), bt, boundaryType)
END DO
!Read and initialize volumes
DO e = 1, self%numVols
READ(10, *) n, elemType, eTemp, eTemp, eTemp, p(1:2)
ALLOCATE(meshVol1DRadSegm:: self%vols(e)%obj)
CALL self%vols(e)%obj%init(n - self%numEdges, p(1:2))
END DO
CLOSE(10)
!Build connectivity between elements
DO e = 1, self%numVols
!Connectivity between volumes
DO et = 1, self%numVols
IF (e /= et) THEN
CALL connected(self%vols(e)%obj, self%vols(et)%obj)
END IF
END DO
!Connectivity betwen vols and edges
DO et = 1, self%numEdges
CALL connected(self%vols(e)%obj, self%edges(et)%obj)
END DO
!Constructs the global K matrix
CALL constructGlobalK(self%K, self%vols(e)%obj)
END DO
END SUBROUTINE readMesh1DRad
SUBROUTINE connectedVolVol(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol), INTENT(inout):: elemA
CLASS(meshVol), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS(meshVol1DRadSegm)
SELECT TYPE(elemB)
TYPE IS(meshVol1DRadSegm)
CALL connectedSegmSegm(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectedVolVol
SUBROUTINE connectedSegmSegm(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(inout), TARGET:: elemA
CLASS(meshVol1DRadSegm), INTENT(inout), TARGET:: elemB
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
END IF
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END SUBROUTINE connectedSegmSegm
SUBROUTINE connectedVolEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol), INTENT(inout):: elemA
CLASS(meshEdge), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS (meshVol1DRadSegm)
SELECT TYPE(elemB)
CLASS IS(meshEdge1DRad)
CALL connectedSegmEdge(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectedVolEdge
SUBROUTINE connectedSegmEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol1DRadSegm), INTENT(inout), TARGET:: elemA
CLASS(meshEdge1DRad), INTENT(inout), TARGET:: elemB
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
END IF
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n1%n == elemB%n1%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END SUBROUTINE connectedSegmEdge
SUBROUTINE constructGlobalK(K, elem)
IMPLICIT NONE
REAL(8), INTENT(inout):: K(1:,1:)
CLASS(meshVol), INTENT(in):: elem
REAL(8):: localK(1:2,1:2)
INTEGER:: i, j
INTEGER:: n(1:2)
SELECT TYPE(elem)
TYPE IS(meshVol1DRadSegm)
localK = elem%elemK()
n = (/ elem%n1%n, elem%n2%n /)
CLASS DEFAULT
n = 0
localK = 0.D0
END SELECT
DO i = 1, 2
DO j = 1, 2
K(n(i), n(j)) = K(n(i), n(j)) + localK(i, j)
END DO
END DO
END SUBROUTINE constructGlobalK
END MODULE moduleMesh1DRadRead

View file

@ -0,0 +1,5 @@
all : moduleMesh2DCart.o
moduleMesh2DCart.o: moduleMesh2DCart.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@

File diff suppressed because it is too large Load diff

View file

@ -1,11 +1,5 @@
all : moduleMeshCyl.o moduleMeshCylBoundary.o moduleMeshCylRead.o all : moduleMesh2DCyl.o
moduleMeshCyl.o: moduleMeshCyl.f90 moduleMesh2DCyl.o: moduleMesh2DCyl.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleMeshCylBoundary.o: moduleMeshCyl.o moduleMeshCylBoundary.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
moduleMeshCylRead.o: moduleMeshCyl.o moduleMeshCylBoundary.o moduleMeshCylRead.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@ $(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -1,164 +0,0 @@
!moduleMeshCylBoundary: Boundary functions for cylindrical coordinates
SUBMODULE (moduleMeshCyl) moduleMeshCylBoundary
USE moduleMeshCyl
CONTAINS
SUBROUTINE reflection(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
REAL(8):: edgeNorm, cosT, sinT, rp(1:2), rpp(1:2), vpp(1:2)
!TODO: Try to do this without select
SELECT TYPE(edge)
TYPE IS(meshEdgeCyl)
edgeNorm = DSQRT((edge%r(2)-edge%r(1))**2 + (edge%z(2)-edge%z(1))**2)
cosT = (edge%z(2)-edge%z(1))/edgeNorm
sinT = DSQRT(1-cosT**2)
rp(1) = part%r(1) - edge%z(1);
rp(2) = part%r(2) - edge%r(1);
rpp(1) = cosT*rp(1) - sinT*rp(2)
rpp(2) = sinT*rp(1) + cosT*rp(2)
rpp(2) = -rpp(2)
vpp(1) = cosT*part%v(1) - sinT*part%v(2)
vpp(2) = sinT*part%v(1) + cosT*part%v(2)
vpp(2) = -vpp(2)
part%r(1) = cosT*rpp(1) + sinT*rpp(2) + edge%z(1);
part%r(2) = -sinT*rpp(1) + cosT*rpp(2) + edge%r(1);
part%v(1) = cosT*vpp(1) + sinT*vpp(2)
part%v(2) = -sinT*vpp(1) + cosT*vpp(2)
END SELECT
part%n_in = .TRUE.
END SUBROUTINE reflection
!Absoption in a surface
SUBROUTINE absorption(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
REAL(8):: rEdge(1:2) !Position of particle projected to the edge
REAL(8):: a, b, c
REAL(8):: a2b2
REAL(8):: d !Distance from particle to edge
SELECT TYPE(edge)
TYPE IS(meshEdgeCyl)
a = (edge%z(1) - edge%z(2))
b = (edge%r(1) - edge%r(2))
c = edge%z(1)*edge%r(2) - edge%z(2)*edge%r(1)
a2b2 = a**2 + b**2
rEdge(1) = (b*( b*part%r(1) - a*part%r(2)) - a*c)/a2b2
rEdge(2) = (a*(-b*part%r(1) + a*part%r(2)) - b*c)/a2b2
d = NORM2(rEdge - part%r(1:2))
!Reduce weight of particle by the distance to the edge and move it to the edge
IF (d > 0.D0) THEN
part%weight = part%weight / d
part%r(1:2) = rEdge
END IF
!Scatter particle in associated volume
IF (ASSOCIATED(edge%e1)) THEN
CALL edge%e1%scatter(part)
ELSE
CALL edge%e2%scatter(part)
END IF
END SELECT
!Remove particle from the domain
part%n_in = .FALSE.
END SUBROUTINE absorption
!Transparent boundary condition
SUBROUTINE transparent(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
!Removes particle from domain
part%n_in = .FALSE.
END SUBROUTINE transparent
!Wall with temperature
SUBROUTINE wallTemperature(edge, part)
USE moduleSpecies
USE moduleBoundary
USE moduleRandom
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
REAL(8):: edgeNorm, cosT, sinT, rp(1:2), rpp(1:2), vpp(1:2)
INTEGER:: i
!Modifies particle velocity according to wall temperature
SELECT TYPE(bound => edge%boundary%bTypes(part%sp)%obj)
TYPE IS(boundaryWallTemperature)
DO i = 1, 3
part%v(i) = part%v(i) + bound%vTh*randomMaxwellian()
END DO
END SELECT
!Reflects particle in the edge
SELECT TYPE(edge)
TYPE IS(meshEdgeCyl)
edgeNorm = DSQRT((edge%r(2)-edge%r(1))**2 + (edge%z(2)-edge%z(1))**2)
cosT = (edge%z(2)-edge%z(1))/edgeNorm
sinT = DSQRT(1-cosT**2)
rp(1) = part%r(1) - edge%z(1);
rp(2) = part%r(2) - edge%r(1);
rpp(1) = cosT*rp(1) - sinT*rp(2)
rpp(2) = sinT*rp(1) + cosT*rp(2)
rpp(2) = -rpp(2)
vpp(1) = cosT*part%v(1) - sinT*part%v(2)
vpp(2) = sinT*part%v(1) + cosT*part%v(2)
vpp(2) = -vpp(2)
part%r(1) = cosT*rpp(1) + sinT*rpp(2) + edge%z(1);
part%r(2) = -sinT*rpp(1) + cosT*rpp(2) + edge%r(1);
part%v(1) = cosT*vpp(1) + sinT*vpp(2)
part%v(2) = -sinT*vpp(1) + cosT*vpp(2)
END SELECT
part%n_in = .TRUE.
END SUBROUTINE wallTemperature
!Symmetry axis. Dummy function
SUBROUTINE symmetryAxis(edge, part)
USE moduleSpecies
IMPLICIT NONE
CLASS(meshEdge), INTENT(inout):: edge
CLASS(particle), INTENT(inout):: part
END SUBROUTINE symmetryAxis
END SUBMODULE moduleMeshCylBoundary

View file

@ -1,599 +0,0 @@
MODULE moduleMeshCylRead
USE moduleMesh
USE moduleMeshCyl
TYPE, EXTENDS(meshGeneric):: meshCylGeneric
CONTAINS
PROCEDURE, PASS:: init => initCylMesh
PROCEDURE, PASS:: readMesh => readMeshCylGmsh
END TYPE
INTERFACE connected
MODULE PROCEDURE connectedVolVol, connectedVolEdge
END INTERFACE connected
CONTAINS
!Init mesh
SUBROUTINE initCylMesh(self, meshFormat)
USE moduleMesh
USE moduleErrors
IMPLICIT NONE
CLASS(meshCylGeneric), INTENT(out):: self
CHARACTER(:), ALLOCATABLE, INTENT(in):: meshFormat
SELECT CASE(meshFormat)
CASE ("gmsh")
self%printOutput => printOutputGmsh
self%printColl => printCollGmsh
self%printEM => printEMGmsh
CASE DEFAULT
CALL criticalError("Mesh type " // meshFormat // " not supported.", "initCylMesh")
END SELECT
END SUBROUTINE initCylMesh
!Read mesh from gmsh file
SUBROUTINE readMeshCylGmsh(self, filename)
USE moduleBoundary
IMPLICIT NONE
CLASS(meshCylGeneric), INTENT(inout):: self
CHARACTER(:), ALLOCATABLE, INTENT(in):: filename
REAL(8):: r, z
INTEGER:: p(1:4)
INTEGER:: e=0, et=0, n=0, eTemp=0, elemType=0, bt = 0
INTEGER:: totalNumElem
INTEGER:: boundaryType
!Read msh
OPEN(10, FILE=TRIM(filename))
!Skip header
READ(10, *)
READ(10, *)
READ(10, *)
READ(10, *)
!Read number of nodes
READ(10, *) self%numNodes
!Allocate required matrices and vectors
ALLOCATE(self%nodes(1:self%numNodes))
ALLOCATE(self%K(1:self%numNodes,1:self%numNodes))
ALLOCATE(self%IPIV(1:self%numNodes,1:self%numNodes))
self%K = 0.D0
self%IPIV = 0
!Read nodes cartesian coordinates (x=z, y=r, z=null)
DO e=1, self%numNodes
READ(10, *) n, z, r
ALLOCATE(meshNodeCyl:: self%nodes(n)%obj)
CALL self%nodes(n)%obj%init(n, (/r, z, 0.D0 /))
END DO
!Skips comments
READ(10, *)
READ(10, *)
!Reads Totalnumber of elements
READ(10, *) TotalnumElem
!counts edges and volume elements
self%numEdges = 0
DO e=1, TotalnumElem
READ(10,*) eTemp, elemType
IF (elemType==1) THEN
self%numEdges=e
END IF
END DO
!Substract the number of edges to the total number of elements
!to obtain the number of volume elements
self%numVols = TotalnumElem - self%numEdges
!Allocates arrays
ALLOCATE(self%edges(1:self%numEdges))
ALLOCATE(self%vols(1:self%numVols))
!Go back to the beggining to read elements
DO e=1, totalNumElem
BACKSPACE(10)
END DO
!Reads edges
DO e=1, self%numEdges
READ(10,*) n, elemType, eTemp, boundaryType, eTemp, p(1:2)
!Associate boundary condition procedure.
bt = getBoundaryId(boundaryType)
ALLOCATE(meshEdgeCyl:: self%edges(e)%obj)
CALL self%edges(e)%obj%init(n, p(1:2), bt, boundaryType)
END DO
!Read and initialize volumes
DO e=1, self%numVols
READ(10,*) n, elemType
BACKSPACE(10)
SELECT CASE(elemType)
CASE (2)
!Triangular element
READ(10,*) n, elemType, eTemp, eTemp, eTemp, p(1:3)
ALLOCATE(meshVolCylTria:: self%vols(e)%obj)
CALL self%vols(e)%obj%init(n - self%numEdges, p(1:3))
CASE (3)
!Quadrilateral element
READ(10,*) n, elemType, eTemp, eTemp, eTemp, p(1:4)
ALLOCATE(meshVolCylQuad:: self%vols(e)%obj)
CALL self%vols(e)%obj%init(n - self%numEdges, p(1:4))
END SELECT
END DO
CLOSE(10)
!Build connectivity between elements
DO e = 1, self%numVols
!Connectivity between volumes
DO et = 1, self%numVols
IF (e /= et) THEN
CALL connected(self%vols(e)%obj, self%vols(et)%obj)
END IF
END DO
!Connectivity between vols and edges
DO et = 1, self%numEdges
CALL connected(self%vols(e)%obj, self%edges(et)%obj)
END DO
!Constructs the global K matrix
CALL constructGlobalK(self%K, self%vols(e)%obj)
END DO
END SUBROUTINE readMeshCylGmsh
!Selects type of elements to build connection
SUBROUTINE connectedVolVol(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol), INTENT(inout):: elemA
CLASS(meshVol), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS(meshVolCylQuad)
!Element A is a quadrilateral
SELECT TYPE(elemB)
TYPE IS(meshVolCylQuad)
!Element B is a quadrilateral
CALL connectedQuadQuad(elemA, elemB)
TYPE IS(meshVolCylTria)
!Element B is a triangle
CALL connectedQuadTria(elemA, elemB)
END SELECT
TYPE IS(meshVolCylTria)
!Element A is a Triangle
SELECT TYPE(elemB)
TYPE IS(meshVolCylQuad)
!Element B is a quadrilateral
CALL connectedQuadTria(elemB, elemA)
TYPE IS(meshVolCylTria)
!Element B is a triangle
CALL connectedTriaTria(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectedVolVol
SUBROUTINE connectedVolEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshVol), INTENT(inout):: elemA
CLASS(meshEdge), INTENT(inout):: elemB
SELECT TYPE(elemB)
CLASS IS(meshEdgeCyl)
SELECT TYPE(elemA)
TYPE IS(meshVolCylQuad)
!Element A is a quadrilateral
CALL connectedQuadEdge(elemA, elemB)
TYPE IS(meshVolCylTria)
!Element A is a triangle
CALL connectedTriaEdge(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectedVolEdge
SUBROUTINE connectedQuadQuad(elemA, elemB)
IMPLICIT NONE
CLASS(meshVolCylQuad), INTENT(inout), TARGET:: elemA
CLASS(meshVolCylQuad), INTENT(inout), TARGET:: elemB
!Check direction 1
IF (.NOT. ASSOCIATED(elemA%e1) .AND. &
elemA%n1%n == elemB%n4%n .AND. &
elemA%n2%n == elemB%n3%n) THEN
elemA%e1 => elemB
elemB%e3 => elemA
END IF
!Check direction 2
IF (.NOT. ASSOCIATED(elemA%e2) .AND. &
elemA%n2%n == elemB%n1%n .AND. &
elemA%n3%n == elemB%n4%n) THEN
elemA%e2 => elemB
elemB%e4 => elemA
END IF
!Check direction 3
IF (.NOT. ASSOCIATED(elemA%e3) .AND. &
elemA%n3%n == elemB%n2%n .AND. &
elemA%n4%n == elemB%n1%n) THEN
elemA%e3 => elemB
elemB%e1 => elemA
END IF
!Check direction 4
IF (.NOT. ASSOCIATED(elemA%e4) .AND. &
elemA%n4%n == elemB%n3%n .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e4 => elemB
elemB%e2 => elemA
END IF
END SUBROUTINE connectedQuadQuad
SUBROUTINE connectedQuadTria(elemA, elemB)
IMPLICIT NONE
CLASS(meshVolCylQuad), INTENT(inout), TARGET:: elemA
CLASS(meshVolCylTria), INTENT(inout), TARGET:: elemB
!Check direction 1
IF (.NOT. ASSOCIATED(elemA%e1)) THEN
IF (elemA%n1%n == elemB%n1%n .AND. &
elemA%n2%n == elemB%n3%n) THEN
elemA%e1 => elemB
elemB%e3 => elemA
ELSEIF (elemA%n1%n == elemB%n3%n .AND. &
elemA%n2%n == elemB%n2%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n1%n == elemB%n2%n .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e1 => elemA
END IF
END IF
!Check direction 2
IF (.NOT. ASSOCIATED(elemA%e2)) THEN
IF (elemA%n2%n == elemB%n1%n .AND. &
elemA%n3%n == elemB%n3%n) THEN
elemA%e2 => elemB
elemB%e3 => elemA
ELSEIF (elemA%n2%n == elemB%n3%n .AND. &
elemA%n3%n == elemB%n2%n) THEN
elemA%e2 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n2%n == elemB%n2%n .AND. &
elemA%n3%n == elemB%n1%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END IF
!Check direction 3
IF (.NOT. ASSOCIATED(elemA%e3)) THEN
IF (elemA%n3%n == elemB%n1%n .AND. &
elemA%n4%n == elemB%n3%n) THEN
elemA%e3 => elemB
elemB%e3 => elemA
ELSEIF (elemA%n3%n == elemB%n3%n .AND. &
elemA%n4%n == elemB%n2%n) THEN
elemA%e3 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n3%n == elemB%n2%n .AND. &
elemA%n4%n == elemB%n1%n) THEN
elemA%e3 => elemB
elemB%e1 => elemA
END IF
END IF
!Check direction 4
IF (.NOT. ASSOCIATED(elemA%e4)) THEN
IF (elemA%n4%n == elemB%n1%n .AND. &
elemA%n1%n == elemB%n3%n) THEN
elemA%e4 => elemB
elemB%e3 => elemA
ELSEIF (elemA%n4%n == elemB%n3%n .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e4 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n4%n == elemB%n2%n .AND. &
elemA%n1%n == elemB%n1%n) THEN
elemA%e4 => elemB
elemB%e1 => elemA
END IF
END IF
END SUBROUTINE connectedQuadTria
SUBROUTINE connectedTriaTria(elemA, elemB)
IMPLICIT NONE
CLASS(meshVolCylTria), INTENT(inout), TARGET:: elemA
CLASS(meshVolCylTria), INTENT(inout), TARGET:: elemB
!Check direction 1
IF (.NOT. ASSOCIATED(elemA%e1)) THEN
IF (elemA%n1%n == elemB%n1%n .AND. &
elemA%n2%n == elemB%n3%n) THEN
elemA%e1 => elemB
elemB%e3 => elemA
ELSEIF (elemA%n1%n == elemB%n2%n .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e1 => elemA
ELSEIF (elemA%n1%n == elemB%n3%n .AND. &
elemA%n2%n == elemB%n2%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
END IF
END IF
!Check direction 2
IF (.NOT. ASSOCIATED(elemA%e2)) THEN
IF (elemA%n2%n == elemB%n1%n .AND. &
elemA%n3%n == elemB%n3%n) THEN
elemA%e2 => elemB
elemB%e3 => elemA
ELSEIF (elemA%n2%n == elemB%n2%n .AND. &
elemA%n3%n == elemB%n1%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
ELSEIF (elemA%n2%n == elemB%n3%n .AND. &
elemA%n3%n == elemB%n2%n) THEN
elemA%e2 => elemB
elemB%e2 => elemA
END IF
END IF
!Check direction 3
IF (.NOT. ASSOCIATED(elemA%e3)) THEN
IF (elemA%n3%n == elemB%n1%n .AND. &
elemA%n1%n == elemB%n3%n) THEN
elemA%e3 => elemB
elemB%e3 => elemA
ELSEIF (elemA%n3%n == elemB%n2%n .AND. &
elemA%n1%n == elemB%n1%n) THEN
elemA%e3 => elemB
elemB%e1 => elemA
ELSEIF (elemA%n3%n == elemB%n3%n .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e3 => elemB
elemB%e2 => elemA
END IF
END IF
END SUBROUTINE connectedTriaTria
SUBROUTINE connectedQuadEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshVolCylQuad), INTENT(inout), TARGET:: elemA
CLASS(meshEdgeCyl), INTENT(inout), TARGET:: elemB
!Check direction 1
IF (.NOT. ASSOCIATED(elemA%e1)) THEN
IF (elemA%n1%n == elemB%n1%n .AND. &
elemA%n2%n == elemB%n2%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n1%n == elemB%n2%n .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e1 => elemA
END IF
END IF
!Check direction 2
IF (.NOT. ASSOCIATED(elemA%e2)) THEN
IF (elemA%n2%n == elemB%n1%n .AND. &
elemA%n3%n == elemB%n2%n) THEN
elemA%e2 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n2%n == elemB%n2%n .AND. &
elemA%n3%n == elemB%n1%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END IF
!Check direction 3
IF (.NOT. ASSOCIATED(elemA%e3)) THEN
IF (elemA%n3%n == elemB%n1%n .AND. &
elemA%n4%n == elemB%n2%n) THEN
elemA%e3 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n3%n == elemB%n2%n .AND. &
elemA%n4%n == elemB%n1%n) THEN
elemA%e3 => elemB
elemB%e1 => elemA
END IF
END IF
!Check direction 4
IF (.NOT. ASSOCIATED(elemA%e4)) THEN
IF (elemA%n4%n == elemB%n1%n .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e4 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n4%n == elemB%n2%n .AND. &
elemA%n1%n == elemB%n1%n) THEN
elemA%e4 => elemB
elemB%e1 => elemA
END IF
END IF
END SUBROUTINE connectedQuadEdge
SUBROUTINE connectedTriaEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshVolCylTria), INTENT(inout), TARGET:: elemA
CLASS(meshEdgeCyl), INTENT(inout), TARGET:: elemB
!Check direction 1
IF (.NOT. ASSOCIATED(elemA%e1)) THEN
IF (elemA%n1%n == elemB%n1%n .AND. &
elemA%n2%n == elemB%n2%n) THEN
elemA%e1 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n1%n == elemB%n2%n .AND. &
elemA%n2%n == elemB%n1%n) THEN
elemA%e1 => elemB
elemB%e1 => elemA
END IF
END IF
!Check direction 2
IF (.NOT. ASSOCIATED(elemA%e2)) THEN
IF (elemA%n2%n == elemB%n1%n .AND. &
elemA%n3%n == elemB%n2%n) THEN
elemA%e2 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n2%n == elemB%n2%n .AND. &
elemA%n3%n == elemB%n1%n) THEN
elemA%e2 => elemB
elemB%e1 => elemA
END IF
END IF
!Check direction 3
IF (.NOT. ASSOCIATED(elemA%e3)) THEN
IF (elemA%n3%n == elemB%n1%n .AND. &
elemA%n1%n == elemB%n2%n) THEN
elemA%e3 => elemB
elemB%e2 => elemA
ELSEIF (elemA%n3%n == elemB%n2%n .AND. &
elemA%n1%n == elemB%n1%n) THEN
elemA%e3 => elemB
elemB%e1 => elemA
END IF
END IF
END SUBROUTINE connectedTriaEdge
SUBROUTINE constructGlobalK(K, elem)
IMPLICIT NONE
REAL(8), INTENT(inout):: K(1:,1:)
CLASS(meshVol), INTENT(in):: elem
REAL(8), ALLOCATABLE:: localK(:,:)
INTEGER:: nNodes, i, j
INTEGER, ALLOCATABLE:: n(:)
SELECT TYPE(elem)
TYPE IS(meshVolCylQuad)
nNodes = 4
ALLOCATE(localK(1:nNodes,1:nNodes))
localK = elem%elemK()
ALLOCATE(n(1:nNodes))
n = (/ elem%n1%n, elem%n2%n, &
elem%n3%n, elem%n4%n /)
TYPE IS(meshVolCylTria)
nNodes = 3
ALLOCATE(localK(1:nNodes,1:nNodes))
localK = elem%elemK()
ALLOCATE(n(1:nNodes))
n = (/ elem%n1%n, elem%n2%n, elem%n3%n /)
CLASS DEFAULT
nNodes = 0
ALLOCATE(localK(1:1, 1:1))
localK = 0.D0
ALLOCATE(n(1:1))
n = 0
END SELECT
DO i = 1, nNodes
DO j = 1, nNodes
K(n(i), n(j)) = K(n(i), n(j)) + localK(i, j)
END DO
END DO
END SUBROUTINE constructGlobalK
END MODULE moduleMeshCylRead

View file

@ -0,0 +1,5 @@
all : moduleMesh3DCart.o
moduleMesh3DCart.o: moduleMesh3DCart.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@

View file

@ -0,0 +1,951 @@
!moduleMesh3DCart: 3D Cartesian coordinate system
! x == x
! y == y
! z == z
MODULE moduleMesh3DCart
USE moduleMesh
USE moduleMeshBoundary
IMPLICIT NONE
TYPE, PUBLIC, EXTENDS(meshNode):: meshNode3DCart
!Element coordinates
REAL(8):: x, y, z
CONTAINS
!meshNode DEFERRED PROCEDURES
PROCEDURE, PASS:: init => initNode3DCart
PROCEDURE, PASS:: getCoordinates => getCoord3DCart
END TYPE meshNode3DCart
!Triangular surface element
TYPE, PUBLIC, EXTENDS(meshEdge):: meshEdge3DCartTria
!Element coordinates
REAL(8):: x(1:3) = 0.D0, y(1:3) = 0.D0, z(1:3) = 0.D0
!Connectivity to nodes
CLASS(meshNode), POINTER:: n1 => NULL(), n2 => NULL(), n3 => NULL()
CONTAINS
!meshEdge DEFERRED PROCEDURES
PROCEDURE, PASS:: init => initEdge3DCartTria
PROCEDURE, PASS:: getNodes => getNodes3DCartTria
PROCEDURE, PASS:: intersection => intersection3DCartTria
PROCEDURE, PASS:: randPos => randPosEdgeTria
!PARTICULAR PROCEDURES
PROCEDURE, NOPASS, PRIVATE:: fPsi => fPsiEdgeTria
END TYPE meshEdge3DCartTria
!Tetrahedron volume element
TYPE, PUBLIC, EXTENDS(meshCell):: meshCell3DCartTetra
!Element Coordinates
REAL(8):: x(1:4) = 0.D0, y(1:4) = 0.D0, z(1:4) = 0.D0
!Connectivity to nodes
CLASS(meshNode), POINTER:: n1 => NULL(), n2 => NULL(), n3 => NULL(), n4 => NULL()
!Connectivity to adjacent elements
CLASS(meshElement), POINTER:: e1 => NULL(), e2 => NULL(), e3 => NULL(), e4 => NULL()
CONTAINS
!meshCell DEFERRED PROCEDURES
PROCEDURE, PASS:: init => initCellTetra
PROCEDURE, PASS:: getNodes => getNodesTetra
PROCEDURE, PASS:: randPos => randPosCellTetra
PROCEDURE, NOPASS:: fPsi => fPsiTetra
PROCEDURE, NOPASS:: dPsi => dPsiTetra
PROCEDURE, PASS:: partialDer => partialDerTetra
PROCEDURE, NOPASS:: detJac => detJ3DCart
PROCEDURE, NOPASS:: invJac => invJ3DCart
PROCEDURE, PASS:: gatherElectricField => gatherEFTetra
PROCEDURE, PASS:: gatherMagneticField => gatherMFTetra
PROCEDURE, PASS:: elemK => elemKTetra
PROCEDURE, PASS:: elemF => elemFTetra
PROCEDURE, NOPASS:: inside => insideTetra
PROCEDURE, PASS:: phy2log => phy2logTetra
PROCEDURE, PASS:: neighbourElement => neighbourElementTetra
!PARTICULAR PROCEDURES
PROCEDURE, PASS, PRIVATE:: calculateVolume => volumeTetra
END TYPE meshCell3DCartTetra
CONTAINS
!NODE FUNCTIONS
!Init node element
SUBROUTINE initNode3DCart(self, n, r)
USE moduleSpecies
USE moduleRefParam
USE OMP_LIB
IMPLICIT NONE
CLASS(meshNode3DCart), INTENT(out):: self
INTEGER, INTENT(in):: n
REAL(8), INTENT(in):: r(1:3)
self%n = n
self%x = r(1)/L_ref
self%y = r(2)/L_ref
self%z = r(3)/L_ref
!Node volume, to be determined in mesh
self%v = 0.D0
!Allocates output:
ALLOCATE(self%output(1:nSpecies))
CALL OMP_INIT_LOCK(self%lock)
END SUBROUTINE initNode3DCart
!Get coordinates from node
PURE FUNCTION getCoord3DCart(self) RESULT(r)
IMPLICIT NONE
CLASS(meshNode3DCart), INTENT(in):: self
REAL(8):: r(1:3)
r = (/self%x, self%y, self%z/)
END FUNCTION getCoord3DCart
!EDGE FUNCTIONS
!Init surface element
SUBROUTINE initEdge3DCartTria(self, n, p, bt, physicalSurface)
USE moduleSpecies
USE moduleBoundary
USE moduleErrors
USE moduleMath
USE moduleRefParam, ONLY: L_ref
IMPLICIT NONE
CLASS(meshEdge3DCartTria), INTENT(out):: self
INTEGER, INTENT(in):: n
INTEGER, INTENT(in):: p(:)
INTEGER, INTENT(in):: bt
INTEGER, INTENT(in):: physicalSurface
REAL(8), DIMENSION(1:3):: r1, r2, r3
REAL(8), DIMENSION(1:3):: vec1, vec2
INTEGER:: s
self%n = n
self%nNodes = SIZE(p)
self%n1 => mesh%nodes(p(1))%obj
self%n2 => mesh%nodes(p(2))%obj
self%n3 => mesh%nodes(p(3))%obj
!Get element coordinates
r1 = self%n1%getCoordinates()
r2 = self%n2%getCoordinates()
r3 = self%n3%getCoordinates()
self%x = (/r1(1), r2(1), r3(1)/)
self%y = (/r1(2), r2(2), r3(2)/)
self%z = (/r1(3), r2(3), r3(3)/)
!Normal vector
vec1 = (/ self%x(2) - self%x(1), &
self%y(2) - self%y(1), &
self%z(2) - self%z(1) /)
vec2 = (/ self%x(3) - self%x(1), &
self%y(3) - self%y(1), &
self%z(3) - self%z(1) /)
self%normal = crossProduct(vec1, vec2)
self%normal = normalize(self%normal)
self%surface = 1.D0/L_ref**2 !TODO: FIX THIS WHEN MOVING TO 3D
!Boundary index
self%boundary => boundary(bt)
ALLOCATE(self%fBoundary(1:nSpecies))
!Assign functions to boundary
DO s = 1, nSpecies
CALL pointBoundaryFunction(self, s)
END DO
!Physical surface
self%physicalSurface = physicalSurface
END SUBROUTINE initEdge3DCartTria
!Get nodes from surface
PURE FUNCTION getNodes3DCartTria(self, nNodes) RESULT(n)
IMPLICIT NONE
CLASS(meshEdge3DCartTria), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
INTEGER:: n(1:nNodes)
n = (/self%n1%n, self%n2%n, self%n3%n/)
END FUNCTION getNodes3DCartTria
!Calculate intersection between position and edge
PURE FUNCTION intersection3DCartTria(self, r0) RESULT(r)
IMPLICIT NONE
CLASS(meshEdge3DCartTria), INTENT(in):: self
REAL(8), INTENT(in):: r0(1:3)
REAL(8), DIMENSION(1:3):: r
REAL(8), DIMENSION(1:3):: edge0, edgeV
REAL(8):: tI
edge0 = (/self%x(1), self%y(1), self%z(1) /)
edgeV = (/self%x(2), self%y(2), self%z(2) /) - edge0
tI = DOT_PRODUCT(r0 - edge0, edgeV)/DOT_PRODUCT(edgeV, edgeV)
r = edge0 + tI*edgeV
END FUNCTION intersection3DCartTria
!Calculate a random position in the surface
FUNCTION randPosEdgeTria(self) RESULT(r)
USE moduleRandom
IMPLICIT NONE
CLASS(meshEdge3DCartTria), INTENT(in):: self
REAL(8):: r(1:3)
REAL(8):: Xi(1:3)
REAL(8):: fPsi(1:3)
Xi(1) = random( 0.D0, 1.D0)
Xi(2) = random( 0.D0, 1.D0 - Xi(1))
Xi(3) = 0.D0
fPsi = self%fPsi(Xi)
r = (/DOT_PRODUCT(fPsi, self%x), &
DOT_PRODUCT(fPsi, self%y), &
DOT_PRODUCT(fPsi, self%z)/)
END FUNCTION randPosEdgeTria
!Shape functions for triangular surface
PURE FUNCTION fPsiEdgeTria(Xi) RESULT(fPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: fPsi(1:3)
fPsi(1) = 1.D0 - Xi(1) - Xi(2)
fPsi(2) = Xi(1)
fPsi(3) = Xi(2)
END FUNCTION fPsiEdgeTria
!VOLUME FUNCTIONS
!TETRA FUNCTIONS
!Init element
SUBROUTINE initCellTetra(self, n, p, nodes)
USE moduleRefParam
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(out):: self
INTEGER, INTENT(in):: n
INTEGER, INTENT(in):: p(:)
TYPE(meshNodeCont), INTENT(in), TARGET:: nodes(:)
REAL(8), DIMENSION(1:3):: r1, r2, r3, r4 !Positions of each node
!Assign node index
self%n = n
!Assign number of nodes of cell
self%nNodes = SIZE(p)
!Assign nodes to element
self%n1 => nodes(p(1))%obj
self%n2 => nodes(p(2))%obj
self%n3 => nodes(p(3))%obj
self%n4 => nodes(p(4))%obj
!Get element coordinates
r1 = self%n1%getCoordinates()
r2 = self%n2%getCoordinates()
r3 = self%n3%getCoordinates()
r4 = self%n4%getCoordinates()
self%x = (/r1(1), r2(1), r3(1), r4(1)/)
self%y = (/r1(2), r2(2), r3(2), r4(2)/)
self%z = (/r1(3), r2(3), r3(3), r4(3)/)
!Computes the element volume
CALL self%calculateVolume()
CALL OMP_INIT_LOCK(self%lock)
ALLOCATE(self%listPart_in(1:nSpecies))
ALLOCATE(self%totalWeight(1:nSpecies))
END SUBROUTINE initCellTetra
!Gets node indexes from cell
PURE FUNCTION getNodesTetra(self, nNodes) RESULT(n)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
INTEGER:: n(1:nNodes)
n = (/self%n1%n, self%n2%n, self%n3%n, self%n4%n /)
END FUNCTION getNodesTetra
!Random position in cell
FUNCTION randPosCellTetra(self) RESULT(r)
USE moduleRandom
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
REAL(8):: r(1:3)
REAL(8):: Xi(1:3)
REAL(8):: fPsi(1:4)
Xi(1) = random( 0.D0, 1.D0)
Xi(2) = random( 0.D0, 1.D0 - Xi(1))
Xi(3) = random( 0.D0, 1.D0 - Xi(1) - Xi(2))
fPsi = self%fPsi(Xi, 4)
r = (/ DOT_PRODUCT(fPsi, self%x), &
DOT_PRODUCT(fPsi, self%y), &
DOT_PRODUCT(fPsi, self%z) /)
END FUNCTION randPosCellTetra
!Compute element functions in point Xi
PURE FUNCTION fPsiTetra(Xi, nNodes) RESULT(fPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
INTEGER, INTENT(in):: nNodes
REAL(8):: fPsi(1:nNodes)
fPsi(1) = 1.D0 - Xi(1) - Xi(2) - Xi(3)
fPsi(2) = Xi(1)
fPsi(3) = Xi(2)
fPsi(4) = Xi(3)
END FUNCTION fPsiTetra
!Compute element derivative functions in point Xi
PURE FUNCTION dPsiTetra(Xi, nNodes) RESULT(dPsi)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
INTEGER, INTENT(in):: nNodes
REAL(8):: dPsi(1:3, 1:nNodes)
dPsi = 0.D0
dPsi(1,1:4) = (/ -1.D0, 1.D0, 0.D0, 0.D0 /)
dPsi(2,1:4) = (/ -1.D0, 0.D0, 1.D0, 0.D0 /)
dPsi(3,1:4) = (/ -1.D0, 0.D0, 0.D0, 1.D0 /)
END FUNCTION dPsiTetra
!Compute the derivatives in global coordinates
PURE FUNCTION partialDerTetra(self, nNodes, dPsi) RESULT(pDer)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8), INTENT(in):: dPsi(1:3, 1:nNodes)
REAL(8):: pDer(1:3, 1:3)
pDer = 0.D0
pDer(1, 1:3) = (/ DOT_PRODUCT(dPsi(1,1:4), self%x(1:4)), &
DOT_PRODUCT(dPsi(2,1:4), self%x(1:4)), &
DOT_PRODUCT(dPsi(3,1:4), self%x(1:4)) /)
pDer(2, 1:3) = (/ DOT_PRODUCT(dPsi(1,1:4), self%y(1:4)), &
DOT_PRODUCT(dPsi(2,1:4), self%y(1:4)), &
DOT_PRODUCT(dPsi(3,1:4), self%y(1:4)) /)
pDer(3, 1:3) = (/ DOT_PRODUCT(dPsi(1,1:4), self%z(1:4)), &
DOT_PRODUCT(dPsi(2,1:4), self%z(1:4)), &
DOT_PRODUCT(dPsi(3,1:4), self%z(1:4)) /)
END FUNCTION partialDerTetra
!Gather electric field at position Xi
PURE FUNCTION gatherEFTetra(self, Xi) RESULT(array)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: array(1:3)
REAL(8):: phi(1:4)
phi = (/ self%n1%emData%phi, &
self%n2%emData%phi, &
self%n3%emData%phi, &
self%n4%emData%phi /)
array = -self%gatherDF(Xi, 4, phi)
END FUNCTION gatherEFTetra
!Gather magnetic field at position Xi
PURE FUNCTION gatherMFTetra(self, Xi) RESULT(array)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
REAL(8):: array(1:3)
REAL(8):: B(1:4,1:3)
B(:,1) = (/ self%n1%emData%B(1), &
self%n2%emData%B(1), &
self%n3%emData%B(1), &
self%n4%emData%B(1) /)
B(:,2) = (/ self%n1%emData%B(2), &
self%n2%emData%B(2), &
self%n3%emData%B(2), &
self%n4%emData%B(2) /)
B(:,3) = (/ self%n1%emData%B(3), &
self%n2%emData%B(3), &
self%n3%emData%B(3), &
self%n4%emData%B(3) /)
array = self%gatherF(Xi, 4, B)
END FUNCTION gatherMFTetra
!Compute cell local stiffness matrix
PURE FUNCTION elemKTetra(self, nNodes) RESULT(localK)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8):: localK(1:nNodes,1:nNodes)
REAL(8):: Xi(1:3)
REAL(8):: fPsi(1:4), dPsi(1:3, 1:4)
REAL(8):: pDer(1:3, 1:3)
REAL(8):: invJ(1:3,1:3), detJ
localK = 0.D0
Xi = 0.D0
!TODO: One point Gauss integral. Upgrade when possible
Xi = (/ 0.25D0, 0.25D0, 0.25D0 /)
dPsi = self%dPsi(Xi, 4)
pDer = self%partialDer(4, dPsi)
detJ = self%detJac(pDer)
invJ = self%invJac(pDer)
fPsi = self%fPsi(Xi, 4)
localK = MATMUL(TRANSPOSE(MATMUL(invJ,dPsi)),MATMUL(invJ,dPsi))*1.D0/detJ
END FUNCTION elemKTetra
!Compute element local source vector
PURE FUNCTION elemFTetra(self, nNodes, source) RESULT(localF)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
INTEGER, INTENT(in):: nNodes
REAL(8), INTENT(in):: source(1:nNodes)
REAL(8):: localF(1:nNodes)
REAL(8):: Xi(1:3)
REAL(8):: fPsi(1:4), dPsi(1:3, 1:4)
REAL(8):: pDer(1:3, 1:3)
REAL(8):: detJ, f
localF = 0.D0
Xi = 0.D0
Xi = (/ 0.25D0, 0.25D0, 0.25D0 /)
dPsi = self%dPsi(Xi, 4)
pDer = self%partialDer(4, dPsi)
detJ = self%detJac(pDer)
fPsi = self%fPsi(Xi, 4)
f = DOT_PRODUCT(fPsi, source)
localF = f*fPsi*1.D0*detJ
END FUNCTION elemFTetra
!Check if Xi is inside the element
PURE FUNCTION insideTetra(Xi) RESULT(ins)
IMPLICIT NONE
REAL(8), INTENT(in):: Xi(1:3)
LOGICAL:: ins
ins = Xi(1) >= 0.D0 .AND. &
Xi(2) >= 0.D0 .AND. &
Xi(3) >= 0.D0 .AND. &
1.D0 - Xi(1) - Xi(2) - Xi(3) >= 0.D0
END FUNCTION insideTetra
!Transform physical coordinates to element coordinates
PURE FUNCTION phy2logTetra(self,r) RESULT(Xi)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
REAL(8), INTENT(in):: r(1:3)
REAL(8):: Xi(1:3)
REAL(8):: dPsi(1:3, 1:4)
REAL(8):: pDer(1:3, 1:3)
REAL(8):: invJ(1:3, 1:3), detJ
REAL(8):: deltaR(1:3)
!Direct method to convert coordinates
Xi = 0.D0
deltaR = (/r(1) - self%x(1), r(2) - self%y(1), r(3) - self%z(1) /)
dPsi = self%dPsi(Xi, 4)
pDer = self%partialDer(4, dPsi)
invJ = self%invJac(pDer)
detJ = self%detJac(pDer)
Xi = MATMUL(invJ, deltaR)/detJ
END FUNCTION phy2logTetra
!Get the neighbour cell for a logical position Xi
SUBROUTINE neighbourElementTetra(self, Xi, neighbourElement)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(in):: self
REAL(8), INTENT(in):: Xi(1:3)
CLASS(meshElement), POINTER, INTENT(out):: neighbourElement
REAL(8):: XiArray(1:4)
INTEGER:: nextInt
!TODO: Review when connectivity
XiArray = (/ Xi(3), 1.D0 - Xi(1) - Xi(2) - Xi(3), Xi(2), Xi(1) /)
nextInt = MINLOC(XiArray, 1)
NULLIFY(neighbourElement)
SELECT CASE(nextInt)
CASE (1)
neighbourElement => self%e1
CASE (2)
neighbourElement => self%e2
CASE (3)
neighbourElement => self%e3
CASE (4)
neighbourElement => self%e4
END SELECT
END SUBROUTINE neighbourElementTetra
!Calculate volume for triangular element
PURE SUBROUTINE volumeTetra(self)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(inout):: self
REAL(8):: Xi(1:3)
REAL(8):: detJ
REAL(8):: fPsi(1:4)
REAL(8):: dPsi(1:3, 1:4), pDer(1:3, 1:3)
self%volume = 0.D0
!2D 1 point Gauss Quad Integral
Xi = (/0.25D0, 0.25D0, 0.25D0/)
dPsi = self%dPsi(Xi, 4)
pDer = self%partialDer(4, dPsi)
detJ = self%detJac(pDer)
!Computes total volume of the cell
self%volume = detJ
!Computes volume per node
fPsi = self%fPsi(Xi, 4)
self%n1%v = self%n1%v + fPsi(1)*self%volume
self%n2%v = self%n2%v + fPsi(2)*self%volume
self%n3%v = self%n3%v + fPsi(3)*self%volume
self%n4%v = self%n4%v + fPsi(4)*self%volume
END SUBROUTINE volumeTetra
!COMMON FUNCTIONS FOR CARTESIAN VOLUME ELEMENTS IN 3D
!Compute element Jacobian determinant
PURE FUNCTION detJ3DCart(pDer) RESULT(dJ)
IMPLICIT NONE
REAL(8), INTENT(in):: pDer(1:3, 1:3)
REAL(8):: dJ
dJ = pDer(1,1)*(pDer(2,2)*pDer(3,3) - pDer(2,3)*pDer(3,2)) &
- pDer(1,2)*(pDer(2,1)*pDer(3,3) - pDer(2,3)*pDer(3,1)) &
+ pDer(1,3)*(pDer(2,1)*pDer(3,2) - pDer(2,2)*pDer(3,1))
END FUNCTION detJ3DCart
!Compute element Jacobian inverse matrix (without determinant)
PURE FUNCTION invJ3DCart(pDer) RESULT(invJ)
IMPLICIT NONE
REAL(8), INTENT(in):: pDer(1:3, 1:3)
REAL(8):: invJ(1:3,1:3)
invJ(1,1:3) = (/ (pDer(2,2)*pDer(3,3) - pDer(2,3)*pDer(3,2)), &
-(pDer(2,1)*pDer(3,3) - pDer(2,3)*pDer(3,1)), &
(pDer(2,1)*pDer(3,2) - pDer(2,2)*pDer(3,1)) /)
invJ(2,1:3) = (/ -(pDer(1,2)*pDer(3,3) - pDer(1,3)*pDer(3,2)), &
(pDer(1,1)*pDer(3,3) - pDer(1,3)*pDer(3,1)), &
-(pDer(1,1)*pDer(3,2) - pDer(1,2)*pDer(3,1)) /)
invJ(3,1:3) = (/ (pDer(1,2)*pDer(2,3) - pDer(1,3)*pDer(2,2)), &
-(pDer(1,1)*pDer(2,3) - pDer(1,3)*pDer(2,1)), &
(pDer(1,1)*pDer(2,2) - pDer(1,2)*pDer(2,1)) /)
invJ = TRANSPOSE(invJ)
END FUNCTION invJ3DCart
SUBROUTINE connectMesh3DCart(self)
IMPLICIT NONE
CLASS(meshGeneric), INTENT(inout):: self
INTEGER:: e, et
DO e = 1, self%numCells
!Connect Cell-Cell
DO et = 1, self%numCells
IF (e /= et) THEN
CALL connectCellCell(self%cells(e)%obj, self%cells(et)%obj)
END IF
END DO
SELECT TYPE(self)
TYPE IS(meshParticles)
!Connect Cell-Edge
DO et = 1, self%numEdges
CALL connectCellEdge(self%cells(e)%obj, self%edges(et)%obj)
END DO
END SELECT
END DO
END SUBROUTINE connectMesh3DCart
!Select type of elements to build connection
SUBROUTINE connectCellCell(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell), INTENT(inout):: elemA
CLASS(meshCell), INTENT(inout):: elemB
SELECT TYPE(elemA)
TYPE IS(meshCell3DCartTetra)
!Element A is a tetrahedron
SELECT TYPE(elemB)
TYPE IS(meshCell3DCartTetra)
!Element B is a tetrahedron
CALL connectTetraTetra(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectCellCell
SUBROUTINE connectCellEdge(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell), INTENT(inout):: elemA
CLASS(meshEdge), INTENT(inout):: elemB
SELECT TYPE(elemB)
CLASS IS(meshEdge3DCartTria)
SELECT TYPE(elemA)
TYPE IS(meshCell3DCartTetra)
!Element A is a tetrahedron
CALL connectTetraEdge(elemA, elemB)
END SELECT
END SELECT
END SUBROUTINE connectCellEdge
!Checks if two sets of nodes are coincidend in any order
PURE FUNCTION coincidentNodes(nodesA, nodesB) RESULT(coincident)
IMPLICIT NONE
INTEGER, DIMENSION(1:3), INTENT(in):: nodesA, nodesB
LOGICAL:: coincident
INTEGER:: i
coincident = .FALSE.
DO i = 1, 3
IF (ANY(nodesA(i) == nodesB)) THEN
coincident = .TRUE.
ELSE
coincident = .FALSE.
EXIT
END IF
END DO
END FUNCTION coincidentNodes
SUBROUTINE connectTetraTetra(elemA, elemB)
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(inout), TARGET:: elemA
CLASS(meshCell3DCartTetra), INTENT(inout), TARGET:: elemB
!Check surface 1
IF (.NOT. ASSOCIATED(elemA%e1)) THEN
IF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elemA%n3%n/), &
(/elemB%n1%n, elemB%n2%n, elemB%n3%n/))) THEN
elemA%e1 => elemB
elemB%e1 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elemA%n3%n/), &
(/elemB%n2%n, elemB%n3%n, elemB%n4%n/))) THEN
elemA%e1 => elemB
elemB%e2 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elemA%n3%n/), &
(/elemB%n1%n, elemB%n2%n, elemB%n4%n/))) THEN
elemA%e1 => elemB
elemB%e3 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elemA%n3%n/), &
(/elemB%n1%n, elemB%n3%n, elemB%n4%n/))) THEN
elemA%e1 => elemB
elemB%e4 => elemA
END IF
END IF
!Check surface 2
IF (.NOT. ASSOCIATED(elemA%e2)) THEN
IF (coincidentNodes((/elemA%n2%n, elemA%n3%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n2%n, elemB%n3%n/))) THEN
elemA%e2 => elemB
elemB%e1 => elemA
ELSEIF (coincidentNodes((/elemA%n2%n, elemA%n3%n, elemA%n4%n/), &
(/elemB%n2%n, elemB%n3%n, elemB%n4%n/))) THEN
elemA%e2 => elemB
elemB%e2 => elemA
ELSEIF (coincidentNodes((/elemA%n2%n, elemA%n3%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n2%n, elemB%n4%n/))) THEN
elemA%e2 => elemB
elemB%e3 => elemA
ELSEIF (coincidentNodes((/elemA%n2%n, elemA%n3%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n3%n, elemB%n4%n/))) THEN
elemA%e2 => elemB
elemB%e4 => elemA
END IF
END IF
!Check surface 3
IF (.NOT. ASSOCIATED(elemA%e3)) THEN
IF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n2%n, elemB%n3%n/))) THEN
elemA%e3 => elemB
elemB%e1 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elemA%n4%n/), &
(/elemB%n2%n, elemB%n3%n, elemB%n4%n/))) THEN
elemA%e3 => elemB
elemB%e2 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n2%n, elemB%n4%n/))) THEN
elemA%e3 => elemB
elemB%e3 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n3%n, elemB%n4%n/))) THEN
elemA%e3 => elemB
elemB%e4 => elemA
END IF
END IF
!Check surface 4
IF (.NOT. ASSOCIATED(elemA%e4)) THEN
IF (coincidentNodes((/elemA%n1%n, elemA%n3%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n2%n, elemB%n3%n/))) THEN
elemA%e4 => elemB
elemB%e1 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n3%n, elemA%n4%n/), &
(/elemB%n2%n, elemB%n3%n, elemB%n4%n/))) THEN
elemA%e4 => elemB
elemB%e2 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n3%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n2%n, elemB%n4%n/))) THEN
elemA%e4 => elemB
elemB%e3 => elemA
ELSEIF (coincidentNodes((/elemA%n1%n, elemA%n3%n, elemA%n4%n/), &
(/elemB%n1%n, elemB%n3%n, elemB%n4%n/))) THEN
elemA%e4 => elemB
elemB%e4 => elemA
END IF
END IF
END SUBROUTINE connectTetraTetra
SUBROUTINE connectTetraEdge(elemA, elemB)
USE moduleMath
IMPLICIT NONE
CLASS(meshCell3DCartTetra), INTENT(inout), TARGET:: elemA
CLASS(meshEdge3DCartTria), INTENT(inout), TARGET:: elemB
INTEGER:: nodesEdge(1:3)
REAL(8), DIMENSION(1:3):: vec1, vec2
REAL(8):: normCell(1:3)
nodesEdge = (/ elemB%n1%n, elemB%n2%n, elemB%n3%n /)
!Check surface 1
IF (.NOT. ASSOCIATED(elemA%e1)) THEN
IF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elema%n3%n/), &
nodesEdge)) THEN
vec1 = (/ elemA%x(2) - elemA%x(1), &
elemA%y(2) - elemA%y(1), &
elemA%z(2) - elemA%z(1) /)
vec2 = (/ elemA%x(3) - elemA%x(1), &
elemA%y(3) - elemA%y(1), &
elemA%z(3) - elemA%z(1) /)
normCell = crossProduct(vec1, vec2)
normCell = normalize(normCell)
IF (DOT_PRODUCT(elemB%normal, normCell) == -1.D0) THEN
elemA%e1 => elemB
elemB%e1 => elemA
ELSE
elemA%e1 => elemB
elemB%e2 => elemA
!Revers the normal to point inside the domain
elemB%normal = -elemB%normal
END IF
END IF
END IF
!Check surface 2
IF (.NOT. ASSOCIATED(elemA%e2)) THEN
IF (coincidentNodes((/elemA%n2%n, elemA%n3%n, elemA%n4%n/), &
nodesEdge)) THEN
vec1 = (/ elemA%x(3) - elemA%x(2), &
elemA%y(3) - elemA%y(2), &
elemA%z(3) - elemA%z(2) /)
vec2 = (/ elemA%x(4) - elemA%x(2), &
elemA%y(4) - elemA%y(2), &
elemA%z(4) - elemA%z(2) /)
normCell = crossProduct(vec1, vec2)
normCell = normalize(normCell)
IF (DOT_PRODUCT(elemB%normal, normCell) == -1.D0) THEN
elemA%e2 => elemB
elemB%e1 => elemA
ELSE
elemA%e2 => elemB
elemB%e2 => elemA
!Revers the normal to point inside the domain
elemB%normal = -elemB%normal
END IF
END IF
END IF
!Check surface 3
IF (.NOT. ASSOCIATED(elemA%e3)) THEN
IF (coincidentNodes((/elemA%n1%n, elemA%n2%n, elema%n4%n/), &
nodesEdge)) THEN
vec1 = (/ elemA%x(2) - elemA%x(1), &
elemA%y(2) - elemA%y(1), &
elemA%z(2) - elemA%z(1) /)
vec2 = (/ elemA%x(4) - elemA%x(1), &
elemA%y(4) - elemA%y(1), &
elemA%z(4) - elemA%z(1) /)
normCell = crossProduct(vec1, vec2)
normCell = normalize(normCell)
IF (DOT_PRODUCT(elemB%normal, normCell) == -1.D0) THEN
elemA%e3 => elemB
elemB%e1 => elemA
ELSE
elemA%e3 => elemB
elemB%e2 => elemA
!Revers the normal to point inside the domain
elemB%normal = -elemB%normal
END IF
END IF
END IF
!Check surface 4
IF (.NOT. ASSOCIATED(elemA%e4)) THEN
IF (coincidentNodes((/elemA%n1%n, elemA%n3%n, elema%n4%n/), &
nodesEdge)) THEN
vec1 = (/ elemA%x(3) - elemA%x(1), &
elemA%y(3) - elemA%y(1), &
elemA%z(3) - elemA%z(1) /)
vec2 = (/ elemA%x(4) - elemA%x(1), &
elemA%y(4) - elemA%y(1), &
elemA%z(4) - elemA%z(1) /)
normCell = crossProduct(vec1, vec2)
normCell = normalize(normCell)
IF (DOT_PRODUCT(elemB%normal, normCell) == -1.D0) THEN
elemA%e4 => elemB
elemB%e1 => elemA
ELSE
elemA%e4 => elemB
elemB%e2 => elemA
!Revers the normal to point inside the domain
elemB%normal = -elemB%normal
END IF
END IF
END IF
END SUBROUTINE connectTetraEdge
END MODULE moduleMesh3DCart

View file

@ -0,0 +1,7 @@
all: moduleMeshInput0D.o moduleMeshOutput0D.o
moduleMeshInput0D.o: moduleMeshOutput0D.o moduleMeshInput0D.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
%.o: %.f90
$(FC) $(FCFLAGS) -c $< -o $(OBJDIR)/$@

View file

@ -0,0 +1,99 @@
MODULE moduleMeshInput0D
!Creates a 0D mesh. mostly used for testing collisional processes.
!This mesh consists on 1 node and 1 volume in which all particles are located.
!No boundary conditions and no pusher should be applied to this geometry.
!Output should go to a single file (per species) in which each row represents an iteration.
!In principle, no EM field is applied.
CONTAINS
!Inits the 0D mesh
SUBROUTINE init0D(self)
USE moduleMesh
USE moduleMeshOutput0D
IMPLICIT NONE
CLASS(meshGeneric), INTENT(inout), TARGET:: self
IF (ASSOCIATED(meshForMCC, self)) self%printColl => printColl0D
SELECT TYPE(self)
TYPE IS(meshParticles)
self%printOutput => printOutput0D
self%printEM => printEM0D
self%readInitial => readInitial0D
END SELECT
self%readMesh => read0D
END SUBROUTINE init0D
!Reads a 0D mesh file.
!No reading is actually done as the 0D mesh is a fixed one
SUBROUTINE read0D(self, filename)
USE moduleMesh
USE moduleMesh0D
IMPLICIT NONE
CLASS(meshGeneric), INTENT(inout):: self
CHARACTER(:), ALLOCATABLE, INTENT(in):: filename !Dummy file, not used
REAL(8):: r(1:3)
!Allocates one node
self%numNodes = 1
ALLOCATE(self%nodes(1:1))
!Allocates one volume
self%numCells = 1
ALLOCATE(self%cells(1:1))
!Allocates matrix K
SELECT TYPE(self)
TYPE IS(meshParticles)
ALLOCATE(self%K(1:1, 1:1))
ALLOCATE(self%IPIV(1:1, 1:1))
self%K = 0.D0
self%IPIV = 0.D0
END SELECT
!Creates the node
ALLOCATE(meshNode0D:: self%nodes(1)%obj)
r = 0.D0
CALL self%nodes(1)%obj%init(1, r)
!Creates the volume
ALLOCATE(meshCell0D:: self%cells(1)%obj)
CALL self%cells(1)%obj%init(1, (/ 1/), self%nodes)
END SUBROUTINE read0D
SUBROUTINE readInitial0D(filename, density, velocity, temperature)
IMPLICIT NONE
CHARACTER(:), ALLOCATABLE, INTENT(in):: filename
REAL(8), ALLOCATABLE, INTENT(out), DIMENSION(:):: density
REAL(8), ALLOCATABLE, INTENT(out), DIMENSION(:,:):: velocity
REAL(8), ALLOCATABLE, INTENT(out), DIMENSION(:):: temperature
REAL(8):: dummy
INTEGER:: stat
ALLOCATE(density(1:1))
ALLOCATE(velocity(1:1, 1:3))
ALLOCATE(temperature(1:1))
OPEN(10, file = TRIM(filename))
!Finds the last line of data
stat = 0
DO WHILE (stat==0)
READ(10, *, iostat = stat)
END DO
!Go back two line
BACKSPACE(10)
BACKSPACE(10)
!Reads data
READ(10, *) dummy, density(1), velocity(1, 1:3), dummy, temperature(1)
END SUBROUTINE readInitial0D
END MODULE moduleMeshInput0D

View file

@ -0,0 +1,78 @@
MODULE moduleMeshOutput0D
CONTAINS
SUBROUTINE printOutput0D(self)
USE moduleMesh
USE moduleRefParam
USE moduleSpecies
USE moduleOutput
USE moduleCaseParam, ONLY: timeStep
IMPLICIT NONE
CLASS(meshParticles), INTENT(in):: self
INTEGER:: i
TYPE(outputFormat):: output
CHARACTER(:), ALLOCATABLE:: fileName
DO i = 1, nSpecies
fileName='OUTPUT_' // species(i)%obj%name // '.dat'
IF (timeStep == 0) THEN
OPEN(20, file = path // folder // '/' // fileName, action = 'write')
WRITE(20, "(A1, 14X, A5, A20, 40X, A20, 2(A20))") "#","t (s)","density (m^-3)", "velocity (m/s)", &
"pressure (Pa)", "temperature (K)"
WRITE(*, "(6X,A15,A)") "Creating file: ", fileName
CLOSE(20)
END IF
OPEN(20, file = path // folder // '/' // fileName, position = 'append', action = 'write')
CALL calculateOutput(self%nodes(1)%obj%output(i), output, self%nodes(1)%obj%v, species(i)%obj)
WRITE(20, "(7(ES20.6E3))") REAL(timeStep)*tauMin*ti_ref, output%density, &
output%velocity, &
output%pressure, &
output%temperature
CLOSE(20)
END DO
END SUBROUTINE printOutput0D
SUBROUTINE printColl0D(self)
USE moduleMesh
USE moduleRefParam
USE moduleCaseParam
USE moduleCollisions
USE moduleOutput
IMPLICIT NONE
CLASS(meshGeneric), INTENT(in):: self
CHARACTER(:), ALLOCATABLE:: fileName
INTEGER:: k
fileName='OUTPUT_Collisions.dat'
IF (timeStep == tInitial) THEN
OPEN(20, file = path // folder // '/' // fileName, action = 'write')
WRITE(20, "(A1, 14X, A5, A20)") "#","t (s)","collisions"
WRITE(*, "(6X,A15,A)") "Creating file: ", fileName
CLOSE(20)
END IF
OPEN(20, file = path // folder // '/' // fileName, position = 'append', action = 'write')
WRITE(20, "(ES20.6E3, 10I20)") REAL(timeStep)*tauMin*ti_ref, (self%cells(1)%obj%tallyColl(k)%tally, k=1,nCollPairs)
CLOSE(20)
END SUBROUTINE printColl0D
SUBROUTINE printEM0D(self)
USE moduleMesh
USE moduleRefParam
USE moduleCaseParam
USE moduleOutput
IMPLICIT NONE
CLASS(meshParticles), INTENT(in):: self
END SUBROUTINE printEM0D
END MODULE moduleMeshOutput0D

View file

@ -0,0 +1,7 @@
all: moduleMeshInputGmsh2.o moduleMeshOutputGmsh2.o
moduleMeshInputGmsh2.o: moduleMeshOutputGmsh2.o moduleMeshInputGmsh2.f90
$(FC) $(FCFLAGS) -c $(subst .o,.f90,$@) -o $(OBJDIR)/$@
%.o: %.f90
$(FC) $(FCFLAGS) -c $< -o $(OBJDIR)/$@

Some files were not shown because too many files have changed in this diff Show more