(git:b195825)
input_section_types.F
Go to the documentation of this file.
1 !--------------------------------------------------------------------------------------------------!
2 ! CP2K: A general program to perform molecular dynamics simulations !
3 ! Copyright 2000-2024 CP2K developers group <https://cp2k.org> !
4 ! !
5 ! SPDX-License-Identifier: GPL-2.0-or-later !
6 !--------------------------------------------------------------------------------------------------!
7 
8 ! **************************************************************************************************
9 !> \brief objects that represent the structure of input sections and the data
10 !> contained in an input section
11 !> \par History
12 !> 06.2004 created [fawzi]
13 !> \author fawzi
14 ! **************************************************************************************************
15 MODULE input_section_types
16 
17  USE cp_linked_list_input, ONLY: &
18  cp_sll_val_create, cp_sll_val_dealloc, cp_sll_val_get_el_at, cp_sll_val_get_length, &
19  cp_sll_val_get_rest, cp_sll_val_insert_el_at, cp_sll_val_next, cp_sll_val_p_type, &
20  cp_sll_val_rm_el_at, cp_sll_val_set_el_at, cp_sll_val_type
21  USE cp_log_handling, ONLY: cp_to_string
22  USE cp_parser_types, ONLY: default_section_character
23  USE input_keyword_types, ONLY: keyword_describe,&
24  keyword_p_type,&
25  keyword_release,&
26  keyword_retain,&
27  keyword_type,&
28  keyword_typo_match,&
29  write_keyword_xml
30  USE input_val_types, ONLY: lchar_t,&
31  no_t,&
32  val_create,&
33  val_duplicate,&
34  val_get,&
35  val_release,&
36  val_type,&
37  val_write
38  USE kinds, ONLY: default_path_length,&
39  default_string_length,&
40  dp
41  USE print_messages, ONLY: print_message
42  USE reference_manager, ONLY: get_citation_key
43  USE string_utilities, ONLY: a2s,&
44  substitute_special_xml_tokens,&
45  typo_match,&
46  uppercase
47 #include "../base/base_uses.f90"
48 
49  IMPLICIT NONE
50  PRIVATE
51 
52  LOGICAL, PRIVATE, PARAMETER :: debug_this_module = .true.
53  CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'input_section_types'
54 
55  PUBLIC :: section_type
56  PUBLIC :: section_create, section_release, section_describe, &
57  section_get_subsection, section_get_keyword, &
58  section_add_keyword, section_add_subsection
59  PUBLIC :: section_get_subsection_index, section_get_keyword_index
60 
61  PUBLIC :: section_vals_type
62  PUBLIC :: section_vals_create, section_vals_retain, section_vals_release, &
63  section_vals_get, section_vals_get_subs_vals, section_vals_val_get, section_vals_list_get, &
64  section_vals_write, section_vals_add_values, section_vals_get_subs_vals2, &
65  section_vals_val_set, section_vals_val_unset, section_vals_get_subs_vals3, &
66  section_vals_set_subs_vals, section_vals_duplicate, section_vals_remove_values
67  PUBLIC :: write_section_xml
68 
69  PUBLIC :: section_get_ival, &
70  section_get_ivals, &
71  section_get_rval, &
72  section_get_lval
73  PUBLIC :: section_typo_match, typo_match_section, typo_matching_rank, typo_matching_line
74 
75 ! **************************************************************************************************
76 !> \brief represent a pointer to a section (to make arrays of pointers)
77 !> \param section the pointer to the section
78 !> \author fawzi
79 ! **************************************************************************************************
80  TYPE section_p_type
81  TYPE(section_type), POINTER :: section => null()
82  END TYPE section_p_type
83 
84 ! **************************************************************************************************
85 !> \brief represent a section of the input file
86 !> \note
87 !> - frozen: if the section has been frozen (and no keyword/subsections
88 !> can be added)
89 !> - repeats: if the section can be repeated more than once in the same
90 !> context
91 !> - ref_count: reference count (see doc/ReferenceCounting.html)
92 !> - n_keywords: the number of keywords in this section
93 !> - name: name of the section
94 !> - location where in the source code (file and line) the section is created
95 !> - description: description of the section
96 !> - citations: references to literature associated to this section
97 !> - keywords: array with the keywords of this section (might be
98 !> oversized)
99 !> - subsections: sections contained in this section
100 !> \author fawzi
101 ! **************************************************************************************************
102  TYPE section_type
103  LOGICAL :: frozen = .false., repeats = .false.
104  INTEGER :: ref_count = 0, n_keywords = 0, n_subsections = 0
105  CHARACTER(len=default_string_length) :: name = ""
106  CHARACTER(len=default_string_length) :: location = ""
107  CHARACTER, DIMENSION(:), POINTER :: description => null()
108  INTEGER, POINTER, DIMENSION(:) :: citations => null()
109  TYPE(keyword_p_type), DIMENSION(:), POINTER :: keywords => null()
110  TYPE(section_p_type), POINTER, DIMENSION(:) :: subsections => null()
111  END TYPE section_type
112 
113 ! **************************************************************************************************
114 !> \brief repesents a pointer to a parsed section (to make arrays of pointers)
115 !> \param section_vals the pointer to the parsed section
116 !> \author fawzi
117 ! **************************************************************************************************
118  TYPE section_vals_p_type
119  TYPE(section_vals_type), POINTER :: section_vals => null()
120  END TYPE section_vals_p_type
121 
122 ! **************************************************************************************************
123 !> \brief stores the values of a section
124 !> \author fawzi
125 ! **************************************************************************************************
126  TYPE section_vals_type
127  INTEGER :: ref_count = 0
128  INTEGER, POINTER, DIMENSION(:) :: ibackup => null()
129  TYPE(section_type), POINTER :: section => null()
130  TYPE(cp_sll_val_p_type), DIMENSION(:, :), POINTER :: values => null()
131  TYPE(section_vals_p_type), DIMENSION(:, :), POINTER :: subs_vals => null()
132  END TYPE section_vals_type
133 
134  TYPE(section_type), POINTER, SAVE :: typo_match_section => null()
135  INTEGER, PARAMETER :: n_typo_matches = 5
136  INTEGER, DIMENSION(n_typo_matches) :: typo_matching_rank = 0
137  CHARACTER(LEN=default_string_length*5), DIMENSION(n_typo_matches):: typo_matching_line = ""
138 
139 CONTAINS
140 
141 ! **************************************************************************************************
142 !> \brief creates a list of keywords
143 !> \param section the list to be created
144 !> \param location from where in the source code section_create() is called
145 !> \param name ...
146 !> \param description ...
147 !> \param n_keywords hint about the number of keywords, defaults to 10
148 !> \param n_subsections a hint about how many sections will be added to this
149 !> structure, defaults to 0
150 !> \param repeats if this section can repeat (defaults to false)
151 !> \param citations ...
152 !> \author fawzi
153 ! **************************************************************************************************
154  SUBROUTINE section_create(section, location, name, description, n_keywords, &
155  n_subsections, repeats, citations)
156 
157  TYPE(section_type), POINTER :: section
158  CHARACTER(len=*), INTENT(in) :: location, name, description
159  INTEGER, INTENT(in), OPTIONAL :: n_keywords, n_subsections
160  LOGICAL, INTENT(in), OPTIONAL :: repeats
161  INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL :: citations
162 
163  INTEGER :: i, my_n_keywords, my_n_subsections, n
164 
165  cpassert(.NOT. ASSOCIATED(section))
166  my_n_keywords = 10
167  IF (PRESENT(n_keywords)) my_n_keywords = n_keywords
168  my_n_subsections = 0
169  IF (PRESENT(n_subsections)) my_n_subsections = n_subsections
170 
171  ALLOCATE (section)
172  section%ref_count = 1
173 
174  section%n_keywords = 0
175  section%n_subsections = 0
176  section%location = location
177 
178  cpassert(len_trim(name) > 0)
179  section%name = name
180  CALL uppercase(section%name)
181 
182  n = len_trim(description)
183  ALLOCATE (section%description(n))
184  DO i = 1, n
185  section%description(i) = description(i:i)
186  END DO
187 
188  section%frozen = .false.
189  section%repeats = .false.
190  IF (PRESENT(repeats)) section%repeats = repeats
191 
192  NULLIFY (section%citations)
193  IF (PRESENT(citations)) THEN
194  ALLOCATE (section%citations(SIZE(citations)))
195  section%citations = citations
196  END IF
197 
198  ALLOCATE (section%keywords(-1:my_n_keywords))
199  DO i = -1, my_n_keywords
200  NULLIFY (section%keywords(i)%keyword)
201  END DO
202 
203  ALLOCATE (section%subsections(my_n_subsections))
204  DO i = 1, my_n_subsections
205  NULLIFY (section%subsections(i)%section)
206  END DO
207 
208  END SUBROUTINE section_create
209 
210 ! **************************************************************************************************
211 !> \brief retains the given keyword list (see doc/ReferenceCounting.html)
212 !> \param section the list to retain
213 !> \author fawzi
214 ! **************************************************************************************************
215  SUBROUTINE section_retain(section)
216 
217  TYPE(section_type), POINTER :: section
218 
219  cpassert(ASSOCIATED(section))
220  cpassert(section%ref_count > 0)
221  section%ref_count = section%ref_count + 1
222 
223  END SUBROUTINE section_retain
224 
225 ! **************************************************************************************************
226 !> \brief releases the given keyword list (see doc/ReferenceCounting.html)
227 !> \param section the list to release
228 !> \author fawzi
229 ! **************************************************************************************************
230  RECURSIVE SUBROUTINE section_release(section)
231 
232  TYPE(section_type), POINTER :: section
233 
234  INTEGER :: i
235 
236  IF (ASSOCIATED(section)) THEN
237  cpassert(section%ref_count > 0)
238  section%ref_count = section%ref_count - 1
239  IF (section%ref_count == 0) THEN
240  IF (ASSOCIATED(section%citations)) THEN
241  DEALLOCATE (section%citations)
242  END IF
243  IF (ASSOCIATED(section%keywords)) THEN
244  DO i = -1, ubound(section%keywords, 1)
245  CALL keyword_release(section%keywords(i)%keyword)
246  END DO
247  DEALLOCATE (section%keywords)
248  END IF
249  section%n_keywords = 0
250  IF (ASSOCIATED(section%subsections)) THEN
251  DO i = 1, SIZE(section%subsections)
252  CALL section_release(section%subsections(i)%section)
253  END DO
254  DEALLOCATE (section%subsections)
255  END IF
256  DEALLOCATE (section%description)
257  DEALLOCATE (section)
258  END IF
259  NULLIFY (section)
260  END IF
261 
262  END SUBROUTINE section_release
263 
264 ! **************************************************************************************************
265 !> \brief collects additional information on the section for IO + documentation
266 !> \param section ...
267 !> \return ...
268 !> \author fawzi
269 ! **************************************************************************************************
270  FUNCTION get_section_info(section) RESULT(message)
271 
272  TYPE(section_type), INTENT(IN) :: section
273  CHARACTER(LEN=default_path_length) :: message
274 
275  INTEGER :: length
276 
277  message = " "
278  length = len_trim(a2s(section%description))
279  IF (length > 0) THEN
280  IF (section%description(length) /= ".") THEN
281  message = "."
282  END IF
283  END IF
284  IF (section%repeats) THEN
285  message = trim(message)//" This section can be repeated."
286  ELSE
287  message = trim(message)//" This section can not be repeated."
288  END IF
289 
290  END FUNCTION get_section_info
291 
292 ! **************************************************************************************************
293 !> \brief prints a description of the given section
294 !> \param section the section to describe
295 !> \param unit_nr the unit to write to
296 !> \param level the level of output: 0: just section name, 1:keywords,
297 !> then see keyword_describe :-)
298 !> \param hide_root if the name of the first section should be hidden
299 !> (defaults to false).
300 !> \param recurse ...
301 !> \author fawzi
302 ! **************************************************************************************************
303  RECURSIVE SUBROUTINE section_describe(section, unit_nr, level, hide_root, recurse)
304 
305  TYPE(section_type), INTENT(IN), POINTER :: section
306  INTEGER, INTENT(in) :: unit_nr, level
307  LOGICAL, INTENT(in), OPTIONAL :: hide_root
308  INTEGER, INTENT(in), OPTIONAL :: recurse
309 
310  CHARACTER(LEN=default_path_length) :: message
311  INTEGER :: ikeyword, isub, my_recurse
312  LOGICAL :: my_hide_root
313 
314  IF (unit_nr > 0) THEN
315  my_hide_root = .false.
316  IF (PRESENT(hide_root)) my_hide_root = hide_root
317  my_recurse = 0
318  IF (PRESENT(recurse)) my_recurse = recurse
319  IF (ASSOCIATED(section)) THEN
320  cpassert(section%ref_count > 0)
321 
322  IF (.NOT. my_hide_root) &
323  WRITE (unit=unit_nr, fmt="('*** section &',A,' ***')") trim(adjustl(section%name))
324  IF (level > 1) THEN
325  message = get_section_info(section)
326  CALL print_message(trim(a2s(section%description))//trim(message), unit_nr, 0, 0, 0)
327  END IF
328  IF (level > 0) THEN
329  IF (ASSOCIATED(section%keywords(-1)%keyword)) THEN
330  CALL keyword_describe(section%keywords(-1)%keyword, unit_nr, &
331  level)
332  END IF
333  IF (ASSOCIATED(section%keywords(0)%keyword)) THEN
334  CALL keyword_describe(section%keywords(0)%keyword, unit_nr, &
335  level)
336  END IF
337  DO ikeyword = 1, section%n_keywords
338  CALL keyword_describe(section%keywords(ikeyword)%keyword, unit_nr, &
339  level)
340  END DO
341  END IF
342  IF (section%n_subsections > 0 .AND. my_recurse >= 0) THEN
343  IF (.NOT. my_hide_root) &
344  WRITE (unit=unit_nr, fmt="('** subsections **')")
345  DO isub = 1, section%n_subsections
346  IF (my_recurse > 0) THEN
347  CALL section_describe(section%subsections(isub)%section, unit_nr, &
348  level, recurse=my_recurse - 1)
349  ELSE
350  WRITE (unit=unit_nr, fmt="(1X,A)") section%subsections(isub)%section%name
351  END IF
352  END DO
353  END IF
354  IF (.NOT. my_hide_root) &
355  WRITE (unit=unit_nr, fmt="('*** &end section ',A,' ***')") trim(adjustl(section%name))
356  ELSE
357  WRITE (unit_nr, "(a)") '<section *null*>'
358  END IF
359  END IF
360 
361  END SUBROUTINE section_describe
362 
363 ! **************************************************************************************************
364 !> \brief returns the index of requested subsection (-1 if not found)
365 !> \param section the root section
366 !> \param subsection_name the name of the subsection you want to get
367 !> \return ...
368 !> \author fawzi
369 !> \note
370 !> private utility function
371 ! **************************************************************************************************
372  FUNCTION section_get_subsection_index(section, subsection_name) RESULT(res)
373 
374  TYPE(section_type), INTENT(IN) :: section
375  CHARACTER(len=*), INTENT(IN) :: subsection_name
376  INTEGER :: res
377 
378  CHARACTER(len=default_string_length) :: upc_name
379  INTEGER :: isub
380 
381  cpassert(section%ref_count > 0)
382  res = -1
383  upc_name = subsection_name
384  CALL uppercase(upc_name)
385  DO isub = 1, section%n_subsections
386  cpassert(ASSOCIATED(section%subsections(isub)%section))
387  IF (section%subsections(isub)%section%name == upc_name) THEN
388  res = isub
389  EXIT
390  END IF
391  END DO
392 
393  END FUNCTION section_get_subsection_index
394 
395 ! **************************************************************************************************
396 !> \brief returns the requested subsection
397 !> \param section the root section
398 !> \param subsection_name the name of the subsection you want to get
399 !> \return ...
400 !> \author fawzi
401 ! **************************************************************************************************
402  FUNCTION section_get_subsection(section, subsection_name) RESULT(res)
403 
404  TYPE(section_type), INTENT(IN) :: section
405  CHARACTER(len=*), INTENT(IN) :: subsection_name
406  TYPE(section_type), POINTER :: res
407 
408  INTEGER :: isub
409 
410  isub = section_get_subsection_index(section, subsection_name)
411  IF (isub > 0) THEN
412  res => section%subsections(isub)%section
413  ELSE
414  NULLIFY (res)
415  END IF
416 
417  END FUNCTION section_get_subsection
418 
419 ! **************************************************************************************************
420 !> \brief returns the index of the requested keyword (or -2 if not found)
421 !> \param section the section the keyword is in
422 !> \param keyword_name the keyword you are interested in
423 !> \return ...
424 !> \author fawzi
425 !> \note
426 !> private utility function
427 ! **************************************************************************************************
428  FUNCTION section_get_keyword_index(section, keyword_name) RESULT(res)
429 
430  TYPE(section_type), INTENT(IN) :: section
431  CHARACTER(len=*), INTENT(IN) :: keyword_name
432  INTEGER :: res
433 
434  INTEGER :: ik, in
435  CHARACTER(len=default_string_length) :: upc_name
436 
437  cpassert(section%ref_count > 0)
438  cpassert(ASSOCIATED(section%keywords))
439  res = -2
440  upc_name = keyword_name
441  CALL uppercase(upc_name)
442  DO ik = -1, 0
443  IF (ASSOCIATED(section%keywords(ik)%keyword)) THEN
444  IF (section%keywords(ik)%keyword%names(1) == upc_name) THEN
445  res = ik
446  END IF
447  END IF
448  END DO
449  IF (res == -2) THEN
450  k_search_loop: DO ik = 1, section%n_keywords
451  cpassert(ASSOCIATED(section%keywords(ik)%keyword))
452  DO in = 1, SIZE(section%keywords(ik)%keyword%names)
453  IF (section%keywords(ik)%keyword%names(in) == upc_name) THEN
454  res = ik
455  EXIT k_search_loop
456  END IF
457  END DO
458  END DO k_search_loop
459  END IF
460 
461  END FUNCTION section_get_keyword_index
462 
463 ! **************************************************************************************************
464 !> \brief returns the requested keyword
465 !> \param section the section the keyword is in
466 !> \param keyword_name the keyword you are interested in
467 !> \return ...
468 !> \author fawzi
469 ! **************************************************************************************************
470  RECURSIVE FUNCTION section_get_keyword(section, keyword_name) RESULT(res)
471 
472  TYPE(section_type), INTENT(IN) :: section
473  CHARACTER(len=*), INTENT(IN) :: keyword_name
474  TYPE(keyword_type), POINTER :: res
475 
476  INTEGER :: ik, my_index
477 
478  IF (index(keyword_name, "%") /= 0) THEN
479  my_index = index(keyword_name, "%") + 1
480  cpassert(ASSOCIATED(section%subsections))
481  DO ik = lbound(section%subsections, 1), ubound(section%subsections, 1)
482  IF (section%subsections(ik)%section%name == keyword_name(1:my_index - 2)) EXIT
483  END DO
484  cpassert(ik <= ubound(section%subsections, 1))
485  res => section_get_keyword(section%subsections(ik)%section, keyword_name(my_index:))
486  ELSE
487  ik = section_get_keyword_index(section, keyword_name)
488  IF (ik == -2) THEN
489  NULLIFY (res)
490  ELSE
491  res => section%keywords(ik)%keyword
492  END IF
493  END IF
494 
495  END FUNCTION section_get_keyword
496 
497 ! **************************************************************************************************
498 !> \brief adds a keyword to the given section
499 !> \param section the section to which the keyword should be added
500 !> \param keyword the keyword to add
501 !> \author fawzi
502 ! **************************************************************************************************
503  SUBROUTINE section_add_keyword(section, keyword)
504 
505  TYPE(section_type), INTENT(INOUT) :: section
506  TYPE(keyword_type), INTENT(IN), POINTER :: keyword
507 
508  INTEGER :: i, j, k
509  TYPE(keyword_p_type), DIMENSION(:), POINTER :: new_keywords
510 
511  cpassert(section%ref_count > 0)
512  cpassert(.NOT. section%frozen)
513  cpassert(ASSOCIATED(keyword))
514  cpassert(keyword%ref_count > 0)
515  CALL keyword_retain(keyword)
516  IF (keyword%names(1) == "_SECTION_PARAMETERS_") THEN
517  CALL keyword_release(section%keywords(-1)%keyword)
518  section%keywords(-1)%keyword => keyword
519  ELSE IF (keyword%names(1) == "_DEFAULT_KEYWORD_") THEN
520  CALL keyword_release(section%keywords(0)%keyword)
521  section%keywords(0)%keyword => keyword
522  ELSE
523  DO k = 1, SIZE(keyword%names)
524  DO i = 1, section%n_keywords
525  DO j = 1, SIZE(section%keywords(i)%keyword%names)
526  IF (keyword%names(k) == section%keywords(i)%keyword%names(j)) THEN
527  CALL cp_abort(__location__, &
528  "trying to add a keyword with a name ("// &
529  trim(keyword%names(k))//") that was already used in section " &
530  //trim(section%name))
531  END IF
532  END DO
533  END DO
534  END DO
535 
536  IF (ubound(section%keywords, 1) == section%n_keywords) THEN
537  ALLOCATE (new_keywords(-1:section%n_keywords + 10))
538  DO i = -1, section%n_keywords
539  new_keywords(i)%keyword => section%keywords(i)%keyword
540  END DO
541  DO i = section%n_keywords + 1, ubound(new_keywords, 1)
542  NULLIFY (new_keywords(i)%keyword)
543  END DO
544  DEALLOCATE (section%keywords)
545  section%keywords => new_keywords
546  END IF
547  section%n_keywords = section%n_keywords + 1
548  section%keywords(section%n_keywords)%keyword => keyword
549  END IF
550 
551  END SUBROUTINE section_add_keyword
552 
553 ! **************************************************************************************************
554 !> \brief adds a subsection to the given section
555 !> \param section to section to which you want to add a subsection
556 !> \param subsection the subsection to add
557 !> \author fawzi
558 ! **************************************************************************************************
559  SUBROUTINE section_add_subsection(section, subsection)
560 
561  TYPE(section_type), INTENT(INOUT) :: section
562  TYPE(section_type), INTENT(IN), POINTER :: subsection
563 
564  INTEGER :: i
565  TYPE(section_p_type), DIMENSION(:), POINTER :: new_subsections
566 
567  cpassert(section%ref_count > 0)
568  cpassert(ASSOCIATED(subsection))
569  cpassert(subsection%ref_count > 0)
570  IF (SIZE(section%subsections) < section%n_subsections + 1) THEN
571  ALLOCATE (new_subsections(section%n_subsections + 10))
572  DO i = 1, section%n_subsections
573  new_subsections(i)%section => section%subsections(i)%section
574  END DO
575  DO i = section%n_subsections + 1, SIZE(new_subsections)
576  NULLIFY (new_subsections(i)%section)
577  END DO
578  DEALLOCATE (section%subsections)
579  section%subsections => new_subsections
580  END IF
581  DO i = 1, section%n_subsections
582  IF (subsection%name == section%subsections(i)%section%name) &
583  CALL cp_abort(__location__, &
584  "trying to add a subsection with a name ("// &
585  trim(subsection%name)//") that was already used in section " &
586  //trim(section%name))
587  END DO
588  CALL section_retain(subsection)
589  section%n_subsections = section%n_subsections + 1
590  section%subsections(section%n_subsections)%section => subsection
591 
592  END SUBROUTINE section_add_subsection
593 
594 ! **************************************************************************************************
595 !> \brief creates a object where to store the values of a section
596 !> \param section_vals the parsed section that will be created
597 !> \param section the structure of the section that you want to parse
598 !> \author fawzi
599 ! **************************************************************************************************
600  RECURSIVE SUBROUTINE section_vals_create(section_vals, section)
601 
602  TYPE(section_vals_type), POINTER :: section_vals
603  TYPE(section_type), POINTER :: section
604 
605  INTEGER :: i
606 
607  cpassert(.NOT. ASSOCIATED(section_vals))
608  ALLOCATE (section_vals)
609  section_vals%ref_count = 1
610  CALL section_retain(section)
611  section_vals%section => section
612  section%frozen = .true.
613  ALLOCATE (section_vals%values(-1:section%n_keywords, 0))
614  ALLOCATE (section_vals%subs_vals(section%n_subsections, 1))
615  DO i = 1, section%n_subsections
616  NULLIFY (section_vals%subs_vals(i, 1)%section_vals)
617  CALL section_vals_create(section_vals%subs_vals(i, 1)%section_vals, &
618  section=section%subsections(i)%section)
619  END DO
620 
621  NULLIFY (section_vals%ibackup)
622 
623  END SUBROUTINE section_vals_create
624 
625 ! **************************************************************************************************
626 !> \brief retains the given section values (see doc/ReferenceCounting.html)
627 !> \param section_vals the object to retain
628 !> \author fawzi
629 ! **************************************************************************************************
630  SUBROUTINE section_vals_retain(section_vals)
631 
632  TYPE(section_vals_type), POINTER :: section_vals
633 
634  cpassert(ASSOCIATED(section_vals))
635  cpassert(section_vals%ref_count > 0)
636  section_vals%ref_count = section_vals%ref_count + 1
637 
638  END SUBROUTINE section_vals_retain
639 
640 ! **************************************************************************************************
641 !> \brief releases the given object
642 !> \param section_vals the section_vals to release
643 !> \author fawzi
644 ! **************************************************************************************************
645  RECURSIVE SUBROUTINE section_vals_release(section_vals)
646 
647  TYPE(section_vals_type), POINTER :: section_vals
648 
649  INTEGER :: i, j
650  TYPE(cp_sll_val_type), POINTER :: vals
651  TYPE(val_type), POINTER :: el
652 
653  IF (ASSOCIATED(section_vals)) THEN
654  cpassert(section_vals%ref_count > 0)
655  section_vals%ref_count = section_vals%ref_count - 1
656  IF (section_vals%ref_count == 0) THEN
657  CALL section_release(section_vals%section)
658  DO j = 1, SIZE(section_vals%values, 2)
659  DO i = -1, ubound(section_vals%values, 1)
660  vals => section_vals%values(i, j)%list
661  DO WHILE (cp_sll_val_next(vals, el_att=el))
662  CALL val_release(el)
663  END DO
664  CALL cp_sll_val_dealloc(section_vals%values(i, j)%list)
665  END DO
666  END DO
667  DEALLOCATE (section_vals%values)
668  DO j = 1, SIZE(section_vals%subs_vals, 2)
669  DO i = 1, SIZE(section_vals%subs_vals, 1)
670  CALL section_vals_release(section_vals%subs_vals(i, j)%section_vals)
671  END DO
672  END DO
673  DEALLOCATE (section_vals%subs_vals)
674  IF (ASSOCIATED(section_vals%ibackup)) THEN
675  DEALLOCATE (section_vals%ibackup)
676  END IF
677  DEALLOCATE (section_vals)
678  END IF
679  END IF
680 
681  END SUBROUTINE section_vals_release
682 
683 ! **************************************************************************************************
684 !> \brief returns various attributes about the section_vals
685 !> \param section_vals the section vals you want information from
686 !> \param ref_count ...
687 !> \param n_repetition number of repetitions of the section
688 !> \param n_subs_vals_rep number of repetitions of the subsections values
689 !> (max(1,n_repetition))
690 !> \param section ...
691 !> \param explicit if the section was explicitly present in
692 !> \author fawzi
693 !> \note For the other arguments see the attributes of section_vals_type
694 ! **************************************************************************************************
695  SUBROUTINE section_vals_get(section_vals, ref_count, n_repetition, &
696  n_subs_vals_rep, section, explicit)
697 
698  TYPE(section_vals_type), INTENT(IN) :: section_vals
699  INTEGER, INTENT(out), OPTIONAL :: ref_count, n_repetition, n_subs_vals_rep
700  TYPE(section_type), OPTIONAL, POINTER :: section
701  LOGICAL, INTENT(out), OPTIONAL :: explicit
702 
703  cpassert(section_vals%ref_count > 0)
704  IF (PRESENT(ref_count)) ref_count = section_vals%ref_count
705  IF (PRESENT(section)) section => section_vals%section
706  IF (PRESENT(n_repetition)) n_repetition = SIZE(section_vals%values, 2)
707  IF (PRESENT(n_subs_vals_rep)) n_subs_vals_rep = SIZE(section_vals%subs_vals, 2)
708  IF (PRESENT(explicit)) explicit = (SIZE(section_vals%values, 2) > 0)
709 
710  END SUBROUTINE section_vals_get
711 
712 ! **************************************************************************************************
713 !> \brief returns the values of the requested subsection
714 !> \param section_vals the root section
715 !> \param subsection_name the name of the requested subsection
716 !> \param i_rep_section index of the repetition of section_vals from which
717 !> you want to extract the subsection (defaults to 1)
718 !> \param can_return_null if the results can be null (defaults to false)
719 !> \return ...
720 !> \author fawzi
721 ! **************************************************************************************************
722  RECURSIVE FUNCTION section_vals_get_subs_vals(section_vals, subsection_name, &
723  i_rep_section, can_return_null) RESULT(res)
724 
725  TYPE(section_vals_type), INTENT(IN) :: section_vals
726  CHARACTER(len=*), INTENT(IN) :: subsection_name
727  INTEGER, INTENT(IN), OPTIONAL :: i_rep_section
728  LOGICAL, INTENT(IN), OPTIONAL :: can_return_null
729  TYPE(section_vals_type), POINTER :: res
730 
731  INTEGER :: irep, isection, my_index
732  LOGICAL :: is_path, my_can_return_null
733 
734  cpassert(section_vals%ref_count > 0)
735 
736  my_can_return_null = .false.
737  IF (PRESENT(can_return_null)) my_can_return_null = can_return_null
738  NULLIFY (res)
739  irep = 1
740  IF (PRESENT(i_rep_section)) irep = i_rep_section
741 
742  ! prepare for recursive parsing of subsections. i_rep_section will be used for last section
743  my_index = index(subsection_name, "%")
744  IF (my_index .EQ. 0) THEN
745  is_path = .false.
746  my_index = len_trim(subsection_name)
747  ELSE
748  is_path = .true.
749  irep = 1
750  my_index = my_index - 1
751  END IF
752 
753  cpassert(irep <= SIZE(section_vals%subs_vals, 2))
754 
755  isection = section_get_subsection_index(section_vals%section, subsection_name(1:my_index))
756  IF (isection > 0) res => section_vals%subs_vals(isection, irep)%section_vals
757  IF (.NOT. (ASSOCIATED(res) .OR. my_can_return_null)) &
758  CALL cp_abort(__location__, &
759  "could not find subsection "//trim(subsection_name(1:my_index))//" in section "// &
760  trim(section_vals%section%name)//" at ")
761  IF (is_path .AND. ASSOCIATED(res)) THEN
762  res => section_vals_get_subs_vals(res, subsection_name(my_index + 2:len_trim(subsection_name)), &
763  i_rep_section, can_return_null)
764  END IF
765 
766  END FUNCTION section_vals_get_subs_vals
767 
768 ! **************************************************************************************************
769 !> \brief returns the values of the n-th non default subsection (null if no
770 !> such section exists (not so many non default section))
771 !> \param section_vals the root section
772 !> \param i_section index of the section
773 !> \param i_rep_section index of the repetition of section_vals from which
774 !> you want to extract the subsection (defaults to 1)
775 !> \return ...
776 !> \author fawzi
777 ! **************************************************************************************************
778  FUNCTION section_vals_get_subs_vals2(section_vals, i_section, i_rep_section) RESULT(res)
779 
780  TYPE(section_vals_type), POINTER :: section_vals
781  INTEGER, INTENT(in) :: i_section
782  INTEGER, INTENT(in), OPTIONAL :: i_rep_section
783  TYPE(section_vals_type), POINTER :: res
784 
785  INTEGER :: i, irep, isect_att
786 
787  cpassert(ASSOCIATED(section_vals))
788  cpassert(section_vals%ref_count > 0)
789  NULLIFY (res)
790  irep = 1
791  IF (PRESENT(i_rep_section)) irep = i_rep_section
792  cpassert(irep <= SIZE(section_vals%subs_vals, 2))
793  isect_att = 0
794  DO i = 1, section_vals%section%n_subsections
795  IF (SIZE(section_vals%subs_vals(i, irep)%section_vals%values, 2) > 0) THEN
796  isect_att = isect_att + 1
797  IF (isect_att == i_section) THEN
798  res => section_vals%subs_vals(i, irep)%section_vals
799  EXIT
800  END IF
801  END IF
802  END DO
803  END FUNCTION section_vals_get_subs_vals2
804 
805 ! **************************************************************************************************
806 !> \brief returns the values of the n-th non default subsection (null if no
807 !> such section exists (not so many non default section))
808 !> \param section_vals the root section
809 !> \param subsection_name ...
810 !> \param i_rep_section index of the repetition of section_vals from which
811 !> you want to extract the subsection (defaults to 1)
812 !> \return ...
813 !> \author fawzi
814 ! **************************************************************************************************
815  FUNCTION section_vals_get_subs_vals3(section_vals, subsection_name, &
816  i_rep_section) RESULT(res)
817 
818  TYPE(section_vals_type), INTENT(IN) :: section_vals
819  CHARACTER(LEN=*), INTENT(IN) :: subsection_name
820  INTEGER, INTENT(in), OPTIONAL :: i_rep_section
821  TYPE(section_vals_type), POINTER :: res
822 
823  INTEGER :: i_section, irep
824 
825  cpassert(section_vals%ref_count > 0)
826  NULLIFY (res)
827  irep = 1
828  IF (PRESENT(i_rep_section)) irep = i_rep_section
829  cpassert(irep <= SIZE(section_vals%subs_vals, 2))
830  i_section = section_get_subsection_index(section_vals%section, subsection_name)
831  res => section_vals%subs_vals(i_section, irep)%section_vals
832 
833  END FUNCTION section_vals_get_subs_vals3
834 
835 ! **************************************************************************************************
836 !> \brief adds the place to store the values of a repetition of the section
837 !> \param section_vals the section you want to extend
838 !> \author fawzi
839 ! **************************************************************************************************
840  SUBROUTINE section_vals_add_values(section_vals)
841 
842  TYPE(section_vals_type), INTENT(INOUT) :: section_vals
843 
844  INTEGER :: i, j
845  TYPE(cp_sll_val_p_type), DIMENSION(:, :), POINTER :: new_values
846  TYPE(section_vals_p_type), DIMENSION(:, :), &
847  POINTER :: new_sps
848 
849  cpassert(section_vals%ref_count > 0)
850  ALLOCATE (new_values(-1:ubound(section_vals%values, 1), SIZE(section_vals%values, 2) + 1))
851  DO j = 1, SIZE(section_vals%values, 2)
852  DO i = -1, ubound(section_vals%values, 1)
853  new_values(i, j)%list => section_vals%values(i, j)%list
854  END DO
855  END DO
856  DEALLOCATE (section_vals%values)
857  section_vals%values => new_values
858  j = SIZE(new_values, 2)
859  DO i = -1, ubound(new_values, 1)
860  NULLIFY (new_values(i, j)%list)
861  END DO
862 
863  IF (SIZE(new_values, 2) > 1) THEN
864  ALLOCATE (new_sps(SIZE(section_vals%subs_vals, 1), &
865  SIZE(section_vals%subs_vals, 2) + 1))
866  DO j = 1, SIZE(section_vals%subs_vals, 2)
867  DO i = 1, SIZE(section_vals%subs_vals, 1)
868  new_sps(i, j)%section_vals => section_vals%subs_vals(i, j)%section_vals
869  END DO
870  END DO
871  DEALLOCATE (section_vals%subs_vals)
872  section_vals%subs_vals => new_sps
873  j = SIZE(new_sps, 2)
874  DO i = 1, SIZE(new_sps, 1)
875  NULLIFY (new_sps(i, j)%section_vals)
876  CALL section_vals_create(new_sps(i, SIZE(new_sps, 2))%section_vals, &
877  section=section_vals%section%subsections(i)%section)
878  END DO
879  END IF
880 
881  END SUBROUTINE section_vals_add_values
882 
883 ! **************************************************************************************************
884 !> \brief removes the values of a repetition of the section
885 !> \param section_vals the section you want to extend
886 !> \author fawzi
887 ! **************************************************************************************************
888  SUBROUTINE section_vals_remove_values(section_vals)
889 
890  TYPE(section_vals_type), POINTER :: section_vals
891 
892  INTEGER :: i, j
893  TYPE(cp_sll_val_p_type), DIMENSION(:, :), POINTER :: new_values
894  TYPE(cp_sll_val_type), POINTER :: vals
895  TYPE(val_type), POINTER :: el
896 
897  IF (ASSOCIATED(section_vals)) THEN
898  cpassert(section_vals%ref_count > 0)
899  NULLIFY (el, vals)
900  ! Allocate a null 0 dimension array of values
901  ALLOCATE (new_values(-1:section_vals%section%n_keywords, 0))
902  ! Release old values
903  DO j = 1, SIZE(section_vals%values, 2)
904  DO i = -1, ubound(section_vals%values, 1)
905  vals => section_vals%values(i, j)%list
906  DO WHILE (cp_sll_val_next(vals, el_att=el))
907  CALL val_release(el)
908  END DO
909  CALL cp_sll_val_dealloc(section_vals%values(i, j)%list)
910  END DO
911  END DO
912  DEALLOCATE (section_vals%values)
913  section_vals%values => new_values
914  END IF
915 
916  END SUBROUTINE section_vals_remove_values
917 
918 ! **************************************************************************************************
919 !> \brief ...
920 !> \param section_vals ...
921 !> \param keyword_name ...
922 !> \return ...
923 ! **************************************************************************************************
924  FUNCTION section_get_cval(section_vals, keyword_name) RESULT(res)
925 
926  TYPE(section_vals_type), INTENT(IN) :: section_vals
927  CHARACTER(len=*), INTENT(in) :: keyword_name
928  CHARACTER(LEN=default_string_length) :: res
929 
930  CALL section_vals_val_get(section_vals, keyword_name, c_val=res)
931 
932  END FUNCTION section_get_cval
933 
934 ! **************************************************************************************************
935 !> \brief ...
936 !> \param section_vals ...
937 !> \param keyword_name ...
938 !> \return ...
939 ! **************************************************************************************************
940  FUNCTION section_get_rval(section_vals, keyword_name) RESULT(res)
941 
942  TYPE(section_vals_type), INTENT(IN) :: section_vals
943  CHARACTER(len=*), INTENT(in) :: keyword_name
944  REAL(kind=dp) :: res
945 
946  CALL section_vals_val_get(section_vals, keyword_name, r_val=res)
947 
948  END FUNCTION section_get_rval
949 
950 ! **************************************************************************************************
951 !> \brief ...
952 !> \param section_vals ...
953 !> \param keyword_name ...
954 !> \return ...
955 ! **************************************************************************************************
956  FUNCTION section_get_rvals(section_vals, keyword_name) RESULT(res)
957 
958  TYPE(section_vals_type), INTENT(IN) :: section_vals
959  CHARACTER(len=*), INTENT(in) :: keyword_name
960  REAL(kind=dp), DIMENSION(:), POINTER :: res
961 
962  CALL section_vals_val_get(section_vals, keyword_name, r_vals=res)
963 
964  END FUNCTION section_get_rvals
965 
966 ! **************************************************************************************************
967 !> \brief ...
968 !> \param section_vals ...
969 !> \param keyword_name ...
970 !> \return ...
971 ! **************************************************************************************************
972  FUNCTION section_get_ival(section_vals, keyword_name) RESULT(res)
973 
974  TYPE(section_vals_type), INTENT(IN) :: section_vals
975  CHARACTER(len=*), INTENT(in) :: keyword_name
976  INTEGER :: res
977 
978  CALL section_vals_val_get(section_vals, keyword_name, i_val=res)
979 
980  END FUNCTION section_get_ival
981 
982 ! **************************************************************************************************
983 !> \brief ...
984 !> \param section_vals ...
985 !> \param keyword_name ...
986 !> \return ...
987 ! **************************************************************************************************
988  FUNCTION section_get_ivals(section_vals, keyword_name) RESULT(res)
989 
990  TYPE(section_vals_type), INTENT(IN) :: section_vals
991  CHARACTER(len=*), INTENT(in) :: keyword_name
992  INTEGER, DIMENSION(:), POINTER :: res
993 
994  CALL section_vals_val_get(section_vals, keyword_name, i_vals=res)
995 
996  END FUNCTION section_get_ivals
997 
998 ! **************************************************************************************************
999 !> \brief ...
1000 !> \param section_vals ...
1001 !> \param keyword_name ...
1002 !> \return ...
1003 ! **************************************************************************************************
1004  FUNCTION section_get_lval(section_vals, keyword_name) RESULT(res)
1005 
1006  TYPE(section_vals_type), INTENT(IN) :: section_vals
1007  CHARACTER(len=*), INTENT(in) :: keyword_name
1008  LOGICAL :: res
1009 
1010  CALL section_vals_val_get(section_vals, keyword_name, l_val=res)
1011 
1012  END FUNCTION section_get_lval
1013 
1014 ! **************************************************************************************************
1015 !> \brief returns the requested value
1016 !> \param section_vals ...
1017 !> \param keyword_name the name of the keyword you want
1018 !> \param i_rep_section which repetition of the section you are interested in
1019 !> (defaults to 1)
1020 !> \param i_rep_val which repetition of the keyword/val you are interested in
1021 !> (defaults to 1)
1022 !> \param n_rep_val returns number of val available
1023 !> \param val ...
1024 !> \param l_val ,i_val,r_val,c_val: returns the logical,integer,real or
1025 !> character value
1026 !> \param i_val ...
1027 !> \param r_val ...
1028 !> \param c_val ...
1029 !> \param l_vals ,i_vals,r_vals,c_vals: returns the logical,integer,real or
1030 !> character arrays. The val reamins the owner of the array
1031 !> \param i_vals ...
1032 !> \param r_vals ...
1033 !> \param c_vals ...
1034 !> \param explicit ...
1035 !> \author fawzi
1036 ! **************************************************************************************************
1037  SUBROUTINE section_vals_val_get(section_vals, keyword_name, i_rep_section, &
1038  i_rep_val, n_rep_val, val, l_val, i_val, r_val, c_val, l_vals, i_vals, r_vals, &
1039  c_vals, explicit)
1040 
1041  TYPE(section_vals_type), INTENT(IN), TARGET :: section_vals
1042  CHARACTER(len=*), INTENT(in) :: keyword_name
1043  INTEGER, INTENT(in), OPTIONAL :: i_rep_section, i_rep_val
1044  INTEGER, INTENT(out), OPTIONAL :: n_rep_val
1045  TYPE(val_type), OPTIONAL, POINTER :: val
1046  LOGICAL, INTENT(out), OPTIONAL :: l_val
1047  INTEGER, INTENT(out), OPTIONAL :: i_val
1048  REAL(kind=dp), INTENT(out), OPTIONAL :: r_val
1049  CHARACTER(LEN=*), INTENT(out), OPTIONAL :: c_val
1050  LOGICAL, DIMENSION(:), OPTIONAL, POINTER :: l_vals
1051  INTEGER, DIMENSION(:), OPTIONAL, POINTER :: i_vals
1052  REAL(kind=dp), DIMENSION(:), OPTIONAL, POINTER :: r_vals
1053  CHARACTER(LEN=default_string_length), &
1054  DIMENSION(:), OPTIONAL, POINTER :: c_vals
1055  LOGICAL, INTENT(out), OPTIONAL :: explicit
1056 
1057  INTEGER :: ik, irk, irs, len_key, my_index, &
1058  tmp_index
1059  LOGICAL :: valrequested
1060  TYPE(cp_sll_val_type), POINTER :: vals
1061  TYPE(keyword_type), POINTER :: keyword
1062  TYPE(section_type), POINTER :: section
1063  TYPE(section_vals_type), POINTER :: s_vals
1064  TYPE(val_type), POINTER :: my_val
1065 
1066  cpassert(section_vals%ref_count > 0)
1067 
1068  my_index = index(keyword_name, '%') + 1
1069  len_key = len_trim(keyword_name)
1070  IF (my_index > 1) THEN
1071  DO
1072  tmp_index = index(keyword_name(my_index:len_key), "%")
1073  IF (tmp_index <= 0) EXIT
1074  my_index = my_index + tmp_index
1075  END DO
1076  s_vals => section_vals_get_subs_vals(section_vals, keyword_name(1:my_index - 2))
1077  ELSE
1078  s_vals => section_vals
1079  END IF
1080 
1081  irk = 1
1082  irs = 1
1083  IF (PRESENT(i_rep_section)) irs = i_rep_section
1084  IF (PRESENT(i_rep_val)) irk = i_rep_val
1085  IF (PRESENT(val)) NULLIFY (val)
1086  IF (PRESENT(explicit)) explicit = .false.
1087  section => s_vals%section
1088  valrequested = PRESENT(l_val) .OR. PRESENT(i_val) .OR. PRESENT(r_val) .OR. &
1089  PRESENT(c_val) .OR. PRESENT(l_vals) .OR. PRESENT(i_vals) .OR. &
1090  PRESENT(r_vals) .OR. PRESENT(c_vals)
1091  ik = section_get_keyword_index(s_vals%section, keyword_name(my_index:len_key))
1092  IF (ik == -2) &
1093  CALL cp_abort(__location__, &
1094  "section "//trim(section%name)//" does not contain keyword "// &
1095  trim(keyword_name(my_index:len_key)))
1096  keyword => section%keywords(ik)%keyword
1097  IF (.NOT. (irs > 0 .AND. irs <= SIZE(s_vals%subs_vals, 2))) &
1098  CALL cp_abort(__location__, &
1099  "section repetition requested ("//cp_to_string(irs)// &
1100  ") out of bounds (1:"//cp_to_string(SIZE(s_vals%subs_vals, 2)) &
1101  //")")
1102  NULLIFY (my_val)
1103  IF (PRESENT(n_rep_val)) n_rep_val = 0
1104  IF (irs <= SIZE(s_vals%values, 2)) THEN ! the section was parsed
1105  vals => s_vals%values(ik, irs)%list
1106  IF (PRESENT(n_rep_val)) n_rep_val = cp_sll_val_get_length(vals)
1107  IF (.NOT. ASSOCIATED(vals)) THEN
1108  ! this keyword was not parsed
1109  IF (ASSOCIATED(keyword%default_value)) THEN
1110  my_val => keyword%default_value
1111  IF (PRESENT(n_rep_val)) n_rep_val = 1
1112  END IF
1113  ELSE
1114  my_val => cp_sll_val_get_el_at(s_vals%values(ik, irs)%list, &
1115  irk)
1116  IF (PRESENT(explicit)) explicit = .true.
1117  END IF
1118  ELSE IF (ASSOCIATED(keyword%default_value)) THEN
1119  IF (PRESENT(n_rep_val)) n_rep_val = 1
1120  my_val => keyword%default_value
1121  END IF
1122  IF (PRESENT(val)) val => my_val
1123  IF (valrequested) THEN
1124  IF (.NOT. ASSOCIATED(my_val)) &
1125  CALL cp_abort(__location__, &
1126  "Value requested, but no value set getting value from "// &
1127  "keyword "//trim(keyword_name(my_index:len_key))//" of section "// &
1128  trim(section%name))
1129  CALL val_get(my_val, l_val=l_val, i_val=i_val, r_val=r_val, &
1130  c_val=c_val, l_vals=l_vals, i_vals=i_vals, r_vals=r_vals, &
1131  c_vals=c_vals)
1132  END IF
1133 
1134  END SUBROUTINE section_vals_val_get
1135 
1136 ! **************************************************************************************************
1137 !> \brief returns the requested list
1138 !> \param section_vals ...
1139 !> \param keyword_name the name of the keyword you want
1140 !> \param i_rep_section which repetition of the section you are interested in
1141 !> (defaults to 1)
1142 !> \param list ...
1143 !> \author Joost VandeVondele
1144 !> \note
1145 !> - most useful if the full list is needed anyway, so that faster iteration can be used
1146 ! **************************************************************************************************
1147  SUBROUTINE section_vals_list_get(section_vals, keyword_name, i_rep_section, &
1148  list)
1149 
1150  TYPE(section_vals_type), INTENT(IN), POINTER :: section_vals
1151  CHARACTER(len=*), INTENT(in) :: keyword_name
1152  INTEGER, OPTIONAL :: i_rep_section
1153  TYPE(cp_sll_val_type), POINTER :: list
1154 
1155  INTEGER :: ik, irs, len_key, my_index, tmp_index
1156  TYPE(section_type), POINTER :: section
1157  TYPE(section_vals_type), POINTER :: s_vals
1158 
1159  cpassert(ASSOCIATED(section_vals))
1160  cpassert(section_vals%ref_count > 0)
1161  NULLIFY (list)
1162  my_index = index(keyword_name, '%') + 1
1163  len_key = len_trim(keyword_name)
1164  IF (my_index > 1) THEN
1165  DO
1166  tmp_index = index(keyword_name(my_index:len_key), "%")
1167  IF (tmp_index <= 0) EXIT
1168  my_index = my_index + tmp_index
1169  END DO
1170  s_vals => section_vals_get_subs_vals(section_vals, keyword_name(1:my_index - 2))
1171  ELSE
1172  s_vals => section_vals
1173  END IF
1174 
1175  irs = 1
1176  IF (PRESENT(i_rep_section)) irs = i_rep_section
1177  section => s_vals%section
1178  ik = section_get_keyword_index(s_vals%section, keyword_name(my_index:len_key))
1179  IF (ik == -2) &
1180  CALL cp_abort(__location__, &
1181  "section "//trim(section%name)//" does not contain keyword "// &
1182  trim(keyword_name(my_index:len_key)))
1183  IF (.NOT. (irs > 0 .AND. irs <= SIZE(s_vals%subs_vals, 2))) &
1184  CALL cp_abort(__location__, &
1185  "section repetition requested ("//cp_to_string(irs)// &
1186  ") out of bounds (1:"//cp_to_string(SIZE(s_vals%subs_vals, 2)) &
1187  //")")
1188  list => s_vals%values(ik, irs)%list
1189 
1190  END SUBROUTINE section_vals_list_get
1191 
1192 ! **************************************************************************************************
1193 !> \brief sets the requested value
1194 !> \param section_vals ...
1195 !> \param keyword_name the name of the keyword you want (can be a path
1196 !> separated by '%')
1197 !> \param i_rep_section isection which repetition of the section you are
1198 !> nterested in (defaults to 1)
1199 !> \param i_rep_val which repetition of the keyword/val you are interested in
1200 !> (defaults to 1)
1201 !> \param val ...
1202 !> \param l_val ,i_val,r_val,c_val: sets the logical,integer,real or
1203 !> character value
1204 !> \param i_val ...
1205 !> \param r_val ...
1206 !> \param c_val ...
1207 !> \param l_vals_ptr ,i_vals_ptr,r_vals,c_vals: sets the logical,integer,real or
1208 !> character arrays. The val becomes the owner of the array
1209 !> \param i_vals_ptr ...
1210 !> \param r_vals_ptr ...
1211 !> \param c_vals_ptr ...
1212 !> \author fawzi
1213 ! **************************************************************************************************
1214  SUBROUTINE section_vals_val_set(section_vals, keyword_name, i_rep_section, i_rep_val, &
1215  val, l_val, i_val, r_val, c_val, l_vals_ptr, i_vals_ptr, r_vals_ptr, c_vals_ptr)
1216 
1217  TYPE(section_vals_type), POINTER :: section_vals
1218  CHARACTER(len=*), INTENT(in) :: keyword_name
1219  INTEGER, INTENT(in), OPTIONAL :: i_rep_section, i_rep_val
1220  TYPE(val_type), OPTIONAL, POINTER :: val
1221  LOGICAL, INTENT(in), OPTIONAL :: l_val
1222  INTEGER, INTENT(in), OPTIONAL :: i_val
1223  REAL(kind=dp), INTENT(in), OPTIONAL :: r_val
1224  CHARACTER(LEN=*), INTENT(in), OPTIONAL :: c_val
1225  LOGICAL, DIMENSION(:), OPTIONAL, POINTER :: l_vals_ptr
1226  INTEGER, DIMENSION(:), OPTIONAL, POINTER :: i_vals_ptr
1227  REAL(kind=dp), DIMENSION(:), OPTIONAL, POINTER :: r_vals_ptr
1228  CHARACTER(LEN=default_string_length), &
1229  DIMENSION(:), OPTIONAL, POINTER :: c_vals_ptr
1230 
1231  INTEGER :: ik, irk, irs, len_key, my_index, &
1232  tmp_index
1233  LOGICAL :: valset
1234  TYPE(cp_sll_val_type), POINTER :: vals
1235  TYPE(keyword_type), POINTER :: keyword
1236  TYPE(section_type), POINTER :: section
1237  TYPE(section_vals_type), POINTER :: s_vals
1238  TYPE(val_type), POINTER :: my_val, old_val
1239 
1240  cpassert(ASSOCIATED(section_vals))
1241  cpassert(section_vals%ref_count > 0)
1242 
1243  my_index = index(keyword_name, '%') + 1
1244  len_key = len_trim(keyword_name)
1245  IF (my_index > 1) THEN
1246  DO
1247  tmp_index = index(keyword_name(my_index:len_key), "%")
1248  IF (tmp_index <= 0) EXIT
1249  my_index = my_index + tmp_index
1250  END DO
1251  s_vals => section_vals_get_subs_vals(section_vals, keyword_name(1:my_index - 2))
1252  ELSE
1253  s_vals => section_vals
1254  END IF
1255 
1256  irk = 1
1257  irs = 1
1258  IF (PRESENT(i_rep_section)) irs = i_rep_section
1259  IF (PRESENT(i_rep_val)) irk = i_rep_val
1260  section => s_vals%section
1261  ik = section_get_keyword_index(s_vals%section, keyword_name(my_index:len_key))
1262  IF (ik == -2) &
1263  CALL cp_abort(__location__, &
1264  "section "//trim(section%name)//" does not contain keyword "// &
1265  trim(keyword_name(my_index:len_key)))
1266  ! Add values..
1267  DO
1268  IF (irs <= SIZE(s_vals%values, 2)) EXIT
1269  CALL section_vals_add_values(s_vals)
1270  END DO
1271  IF (.NOT. (irs > 0 .AND. irs <= SIZE(s_vals%subs_vals, 2))) &
1272  CALL cp_abort(__location__, &
1273  "section repetition requested ("//cp_to_string(irs)// &
1274  ") out of bounds (1:"//cp_to_string(SIZE(s_vals%subs_vals, 2)) &
1275  //")")
1276  keyword => s_vals%section%keywords(ik)%keyword
1277  NULLIFY (my_val)
1278  IF (PRESENT(val)) my_val => val
1279  valset = PRESENT(l_val) .OR. PRESENT(i_val) .OR. PRESENT(r_val) .OR. &
1280  PRESENT(c_val) .OR. PRESENT(l_vals_ptr) .OR. PRESENT(i_vals_ptr) .OR. &
1281  PRESENT(r_vals_ptr) .OR. PRESENT(c_vals_ptr)
1282  IF (ASSOCIATED(my_val)) THEN
1283  ! check better?
1284  IF (valset) &
1285  CALL cp_abort(__location__, &
1286  " both val and values present, in setting "// &
1287  "keyword "//trim(keyword_name(my_index:len_key))//" of section "// &
1288  trim(section%name))
1289  ELSE
1290  ! ignore ?
1291  IF (.NOT. valset) &
1292  CALL cp_abort(__location__, &
1293  " empty value in setting "// &
1294  "keyword "//trim(keyword_name(my_index:len_key))//" of section "// &
1295  trim(section%name))
1296  cpassert(valset)
1297  IF (keyword%type_of_var == lchar_t) THEN
1298  CALL val_create(my_val, lc_val=c_val, lc_vals_ptr=c_vals_ptr)
1299  ELSE
1300  CALL val_create(my_val, l_val=l_val, i_val=i_val, r_val=r_val, &
1301  c_val=c_val, l_vals_ptr=l_vals_ptr, i_vals_ptr=i_vals_ptr, &
1302  r_vals_ptr=r_vals_ptr, &
1303  c_vals_ptr=c_vals_ptr, enum=keyword%enum)
1304  END IF
1305  cpassert(ASSOCIATED(my_val))
1306  cpassert(my_val%type_of_var == keyword%type_of_var)
1307  END IF
1308  vals => s_vals%values(ik, irs)%list
1309  IF (irk == -1) THEN
1310  CALL cp_sll_val_insert_el_at(vals, my_val, index=-1)
1311  ELSE IF (irk <= cp_sll_val_get_length(vals)) THEN
1312  IF (irk <= 0) &
1313  CALL cp_abort(__location__, &
1314  "invalid irk "//trim(adjustl(cp_to_string(irk)))// &
1315  " in keyword "//trim(keyword_name(my_index:len_key))//" of section "// &
1316  trim(section%name))
1317  old_val => cp_sll_val_get_el_at(vals, index=irk)
1318  CALL val_release(old_val)
1319  CALL cp_sll_val_set_el_at(vals, value=my_val, index=irk)
1320  ELSE IF (irk > cp_sll_val_get_length(vals) + 1) THEN
1321  ! change?
1322  CALL cp_abort(__location__, &
1323  "cannot add extra keyword repetitions to keyword" &
1324  //trim(keyword_name(my_index:len_key))//" of section "// &
1325  trim(section%name))
1326  ELSE
1327  CALL cp_sll_val_insert_el_at(vals, my_val, index=irk)
1328  END IF
1329  s_vals%values(ik, irs)%list => vals
1330  NULLIFY (my_val)
1331  END SUBROUTINE section_vals_val_set
1332 
1333 ! **************************************************************************************************
1334 !> \brief unsets (removes) the requested value (if it is a keyword repetitions
1335 !> removes the repetition, so be careful: the repetition indices bigger
1336 !> than the actual change.
1337 !> \param section_vals ...
1338 !> \param keyword_name the name of the keyword you want (can be a path
1339 !> separated by '%')
1340 !> \param i_rep_section which repetition of the section you are interested in
1341 !> (defaults to 1)
1342 !> \param i_rep_val which repetition of the keyword/val you are interested in
1343 !> (defaults to 1)
1344 !> \author fawzi
1345 ! **************************************************************************************************
1346  SUBROUTINE section_vals_val_unset(section_vals, keyword_name, i_rep_section, i_rep_val)
1347 
1348  TYPE(section_vals_type), POINTER :: section_vals
1349  CHARACTER(len=*), INTENT(in) :: keyword_name
1350  INTEGER, INTENT(in), OPTIONAL :: i_rep_section, i_rep_val
1351 
1352  INTEGER :: ik, irk, irs, len_key, my_index, &
1353  tmp_index
1354  TYPE(cp_sll_val_type), POINTER :: pos
1355  TYPE(section_type), POINTER :: section
1356  TYPE(section_vals_type), POINTER :: s_vals
1357  TYPE(val_type), POINTER :: old_val
1358 
1359  NULLIFY (pos)
1360  cpassert(ASSOCIATED(section_vals))
1361  cpassert(section_vals%ref_count > 0)
1362 
1363  my_index = index(keyword_name, '%') + 1
1364  len_key = len_trim(keyword_name)
1365  IF (my_index > 1) THEN
1366  DO
1367  tmp_index = index(keyword_name(my_index:len_key), "%")
1368  IF (tmp_index <= 0) EXIT
1369  my_index = my_index + tmp_index
1370  END DO
1371  s_vals => section_vals_get_subs_vals(section_vals, keyword_name(1:my_index - 2))
1372  ELSE
1373  s_vals => section_vals
1374  END IF
1375 
1376  irk = 1
1377  irs = 1
1378  IF (PRESENT(i_rep_section)) irs = i_rep_section
1379  IF (PRESENT(i_rep_val)) irk = i_rep_val
1380  section => s_vals%section
1381  ik = section_get_keyword_index(s_vals%section, keyword_name(my_index:len_key))
1382  IF (ik == -2) &
1383  CALL cp_abort(__location__, &
1384  "section "//trim(section%name)//" does not contain keyword "// &
1385  trim(keyword_name(my_index:len_key)))
1386  ! ignore unset of non set values
1387  IF (irs <= SIZE(s_vals%values, 2)) THEN
1388  IF (.NOT. (irs > 0 .AND. irs <= SIZE(s_vals%subs_vals, 2))) &
1389  CALL cp_abort(__location__, &
1390  "section repetition requested ("//cp_to_string(irs)// &
1391  ") out of bounds (1:"//cp_to_string(SIZE(s_vals%subs_vals, 2)) &
1392  //")")
1393  IF (irk == -1) THEN
1394  pos => cp_sll_val_get_rest(s_vals%values(ik, irs)%list, iter=-1)
1395  ELSE
1396  pos => cp_sll_val_get_rest(s_vals%values(ik, irs)%list, iter=irk - 1)
1397  END IF
1398  IF (ASSOCIATED(pos)) THEN
1399  old_val => cp_sll_val_get_el_at(s_vals%values(ik, irs)%list, index=irk)
1400  CALL val_release(old_val)
1401  CALL cp_sll_val_rm_el_at(s_vals%values(ik, irs)%list, index=irk)
1402  END IF
1403  END IF
1404 
1405  END SUBROUTINE section_vals_val_unset
1406 
1407 ! **************************************************************************************************
1408 !> \brief writes the values in the given section in a way that is suitable to
1409 !> the automatic parsing
1410 !> \param section_vals the section to write out
1411 !> \param unit_nr the unit where to write to
1412 !> \param hide_root ...
1413 !> \param hide_defaults ...
1414 !> \author fawzi
1415 !> \note
1416 !> skips required sections which weren't read
1417 ! **************************************************************************************************
1418  RECURSIVE SUBROUTINE section_vals_write(section_vals, unit_nr, hide_root, hide_defaults)
1419 
1420  TYPE(section_vals_type), INTENT(IN) :: section_vals
1421  INTEGER, INTENT(in) :: unit_nr
1422  LOGICAL, INTENT(in), OPTIONAL :: hide_root, hide_defaults
1423 
1424  INTEGER, PARAMETER :: incr = 2
1425 
1426  CHARACTER(len=default_string_length) :: myfmt
1427  INTEGER :: i_rep_s, ik, isec, ival, nr, nval
1428  INTEGER, SAVE :: indent = 1
1429  LOGICAL :: defaultsection, explicit, &
1430  my_hide_defaults, my_hide_root
1431  TYPE(cp_sll_val_type), POINTER :: new_pos, vals
1432  TYPE(keyword_type), POINTER :: keyword
1433  TYPE(section_type), POINTER :: section
1434  TYPE(section_vals_type), POINTER :: sval
1435  TYPE(val_type), POINTER :: val
1436 
1437  my_hide_root = .false.
1438  my_hide_defaults = .true.
1439  IF (PRESENT(hide_root)) my_hide_root = hide_root
1440  IF (PRESENT(hide_defaults)) my_hide_defaults = hide_defaults
1441 
1442  cpassert(section_vals%ref_count > 0)
1443  IF (unit_nr > 0) THEN
1444  CALL section_vals_get(section_vals, explicit=explicit, n_repetition=nr, section=section)
1445  IF (explicit .OR. (.NOT. my_hide_defaults)) THEN
1446  DO i_rep_s = 1, nr
1447  IF (.NOT. my_hide_root) THEN
1448  WRITE (unit=myfmt, fmt="(I0,A1)") indent, "X"
1449  IF (ASSOCIATED(section%keywords(-1)%keyword)) THEN
1450  WRITE (unit=unit_nr, fmt="("//trim(myfmt)//",A)", advance="NO") &
1451  default_section_character//trim(adjustl(section%name))
1452  ELSE
1453  WRITE (unit=unit_nr, fmt="("//trim(myfmt)//",A)") &
1454  default_section_character//trim(adjustl(section%name))
1455  END IF
1456  END IF
1457  defaultsection = (SIZE(section_vals%values, 2) == 0)
1458  IF (.NOT. defaultsection) THEN
1459  IF (.NOT. my_hide_root) indent = indent + incr
1460  WRITE (unit=myfmt, fmt="(I0,A1)") indent, "X"
1461  DO ik = -1, section%n_keywords
1462  keyword => section%keywords(ik)%keyword
1463  IF (ASSOCIATED(keyword)) THEN
1464  IF (keyword%type_of_var /= no_t .AND. keyword%names(1) (1:2) /= "__") THEN
1465  CALL section_vals_val_get(section_vals, keyword%names(1), &
1466  i_rep_s, n_rep_val=nval)
1467  IF (i_rep_s <= SIZE(section_vals%values, 2)) THEN
1468  ! Section was parsed
1469  vals => section_vals%values(ik, i_rep_s)%list
1470  DO ival = 1, nval
1471  IF (ival == 1) THEN
1472  new_pos => vals
1473  ELSE
1474  new_pos => new_pos%rest
1475  END IF
1476  IF (.NOT. ASSOCIATED(new_pos)) THEN
1477  ! this keyword was not parsed
1478  IF (ASSOCIATED(keyword%default_value)) THEN
1479  val => keyword%default_value
1480  IF (my_hide_defaults) cycle
1481  END IF
1482  ELSE
1483  val => new_pos%first_el
1484  END IF
1485  IF (keyword%names(1) /= '_DEFAULT_KEYWORD_' .AND. &
1486  keyword%names(1) /= '_SECTION_PARAMETERS_') THEN
1487  WRITE (unit=unit_nr, fmt="("//trim(myfmt)//",A)", advance="NO") &
1488  trim(keyword%names(1))
1489  ELSE IF (keyword%names(1) == '_DEFAULT_KEYWORD_' .AND. &
1490  keyword%type_of_var /= lchar_t) THEN
1491  WRITE (unit=unit_nr, fmt="("//trim(myfmt)//")", advance="NO")
1492  END IF
1493  CALL val_write(val, unit_nr=unit_nr, unit=keyword%unit, fmt=myfmt)
1494  END DO
1495  ELSE IF (ASSOCIATED(keyword%default_value)) THEN
1496  ! Section was not parsed but default for the keywords may exist
1497  IF (my_hide_defaults) cycle
1498  val => keyword%default_value
1499  IF (keyword%names(1) /= '_DEFAULT_KEYWORD_' .AND. &
1500  keyword%names(1) /= '_SECTION_PARAMETERS_') THEN
1501  WRITE (unit=unit_nr, fmt="("//trim(myfmt)//",A)", advance="NO") &
1502  trim(keyword%names(1))
1503  ELSE IF (keyword%names(1) == '_DEFAULT_KEYWORD_' .AND. &
1504  keyword%type_of_var /= lchar_t) THEN
1505  WRITE (unit=unit_nr, fmt="("//trim(myfmt)//")", advance="NO")
1506  END IF
1507  CALL val_write(val, unit_nr=unit_nr, unit=keyword%unit, fmt=myfmt)
1508  END IF
1509  END IF
1510  END IF
1511  END DO
1512  IF (ASSOCIATED(section_vals%subs_vals)) THEN
1513  DO isec = 1, SIZE(section_vals%subs_vals, 1)
1514  sval => section_vals%subs_vals(isec, i_rep_s)%section_vals
1515  IF (ASSOCIATED(sval)) THEN
1516  CALL section_vals_write(sval, unit_nr=unit_nr, hide_defaults=hide_defaults)
1517  END IF
1518  END DO
1519  END IF
1520  END IF
1521  IF (.NOT. my_hide_root) THEN
1522  indent = indent - incr
1523  WRITE (unit=myfmt, fmt="(I0,A1)") indent, "X"
1524  WRITE (unit=unit_nr, fmt="("//trim(myfmt)//",A)") &
1525  default_section_character//"END "//trim(adjustl(section%name))
1526  END IF
1527  END DO
1528  END IF
1529  END IF
1530 
1531  END SUBROUTINE section_vals_write
1532 
1533 ! **************************************************************************************************
1534 !> \brief writes the values in the given section in xml
1535 !> \param section ...
1536 !> \param level ...
1537 !> \param unit_number ...
1538 ! **************************************************************************************************
1539  RECURSIVE SUBROUTINE write_section_xml(section, level, unit_number)
1540 
1541  TYPE(section_type), POINTER :: section
1542  INTEGER, INTENT(IN) :: level, unit_number
1543 
1544  CHARACTER(LEN=3) :: repeats
1545  CHARACTER(LEN=8) :: short_string
1546  INTEGER :: i, l0, l1, l2
1547 
1548  IF (ASSOCIATED(section)) THEN
1549 
1550  cpassert(section%ref_count > 0)
1551 
1552  ! Indentation for current level, next level, etc.
1553 
1554  l0 = level
1555  l1 = level + 1
1556  l2 = level + 2
1557 
1558  IF (section%repeats) THEN
1559  repeats = "yes"
1560  ELSE
1561  repeats = "no "
1562  END IF
1563 
1564  WRITE (unit=unit_number, fmt="(A)") &
1565  repeat(" ", l0)//"<SECTION repeats="""//trim(repeats)//""">", &
1566  repeat(" ", l1)//"<NAME>"//trim(section%name)//"</NAME>", &
1567  repeat(" ", l1)//"<DESCRIPTION>"// &
1568  trim(substitute_special_xml_tokens(a2s(section%description))) &
1569  //"</DESCRIPTION>"
1570 
1571  IF (ASSOCIATED(section%citations)) THEN
1572  DO i = 1, SIZE(section%citations, 1)
1573  short_string = ""
1574  WRITE (unit=short_string, fmt="(I8)") section%citations(i)
1575  WRITE (unit=unit_number, fmt="(A)") &
1576  repeat(" ", l1)//"<REFERENCE>", &
1577  repeat(" ", l2)//"<NAME>"//trim(get_citation_key(section%citations(i)))//"</NAME>", &
1578  repeat(" ", l2)//"<NUMBER>"//trim(adjustl(short_string))//"</NUMBER>", &
1579  repeat(" ", l1)//"</REFERENCE>"
1580  END DO
1581  END IF
1582 
1583  WRITE (unit=unit_number, fmt="(A)") &
1584  repeat(" ", l1)//"<LOCATION>"//trim(section%location)//"</LOCATION>"
1585 
1586  DO i = -1, section%n_keywords
1587  IF (ASSOCIATED(section%keywords(i)%keyword)) THEN
1588  CALL write_keyword_xml(section%keywords(i)%keyword, l1, unit_number)
1589  END IF
1590  END DO
1591 
1592  DO i = 1, section%n_subsections
1593  CALL write_section_xml(section%subsections(i)%section, l1, unit_number)
1594  END DO
1595 
1596  WRITE (unit=unit_number, fmt="(A)") repeat(" ", l0)//"</SECTION>"
1597 
1598  END IF
1599 
1600  END SUBROUTINE write_section_xml
1601 
1602 ! **************************************************************************************************
1603 !> \brief ...
1604 !> \param section ...
1605 !> \param section_name ...
1606 !> \param unknown_string ...
1607 !> \param location_string ...
1608 !> \param matching_rank ...
1609 !> \param matching_string ...
1610 !> \param bonus ...
1611 ! **************************************************************************************************
1612  RECURSIVE SUBROUTINE section_typo_match(section, section_name, unknown_string, location_string, &
1613  matching_rank, matching_string, bonus)
1614 
1615  TYPE(section_type), INTENT(IN), POINTER :: section
1616  CHARACTER(LEN=*) :: section_name, unknown_string, &
1617  location_string
1618  INTEGER, DIMENSION(:), INTENT(INOUT) :: matching_rank
1619  CHARACTER(LEN=*), DIMENSION(:), INTENT(INOUT) :: matching_string
1620  INTEGER, INTENT(IN) :: bonus
1621 
1622  CHARACTER(LEN=LEN(matching_string(1))) :: line
1623  INTEGER :: i, imatch, imax, irank, newbonus
1624 
1625  IF (ASSOCIATED(section)) THEN
1626  cpassert(section%ref_count > 0)
1627  imatch = typo_match(trim(section%name), trim(unknown_string))
1628  IF (imatch > 0) THEN
1629  imatch = imatch + bonus
1630  WRITE (unit=line, fmt='(T2,A)') &
1631  " subsection "//trim(adjustl(section%name))// &
1632  " in section "//trim(adjustl(location_string))
1633  imax = SIZE(matching_rank, 1)
1634  irank = imax + 1
1635  DO i = imax, 1, -1
1636  IF (imatch > matching_rank(i)) irank = i
1637  END DO
1638  IF (irank <= imax) THEN
1639  matching_rank(irank + 1:imax) = matching_rank(irank:imax - 1)
1640  matching_string(irank + 1:imax) = matching_string(irank:imax - 1)
1641  matching_rank(irank) = imatch
1642  matching_string(irank) = line
1643  END IF
1644  END IF
1645 
1646  IF (section_name == section%name) THEN
1647  newbonus = 10
1648  ELSE
1649  newbonus = 0
1650  END IF
1651 
1652  DO i = -1, section%n_keywords
1653  IF (ASSOCIATED(section%keywords(i)%keyword)) THEN
1654  CALL keyword_typo_match(section%keywords(i)%keyword, unknown_string, location_string// &
1655  "%"//trim(section%name), matching_rank, matching_string, newbonus)
1656  END IF
1657  END DO
1658 
1659  DO i = 1, section%n_subsections
1660  CALL section_typo_match(section%subsections(i)%section, section_name, unknown_string, &
1661  location_string//"%"//trim(section%name), matching_rank, matching_string, newbonus)
1662  END DO
1663 
1664  END IF
1665 
1666  END SUBROUTINE section_typo_match
1667 
1668 ! **************************************************************************************************
1669 !> \brief replaces of the requested subsection with the one given
1670 !> \param section_vals the root section
1671 !> \param subsection_name the name of the subsection to replace
1672 !> \param new_section_vals the new section_vals to use
1673 !> \param i_rep_section index of the repetition of section_vals of which
1674 !> you want to replace the subsection (defaults to 1)
1675 !> \author fawzi
1676 ! **************************************************************************************************
1677  SUBROUTINE section_vals_set_subs_vals(section_vals, subsection_name, &
1678  new_section_vals, i_rep_section)
1679  TYPE(section_vals_type), POINTER :: section_vals
1680  CHARACTER(len=*), INTENT(in) :: subsection_name
1681  TYPE(section_vals_type), POINTER :: new_section_vals
1682  INTEGER, INTENT(in), OPTIONAL :: i_rep_section
1683 
1684  INTEGER :: irep, isection, len_key, my_index, &
1685  tmp_index
1686  TYPE(section_vals_type), POINTER :: s_vals
1687 
1688  cpassert(ASSOCIATED(section_vals))
1689  cpassert(section_vals%ref_count > 0)
1690  cpassert(ASSOCIATED(new_section_vals))
1691  cpassert(new_section_vals%ref_count > 0)
1692 
1693  irep = 1
1694  IF (PRESENT(i_rep_section)) irep = i_rep_section
1695 
1696  my_index = index(subsection_name, '%') + 1
1697  len_key = len_trim(subsection_name)
1698  IF (my_index > 1) THEN
1699  DO
1700  tmp_index = index(subsection_name(my_index:len_key), "%")
1701  IF (tmp_index <= 0) EXIT
1702  my_index = my_index + tmp_index
1703  END DO
1704  s_vals => section_vals_get_subs_vals(section_vals, subsection_name(1:my_index - 2))
1705  ELSE
1706  s_vals => section_vals
1707  END IF
1708 
1709  cpassert(irep <= SIZE(s_vals%subs_vals, 2))
1710 
1711  isection = section_get_subsection_index(s_vals%section, subsection_name(my_index:len_trim(subsection_name)))
1712  IF (isection <= 0) &
1713  CALL cp_abort(__location__, &
1714  "could not find subsection "//subsection_name(my_index:len_trim(subsection_name))//" in section "// &
1715  trim(section_vals%section%name)//" at ")
1716  CALL section_vals_retain(new_section_vals)
1717  CALL section_vals_release(s_vals%subs_vals(isection, irep)%section_vals)
1718  s_vals%subs_vals(isection, irep)%section_vals => new_section_vals
1719 
1720  END SUBROUTINE section_vals_set_subs_vals
1721 
1722 ! **************************************************************************************************
1723 !> \brief creates a deep copy from section_vals_in to section_vals_out
1724 !> \param section_vals_in the section_vals to copy
1725 !> \param section_vals_out the section_vals to create
1726 !> \param i_rep_start ...
1727 !> \param i_rep_end ...
1728 !> \author fawzi
1729 ! **************************************************************************************************
1730  SUBROUTINE section_vals_duplicate(section_vals_in, section_vals_out, &
1731  i_rep_start, i_rep_end)
1732  TYPE(section_vals_type), POINTER :: section_vals_in, section_vals_out
1733  INTEGER, INTENT(IN), OPTIONAL :: i_rep_start, i_rep_end
1734 
1735  cpassert(ASSOCIATED(section_vals_in))
1736  cpassert(.NOT. ASSOCIATED(section_vals_out))
1737  CALL section_vals_create(section_vals_out, section_vals_in%section)
1738  CALL section_vals_copy(section_vals_in, section_vals_out, i_rep_start, i_rep_end)
1739  END SUBROUTINE section_vals_duplicate
1740 
1741 ! **************************************************************************************************
1742 !> \brief deep copy from section_vals_in to section_vals_out
1743 !> \param section_vals_in the section_vals to copy
1744 !> \param section_vals_out the section_vals where to copy
1745 !> \param i_rep_low ...
1746 !> \param i_rep_high ...
1747 !> \author fawzi
1748 !> \note
1749 !> private, only works with a newly initialized section_vals_out
1750 ! **************************************************************************************************
1751  RECURSIVE SUBROUTINE section_vals_copy(section_vals_in, section_vals_out, &
1752  i_rep_low, i_rep_high)
1753  TYPE(section_vals_type), POINTER :: section_vals_in, section_vals_out
1754  INTEGER, INTENT(IN), OPTIONAL :: i_rep_low, i_rep_high
1755 
1756  INTEGER :: iend, irep, isec, istart, ival
1757  TYPE(cp_sll_val_type), POINTER :: v1, v2
1758  TYPE(val_type), POINTER :: el
1759 
1760  NULLIFY (v2, el)
1761 
1762  cpassert(ASSOCIATED(section_vals_in))
1763  cpassert(ASSOCIATED(section_vals_out))
1764  ! IF(.NOT. ASSOCIATED(section_vals_in%section, section_vals_out%section))&
1765  ! CPABORT("")
1766 
1767  istart = 1
1768  iend = SIZE(section_vals_in%values, 2)
1769  IF (PRESENT(i_rep_low)) istart = i_rep_low
1770  IF (PRESENT(i_rep_high)) iend = i_rep_high
1771  DO irep = istart, iend
1772  CALL section_vals_add_values(section_vals_out)
1773  DO ival = lbound(section_vals_in%values, 1), ubound(section_vals_in%values, 1)
1774  v1 => section_vals_in%values(ival, irep)%list
1775  IF (ASSOCIATED(v1)) THEN
1776  CALL val_duplicate(v1%first_el, el)
1777  CALL cp_sll_val_create(v2, el)
1778  NULLIFY (el)
1779  section_vals_out%values(ival, irep - istart + 1)%list => v2
1780  DO
1781  IF (.NOT. ASSOCIATED(v1%rest)) EXIT
1782  v1 => v1%rest
1783  CALL val_duplicate(v1%first_el, el)
1784  CALL cp_sll_val_create(v2%rest, first_el=el)
1785  NULLIFY (el)
1786  v2 => v2%rest
1787  END DO
1788  END IF
1789  END DO
1790  END DO
1791  IF (.NOT. PRESENT(i_rep_low) .AND. (.NOT. PRESENT(i_rep_high))) THEN
1792  IF (.NOT. (SIZE(section_vals_in%values, 2) == SIZE(section_vals_out%values, 2))) &
1793  cpabort("")
1794  IF (.NOT. (SIZE(section_vals_in%subs_vals, 2) == SIZE(section_vals_out%subs_vals, 2))) &
1795  cpabort("")
1796  END IF
1797  iend = SIZE(section_vals_in%subs_vals, 2)
1798  IF (PRESENT(i_rep_high)) iend = i_rep_high
1799  DO irep = istart, iend
1800  DO isec = 1, SIZE(section_vals_in%subs_vals, 1)
1801  CALL section_vals_copy(section_vals_in%subs_vals(isec, irep)%section_vals, &
1802  section_vals_out%subs_vals(isec, irep - istart + 1)%section_vals)
1803  END DO
1804  END DO
1805 
1806  END SUBROUTINE section_vals_copy
1807 
1808 END MODULE input_section_types
imax
static int imax(int x, int y)
Returns the larger of two given integer (missing from the C standard)
Definition: dbm_distribution.c:73
cp_linked_list_input
Definition: cp_linked_list_input.F:9
cp_linked_list_input::cp_sll_val_get_rest
type(cp_sll_val_type) function, pointer, public cp_sll_val_get_rest(sll, iter)
returns the rest of the list
Definition: cp_linked_list_input.F:925
cp_linked_list_input::cp_sll_val_get_length
integer function, public cp_sll_val_get_length(sll)
returns the length of the list
Definition: cp_linked_list_input.F:1075
cp_linked_list_input::cp_sll_val_next
logical function, public cp_sll_val_next(iterator, el_att)
returns true if the actual element is valid (i.e. iterator ont at end) moves the iterator to the next...
Definition: cp_linked_list_input.F:1474
cp_linked_list_input::cp_sll_val_rm_el_at
subroutine, public cp_sll_val_rm_el_at(sll, index)
removes the element at the given index
Definition: cp_linked_list_input.F:1995
cp_linked_list_input::cp_sll_val_create
subroutine, public cp_sll_val_create(sll, first_el, rest)
allocates and initializes a single linked list
Definition: cp_linked_list_input.F:508
cp_linked_list_input::cp_sll_val_set_el_at
subroutine, public cp_sll_val_set_el_at(sll, index, value)
sets the element at the given index
Definition: cp_linked_list_input.F:1353
cp_linked_list_input::cp_sll_val_insert_el_at
subroutine, public cp_sll_val_insert_el_at(sll, el, index)
inserts the element at the given index
Definition: cp_linked_list_input.F:1853
cp_linked_list_input::cp_sll_val_get_el_at
type(val_type) function, pointer, public cp_sll_val_get_el_at(sll, index)
returns the element at the given index
Definition: cp_linked_list_input.F:1212
cp_linked_list_input::cp_sll_val_dealloc
subroutine, public cp_sll_val_dealloc(sll)
deallocates the singly linked list starting at sll. Does not work if loops are present!
Definition: cp_linked_list_input.F:599
cp_log_handling
various routines to log and control the output. The idea is that decisions about where to log should ...
Definition: cp_log_handling.F:41
cp_parser_types
Utility routines to read data from files. Kept as close as possible to the old parser because.
Definition: cp_parser_types.F:21
cp_parser_types::default_section_character
character(len=1), parameter, public default_section_character
Definition: cp_parser_types.F:62
input_keyword_types
represents keywords in an input
Definition: input_keyword_types.F:14
input_keyword_types::keyword_retain
subroutine, public keyword_retain(keyword)
retains the given keyword (see doc/ReferenceCounting.html)
Definition: input_keyword_types.F:413
input_keyword_types::keyword_describe
subroutine, public keyword_describe(keyword, unit_nr, level)
writes out a description of the keyword
Definition: input_keyword_types.F:501
input_keyword_types::write_keyword_xml
subroutine, public write_keyword_xml(keyword, level, unit_number)
Prints a description of a keyword in XML format.
Definition: input_keyword_types.F:635
input_keyword_types::keyword_release
subroutine, public keyword_release(keyword)
releases the given keyword (see doc/ReferenceCounting.html)
Definition: input_keyword_types.F:426
input_keyword_types::keyword_typo_match
subroutine, public keyword_typo_match(keyword, unknown_string, location_string, matching_rank, matching_string, bonus)
...
Definition: input_keyword_types.F:826
input_section_types
objects that represent the structure of input sections and the data contained in an input section
Definition: input_section_types.F:15
input_section_types::section_vals_val_unset
subroutine, public section_vals_val_unset(section_vals, keyword_name, i_rep_section, i_rep_val)
unsets (removes) the requested value (if it is a keyword repetitions removes the repetition,...
Definition: input_section_types.F:1347
input_section_types::section_get_rval
real(kind=dp) function, public section_get_rval(section_vals, keyword_name)
...
Definition: input_section_types.F:941
input_section_types::section_typo_match
recursive subroutine, public section_typo_match(section, section_name, unknown_string, location_string, matching_rank, matching_string, bonus)
...
Definition: input_section_types.F:1614
input_section_types::section_get_subsection
type(section_type) function, pointer, public section_get_subsection(section, subsection_name)
returns the requested subsection
Definition: input_section_types.F:403
input_section_types::write_section_xml
recursive subroutine, public write_section_xml(section, level, unit_number)
writes the values in the given section in xml
Definition: input_section_types.F:1540
input_section_types::section_vals_create
recursive subroutine, public section_vals_create(section_vals, section)
creates a object where to store the values of a section
Definition: input_section_types.F:601
input_section_types::section_create
subroutine, public section_create(section, location, name, description, n_keywords, n_subsections, repeats, citations)
creates a list of keywords
Definition: input_section_types.F:156
input_section_types::section_vals_val_set
subroutine, public section_vals_val_set(section_vals, keyword_name, i_rep_section, i_rep_val, val, l_val, i_val, r_val, c_val, l_vals_ptr, i_vals_ptr, r_vals_ptr, c_vals_ptr)
sets the requested value
Definition: input_section_types.F:1216
input_section_types::section_get_ivals
integer function, dimension(:), pointer, public section_get_ivals(section_vals, keyword_name)
...
Definition: input_section_types.F:989
input_section_types::section_vals_get_subs_vals2
type(section_vals_type) function, pointer, public section_vals_get_subs_vals2(section_vals, i_section, i_rep_section)
returns the values of the n-th non default subsection (null if no such section exists (not so many no...
Definition: input_section_types.F:779
input_section_types::section_add_keyword
subroutine, public section_add_keyword(section, keyword)
adds a keyword to the given section
Definition: input_section_types.F:504
input_section_types::typo_match_section
type(section_type), pointer, save, public typo_match_section
Definition: input_section_types.F:134
input_section_types::section_get_keyword_index
integer function, public section_get_keyword_index(section, keyword_name)
returns the index of the requested keyword (or -2 if not found)
Definition: input_section_types.F:429
input_section_types::section_vals_remove_values
subroutine, public section_vals_remove_values(section_vals)
removes the values of a repetition of the section
Definition: input_section_types.F:889
input_section_types::section_add_subsection
subroutine, public section_add_subsection(section, subsection)
adds a subsection to the given section
Definition: input_section_types.F:560
input_section_types::section_get_ival
integer function, public section_get_ival(section_vals, keyword_name)
...
Definition: input_section_types.F:973
input_section_types::section_vals_list_get
subroutine, public section_vals_list_get(section_vals, keyword_name, i_rep_section, list)
returns the requested list
Definition: input_section_types.F:1149
input_section_types::typo_matching_rank
integer, dimension(n_typo_matches), public typo_matching_rank
Definition: input_section_types.F:136
input_section_types::section_vals_retain
subroutine, public section_vals_retain(section_vals)
retains the given section values (see doc/ReferenceCounting.html)
Definition: input_section_types.F:631
input_section_types::section_vals_get_subs_vals
recursive type(section_vals_type) function, pointer, public section_vals_get_subs_vals(section_vals, subsection_name, i_rep_section, can_return_null)
returns the values of the requested subsection
Definition: input_section_types.F:724
input_section_types::section_release
recursive subroutine, public section_release(section)
releases the given keyword list (see doc/ReferenceCounting.html)
Definition: input_section_types.F:231
input_section_types::section_get_keyword
recursive type(keyword_type) function, pointer, public section_get_keyword(section, keyword_name)
returns the requested keyword
Definition: input_section_types.F:471
input_section_types::section_vals_write
recursive subroutine, public section_vals_write(section_vals, unit_nr, hide_root, hide_defaults)
writes the values in the given section in a way that is suitable to the automatic parsing
Definition: input_section_types.F:1419
input_section_types::section_vals_get
subroutine, public section_vals_get(section_vals, ref_count, n_repetition, n_subs_vals_rep, section, explicit)
returns various attributes about the section_vals
Definition: input_section_types.F:697
input_section_types::section_describe
recursive subroutine, public section_describe(section, unit_nr, level, hide_root, recurse)
prints a description of the given section
Definition: input_section_types.F:304
input_section_types::section_vals_get_subs_vals3
type(section_vals_type) function, pointer, public section_vals_get_subs_vals3(section_vals, subsection_name, i_rep_section)
returns the values of the n-th non default subsection (null if no such section exists (not so many no...
Definition: input_section_types.F:817
input_section_types::section_vals_set_subs_vals
subroutine, public section_vals_set_subs_vals(section_vals, subsection_name, new_section_vals, i_rep_section)
replaces of the requested subsection with the one given
Definition: input_section_types.F:1679
input_section_types::section_get_subsection_index
integer function, public section_get_subsection_index(section, subsection_name)
returns the index of requested subsection (-1 if not found)
Definition: input_section_types.F:373
input_section_types::section_vals_duplicate
subroutine, public section_vals_duplicate(section_vals_in, section_vals_out, i_rep_start, i_rep_end)
creates a deep copy from section_vals_in to section_vals_out
Definition: input_section_types.F:1732
input_section_types::typo_matching_line
character(len=default_string_length *5), dimension(n_typo_matches), public typo_matching_line
Definition: input_section_types.F:137
input_section_types::section_vals_val_get
subroutine, public section_vals_val_get(section_vals, keyword_name, i_rep_section, i_rep_val, n_rep_val, val, l_val, i_val, r_val, c_val, l_vals, i_vals, r_vals, c_vals, explicit)
returns the requested value
Definition: input_section_types.F:1040
input_section_types::section_vals_add_values
subroutine, public section_vals_add_values(section_vals)
adds the place to store the values of a repetition of the section
Definition: input_section_types.F:841
input_section_types::section_vals_release
recursive subroutine, public section_vals_release(section_vals)
releases the given object
Definition: input_section_types.F:646
input_section_types::section_get_lval
logical function, public section_get_lval(section_vals, keyword_name)
...
Definition: input_section_types.F:1005
input_val_types
a wrapper for basic fortran types.
Definition: input_val_types.F:14
input_val_types::lchar_t
integer, parameter, public lchar_t
Definition: input_val_types.F:41
input_val_types::val_duplicate
subroutine, public val_duplicate(val_in, val_out)
creates a copy of the given value
Definition: input_val_types.F:737
input_val_types::val_write
subroutine, public val_write(val, unit_nr, unit, unit_str, fmt)
writes out the values stored in the val
Definition: input_val_types.F:477
input_val_types::val_get
subroutine, public val_get(val, has_l, has_i, has_r, has_lc, has_c, l_val, l_vals, i_val, i_vals, r_val, r_vals, c_val, c_vals, len_c, type_of_var, enum)
returns the stored values
Definition: input_val_types.F:334
input_val_types::val_create
subroutine, public val_create(val, l_val, l_vals, l_vals_ptr, i_val, i_vals, i_vals_ptr, r_val, r_vals, r_vals_ptr, c_val, c_vals, c_vals_ptr, lc_val, lc_vals, lc_vals_ptr, enum)
creates a keyword value
Definition: input_val_types.F:103
input_val_types::val_release
subroutine, public val_release(val)
releases the given val
Definition: input_val_types.F:262
input_val_types::no_t
integer, parameter, public no_t
Definition: input_val_types.F:41
kinds
Defines the basic variable types.
Definition: kinds.F:23
kinds::dp
integer, parameter, public dp
Definition: kinds.F:34
kinds::default_string_length
integer, parameter, public default_string_length
Definition: kinds.F:57
kinds::default_path_length
integer, parameter, public default_path_length
Definition: kinds.F:58
list
An array-based list which grows on demand. When the internal array is full, a new array of twice the ...
Definition: list.F:24
print_messages
Perform an abnormal program termination.
Definition: print_messages.F:21
print_messages::print_message
subroutine, public print_message(message, output_unit, declev, before, after)
Perform a basic blocking of the text in message and print it optionally decorated with a frame of sta...
Definition: print_messages.F:56
reference_manager
provides a uniform framework to add references to CP2K cite and output these
Definition: reference_manager.F:24
reference_manager::get_citation_key
pure character(len=default_string_length) function, public get_citation_key(key)
...
Definition: reference_manager.F:733
string_utilities
Utilities for string manipulations.
Definition: string_utilities.F:16
string_utilities::typo_match
elemental integer function, public typo_match(string, typo_string)
returns a non-zero positive value if typo_string equals string apart from a few typos....
Definition: string_utilities.F:70
string_utilities::a2s
pure character(len=size(array)) function, public a2s(array)
Converts a character-array into a string.
Definition: string_utilities.F:134
string_utilities::substitute_special_xml_tokens
character(len=2 *len(inp_string)) function, public substitute_special_xml_tokens(inp_string)
Substitutes the five predefined XML entities: &, <, >, ', and ".
Definition: string_utilities.F:3298
string_utilities::uppercase
elemental subroutine, public uppercase(string)
Convert all lower case characters in a string to upper case.
Definition: string_utilities.F:3361