JGonzalez/fpakc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'development' into feature/see

Browse source
This commit is contained in:
Jorge Gonzalez 2024-07-11 19:11:52 +02:00
commit 51f2726c3d
23 changed files with 424 additions and 242 deletions
Download patch file Download diff file Expand all files Collapse all files

1
doc/user-manual/.gitignore vendored
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

BIN
doc/user-manual/fpakc_UserManual.pdf
View file

Binary file not shown.

116
doc/user-manual/fpakc_UserManual.tex
View file

@ -72,7 +72,7 @@
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 \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.
Particles properties are scattered into a finite element mesh in 1, 2 or three dimensions, with the possibility to choose different geometries. 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 official repository can be found at: \url{https://gitlab.com/JorgeGonz/fpakc.git}.
The code is currently in very early steps of development and further improvements are expected very soon. The code is currently in the very early steps of development and further refinements are expected very soon.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Main Guidelines} \section{Main Guidelines}
@ -86,11 +86,11 @@
\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 understood 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 also 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 \acrshort{fpakc} and its 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.
@ -105,16 +105,16 @@
\section{The Particle Method} \section{The Particle Method}
\Gls{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 could 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.
During the initiation phase, the input and mesh file(s) are reading. 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. If an initial distribution for a species is specified in the input file, particles to match that distribution are loaded into the cells.
The general steps performed in each iteration are: The general steps performed in each iteration are:
\begin{enumerate} \begin{enumerate}
\item Firstly, new particles are introduced into the domain as specified in the input file. \item Firstly, new particles are introduced into the domain as specified in the input file.
\item Particles are then pushed accounting for possible acceleration by external forces. \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. 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 is computed. 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. 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. \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.
@ -124,10 +124,10 @@
\item Finally, particle properties are scattered among the mesh nodes. \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.
\item If requested, the electromagnetic field is computed. \item 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 is completed. \item If the number of iteration requires writing output files, it is done after all steps for the particles are completed.
\end{enumerate} \end{enumerate}
\Gls{fpakc} has the capability to configure all the behavior of the simulation via the input file. \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}. 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}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -168,8 +168,8 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\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 or might be eliminated from it. 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. 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.
@ -178,7 +178,7 @@
\section{Variable Weighting Scheme\label{sec:weightingScheme}} \section{Variable Weighting Scheme\label{sec:weightingScheme}}
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. 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}.
These schemes detect when a particle change cells and split it if necessary to improve statistics. These schemes detect when a particle changes cells and split it if necessary to improve statistics.
The use of a Variable Weighting Scheme is defined by the user in the input file. 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. Beware that this can increase the number of particles in the simulation and increase computational time.
@ -189,16 +189,16 @@
\Gls{fpakc} distinguish between two types of interactions: \acrfull{mcc} and \acrfull{cs}. \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. \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 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 collisions. 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. \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. The interactions between the different species is defined by the user.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{\acrlong{mcc}} \subsection{\acrlong{mcc}}
For each cell the maximum number of collisions between particle is computed. For each cell, the maximum number of collisions between particle is computed.
For each collision, a random pair of particles is chosen. For each collision, a random pair of particles is chosen.
A loop over all possible collisions for the pair of particles chosen is performed. 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 take place. 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. If not, the next type for the particle pair is checked.
Below are described the type of collision process implemented in \acrshort{fpakc}: Below are described the type of collision process implemented in \acrshort{fpakc}:
@ -219,7 +219,7 @@
\item Recombination. \item Recombination.
When an electron and an ion interact, there is a possibility for them to be recombined into a neutral particle. 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 modelled yet. The photons emitted by this process are not modelled yet.
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -238,7 +238,7 @@
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{Probing}\label{sec:probing} \section{Probing}\label{sec:probing}
@ -250,21 +250,21 @@
The user can decide the grid width and the number of points in each direction. 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. The distribution function will be calculated and wrote with a time step decided by the user.
If a particle velocity resides outside of the velocity grid (in any direction), it wont be added to the tally of the distribution function. 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 taking into account 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. 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 taking into account 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. 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.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\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.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -273,11 +273,11 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Average scheme} \section{Average scheme}
Particle-in-cell codes has an intrinsic statistical noise associated with them. 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. 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. 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 amount of iterations printed. 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. \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}. This scheme is based on the Welford's online algorithm~\cite{welford1962note}.
@ -286,7 +286,7 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\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.
@ -369,7 +369,7 @@ make
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\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.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -380,9 +380,9 @@ make
\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. \item \textbf{folder}: Character.
Base name of the folder in wich output files are placed. Base name of the folder in which output files are placed.
The date and time is appended to this name. The date and time is appended to this name.
If none is provided, only the date and time is writted as the folder 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.
@ -515,7 +515,7 @@ make
\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{wallTemperature}: Reflective wall with cosntant temperature that exchange heat with particles. \item \textbf{wallTemperature}: Reflective wall with constant temperature that exchange heat with particles.
Required parameters are: Required parameters are:
\begin{itemize} \begin{itemize}
\item \textbf{temperature}: Real. \item \textbf{temperature}: Real.
@ -526,8 +526,8 @@ make
Specific heat capacity of the material. Specific heat capacity of the material.
\end{itemize} \end{itemize}
\item \textbf{ionization}: Per each particle crossing the surface with this type of boundary, a number of ionization events are calculated. \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. A pair of ion-electron is generated for each ionization event, taking as a reference a neutral background.
Secondary electron is taken as same type as incident particle. The secondary electron is taken as the same type as the incident particle.
The available input is: The available input is:
\begin{itemize} \begin{itemize}
\item \textbf{neutral}: Object. \item \textbf{neutral}: Object.
@ -540,7 +540,7 @@ make
\item \textbf{mass}: Real. \item \textbf{mass}: Real.
Units in $\unit{kg}$. Units in $\unit{kg}$.
Mass of neutral species. Mass of neutral species.
If missing, the mass of the ion is ussed If missing, the mass of the ion is used
\item \textbf{density}: Real. \item \textbf{density}: Real.
Units in $\unit{m^{-3}}$. Units in $\unit{m^{-3}}$.
Density of neutral background. Density of neutral background.
@ -558,18 +558,18 @@ make
\end{itemize} \end{itemize}
\item \textbf{effectiveTime}: Real. \item \textbf{effectiveTime}: Real.
Units in $\unit{s}$. Units in $\unit{s}$.
As the particle is no longer simulated once it crossed the boundary, this time represent the effective time in which the particle produces ionization processes in the neutral background. 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. Required parameter.
\item \textbf{energyThreashold}: Real. \item \textbf{energyThreashold}: Real.
Units in $\unit{eV}$. Units in $\unit{eV}$.
Ionization energy threshold for the simulated process. Ionization energy threshold for the simulated process.
Required parameter. Required parameter.
\item \textbf{crossSection}: Character. \item \textbf{crossSection}: Character.
Complete path to the cross section data for the ionization process. Complete path to the cross-section data for the ionization process.
\end{itemize} \end{itemize}
\item \textbf{axis}: Identifies the symmetry axis for 2D cylindrical simulations. \item \textbf{axis}: Identifies the symmetry axis for 2D cylindrical simulations.
If for some reason a particle interact with this axis, it is reflected. If , for some reason, a particle interacts with this axis, it is reflected.
\end{itemize} \end{itemize}
\end{itemize} \end{itemize}
@ -596,7 +596,7 @@ make
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\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.
@ -610,7 +610,9 @@ 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 surface of injection.
\item \textbf{sccm}: Standard cubic centimetre.
\item \textbf{part/s}: Particles (real) per second. \item \textbf{part/s}: Particles (real) per second.
\end{itemize} \end{itemize}
\item \textbf{v}: Real. \item \textbf{v}: Real.
@ -627,7 +629,7 @@ make
\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. \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 takes into account the positive part of the half-Maxwellian. 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.
@ -636,6 +638,11 @@ make
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}
@ -651,7 +658,7 @@ 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}
@ -677,8 +684,8 @@ make
Indicates the type of pusher used for each species: Indicates the type of pusher used for each species:
\begin{itemize} \begin{itemize}
\item \textbf{Neutral}: Pushes a particle without any external force. \item \textbf{Neutral}: Pushes a particle without any external force.
\item \textbf{Electrostatic}: Pushes a particle including the effect of the electrostatic field. \item \textbf{Electrostatic}: Pushes a particle, including the effect of the electrostatic field.
\item \textbf{Electromagnetic}: Pushes particles accounting for the electromagnetic field. \item \textbf{Electromagnetic}: Pushes a particle, accounting for the electromagnetic 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.
@ -711,6 +718,10 @@ make
The file format must be the same as in \textbf{geometry.meshType} The file format must be the same as in \textbf{geometry.meshType}
Initial particles are assumed to have a Maxwellian distribution. Initial particles are assumed to have a Maxwellian distribution.
File must be located at \textbf{output.path}. File must be located at \textbf{output.path}.
\item \textbf{particlesPerCell}: Integer.
Optional.
Initial number of particles per cell.
If not, the number of particles per cell will be assigned based on the species weight and the cell volume.
\end{itemize} \end{itemize}
\end{itemize} \end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -726,11 +737,11 @@ make
\end{itemize} \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{meshCollisions}: Character. \item \textbf{meshCollisions}: Character.
Determines a specific mesh for \acrshort{mcc} processes. Determines a specific mesh for \acrshort{mcc} processes.
The file needs to be located in the folder \textbf{output.folder}. The file needs to be located in the folder \textbf{output.folder}.
@ -757,13 +768,18 @@ make
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. \item \textbf{Coulomb}: Array of objects.
@ -773,7 +789,7 @@ make
\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 indifferent.
\end{itemize} \end{itemize}
\end{itemize} \end{itemize}
@ -799,9 +815,9 @@ make
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{1D Emissive Cathode (1D\_Cathode)} \section{1D Emissive Cathode (1D\_Cathode)}
Emission from a 1D cathode in both, cartesian and radial coordinates. Emission from a 1D cathode in both, Cartesian and radial coordinates.
Both cases insert the same amount of electrons from the minimum coordinate and have the same boundary conditions for particles and the electrostatic field. 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 ilustrate hoy \acrshort{fpakc} can deal with different geometries by just modifying some parameters in the input file. 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.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

