ETS  \$Id: Doxyfile 2162 2020-02-26 14:16:09Z g2dpc $
 All Classes Files Functions Variables Pages
solver_test.F90
Go to the documentation of this file.
1 ! + + + + + + + + + + + + + + + + + + + + + + + + + + + +
2 ! + + + + + + + + + + + + + + + + + + + + + + + + + + + +
10 ! + + + + + + + + + + + + + + + + + + + + + + + + + + + +
11 PROGRAM solver_test
12 ! + + + + + + + + + + + + + + + + + + + + + + + + + + + !
13 ! This routine aimed in testing the solver solution !
14 ! method for the set of transport equations !
15 ! with given sources and transport coefficients. !
16 ! + + + + + + + + + + + + + + + + + + + + + + + + + + + +
17 ! Source: --- +
18 ! Developers: D.Kalupin, R.Stankiewicz +
19 ! Kontacts: D.Kalupin@fz-juelich.de +
20 ! Roman.Stankiewich@gmail.com +
21 ! +
22 ! Comments: It will be removed as soon the +
23 ! KEPLER implementation is done +
24 ! +
25 ! + + + + + + + + + + + + + + + + + + + + + + + + + + + +
26 
27 
28 ! + + + Declaration of variables: + + + + + + + + + + + +
29 
30  use itm_types
31  USE euitm_schemas
32  use copy_structures
33 #ifdef UAL
34  USE euitm_routines
35 #endif
36  USE type_analytics
37  USE ets_plasma
38  USE allocate_deallocate
39  USE ets
40  USE convergence_check
41  USE copy_cpo_ets
42  USE analytics1
43  USE itm_test_routines
44  use deallocate_structures
45  use xml_file_reader
46  use ets_version
47  USE plasma_composition
48 
49  IMPLICIT NONE
50 
51  INTEGER :: ifail
52 
53  INTEGER :: shot_no !shot mumber
54  INTEGER :: run_no !run mumber
55 
56  INTEGER :: nrho !number of radial points (input)
57  INTEGER :: ntime !number of time points (input)
58  INTEGER, PARAMETER :: nslice = 1 !number of CPO ocurancies in the work flow
59 
60  INTEGER :: nnucl !number of neutrals species (input)
61  INTEGER :: nion !number of ion species (input)
62  INTEGER :: nimp !number of impurity species (input)
63  INTEGER, ALLOCATABLE, SAVE :: nzimp(:) !number of charge states for each impurity (input)
64 
65  INTEGER :: nneut !number of neutrals species (input)
66  INTEGER, ALLOCATABLE, SAVE :: ncomp(:) !number of components for each neutral
67  INTEGER, ALLOCATABLE, SAVE :: ntype(:) !number of types for each neutral
68 
69 
70  REAL (R8), ALLOCATABLE, SAVE :: amn(:)
71  REAL (R8), ALLOCATABLE, SAVE :: zn(:)
72  REAL (R8), ALLOCATABLE, SAVE :: zion(:)
73  REAL (R8), ALLOCATABLE, SAVE :: amn_imp(:)
74  REAL (R8), ALLOCATABLE, SAVE :: zn_imp(:)
75  REAL (R8), ALLOCATABLE, SAVE :: max_z_imp(:)
76 
77  INTEGER :: cold_neutrals
78  INTEGER :: thermal_neutrals
79  INTEGER :: fast_neutrals
80  INTEGER :: nbi_neutrals
81 
82  INTEGER :: irho !current radial knot
83  INTEGER :: iion !current ion type
84  INTEGER :: itime !current time step
85 
86  INTEGER :: nsol !Number of analytical example
87  INTEGER :: solver_type !representation of transport equations
88 !1-"standard"; 2-"integral"(default)
89  INTEGER :: sigma_source !source for plasma conductivity
90 
91  REAL (R8) :: convrec !required convergency
92  REAL (R8) :: time !Time
93  REAL (R8) :: tau !time step, and mixing coefficient
94  REAL (R8) :: amix !mixing factor
95  INTEGER :: iter !iteration index
96  INTEGER, PARAMETER :: maxiter=1000 !maximum number of convergence iterations
97 
98  INTEGER :: psi_bnd_type !Type of boundary conditions current
99  INTEGER :: ni_bnd_type !Type of boundary conditions ion density
100  INTEGER :: ti_bnd_type !Type of boundary conditions ion temperature
101  INTEGER :: te_bnd_type !Type of boundary conditions electron temperature
102  INTEGER :: vtor_bnd_type !Type of boundary conditions toroidal rotation
103 
104  TYPE (run_control) :: control !contains all parameters required by run
105 
106 ! +++ CPO derived types:
107  TYPE (type_equilibrium), POINTER :: equilibrium_old(:) !input CPO with geometry quantities
108  TYPE (type_equilibrium), POINTER :: equilibrium_iter(:) !input CPO with geometry quantities
109  TYPE (type_coreprof), POINTER :: coreprof_old(:) !input CPO with plasma profiles at the previous time step
110  TYPE (type_coreprof), POINTER :: coreprof_new(:) !output CPO with plasma profiles at the next time step
111  TYPE (type_coreprof), POINTER :: coreprof_iter(:) !input CPO with plasma profiles at previous iteration
112  TYPE (type_coreprof), POINTER :: coreprof_analytic(:)!input CPO with plasma profiles at previous iteration
113  TYPE (type_coretransp), POINTER :: coretransp(:) !input CPO with transport coefficients
114  TYPE (type_coresource), POINTER :: coresource(:) !input CPO with sources
115  TYPE (type_coreimpur), POINTER :: coreimpur(:) !input CPO with impurities
116  type (type_param) :: code_parameters, ets_parameters
117  character (len=32) :: database_format
118 
119  INTEGER :: control_integer(4) !integer control parameters
120  REAL (R8) :: control_double(6) !real control parameters
121 
122  INTEGER :: idx
123 
124 !
125 ! the following interface blocks are for testing the Kepler interface
126 ! which does not allow for routines in modules to be called
127 !
128  interface
129  subroutine analyticalplasma(TIMEx,COREPROF_in, &
130  equilibrium,coreprof,coretransp,coresource,coreimpur, code_parameters)
131 
132  use itm_types
133  USE euitm_schemas
134  use analytics1
135 
136  implicit none
137 
138 ! input arguments
139  REAL (R8) :: timex
140  TYPE (type_coreprof), POINTER :: coreprof_in(:)
141 ! output arguments
142  TYPE (type_equilibrium),POINTER :: equilibrium(:)
143  TYPE (type_coreprof), POINTER :: coreprof(:)
144  TYPE (type_coretransp), POINTER :: coretransp(:)
145  TYPE (type_coresource), POINTER :: coresource(:)
146  TYPE (type_coreimpur), POINTER :: coreimpur(:)
147  type (type_param) :: code_parameters
148 
149  end subroutine analyticalplasma
150 
151  subroutine itmets &
152  (coreprof_old, coreprof_iter, coreprof_new, &
153  equilibrium_old, equilibrium_iter, &
154  coretransp, coresource, coreimpur, &
155  control_integerx, control_doublex, ets_parameters)
156 
157  USE euitm_schemas
158  USE ets_plasma
159  USE ets
160 
161  IMPLICIT NONE
162 
163 ! input arguments
164  TYPE (type_equilibrium), POINTER :: equilibrium_old(:), equilibrium_iter(:)
165  TYPE (type_coreprof), POINTER :: coreprof_old(:), coreprof_iter(:)
166  TYPE (type_coretransp), POINTER :: coretransp(:)
167  TYPE (type_coresource), POINTER :: coresource(:)
168  TYPE (type_coreimpur), POINTER :: coreimpur(:)
169  INTEGER :: control_integerx(4) !integer control parameters
170  REAL (R8) :: control_doublex(5) !real control parameters
171 !output arguments
172  TYPE (type_coreprof), POINTER :: coreprof_new(:)
173  type (type_param) :: ets_parameters
174 
175  end subroutine itmets
176 
177  subroutine convergence(COREPROF_ITER, COREPROF_OUT, CONTROL_DOUBLE)
178 
179  USE euitm_schemas
180  USE ets_plasma
181  USE convergence_check
182 
183  implicit none
184 
185 ! input arguments
186  TYPE (type_coreprof), POINTER :: coreprof_iter(:)
187  TYPE (type_coreprof), POINTER :: coreprof_out(:)
188 
189 !output arguments
190  REAL (R8) :: control_double(5)
191 
192  end subroutine convergence
193 
194  end interface
195 
196 !
197 ! start of the actual program
198 !
199 
200 ! call perfinit
201 ! call perfon ('whole')
202 
203 !
204 ! get the input data
205 !
206 
207 ! call perfon ('read')
208  shot_no=0
209  run_no=-1
210 
211  call fill_param(ets_parameters, 'XML/ets.xml', '', 'XML/ets.xsd')
212  call fill_param(code_parameters, 'XML/ets_analytics.xml', '', 'XML/ets_analytics.xsd')
213  CALL process_xml(solver_type,sigma_source,tau,amix,convrec,nrho,nion,nimp,nzimp,ntime,nsol, &
214  psi_bnd_type,ni_bnd_type,ti_bnd_type,te_bnd_type,vtor_bnd_type, &
215  shot_no, run_no, code_parameters, database_format)
216 !
217 ! save the necessary data in the CONTROL structure
218 !
219  ifail = 0
220 
221  CALL allocate_run_control( control, ifail)
222  call set_control(solver_type,sigma_source,tau,amix,convrec,control)
223  control_integer(1) = control%SOLVER_TYPE
224  control_integer(2) = control%SIGMA_SOURCE
225  control_double(1) = control%TAU
226  control_double(2) = control%AMIX
227  control_double(3) = control%AMIXTR
228  control_double(4) = control%CONV
229  control_double(5) = control%CONVREC
230 ! call perfoff
231 
232 !
233 ! if the UAL preprocessor option is defined, and if the run and sequence
234 ! numbers are OK, we will write out the results using the UAL
235 !
236 ! here we initialize the UAL
237 !
238 
239 #ifdef UAL
240  if(shot_no.gt.0.and.run_no.ge.0) then
241 ! call perfon ('ualo')
242  write(*,*) 'Using ', trim(database_format),' for the backend'
243  select case (database_format)
244  case ("mdsplus")
245  call euitm_create('euitm',shot_no,run_no,0,0,idx)
246  case ("hdf5")
247  call euitm_create_hdf5('euitm',shot_no,run_no,0,0,idx)
248  case default
249  write(*,*) 'Unexpected database format choice : ',trim(database_format)
250  stop 'Error: unrecognized database format'
251  end select
252 ! call perfoff
253  endif
254 #endif
255 
256 
257 ! call perfon ('alloc')
258 
259  nnucl = nion
260  nneut = nion
261  ALLOCATE (ncomp(nneut))
262  ALLOCATE (ntype(nneut))
263  ncomp = 1
264  ntype = 1
265 
266  CALL allocate_coreprof_cpo(nslice, nrho, nnucl, nion, nimp, nzimp, nneut, ntype, ncomp, coreprof_old)
267  CALL allocate_coreprof_cpo(nslice, nrho, nnucl, nion, nimp, nzimp, nneut, ntype, ncomp, coreprof_iter)
268 
269  ALLOCATE (amn(nion))
270  ALLOCATE (zn(nion))
271  ALLOCATE (zion(nion))
272  ALLOCATE (amn_imp(nimp))
273  ALLOCATE (zn_imp(nimp))
274  ALLOCATE (max_z_imp(nimp))
275 
276  amn = 2.0_r8
277  zn = 1.0_r8
278  zion = 1.0_r8
279  amn_imp = 0.0_r8
280  zn_imp = 0.0_r8
281  max_z_imp = 0.0_r8
282 
283  cold_neutrals = 0
284  thermal_neutrals = 0
285  fast_neutrals = 0
286  nbi_neutrals = 0
287 
288  CALL set_plasma_composition(coreprof_iter, &
289  nion, nimp, nneut, &
290  amn, zn, zion, &
291  amn_imp, zn_imp, max_z_imp, &
292  ncomp, ntype, &
293  cold_neutrals, thermal_neutrals,&
294  fast_neutrals, nbi_neutrals)
295 
296  call deallocate_cpo(coreprof_old(1)%COMPOSITIONS)
297  CALL copy_cpo(coreprof_iter(1)%COMPOSITIONS, coreprof_old(1)%COMPOSITIONS)
298 ! call perfoff
299 
300  allocate(coreprof_old(1)%codeparam%codename(1))
301  coreprof_old(1)%codeparam%codename(1)='solver_test'
302  allocate(coreprof_old(1)%codeparam%codeversion(1))
303  coreprof_old(1)%codeparam%codeversion(1)=version
304  allocate(coreprof_old(1)%codeparam%parameters(size(code_parameters%parameters)))
305  coreprof_old(1)%codeparam%parameters=code_parameters%parameters
306 
307 !
308 ! initialize the start of the run
309 !
310 ! we use ANALYTICAL_PLASMA to set up the initial plasma profile in
311 ! COREPROF_OLD, but then need to destroy the unneeded CPOs created by
312 ! ANALYTICAL_PLASMA
313 !
314 
315 ! call perfon ('initprof')
316  time = 0.0e0_r8
317 
318  CALL analytical_plasma(time, coreprof_old, equilibrium_old, coreprof_analytic, &
319  coretransp, coresource, coreimpur, code_parameters)
320 
321 !fc2k work around (either use the previous lines or the following ones)
322 
323 ! CALL ANALYTICALPLASMA (TIME, coreprof_old, EQUILIBRIUM_OLD, COREPROF_ANALYTIC, &
324 ! CORETRANSP, CORESOURCE, COREIMPUR)
325 
326  call deallocate_cpo(coreprof_old)
327  call copy_cpo(coreprof_analytic,coreprof_old)
328  CALL deallocate_cpo(coreprof_analytic)
329  CALL deallocate_cpo(coretransp )
330  CALL deallocate_cpo(coresource )
331  CALL deallocate_cpo(coreimpur )
332 ! call perfoff
333 
334 
335 !----------------------------------------------------------------------!
336 ! Time evolution from the time step '1' until the NTIME !
337 !----------------------------------------------------------------------!
338 
339 ! call perfon ('timestep')
340  time_loop1: DO itime = 1,ntime
341 
342  time = time + tau
343 
344  WRITE (6,*) '========================================'
345  WRITE (6,*) 'TIME=',time
346  WRITE (6,*) '========================================'
347 
348 !
349 ! initialize iteration loop, using ANALYTICAL_PLASMA to provide the
350 ! equilibrium, sources, transport coefficients and analytic answer (in
351 ! COREPROF_ANALYTIC
352 !
353  iter = 0
354 
355 ! call perfon ('t.analyt')
356  CALL analytical_plasma(time, coreprof_old, equilibrium_iter, coreprof_analytic, &
357  coretransp, coresource, coreimpur, code_parameters)
358 
359 !fc2k work around (either use the previous lines or the following ones)
360 
361 ! CALL ANALYTICALPLASMA (TIME, coreprof_old, EQUILIBRIUM_ITER, COREPROF_ANALYTIC, &
362 ! CORETRANSP, CORESOURCE, COREIMPUR)
363 ! call perfoff
364 
365 !
366 ! we need a new coreprof for the iteration loop
367 !
368 
369 ! call perfon ('t.copy.i')
370  call copy_cpo(coreprof_old,coreprof_iter)
371  CALL copy_boundary_cond(coreprof_analytic, coreprof_iter)
372 
373 ! call perfoff
374 
375 !
376 ! this is the iteration loop where we iterate until convergence
377 !
378 
379 10 CONTINUE
380 
381 !
382 ! increment iteration number and stop if too many iterations
383 !
384  iter = iter + 1
385  if(iter.gt.maxiter) then
386  write(*,'(a,i0,a)') 'Maximum number of iterations ( ',maxiter,' ) exceeded'
387  write(*,'(a,1pg10.3,a,i0)') 'Time = ', time, ' Number of time iterations = ', itime
388  stop 'Error'
389  endif
390 
391 !
392 ! this is the call to the ETS
393 !
394 ! it uses as input
395 ! COREPROF_OLD : COREPROF at the old timestep
396 ! COREPROF_ITER : COREPROF at the previous iteration
397 ! EQUILIBRIUM_OLD : EQUILIBRIUM at the old timestep
398 ! EQUILIBRIUM_ITER : EQUILIBRIUM at the previous iteration
399 ! CORETRANSP : CORETRANSP from ANALYTICAL_PLASMA
400 ! CORESOURCE : CORESOURCE from ANALYTICAL_PLASMA
401 ! COREIMPUR : COREIMPUR from ANALYTICAL_PLASMA
402 ! CONTROL : control information (either a structure or two arrays)
403 !
404 ! and provides as output
405 ! COREPROF_NEW : COREPROF at the new iteration
406 !
407 
408 ! call perfon ('t.ets')
409 
410  CALL itm_ets &
411  (coreprof_old, coreprof_iter, coreprof_new, &
412  equilibrium_old, equilibrium_iter, &
413  coretransp, coresource, coreimpur, &
414  control_integer, control_double, ets_parameters)
415 
416 !fc2k work around (either use the previous lines or the following ones)
417 
418 ! CALL ITMETS &
419 ! (COREPROF_OLD, COREPROF_ITER, COREPROF_NEW, &
420 ! EQUILIBRIUM_OLD, EQUILIBRIUM_ITER, &
421 ! CORETRANSP, CORESOURCE, COREIMPUR, &
422 ! CONTROL_INTEGER, CONTROL_DOUBLE, ets_parameters)
423 
424 ! call perfoff
425 
426 !
427 ! now we check for convergence
428 !
429 ! note that CHECK_CONVERGENCE also copies COREPROF_NEW to COREPROF_ITER [no longer true]
430 !
431 
432 ! call perfon ('t.conv')
433 
434  CALL check_convergence(coreprof_iter, coreprof_new, control_double)
435 
436 !fc2k work around (either use the previous lines or the following ones)
437 
438 ! CALL CONVERGENCE (COREPROF_ITER, COREPROF_NEW, CONTROL_DOUBLE)
439 
440 !
441 ! since CHECK_CONVERGENCE copied COREPROF_NEW to COREPROF_ITER, we now
442 ! need to destroy the extra copy of COREPROF
443 !
444 
445  CALL deallocate_cpo(coreprof_iter )
446  CALL copy_cpo(coreprof_new,coreprof_iter) ! latest version of CHECK_CONVERGENCE no longer copies
447 
448  CALL deallocate_cpo(coreprof_new )
449 
450 ! call perfoff
451 
452 !
453 ! here we loop back if the convergence criterion has not been satisfied
454 ! (currently disabled)
455 !
456 
457  write(*,*) 'Convergence test: ', iter, control_double(4), control_double(5)
458 !DPC remove temporarily IF (CONTROL%CONV.GT.CONTROL%CONVREC) GOTO 10
459  IF (control_double(4).GT.control_double(5)) goto 10
460 
461 !
462 ! at this point the iteration loop has converged and we write out the results
463 !
464 
465 ! call perfon ('t.write')
466  CALL write_out(itime,coreprof_iter, coreprof_analytic)
467 ! call perfoff
468 #ifdef UAL
469  if(shot_no.gt.0.and.run_no.ge.0) then
470 ! call perfon ('t.ualw')
471  coreprof_iter(1)%time=time
472  if(itime.eq.1) then
473  write(*,*) 'euitm_put_non_timed: coreprof', coreprof_iter(1)%time, &
474  trim(coreprof_iter(1)%codeparam%codename(1)), &
475  ' ', &
476  trim(coreprof_iter(1)%codeparam%codeversion(1))
477  call euitm_put_non_timed(idx,"coreprof",coreprof_iter(1))
478  endif
479  write(*,*) 'euitm_put_slice: coreprof', coreprof_iter(1)%time
480  call euitm_put_slice(idx,"coreprof",coreprof_iter(1))
481  equilibrium_iter(1)%time=time
482  write(*,*) 'euitm_put_slice: equilibrium', equilibrium_iter(1)%time
483  call euitm_put_slice(idx,"equilibrium",equilibrium_iter(1))
484  coretransp(1)%time=time
485  write(*,*) 'euitm_put_slice: coretransp', coretransp(1)%time
486  call euitm_put_slice(idx,"coretransp",coretransp(1))
487  coresource(1)%time=time
488  write(*,*) 'euitm_put_slice: coresource', coresource(1)%time
489  call euitm_put_slice(idx,"coresource",coresource(1))
490  coreprof_analytic(1)%time=time
491  write(*,*) 'euitm_put_slice: coreprof/1', coreprof_analytic(1)%time
492  call euitm_put_slice(idx,"coreprof/1",coreprof_analytic(1))
493 ! call perfoff
494  endif
495 #endif
496 
497 !
498 ! we need to prepare for the next time-step
499 !
500 ! this involves
501 ! copying current _ITER values to _OLD
502 ! destroying the now unneeded _ITER structures
503 ! destroying the unneeded ANALYTIC solution
504 ! destroying the unneeded CORETRANSP, CORESOURCE and COREIMPUR
505 
506 ! call perfon ('t.copy.o')
507 
508  CALL deallocate_cpo(coreprof_old )
509  call copy_cpo(coreprof_iter,coreprof_old)
510  CALL deallocate_cpo(coreprof_iter )
511  CALL deallocate_cpo(equilibrium_old )
512  call copy_cpo(equilibrium_iter,equilibrium_old)
513  CALL deallocate_cpo(equilibrium_iter )
514  CALL deallocate_cpo(coreprof_analytic)
515  CALL deallocate_cpo(coretransp )
516  CALL deallocate_cpo(coresource )
517  CALL deallocate_cpo(coreimpur )
518 
519 ! call perfoff
520 
521  END DO time_loop1
522 ! call perfoff
523 
524 !
525 ! the computation has finished, we just need to clean up
526 !
527 ! we need to
528 ! deallocate unneeded structures
529 ! finalize any I/O
530 !
531 
532 ! call perfon ('dealloc')
533 
534  CALL deallocate_run_control(control, ifail)
535  CALL deallocate_cpo(equilibrium_old )
536  CALL deallocate_cpo(coreprof_old )
537  call deallocate_cpo(code_parameters )
538  call deallocate_cpo(ets_parameters )
539 ! call perfoff
540 
541 
542 #ifdef UAL
543  if(shot_no.gt.0.and.run_no.ge.0) then
544 ! call perfon ('ualc')
545  call euitm_close(idx)
546 ! call perfoff
547  endif
548 #endif
549 
550 ! call perfoff
551 
552 ! call perfout ('whole')
553 
554 
555 END PROGRAM solver_test
type_analytics
The module declares types of variables used in analytical solution.
Definition: type_analytics.f90:9
itm_test_routines
Module provides routines for testing.
Definition: itm_test_routines.f90:8
itm_test_routines::process_xml
subroutine process_xml(SOLVER_TYPE, SIGMA_SOURCE, TAU, AMIX, CONVREC, NRHO, NION, NIMP, NZIMP, NTIME, NSOL, PSI_BND_TYPE, NI_BND_TYPE, TI_BND_TYPE, TE_BND_TYPE, VTOR_BND_TYPE, shot_no, run_no, codeparam, database_format)
process the xml version of the input file from codeparam
Definition: itm_test_routines.f90:21
solver_test
program solver_test
This routine aimed in testing the solver solution method for the set of transport equations with give...
Definition: solver_test.F90:11
copy_cpo_ets
Module provides routines for copying parts of CPOs (COREPROF and EQUILIBRIUM)
Definition: copy_cpo_ets.f90:8
itm_test_routines::write_out
subroutine write_out(ITIME, COREPROF_NEW, COREPROF_ANALYTIC)
This subroutine stores the results of computations into files.
Definition: itm_test_routines.f90:431
convergence_check::check_convergence
subroutine check_convergence(COREPROF_ITER, COREPROF_NEW, CONTROL_DOUBLE)
Convergence check This routine checks the convergence of plasma profiles.
Definition: convergence_check.f90:22
ets::itm_ets
subroutine itm_ets(COREPROF_OLD, COREPROF_ITER, COREPROF_NEW, EQUILIBRIUM_OLD, EQUILIBRIUM_ITER, CORETRANSP, CORESOURCE, COREIMPUR, CONTROL_INTEGER, CONTROL_DOUBLE, code_parameters)
ETS.
Definition: ets.F90:25
allocate_deallocate::allocate_coreprof_cpo
subroutine allocate_coreprof_cpo(NSLICE, NRHO, NNUCL, NION, NIMP, NZIMP, NNEUT, NTYPE, NCOMP, COREPROF)
This routine allocates COREPROF CPO.
Definition: allocate_deallocate.f90:33
plasma_composition
Definition: plasma_composition.f90:1
ets_plasma::allocate_run_control
subroutine allocate_run_control(CONTROL, ifail)
Allocate parameters required by the run control and iterations loop.
Definition: ets_plasma.f90:1784
ets
Module provides the interface between (external) CPO and internal ETS derived types.
Definition: ets.F90:8
ets_plasma::deallocate_run_control
subroutine deallocate_run_control(CONTROL, ifail)
Deallocate plasma profiles needed by the transport solver.
Definition: ets_plasma.f90:1831
allocate_deallocate
This module contains routines for allocation/deallocation if CPOs used in ETS.
Definition: allocate_deallocate.f90:8
itm_test_routines::set_control
subroutine set_control(SOLVER_TYPE, SIGMA_SOURCE, TAU, AMIX, CONVREC, CONTROL)
setup control structure
Definition: itm_test_routines.f90:381
ets_plasma::run_control
Definition: ets_plasma.f90:426
ets_version
Definition: ets_version.f90:1
plasma_composition::set_plasma_composition
subroutine set_plasma_composition(COREPROF_OUT, NION, NIMP, NNEUT, AMN_ION, ZN_ION, Z_ION, AMN_IMP, ZN_IMP, MAXZ_IMP, NCOMP_IN, NTYPE_IN, NCOLD, NTHERMAL, NFAST, NNBI)
Definition: plasma_composition.f90:6
analyticalplasma
subroutine analyticalplasma(TIME, COREPROF_in, EQUILIBRIUM, COREPROF, CORETRANSP, CORESOURCE, COREIMPUR, code_parameters)
Module to cope with problems in fc2k.
Definition: fc2k_workaround_analytics.f90:17
ets_plasma
The module declares types of variables used in ETS (transport code)
Definition: ets_plasma.f90:8
copy_cpo_ets::copy_boundary_cond
subroutine copy_boundary_cond(COREPROF_IN, COREPROF_OUT)
Definition: copy_cpo_ets.f90:20
analytics1::analytical_plasma
subroutine analytical_plasma(TIME, COREPROF_in, EQUILIBRIUM, COREPROF_ANALYTIC, CORETRANSP, CORESOURCE, COREIMPUR, code_parameters)
This routine manufactures the solution for the set of transport equations describing the main plasma...
Definition: analytics1.f90:25
convergence_check
Module provides the convergence check for the ETS.
Definition: convergence_check.f90:8
euitm_close
subroutine euitm_close(idx)
Definition: euitm_dummies.f90:9
analytics1
Module for manufacture of a test case for the ETS.
Definition: analytics1.f90:8