4
src/fpakc.f90
View file

@ -27,6 +27,10 @@ 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 !Do '0' iteration
t = tInitial t = tInitial

21
src/modules/common/moduleRandom.f90
View file

@ -40,10 +40,10 @@ 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
@ -91,10 +91,21 @@ MODULE moduleRandom
REAL(8), INTENT(in):: cumWeight(1:) REAL(8), INTENT(in):: cumWeight(1:)
REAL(8), INTENT(in):: sumWeight REAL(8), INTENT(in):: sumWeight
REAL(8):: rnd0b REAL(8):: rnd0b
INTEGER:: rnd INTEGER:: rnd, i
rnd0b = random(0.D0, sumWeight) rnd0b = random()
rnd = MINLOC(DABS(rnd0b - cumWeight), 1) 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 FUNCTION randomWeighted

2
src/modules/common/moduleTable.f90
View file

@ -96,7 +96,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

91
src/modules/init/moduleInput.f90
View file

@ -84,20 +84,6 @@ MODULE moduleInput
CALL readParallel(config) CALL readParallel(config)
CALL checkStatus(config, "readParallel") CALL checkStatus(config, "readParallel")
!If everything is correct, creates the output folder
CALL EXECUTE_COMMAND_LINE('mkdir ' // path // folder )
!Copies input file to output folder
CALL EXECUTE_COMMAND_LINE('cp ' // inputFile // ' ' // path // folder)
!Copies particle mesh
IF (mesh%dimen > 0) THEN
CALL EXECUTE_COMMAND_LINE('cp ' // pathMeshParticle // ' ' // path // folder)
IF (doubleMesh) THEN
CALL EXECUTE_COMMAND_LINE('cp ' // pathMeshColl // ' ' // path // folder)
END IF
END IF
END SUBROUTINE readConfig END SUBROUTINE readConfig
!Checks the status of the JSON case file and, if failed, exits the execution. !Checks the status of the JSON case file and, if failed, exits the execution.
@ -322,7 +308,7 @@ MODULE moduleInput
LOGICAL:: found LOGICAL:: found
CHARACTER(:), ALLOCATABLE:: object CHARACTER(:), ALLOCATABLE:: object
INTEGER:: nInitial INTEGER:: nInitial
INTEGER:: i, j, p, e INTEGER:: i, p, e
CHARACTER(LEN=2):: iString CHARACTER(LEN=2):: iString
CHARACTER(:), ALLOCATABLE:: spName CHARACTER(:), ALLOCATABLE:: spName
INTEGER:: sp INTEGER:: sp
@ -338,7 +324,8 @@ MODULE moduleInput
REAL(8):: densityCen REAL(8):: densityCen
!Mean velocity and temperature at particle position !Mean velocity and temperature at particle position
REAL(8):: velocityXi(1:3), temperatureXi REAL(8):: velocityXi(1:3), temperatureXi
INTEGER:: nNewPart = 0.D0 INTEGER:: nNewPart = 0
REAL(8):: weight = 0.D0
CLASS(meshCell), POINTER:: cell CLASS(meshCell), POINTER:: cell
TYPE(particle), POINTER:: partNew TYPE(particle), POINTER:: partNew
REAL(8):: vTh REAL(8):: vTh
@ -357,6 +344,9 @@ MODULE moduleInput
!Reads node values at the nodes !Reads node values at the nodes
filename = path // spFile filename = path // spFile
CALL mesh%readInitial(filename, density, velocity, temperature) CALL mesh%readInitial(filename, density, velocity, temperature)
!Check if initial number of particles is given
CALL config%get(object // '.particlesPerCell', nNewPart, found)
!For each volume in the node, create corresponding particles !For each volume in the node, create corresponding particles
DO e = 1, mesh%numCells DO e = 1, mesh%numCells
!Scale variables !Scale variables
@ -369,7 +359,11 @@ MODULE moduleInput
densityCen = mesh%cells(e)%obj%gatherF((/ 0.D0, 0.D0, 0.D0 /), nNodes, sourceScalar) densityCen = mesh%cells(e)%obj%gatherF((/ 0.D0, 0.D0, 0.D0 /), nNodes, sourceScalar)
!Calculate number of particles !Calculate number of particles
nNewPart = INT(densityCen * (mesh%cells(e)%obj%volume*Vol_ref) / species(sp)%obj%weight) IF (.NOT. found) THEN
nNewPart = FLOOR(densityCen * (mesh%cells(e)%obj%volume*Vol_ref) / species(sp)%obj%weight)
END IF
weight = densityCen * (mesh%cells(e)%obj%volume*Vol_ref) / REAL(nNewPart)
!Allocate new particles !Allocate new particles
DO p = 1, nNewPart DO p = 1, nNewPart
@ -406,7 +400,7 @@ MODULE moduleInput
partNew%n_in = .TRUE. partNew%n_in = .TRUE.
partNew%weight = species(sp)%obj%weight partNew%weight = weight
!Assign particle to temporal list of particles !Assign particle to temporal list of particles
CALL partInitial%add(partNew) CALL partInitial%add(partNew)
@ -634,7 +628,7 @@ MODULE moduleInput
INTEGER:: i, k, ij INTEGER:: i, k, ij
INTEGER:: pt_i, pt_j INTEGER:: pt_i, pt_j
REAL(8):: energyThreshold, energyBinding REAL(8):: energyThreshold, energyBinding
CHARACTER(:), ALLOCATABLE:: electron CHARACTER(:), ALLOCATABLE:: electron, electronSecondary
INTEGER:: e INTEGER:: e
CLASS(meshCell), POINTER:: cell CLASS(meshCell), POINTER:: cell
@ -711,9 +705,17 @@ MODULE moduleInput
IF (.NOT. found) CALL criticalError('energyThreshold not found for collision' // object, 'readInteractions') IF (.NOT. found) CALL criticalError('energyThreshold not found for collision' // object, 'readInteractions')
CALL config%get(object // '.electron', electron, found) CALL config%get(object // '.electron', electron, found)
IF (.NOT. found) CALL criticalError('electron not found for collision' // object, 'readInteractions') IF (.NOT. found) CALL criticalError('electron not found for collision' // object, 'readInteractions')
CALL config%get(object // '.electronSecondary', electronSecondary, found)
IF (found) THEN
CALL initBinaryIonization(interactionMatrix(ij)%collisions(k)%obj, &
crossSecFilePath, energyThreshold, electron, electronSecondary)
ELSE
CALL initBinaryIonization(interactionMatrix(ij)%collisions(k)%obj, & CALL initBinaryIonization(interactionMatrix(ij)%collisions(k)%obj, &
crossSecFilePath, energyThreshold, electron) crossSecFilePath, energyThreshold, electron)
END IF
CASE ('recombination') CASE ('recombination')
!Electorn impact ionization !Electorn impact ionization
CALL config%get(object // '.energyBinding', energyBinding, found) CALL config%get(object // '.energyBinding', energyBinding, found)
@ -805,8 +807,8 @@ MODULE moduleInput
REAL(8), DIMENSION(:), ALLOCATABLE:: v0 REAL(8), DIMENSION(:), ALLOCATABLE:: v0
REAL(8):: effTime REAL(8):: effTime
REAL(8):: eThreshold !Energy threshold REAL(8):: eThreshold !Energy threshold
INTEGER:: speciesID INTEGER:: speciesID, electronSecondaryID
CHARACTER(:), ALLOCATABLE:: speciesName, crossSection, yield CHARACTER(:), ALLOCATABLE:: speciesName, crossSection, yield, electronSecondary
LOGICAL:: found LOGICAL:: found
INTEGER:: nTypes INTEGER:: nTypes
@ -861,9 +863,18 @@ MODULE moduleInput
CALL config%get(object // '.crossSection', crossSection, found) CALL config%get(object // '.crossSection', crossSection, found)
IF (.NOT. found) CALL criticalError("missing parameter 'crossSection' for neutrals in ionization", 'readBoundary') IF (.NOT. found) CALL criticalError("missing parameter 'crossSection' for neutrals in ionization", 'readBoundary')
CALL config%get(object // '.electronSecondary', electronSecondary, found)
electronSecondaryID = speciesName2Index(electronSecondary)
IF (found) THEN
CALL initIonization(boundary(i)%bTypes(s)%obj, species(s)%obj%m, m0, n0, v0, T0, &
speciesID, effTime, crossSection, eThreshold,electronSecondaryID)
ELSE
CALL initIonization(boundary(i)%bTypes(s)%obj, species(s)%obj%m, m0, n0, v0, T0, & CALL initIonization(boundary(i)%bTypes(s)%obj, species(s)%obj%m, m0, n0, v0, T0, &
speciesID, effTime, crossSection, eThreshold) speciesID, effTime, crossSection, eThreshold)
END IF
CASE('wallTemperature') CASE('wallTemperature')
CALL config%get(object // '.temperature', Tw, found) CALL config%get(object // '.temperature', Tw, found)
IF (.NOT. found) CALL criticalError("temperature not found for wallTemperature boundary type", 'readBoundary') IF (.NOT. found) CALL criticalError("temperature not found for wallTemperature boundary type", 'readBoundary')
@ -921,7 +932,6 @@ MODULE moduleInput
LOGICAL:: found LOGICAL:: found
CHARACTER(:), ALLOCATABLE:: meshFormat, meshFile CHARACTER(:), ALLOCATABLE:: meshFormat, meshFile
REAL(8):: volume REAL(8):: volume
CHARACTER(:), ALLOCATABLE:: meshFileVTU !Temporary to test VTU OUTPUT
object = 'geometry' object = 'geometry'
@ -1234,6 +1244,7 @@ MODULE moduleInput
REAL(8):: flow REAL(8):: flow
CHARACTER(:), ALLOCATABLE:: units CHARACTER(:), ALLOCATABLE:: units
INTEGER:: physicalSurface INTEGER:: physicalSurface
INTEGER:: particlesPerEdge
INTEGER:: sp INTEGER:: sp
CALL config%info('inject', found, n_children = nInject) CALL config%info('inject', found, n_children = nInject)
@ -1258,8 +1269,10 @@ MODULE moduleInput
CALL config%get(object // '.flow', flow, found) CALL config%get(object // '.flow', flow, found)
CALL config%get(object // '.units', units, found) CALL config%get(object // '.units', units, found)
CALL config%get(object // '.physicalSurface', physicalSurface, found) CALL config%get(object // '.physicalSurface', physicalSurface, found)
particlesPerEdge = 0
CALL config%get(object // '.particlesPerEdge', particlesPerEdge, found)
CALL inject(i)%init(i, v, normal, T, flow, units, sp, physicalSurface) CALL inject(i)%init(i, v, normal, T, flow, units, sp, physicalSurface, particlesPerEdge)
CALL readVelDistr(config, inject(i), object) CALL readVelDistr(config, inject(i), object)
@ -1381,5 +1394,37 @@ MODULE moduleInput
END SUBROUTINE readParallel END SUBROUTINE readParallel
SUBROUTINE initOutput(inputFile)
USE moduleRefParam
USE moduleMesh, ONLY: mesh, doubleMesh, pathMeshParticle, pathMeshColl
USE moduleOutput, ONLY: path, folder
IMPLICIT NONE
CHARACTER(:), ALLOCATABLE, INTENT(in):: inputFile
INTEGER:: fileReference = 30
!If everything is correct, creates the output folder
CALL EXECUTE_COMMAND_LINE('mkdir ' // path // folder )
!Copies input file to output folder
CALL EXECUTE_COMMAND_LINE('cp ' // inputFile // ' ' // path // folder)
!Copies particle mesh
IF (mesh%dimen > 0) THEN
CALL EXECUTE_COMMAND_LINE('cp ' // pathMeshParticle // ' ' // path // folder)
IF (doubleMesh) THEN
CALL EXECUTE_COMMAND_LINE('cp ' // pathMeshColl // ' ' // path // folder)
END IF
END IF
! Write commit of fpakc
CALL SYSTEM('git rev-parse HEAD > ' // path // folder // '/' // 'fpakc_commit.txt')
! Write file with reference values
OPEN (fileReference, file=path // folder // '/' // 'reference.txt')
WRITE(fileReference, "(7(1X,A20))") 'L_ref', 'v_ref', 'ti_ref', 'Vol_ref', 'EF_ref', 'Volt_ref', 'B_ref'
WRITE(fileReference, "(7(1X,ES20.6E3))") L_ref, v_ref, ti_ref, Vol_ref, EF_ref, Volt_ref, B_ref
CLOSE(fileReference)
END SUBROUTINE initOutput
END MODULE moduleInput END MODULE moduleInput

3
src/modules/mesh/1DCart/moduleMesh1DCart.f90
View file

@ -104,6 +104,7 @@ MODULE moduleMesh1DCart
USE moduleSpecies USE moduleSpecies
USE moduleBoundary USE moduleBoundary
USE moduleErrors USE moduleErrors
USE moduleRefParam, ONLY: L_ref
IMPLICIT NONE IMPLICIT NONE
CLASS(meshEdge1DCart), INTENT(out):: self CLASS(meshEdge1DCart), INTENT(out):: self
@ -122,6 +123,8 @@ MODULE moduleMesh1DCart
self%x = r1(1) self%x = r1(1)
self%surface = 1.D0 / L_ref**2
self%normal = (/ 1.D0, 0.D0, 0.D0 /) self%normal = (/ 1.D0, 0.D0, 0.D0 /)
!Boundary index !Boundary index

3
src/modules/mesh/1DRad/moduleMesh1DRad.f90
View file

@ -104,6 +104,7 @@ MODULE moduleMesh1DRad
USE moduleSpecies USE moduleSpecies
USE moduleBoundary USE moduleBoundary
USE moduleErrors USE moduleErrors
USE moduleRefParam, ONLY: L_ref
IMPLICIT NONE IMPLICIT NONE
CLASS(meshEdge1DRad), INTENT(out):: self CLASS(meshEdge1DRad), INTENT(out):: self
@ -122,6 +123,8 @@ MODULE moduleMesh1DRad
self%r = r1(1) self%r = r1(1)
self%surface = 1.D0 / L_ref**2
self%normal = (/ 1.D0, 0.D0, 0.D0 /) self%normal = (/ 1.D0, 0.D0, 0.D0 /)
!Boundary index !Boundary index

16
src/modules/mesh/2DCart/moduleMesh2DCart.f90
View file

@ -144,6 +144,7 @@ MODULE moduleMesh2DCart
USE moduleSpecies USE moduleSpecies
USE moduleBoundary USE moduleBoundary
USE moduleErrors USE moduleErrors
USE moduleRefParam, ONLY: L_ref
IMPLICIT NONE IMPLICIT NONE
CLASS(meshEdge2DCart), INTENT(out):: self CLASS(meshEdge2DCart), INTENT(out):: self
@ -163,7 +164,7 @@ MODULE moduleMesh2DCart
r2 = self%n2%getCoordinates() r2 = self%n2%getCoordinates()
self%x = (/r1(1), r2(1)/) self%x = (/r1(1), r2(1)/)
self%y = (/r1(2), r2(2)/) self%y = (/r1(2), r2(2)/)
self%weight = 1.D0 self%surface = SQRT((self%x(2) - self%x(1))**2 + (self%y(2) - self%y(1))**2) / L_ref
!Normal vector !Normal vector
self%normal = (/ -(self%y(2)-self%y(1)), & self%normal = (/ -(self%y(2)-self%y(1)), &
self%x(2)-self%x(1) , & self%x(2)-self%x(1) , &
@ -318,6 +319,8 @@ MODULE moduleMesh2DCart
INTEGER, INTENT(in):: nNodes INTEGER, INTENT(in):: nNodes
REAL(8):: fPsi(1:nNodes) REAL(8):: fPsi(1:nNodes)
fPsi = 0.D0
fPsi = (/ (1.D0 - Xi(1)) * (1.D0 - Xi(2)), & fPsi = (/ (1.D0 - Xi(1)) * (1.D0 - Xi(2)), &
(1.D0 + Xi(1)) * (1.D0 - Xi(2)), & (1.D0 + Xi(1)) * (1.D0 - Xi(2)), &
(1.D0 + Xi(1)) * (1.D0 + Xi(2)), & (1.D0 + Xi(1)) * (1.D0 + Xi(2)), &
@ -508,15 +511,15 @@ MODULE moduleMesh2DCart
conv = 1.D0 conv = 1.D0
XiO = 0.D0 XiO = 0.D0
f(3) = 0.D0
DO WHILE(conv > 1.D-4) DO WHILE(conv > 1.D-4)
dPsi = self%dPsi(XiO, 4) dPsi = self%dPsi(XiO, 4)
pDer = self%partialDer(4, dPsi) pDer = self%partialDer(4, dPsi)
detJ = self%detJac(pDer) detJ = self%detJac(pDer)
invJ = self%invJac(pDer) invJ = self%invJac(pDer)
fPsi = self%fPsi(XiO, 4) fPsi = self%fPsi(XiO, 4)
f = (/ DOT_PRODUCT(fPsi,self%x), & f(1:2) = (/ DOT_PRODUCT(fPsi,self%x), &
DOT_PRODUCT(fPsi,self%y), & DOT_PRODUCT(fPsi,self%y) /) - r(1:2)
0.D0 /) - r
Xi = XiO - MATMUL(invJ, f)/detJ Xi = XiO - MATMUL(invJ, f)/detJ
conv = MAXVAL(DABS(Xi-XiO),1) conv = MAXVAL(DABS(Xi-XiO),1)
XiO = Xi XiO = Xi
@ -554,6 +557,7 @@ MODULE moduleMesh2DCart
!Compute element volume !Compute element volume
PURE SUBROUTINE volumeQuad(self) PURE SUBROUTINE volumeQuad(self)
USE moduleRefParam, ONLY: L_ref
IMPLICIT NONE IMPLICIT NONE
CLASS(meshCell2DCartQuad), INTENT(inout):: self CLASS(meshCell2DCartQuad), INTENT(inout):: self
@ -569,8 +573,9 @@ MODULE moduleMesh2DCart
pDer = self%partialDer(4, dPsi) pDer = self%partialDer(4, dPsi)
detJ = self%detJac(pDer) detJ = self%detJac(pDer)
fPsi = self%fPsi(Xi, 4) fPsi = self%fPsi(Xi, 4)
!Compute total volume of the cell !Compute total volume of the cell
self%volume = detJ*4.D0 self%volume = detJ*4.D0/L_ref
!Compute volume per node !Compute volume per node
self%n1%v = self%n1%v + fPsi(1)*self%volume self%n1%v = self%n1%v + fPsi(1)*self%volume
self%n2%v = self%n2%v + fPsi(2)*self%volume self%n2%v = self%n2%v + fPsi(2)*self%volume
@ -762,6 +767,7 @@ MODULE moduleMesh2DCart
pDer = self%partialDer(3, dPsi) pDer = self%partialDer(3, dPsi)
detJ = self%detJac(pDer) detJ = self%detJac(pDer)
invJ = self%invJac(pDer) invJ = self%invJac(pDer)
localK = localK + MATMUL(TRANSPOSE(MATMUL(invJ,dPsi)),MATMUL(invJ,dPsi))*wTria(l)/detJ localK = localK + MATMUL(TRANSPOSE(MATMUL(invJ,dPsi)),MATMUL(invJ,dPsi))*wTria(l)/detJ
END DO END DO

53
src/modules/mesh/2DCyl/moduleMesh2DCyl.f90
View file

@ -144,6 +144,7 @@ MODULE moduleMesh2DCyl
USE moduleSpecies USE moduleSpecies
USE moduleBoundary USE moduleBoundary
USE moduleErrors USE moduleErrors
USE moduleConstParam, ONLY: PI
IMPLICIT NONE IMPLICIT NONE
CLASS(meshEdge2DCyl), INTENT(out):: self CLASS(meshEdge2DCyl), INTENT(out):: self
@ -163,7 +164,15 @@ MODULE moduleMesh2DCyl
r2 = self%n2%getCoordinates() r2 = self%n2%getCoordinates()
self%z = (/r1(1), r2(1)/) self%z = (/r1(1), r2(1)/)
self%r = (/r1(2), r2(2)/) self%r = (/r1(2), r2(2)/)
self%weight = r2(2)**2 - r1(2)**2 !Edge surface
IF (self%z(2) /= self%z(1)) THEN
self%surface = ABS(self%r(2) + self%r(1))*ABS(self%z(2) - self%z(1))
ELSE
self%surface = ABS(self%r(2)**2 - self%r(1)**2)
END IF
self%surface = self%surface * PI
!Normal vector !Normal vector
self%normal = (/ -(self%r(2)-self%r(1)), & self%normal = (/ -(self%r(2)-self%r(1)), &
self%z(2)-self%z(1) , & self%z(2)-self%z(1) , &
@ -223,21 +232,13 @@ MODULE moduleMesh2DCyl
CLASS(meshEdge2DCyl), INTENT(in):: self CLASS(meshEdge2DCyl), INTENT(in):: self
REAL(8):: rnd REAL(8):: rnd
REAL(8):: r(1:3) REAL(8):: r(1:3)
REAL(8):: dr, dz REAL(8):: p1(1:2), p2(1:2)
rnd = random() rnd = random()
dr = self%r(2) - self%r(1)
dz = self%z(2) - self%z(1)
IF (dr /= 0.D0) THEN
r(2) = dr * DSQRT(rnd) + self%r(1)
r(1) = dz * (r(2) - self%r(1))/dr + self%z(1)
ELSE
r(2) = self%r(1)
r(1) = dz * rnd + self%z(1)
END IF
p1 = (/self%z(1), self%r(1) /)
p2 = (/self%z(2), self%r(2) /)
r(1:2) = (1.D0 - rnd)*p1 + rnd*p2
r(3) = 0.D0 r(3) = 0.D0
END FUNCTION randPosEdge END FUNCTION randPosEdge
@ -246,7 +247,6 @@ MODULE moduleMesh2DCyl
!QUAD FUNCTIONS !QUAD FUNCTIONS
!Init element !Init element
SUBROUTINE initCellQuad2DCyl(self, n, p, nodes) SUBROUTINE initCellQuad2DCyl(self, n, p, nodes)
USE moduleRefParam
IMPLICIT NONE IMPLICIT NONE
CLASS(meshCell2DCylQuad), INTENT(out):: self CLASS(meshCell2DCylQuad), INTENT(out):: self
@ -326,6 +326,8 @@ MODULE moduleMesh2DCyl
INTEGER, INTENT(in):: nNodes INTEGER, INTENT(in):: nNodes
REAL(8):: fPsi(1:nNodes) REAL(8):: fPsi(1:nNodes)
fPsi = 0.D0
fPsi = (/ (1.D0 - Xi(1)) * (1.D0 - Xi(2)), & fPsi = (/ (1.D0 - Xi(1)) * (1.D0 - Xi(2)), &
(1.D0 + Xi(1)) * (1.D0 - Xi(2)), & (1.D0 + Xi(1)) * (1.D0 - Xi(2)), &
(1.D0 + Xi(1)) * (1.D0 + Xi(2)), & (1.D0 + Xi(1)) * (1.D0 + Xi(2)), &
@ -496,7 +498,7 @@ MODULE moduleMesh2DCyl
END FUNCTION elemFQuad END FUNCTION elemFQuad
!Checks if Xi is inside the element !Check if Xi is inside the element
PURE FUNCTION insideQuad(Xi) RESULT(ins) PURE FUNCTION insideQuad(Xi) RESULT(ins)
IMPLICIT NONE IMPLICIT NONE
@ -524,15 +526,15 @@ MODULE moduleMesh2DCyl
conv = 1.D0 conv = 1.D0
XiO = 0.D0 XiO = 0.D0
f(3) = 0.D0
DO WHILE(conv > 1.D-4) DO WHILE(conv > 1.D-4)
dPsi = self%dPsi(XiO, 4) dPsi = self%dPsi(XiO, 4)
pDer = self%partialDer(4, dPsi) pDer = self%partialDer(4, dPsi)
detJ = self%detJac(pDer) detJ = self%detJac(pDer)
invJ = self%invJac(pDer) invJ = self%invJac(pDer)
fPsi = self%fPsi(XiO, 4) fPsi = self%fPsi(XiO, 4)
f = (/ DOT_PRODUCT(fPsi,self%z), & f(1:2) = (/ DOT_PRODUCT(fPsi,self%z), &
DOT_PRODUCT(fPsi,self%r), & DOT_PRODUCT(fPsi,self%r) /) - r(1:2)
0.D0 /) - r
Xi = XiO - MATMUL(invJ, f)/detJ Xi = XiO - MATMUL(invJ, f)/detJ
conv = MAXVAL(DABS(Xi-XiO),1) conv = MAXVAL(DABS(Xi-XiO),1)
XiO = Xi XiO = Xi
@ -553,7 +555,7 @@ MODULE moduleMesh2DCyl
XiArray = (/ -Xi(2), Xi(1), Xi(2), -Xi(1) /) XiArray = (/ -Xi(2), Xi(1), Xi(2), -Xi(1) /)
nextInt = MAXLOC(XiArray,1) nextInt = MAXLOC(XiArray,1)
!Selects the higher value of directions and searches in that direction !Select the higher value of directions and searches in that direction
NULLIFY(neighbourElement) NULLIFY(neighbourElement)
SELECT CASE (nextInt) SELECT CASE (nextInt)
CASE (1) CASE (1)
@ -581,6 +583,7 @@ MODULE moduleMesh2DCyl
REAL(8):: dPsi(1:3, 1:4), pDer(1:3, 1:3) REAL(8):: dPsi(1:3, 1:4), pDer(1:3, 1:3)
self%volume = 0.D0 self%volume = 0.D0
!2D 1 point Gauss Quad Integral !2D 1 point Gauss Quad Integral
Xi = 0.D0 Xi = 0.D0
dPsi = self%dPsi(Xi, 4) dPsi = self%dPsi(Xi, 4)
@ -589,18 +592,18 @@ MODULE moduleMesh2DCyl
fPsi = self%fPsi(Xi, 4) fPsi = self%fPsi(Xi, 4)
r = DOT_PRODUCT(fPsi,self%r) r = DOT_PRODUCT(fPsi,self%r)
!Computes total volume of the cell !Computes total volume of the cell
self%volume = r*detJ*PI8 !4*2*pi self%volume = r*detJ*PI8 !2*pi * 4 (weight of 1 point 2D-Gaussian integral)
!Computes volume per node !Computes volume per node. Change the radius point to calculate the area to improve accuracy near the axis.
Xi = (/-5.D-1, -5.D-1, 0.D0/) Xi = (/-5.D-1, -0.25D0, 0.D0/)
r = self%gatherF(Xi, 4, self%r) r = self%gatherF(Xi, 4, self%r)
self%n1%v = self%n1%v + fPsi(1)*r*detJ*PI8 self%n1%v = self%n1%v + fPsi(1)*r*detJ*PI8
Xi = (/ 5.D-1, -5.D-1, 0.D0/) Xi = (/ 5.D-1, -0.25D0, 0.D0/)
r = self%gatherF(Xi, 4, self%r) r = self%gatherF(Xi, 4, self%r)
self%n2%v = self%n2%v + fPsi(2)*r*detJ*PI8 self%n2%v = self%n2%v + fPsi(2)*r*detJ*PI8
Xi = (/ 5.D-1, 5.D-1, 0.D0/) Xi = (/ 5.D-1, 0.75D0, 0.D0/)
r = self%gatherF(Xi, 4, self%r) r = self%gatherF(Xi, 4, self%r)
self%n3%v = self%n3%v + fPsi(3)*r*detJ*PI8 self%n3%v = self%n3%v + fPsi(3)*r*detJ*PI8
Xi = (/-5.D-1, 5.D-1, 0.D0/) Xi = (/-5.D-1, 0.75D0, 0.D0/)
r = self%gatherF(Xi, 4, self%r) r = self%gatherF(Xi, 4, self%r)
self%n4%v = self%n4%v + fPsi(4)*r*detJ*PI8 self%n4%v = self%n4%v + fPsi(4)*r*detJ*PI8

3
src/modules/mesh/3DCart/moduleMesh3DCart.f90
View file

@ -109,6 +109,7 @@ MODULE moduleMesh3DCart
USE moduleBoundary USE moduleBoundary
USE moduleErrors USE moduleErrors
USE moduleMath USE moduleMath
USE moduleRefParam, ONLY: L_ref
IMPLICIT NONE IMPLICIT NONE
CLASS(meshEdge3DCartTria), INTENT(out):: self CLASS(meshEdge3DCartTria), INTENT(out):: self
@ -142,6 +143,8 @@ MODULE moduleMesh3DCart
self%normal = crossProduct(vec1, vec2) self%normal = crossProduct(vec1, vec2)
self%normal = normalize(self%normal) self%normal = normalize(self%normal)
self%surface = 1.D0/L_ref**2 !TODO: FIX THIS WHEN MOVING TO 3D
!Boundary index !Boundary index
self%boundary => boundary(bt) self%boundary => boundary(bt)
ALLOCATE(self%fBoundary(1:nSpecies)) ALLOCATE(self%fBoundary(1:nSpecies))

5
src/modules/mesh/inout/gmsh2/moduleMeshInputGmsh2.f90
View file

@ -108,6 +108,7 @@ MODULE moduleMeshInputGmsh2
READ(10, *) totalNumElem READ(10, *) totalNumElem
!Count edges and volume elements !Count edges and volume elements
numEdges = 0
SELECT TYPE(self) SELECT TYPE(self)
TYPE IS(meshParticles) TYPE IS(meshParticles)
self%numEdges = 0 self%numEdges = 0
@ -328,7 +329,7 @@ MODULE moduleMeshInputGmsh2
DO i = 1, numNodes DO i = 1, numNodes
!Reads the density !Reads the density
READ(10, *), e, density(i) READ(10, *) e, density(i)
END DO END DO
@ -339,7 +340,7 @@ MODULE moduleMeshInputGmsh2
DO i = 1, numNodes DO i = 1, numNodes
!Reads the velocity !Reads the velocity
READ(10, *), e, velocity(i, 1:3) READ(10, *) e, velocity(i, 1:3)
END DO END DO

1
src/modules/mesh/inout/vtu/moduleMeshInputVTU.f90
View file

@ -275,6 +275,7 @@ MODULE moduleMeshInputVTU
END DO END DO
!Count the number of edges !Count the number of edges
numEdges = 0
SELECT CASE(self%dimen) SELECT CASE(self%dimen)
CASE(3) CASE(3)
!Edges are triangles, type 5 in VTK !Edges are triangles, type 5 in VTK

9
src/modules/mesh/inout/vtu/moduleMeshOutputVTU.f90
View file

@ -315,9 +315,8 @@ MODULE moduleMeshOutputVTU
CLASS(meshParticles), INTENT(in):: self CLASS(meshParticles), INTENT(in):: self
INTEGER, INTENT(in):: t INTEGER, INTENT(in):: t
INTEGER:: n, i, fileID INTEGER:: i, fileID
CHARACTER(:), ALLOCATABLE:: fileName, fileNameCollection CHARACTER(:), ALLOCATABLE:: fileName, fileNameCollection
TYPE(outputFormat):: output(1:self%numNodes)
fileID = 60 fileID = 60
@ -352,10 +351,9 @@ MODULE moduleMeshOutputVTU
CLASS(meshGeneric), INTENT(in):: self CLASS(meshGeneric), INTENT(in):: self
INTEGER, INTENT(in):: t INTEGER, INTENT(in):: t
INTEGER:: n, i, fileID INTEGER:: fileID
CHARACTER(:), ALLOCATABLE:: fileName, fileNameCollection CHARACTER(:), ALLOCATABLE:: fileName, fileNameCollection
CHARACTER (LEN=iterationDigits):: tstring CHARACTER (LEN=iterationDigits):: tstring
TYPE(outputFormat):: output(1:self%numNodes)
fileID = 62 fileID = 62
@ -424,9 +422,8 @@ MODULE moduleMeshOutputVTU
IMPLICIT NONE IMPLICIT NONE
CLASS(meshParticles), INTENT(in):: self CLASS(meshParticles), INTENT(in):: self
INTEGER:: n, i, fileIDMean, fileIDDeviation INTEGER:: i, fileIDMean, fileIDDeviation
CHARACTER(:), ALLOCATABLE:: fileNameMean, fileNameDeviation CHARACTER(:), ALLOCATABLE:: fileNameMean, fileNameDeviation
TYPE(outputFormat):: output(1:self%numNodes)
fileIDMean = 66 fileIDMean = 66
fileIDDeviation = 67 fileIDDeviation = 67

20
src/modules/mesh/moduleMesh.f90
View file

@ -76,8 +76,8 @@ MODULE moduleMesh
CLASS(meshCell), POINTER:: eColl => NULL() CLASS(meshCell), POINTER:: eColl => NULL()
!Normal vector !Normal vector
REAL(8):: normal(1:3) REAL(8):: normal(1:3)
!Weight for random injection of particles ! Surface of edge
REAL(8):: weight = 1.D0 REAL(8):: surface = 0.D0
!Pointer to boundary type !Pointer to boundary type
TYPE(boundaryCont), POINTER:: boundary TYPE(boundaryCont), POINTER:: boundary
!Array of functions for boundary conditions !Array of functions for boundary conditions
@ -613,6 +613,7 @@ MODULE moduleMesh
INTEGER:: sp INTEGER:: sp
INTEGER:: i INTEGER:: i
CLASS(meshNode), POINTER:: node CLASS(meshNode), POINTER:: node
REAL(8):: pFraction !Particle fraction
cellNodes = self%getNodes(nNodes) cellNodes = self%getNodes(nNodes)
fPsi = self%fPsi(part%Xi, nNodes) fPsi = self%fPsi(part%Xi, nNodes)
@ -623,10 +624,11 @@ MODULE moduleMesh
DO i = 1, nNodes DO i = 1, nNodes
node => mesh%nodes(cellNodes(i))%obj node => mesh%nodes(cellNodes(i))%obj
pFraction = fPsi(i)*part%weight
CALL OMP_SET_LOCK(node%lock) CALL OMP_SET_LOCK(node%lock)
node%output(sp)%den = node%output(sp)%den + part%weight*fPsi(i) node%output(sp)%den = node%output(sp)%den + pFraction
node%output(sp)%mom(:) = node%output(sp)%mom(:) + part%weight*fPsi(i)*part%v(:) node%output(sp)%mom(:) = node%output(sp)%mom(:) + pFraction*part%v(:)
node%output(sp)%tensorS(:,:) = node%output(sp)%tensorS(:,:) + part%weight*fPsi(i)*tensorS node%output(sp)%tensorS(:,:) = node%output(sp)%tensorS(:,:) + pFraction*tensorS
CALL OMP_UNSET_LOCK(node%lock) CALL OMP_UNSET_LOCK(node%lock)
END DO END DO
@ -911,7 +913,9 @@ MODULE moduleMesh
!Loop over collisions !Loop over collisions
DO c = 1, interactionMatrix(k)%amount DO c = 1, interactionMatrix(k)%amount
IF (rnd_real <= probabilityColl(c)) THEN IF (rnd_real <= probabilityColl(c)) THEN
!$OMP CRITICAL
CALL interactionMatrix(k)%collisions(c)%obj%collide(part_i, part_j, vRel) CALL interactionMatrix(k)%collisions(c)%obj%collide(part_i, part_j, vRel)
!$OMP END CRITICAL
!If collisions are gonna be output, count the collision !If collisions are gonna be output, count the collision
IF (collOutput) THEN IF (collOutput) THEN
@ -1021,6 +1025,9 @@ MODULE moduleMesh
ALLOCATE(deltaV_ij(1:cell%listPart_in(i)%amount, 1:3)) ALLOCATE(deltaV_ij(1:cell%listPart_in(i)%amount, 1:3))
ALLOCATE(p_ij(1:cell%listPart_in(i)%amount, 1:3)) ALLOCATE(p_ij(1:cell%listPart_in(i)%amount, 1:3))
ALLOCATE(mass_ij(1:cell%listPart_in(i)%amount)) ALLOCATE(mass_ij(1:cell%listPart_in(i)%amount))
deltaV_ij = 0.D0
p_ij = 0.D0
mass_ij = 0.D0
!Loop over particles of species_i !Loop over particles of species_i
partTemp => cell%listPart_in(i)%head partTemp => cell%listPart_in(i)%head
p = 1 p = 1
@ -1105,6 +1112,9 @@ MODULE moduleMesh
ALLOCATE(deltaV_ji(1:cell%listPart_in(j)%amount, 1:3)) ALLOCATE(deltaV_ji(1:cell%listPart_in(j)%amount, 1:3))
ALLOCATE(p_ji(1:cell%listPart_in(j)%amount, 1:3)) ALLOCATE(p_ji(1:cell%listPart_in(j)%amount, 1:3))
ALLOCATE(mass_ji(1:cell%listPart_in(j)%amount)) ALLOCATE(mass_ji(1:cell%listPart_in(j)%amount))
deltaV_ji = 0.D0
p_ji = 0.D0
mass_ji = 0.D0
!Loop over particles of species_j !Loop over particles of species_j
partTemp => cell%listPart_in(j)%head partTemp => cell%listPart_in(j)%head
p = 1 p = 1

6
src/modules/mesh/moduleMeshBoundary.f90
View file

@ -147,7 +147,13 @@ MODULE moduleMeshBoundary
ALLOCATE(newElectron) ALLOCATE(newElectron)
ALLOCATE(newIon) ALLOCATE(newIon)
IF (ASSOCIATED(bound%electronSecondary)) THEN
newElectron%species => bound%electronSecondary
ELSE
newElectron%species => part%species newElectron%species => part%species
END IF
newIon%species => bound%species newIon%species => bound%species
newElectron%v = v0 + (1.D0 + bound%deltaV*v0/NORM2(v0)) newElectron%v = v0 + (1.D0 + bound%deltaV*v0/NORM2(v0))

24
src/modules/moduleBoundary.f90
View file

@ -38,6 +38,7 @@ MODULE moduleBoundary
TYPE, PUBLIC, EXTENDS(boundaryGeneric):: boundaryIonization TYPE, PUBLIC, EXTENDS(boundaryGeneric):: boundaryIonization
REAL(8):: m0, n0, v0(1:3), vTh !Properties of background neutrals. REAL(8):: m0, n0, v0(1:3), vTh !Properties of background neutrals.
CLASS(speciesGeneric), POINTER:: species !Ion species CLASS(speciesGeneric), POINTER:: species !Ion species
CLASS(speciesCharged), POINTER:: electronSecondary !Pointer to species considerer as secondary electron
TYPE(table1D):: crossSection TYPE(table1D):: crossSection
REAL(8):: effectiveTime REAL(8):: effectiveTime
REAL(8):: eThreshold REAL(8):: eThreshold
@ -113,17 +114,19 @@ MODULE moduleBoundary
END SUBROUTINE initWallTemperature END SUBROUTINE initWallTemperature
SUBROUTINE initIonization(boundary, me, m0, n0, v0, T0, speciesID, effTime, crossSection, eThreshold) SUBROUTINE initIonization(boundary, me, m0, n0, v0, T0, ion, effTime, crossSection, eThreshold, electronSecondary)
USE moduleRefParam USE moduleRefParam
USE moduleSpecies USE moduleSpecies
USE moduleCaseParam USE moduleCaseParam
USE moduleConstParam USE moduleConstParam
USE moduleErrors
IMPLICIT NONE IMPLICIT NONE
CLASS(boundaryGeneric), ALLOCATABLE, INTENT(out):: boundary CLASS(boundaryGeneric), ALLOCATABLE, INTENT(out):: boundary
REAL(8), INTENT(in):: me !Electron mass REAL(8), INTENT(in):: me !Electron mass
REAL(8), INTENT(in):: m0, n0, v0(1:3), T0 !Neutral properties REAL(8), INTENT(in):: m0, n0, v0(1:3), T0 !Neutral properties
INTEGER:: speciesID INTEGER, INTENT(in):: ion
INTEGER, OPTIONAL, INTENT(in):: electronSecondary
REAL(8):: effTime REAL(8):: effTime
CHARACTER(:), ALLOCATABLE, INTENT(in):: crossSection CHARACTER(:), ALLOCATABLE, INTENT(in):: crossSection
REAL(8), INTENT(in):: eThreshold REAL(8), INTENT(in):: eThreshold
@ -136,7 +139,22 @@ MODULE moduleBoundary
boundary%n0 = n0 * Vol_ref boundary%n0 = n0 * Vol_ref
boundary%v0 = v0 / v_ref boundary%v0 = v0 / v_ref
boundary%vTh = DSQRT(kb*T0/m0)/v_ref boundary%vTh = DSQRT(kb*T0/m0)/v_ref
boundary%species => species(speciesID)%obj boundary%species => species(ion)%obj
IF (PRESENT(electronSecondary)) THEN
SELECT TYPE(sp => species(electronSecondary)%obj)
TYPE IS(speciesCharged)
boundary%electronSecondary => sp
CLASS DEFAULT
CALL criticalError("Species " // sp%name // " chosen for " // &
"secondary electron is not a charged species", 'initIonization')
END SELECT
ELSE
boundary%electronSecondary => NULL()
END IF
boundary%effectiveTime = effTime / ti_ref boundary%effectiveTime = effTime / ti_ref
CALL boundary%crossSection%init(crossSection) CALL boundary%crossSection%init(crossSection)
CALL boundary%crossSection%convert(eV2J/(m_ref*v_ref**2), 1.D0/L_ref**2) CALL boundary%crossSection%convert(eV2J/(m_ref*v_ref**2), 1.D0/L_ref**2)

31
src/modules/moduleCollisions.f90
View file

@ -44,6 +44,7 @@ MODULE moduleCollisions
REAL(8):: eThreshold !Minimum energy (non-dimensional units) required for ionization REAL(8):: eThreshold !Minimum energy (non-dimensional units) required for ionization
REAL(8):: deltaV !Change in velocity due to exchange of eThreshold REAL(8):: deltaV !Change in velocity due to exchange of eThreshold
CLASS(speciesCharged), POINTER:: electron !Pointer to species considerer as electrons CLASS(speciesCharged), POINTER:: electron !Pointer to species considerer as electrons
CLASS(speciesCharged), POINTER:: electronSecondary !Pointer to species considerer as secondary electron
CONTAINS CONTAINS
PROCEDURE, PASS:: collide => collideBinaryIonization PROCEDURE, PASS:: collide => collideBinaryIonization
@ -241,7 +242,7 @@ MODULE moduleCollisions
!ELECTRON IMPACT IONIZATION !ELECTRON IMPACT IONIZATION
!Inits electron impact ionization !Inits electron impact ionization
SUBROUTINE initBinaryIonization(collision, crossSectionFilename, energyThreshold, electron) SUBROUTINE initBinaryIonization(collision, crossSectionFilename, energyThreshold, electron, electronSecondary)
USE moduleTable USE moduleTable
USE moduleRefParam USE moduleRefParam
USE moduleConstParam USE moduleConstParam
@ -253,7 +254,8 @@ MODULE moduleCollisions
CHARACTER(:), ALLOCATABLE, INTENT(in):: crossSectionFilename CHARACTER(:), ALLOCATABLE, INTENT(in):: crossSectionFilename
REAL(8), INTENT(in):: energyThreshold REAL(8), INTENT(in):: energyThreshold
CHARACTER(:), ALLOCATABLE, INTENT(in):: electron CHARACTER(:), ALLOCATABLE, INTENT(in):: electron
INTEGER:: electronIndex CHARACTER(:), ALLOCATABLE, OPTIONAL, INTENT(in):: electronSecondary
INTEGER:: electronIndex, electronSecondaryIndex
ALLOCATE(collisionBinaryIonization:: collision) ALLOCATE(collisionBinaryIonization:: collision)
@ -276,12 +278,29 @@ MODULE moduleCollisions
TYPE IS(speciesCharged) TYPE IS(speciesCharged)
collision%electron => sp collision%electron => sp
CLASS DEFAULT
CALL criticalError("Species " // sp%name // " chosen for " // &
"impacting electron is not a charged species", 'initBinaryIonization')
END SELECT
IF (PRESENT(electronSecondary)) THEN
electronSecondaryIndex = speciesName2Index(electronSecondary)
SELECT TYPE(sp => species(electronSecondaryIndex)%obj)
TYPE IS(speciesCharged)
collision%electronSecondary => sp
CLASS DEFAULT CLASS DEFAULT
CALL criticalError("Species " // sp%name // " chosen for " // & CALL criticalError("Species " // sp%name // " chosen for " // &
"secondary electron is not a charged species", 'initBinaryIonization') "secondary electron is not a charged species", 'initBinaryIonization')
END SELECT END SELECT
ELSE
collision%electronSecondary => NULL()
END IF
!momentum change per ionization process !momentum change per ionization process
collision%deltaV = sqrt(collision%eThreshold / collision%electron%m) collision%deltaV = sqrt(collision%eThreshold / collision%electron%m)
@ -336,6 +355,12 @@ MODULE moduleCollisions
!Copy basic information from primary electron !Copy basic information from primary electron
newElectron = electron newElectron = electron
!If secondary electron species indicates, convert
IF (ASSOCIATED(self%electronSecondary)) THEN
newElectron%species => self%electronSecondary
END IF
!Secondary electorn gains energy from ionization !Secondary electorn gains energy from ionization
newElectron%v = vChange newElectron%v = vChange
@ -362,7 +387,7 @@ MODULE moduleCollisions
CALL sp%ionize(neutral) CALL sp%ionize(neutral)
CLASS DEFAULT CLASS DEFAULT
! CALL criticalError(sp%name // " is not a neutral", 'collideBinaryIonization') CALL criticalError(sp%name // " is not a neutral", 'collideBinaryIonization')
RETURN RETURN
END SELECT END SELECT

131
src/modules/moduleInject.f90
View file

@ -61,8 +61,9 @@ MODULE moduleInject
CLASS(speciesGeneric), POINTER:: species !Species of injection CLASS(speciesGeneric), POINTER:: species !Species of injection
INTEGER:: nEdges INTEGER:: nEdges
INTEGER, ALLOCATABLE:: edges(:) !Array with edges INTEGER, ALLOCATABLE:: edges(:) !Array with edges
REAL(8), ALLOCATABLE:: cumWeight(:) !Array of cummulative probability INTEGER, ALLOCATABLE:: particlesPerEdge(:) ! Particles per edge
REAL(8):: sumWeight REAL(8), ALLOCATABLE:: weightPerEdge(:) ! Weight per edge
REAL(8):: surface ! Total surface of injection
TYPE(velDistCont):: v(1:3) !Velocity distribution function in each direction TYPE(velDistCont):: v(1:3) !Velocity distribution function in each direction
CONTAINS CONTAINS
PROCEDURE, PASS:: init => initInject PROCEDURE, PASS:: init => initInject
@ -75,7 +76,7 @@ MODULE moduleInject
CONTAINS CONTAINS
!Initialize an injection of particles !Initialize an injection of particles
SUBROUTINE initInject(self, i, v, n, T, flow, units, sp, physicalSurface) SUBROUTINE initInject(self, i, v, n, T, flow, units, sp, physicalSurface, particlesPerEdge)
USE moduleMesh USE moduleMesh
USE moduleRefParam USE moduleRefParam
USE moduleConstParam USE moduleConstParam
@ -87,48 +88,28 @@ MODULE moduleInject
CLASS(injectGeneric), INTENT(inout):: self CLASS(injectGeneric), INTENT(inout):: self
INTEGER, INTENT(in):: i INTEGER, INTENT(in):: i
REAL(8), INTENT(in):: v, n(1:3), T(1:3) REAL(8), INTENT(in):: v, n(1:3), T(1:3)
INTEGER, INTENT(in):: sp, physicalSurface INTEGER, INTENT(in):: sp, physicalSurface, particlesPerEdge
REAL(8):: tauInject REAL(8):: tauInject
REAL(8), INTENT(in):: flow REAL(8), INTENT(in):: flow
CHARACTER(:), ALLOCATABLE, INTENT(in):: units CHARACTER(:), ALLOCATABLE, INTENT(in):: units
INTEGER:: e, et INTEGER:: e, et
INTEGER:: phSurface(1:mesh%numEdges) INTEGER:: phSurface(1:mesh%numEdges)
INTEGER:: nVolColl INTEGER:: nVolColl
REAL(8):: fluxPerStep = 0.D0
self%id = i self%id = i
self%vMod = v / v_ref self%vMod = v / v_ref
self%n = n / NORM2(n) self%n = n / NORM2(n)
self%T = T / T_ref self%T = T / T_ref
self%species => species(sp)%obj
tauInject = tau(self%species%n)
SELECT CASE(units)
CASE ("sccm")
!Standard cubic centimeter per minute
self%nParticles = INT(flow*sccm2atomPerS*tauInject*ti_ref/species(sp)%obj%weight)
CASE ("A")
!Input current in Ampers
self%nParticles = INT(flow*tauInject*ti_ref/(qe*species(sp)%obj%weight))
CASE ("part/s")
!Input current in Ampers
self%nParticles = INT(flow*tauInject*ti_ref/species(sp)%obj%weight)
CASE DEFAULT
CALL criticalError("No support for units: " // units, 'initInject')
END SELECT
!Scale particles for different species steps
IF (self%nParticles == 0) CALL criticalError("The number of particles for inject is 0.", 'initInject')
!Gets the edge elements from which particles are injected !Gets the edge elements from which particles are injected
DO e = 1, mesh%numEdges DO e = 1, mesh%numEdges
phSurface(e) = mesh%edges(e)%obj%physicalSurface phSurface(e) = mesh%edges(e)%obj%physicalSurface
END DO END DO
self%nEdges = COUNT(phSurface == physicalSurface) self%nEdges = COUNT(phSurface == physicalSurface)
ALLOCATE(inject(i)%edges(1:self%nEdges)) ALLOCATE(self%edges(1:self%nEdges))
ALLOCATE(self%particlesPerEdge(1:self%nEdges))
ALLOCATE(self%weightPerEdge(1:self%nEdges))
et = 0 et = 0
DO e=1, mesh%numEdges DO e=1, mesh%numEdges
IF (mesh%edges(e)%obj%physicalSurface == physicalSurface) THEN IF (mesh%edges(e)%obj%physicalSurface == physicalSurface) THEN
@ -160,15 +141,63 @@ MODULE moduleInject
END DO END DO
!Calculates cumulative probability !Calculates total area
ALLOCATE(self%cumWeight(1:self%nEdges)) self%surface = 0.D0
et = 1 DO et = 1, self%nEdges
self%cumWeight(1) = mesh%edges(self%edges(et))%obj%weight self%surface = self%surface + mesh%edges(self%edges(et))%obj%surface
DO et = 2, self%nEdges
self%cumWeight(et) = mesh%edges(self%edges(et))%obj%weight + self%cumWeight(et-1)
END DO END DO
self%sumWeight = self%cumWeight(self%nEdges)
! Information about species and flux
self%species => species(sp)%obj
tauInject = tau(self%species%n)
! Convert units
SELECT CASE(units)
CASE ("sccm")
!Standard cubic centimeter per minute
fluxPerStep = flow*sccm2atomPerS
CASE ("A")
!Current in Ampers
fluxPerStep = flow/qe
CASE ("Am2")
!Input current in Ampers per square meter
fluxPerStep = flow*self%surface*L_ref**2/qe
CASE ("part/s")
!Input current in Ampers
fluxPerStep = flow
CASE DEFAULT
CALL criticalError("No support for units: " // units, 'initInject')
END SELECT
fluxPerStep = fluxPerStep * tauInject * ti_ref / self%surface
!Assign particles per edge
IF (particlesPerEdge > 0) THEN
! Particles per edge defined by the user
self%particlesPerEdge = particlesPerEdge
DO et = 1, self%nEdges
self%weightPerEdge(et) = fluxPerStep*mesh%edges(self%edges(et))%obj%surface / REAL(particlesPerEdge)
END DO
ELSE
! No particles assigned per edge, use the species weight
self%weightPerEdge = self%species%weight
DO et = 1, self%nEdges
self%particlesPerEdge(et) = FLOOR(fluxPerStep*mesh%edges(self%edges(et))%obj%surface /self%species%weight)
END DO
END IF
self%nParticles = SUM(self%particlesPerEdge)
!Scale particles for different species steps
IF (self%nParticles == 0) CALL criticalError("The number of particles for inject is 0.", 'initInject')
END SUBROUTINE initInject END SUBROUTINE initInject
@ -279,9 +308,8 @@ MODULE moduleInject
IMPLICIT NONE IMPLICIT NONE
CLASS(injectGeneric), INTENT(in):: self CLASS(injectGeneric), INTENT(in):: self
INTEGER:: randomX INTEGER, SAVE:: nMin
INTEGER, SAVE:: nMin, nMax !Min and Max index in partInj array INTEGER:: i, j, e
INTEGER:: i
INTEGER:: n, sp INTEGER:: n, sp
CLASS(meshEdge), POINTER:: randomEdge CLASS(meshEdge), POINTER:: randomEdge
REAL(8):: direction(1:3) REAL(8):: direction(1:3)
@ -296,22 +324,23 @@ MODULE moduleInject
END IF END IF
END DO END DO
nMin = nMin + 1 nMin = nMin + 1
nMax = nMin + self%nParticles - 1
!Assign weight to particle.
partInj(nMin:nMax)%weight = self%species%weight
!Particle is considered to be outside the domain
partInj(nMin:nMax)%n_in = .FALSE.
!$OMP END SINGLE !$OMP END SINGLE
!$OMP DO !$OMP DO
DO n = nMin, nMax DO e = 1, self%nEdges
randomX = randomWeighted(self%cumWeight, self%sumWeight) ! Select edge for injection
randomEdge => mesh%edges(self%edges(e))%obj
randomEdge => mesh%edges(self%edges(randomX))%obj ! Inject particles in edge
DO i = 1, self%particlesPerEdge(e)
! Index in the global partInj array
n = nMin - 1 + SUM(self%particlesPerEdge(1:e-1)) + i
!Particle is considered to be outside the domain
partInj(n)%n_in = .FALSE.
!Random position in edge !Random position in edge
partInj(n)%r = randomEdge%randPos() partInj(n)%r = randomEdge%randPos()
!Assign weight to particle.
partInj(n)%weight = self%weightPerEdge(e)
!Volume associated to the edge: !Volume associated to the edge:
IF (ASSOCIATED(randomEdge%e1)) THEN IF (ASSOCIATED(randomEdge%e1)) THEN
partInj(n)%cell = randomEdge%e1%n partInj(n)%cell = randomEdge%e1%n
@ -331,13 +360,15 @@ MODULE moduleInject
direction = self%n direction = self%n
partInj(n)%v = 0.D0
!Sample initial velocity !Sample initial velocity
partInj(n)%v = self%vMod*direction + (/ self%v(1)%obj%randomVel(), & partInj(n)%v = self%vMod*direction + (/ self%v(1)%obj%randomVel(), &
self%v(2)%obj%randomVel(), & self%v(2)%obj%randomVel(), &
self%v(3)%obj%randomVel() /) self%v(3)%obj%randomVel() /)
!For each direction, velocities have to agree with the direction of injection !For each direction, velocities have to agree with the direction of injection
DO i = 1, 3 DO j = 1, 3
DO WHILE (partInj(n)%v(i)*direction(i) < 0) DO WHILE (partInj(n)%v(i)*direction(i) < 0)
partInj(n)%v(i) = self%vMod*direction(i) + self%v(i)%obj%randomVel() partInj(n)%v(i) = self%vMod*direction(i) + self%v(i)%obj%randomVel()
@ -353,6 +384,8 @@ MODULE moduleInject
CALL solver%updateParticleCell(partInj(n)) CALL solver%updateParticleCell(partInj(n))
END DO END DO
END DO
!$OMP END DO !$OMP END DO
END SUBROUTINE addParticles END SUBROUTINE addParticles

26
src/modules/moduleProbe.f90
View file

@ -101,7 +101,7 @@ MODULE moduleProbe
!Maximum radius !Maximum radius
!TODO: Make this an input parameter !TODO: Make this an input parameter
self%maxR = 1.D0 self%maxR = 1.D-2/L_ref
!Init the probe lock !Init the probe lock
CALL OMP_INIT_LOCK(self%lock) CALL OMP_INIT_LOCK(self%lock)
@ -148,7 +148,7 @@ MODULE moduleProbe
deltaR = NORM2(self%r - part%r) deltaR = NORM2(self%r - part%r)
!Only include particle if it is inside the maximum radius !Only include particle if it is inside the maximum radius
IF (deltaR < self%maxR) THEN ! IF (deltaR < self%maxR) THEN
!find lower index for all dimensions !find lower index for all dimensions
CALL self%findLowerIndex(part%v, i, j, k, inside) CALL self%findLowerIndex(part%v, i, j, k, inside)
@ -162,28 +162,28 @@ MODULE moduleProbe
fk = self%vk(k+1) - part%v(3) fk = self%vk(k+1) - part%v(3)
fk1 = part%v(3) - self%vk(k) fk1 = part%v(3) - self%vk(k)
! weight = part%weight * DEXP(deltaR/self%maxR) weight = part%weight * DEXP(-deltaR/self%maxR)
weight = part%weight ! weight = part%weight
!Lock the probe !Lock the probe
CALL OMP_SET_LOCK(self%lock) CALL OMP_SET_LOCK(self%lock)
!Assign particle weight to distribution function !Assign particle weight to distribution function
self%f(i , j , k ) = fi * fj * fk * weight self%f(i , j , k ) = self%f(i , j , k ) + fi * fj * fk * weight
self%f(i+1, j , k ) = fi1 * fj * fk * weight self%f(i+1, j , k ) = self%f(i+1, j , k ) + fi1 * fj * fk * weight
self%f(i , j+1, k ) = fi * fj1 * fk * weight self%f(i , j+1, k ) = self%f(i , j+1, k ) + fi * fj1 * fk * weight
self%f(i+1, j+1, k ) = fi1 * fj1 * fk * weight self%f(i+1, j+1, k ) = self%f(i+1, j+1, k ) + fi1 * fj1 * fk * weight
self%f(i , j , k+1) = fi * fj * fk1 * weight self%f(i , j , k+1) = self%f(i , j , k+1) + fi * fj * fk1 * weight
self%f(i+1, j , k+1) = fi1 * fj * fk1 * weight self%f(i+1, j , k+1) = self%f(i+1, j , k+1) + fi1 * fj * fk1 * weight
self%f(i , j+1, k+1) = fi * fj1 * fk1 * weight self%f(i , j+1, k+1) = self%f(i , j+1, k+1) + fi * fj1 * fk1 * weight
self%f(i+1, j+1, k+1) = fi1 * fj1 * fk1 * weight self%f(i+1, j+1, k+1) = self%f(i+1, j+1, k+1) + fi1 * fj1 * fk1 * weight
!Unlock the probe !Unlock the probe
CALL OMP_UNSET_LOCK(self%lock) CALL OMP_UNSET_LOCK(self%lock)
END IF END IF
END IF ! END IF
END IF END IF

1
src/modules/solver/electromagnetic/moduleEM.f90
View file

@ -30,6 +30,7 @@ MODULE moduleEM
INTEGER, ALLOCATABLE:: nodes(:) INTEGER, ALLOCATABLE:: nodes(:)
INTEGER:: n INTEGER:: n
nNodes = 1
nNodes = edge%nNodes nNodes = edge%nNodes
nodes = edge%getNodes(nNodes) nodes = edge%getNodes(nNodes)

5
src/modules/solver/moduleSolver.f90
View file

@ -517,11 +517,6 @@ MODULE moduleSolver
INTEGER, INTENT(in):: t INTEGER, INTENT(in):: t
IF (t == tInitial) THEN
CALL SYSTEM('git rev-parse HEAD > ' // path // folder // '/' // 'fpack_commit.txt')
END IF
CALL outputProbes(t) CALL outputProbes(t)
counterOutput = counterOutput + 1 counterOutput = counterOutput + 1