Changeset 5001 for LMDZ6/trunk/libf/misc

Timestamp:

Jul 1, 2024, 11:25:05 AM (5 months ago)

Author:

dcugnet

Message:

• strings_mod:
  • remove "test()" function (was not very clear)
  • modifications of the "str2bool" function: result is O/1 for .FALSE./.TRUE. and -1 if the string was not a boolean.
  • more general "find()" function (for several numerical types)
  • more general "cat()" function (can append a 2D array with vectors, 1D arrays with scalars)
  • few simplifications (in "strParse") and minor changes
• readTracFiles_mod:
  • remove internal usage of direct keys ("%" symbol) in favor of the "getKey" function. => moving toward a totally generic tracers derived type.
  • improve the internal management of the error return value "lerr".
  • remove "fGetKey", "fGetKeys", "setDirectKeys" functions
  • new functions to add/remove a phase: "addPhase", "delPhase"
  • more general "addKey(key[(:)], val[(:)], ky(:), [lOverWrite])" function: . input argument "val" can be string/integer/real/logical . (key, val, ky ): add the <key> =<val> pair to ky . (key, val(:), ky(:)): add the <key> =<val(i)> pair to ky(i) for 1<=i<=SIZE(ky) . (key(:), val(:), ky(:)): add the <key(i)>=<val(i)> pair to ky(i) for 1<=i<=SIZE(ky)
  • more general "getKey(key[(:)], val[(:)], itr [, ky(:)][, nam(:)][, def][, lDisp])" (tracer index version)

and "getKey(key[(:)], val[(:)], tname[, ky(:)]. [, def][, lDisp])" (tracer name version) functions:

. output argument "val" can be string/integer/real/logical
. if present, the default value <def> is retained if the corresponding key was not found.
. get values from "ky(:)" if present, otherwise from internal database "tracers(:)" or "isotope ».
. if "keyn" is a vector, try with each element in indices order until a value is found
. (key[(:)], val, itr/tname[,ky(:)][, ...]): get the value <val> of tracer nr. itr or named "tname"
. (key[(:)], val(:), itr/tname[,ky(:)][, ...]): same + parsing of the value with « , », then storage in <val(:)>
. (key[(:)], val(:)[, ky(:)][, nam(:)][, ...]): same for all tracers (optional names list <nam(:)>) of database.
. (key[(:)], val(:), tname(:)[, ky(:)][, ...]): same for the tracers named « tnames(:)"

• more general "dispTraSection" function
• much simplified "indexUpdate" function ; "ancestor*" and "idxAncestor" functions are removed.
• "readIsotopesFile" is renamed to "processIsotopes" for more clarity
• cosmetic changes

• fix for isotopes: iq_val and iq_liq are usable for "q" only, not for "q_follow" and "zx_defau_diag" => use hardcoded indices (1 for vapor and 2 for liquid) for these variables

Location:

LMDZ6/trunk/libf/misc

Files:

• readTracFiles_mod.f90 (modified) (64 diffs)
• strings_mod.F90 (modified) (67 diffs)

LMDZ6/trunk/libf/misc/readTracFiles_mod.f90

@@ -2 +2 @@
 
   USE strings_mod,    ONLY: msg, find, get_in, dispTable, strHead,  strReduce,  strFind, strStack, strIdx, &
-       test, removeComment, cat, fmsg, maxlen, checkList, strParse, strReplace, strTail, strCount, reduceExpr, &
-       int2str, str2int, real2str, str2real, bool2str, str2bool
+             removeComment, cat, fmsg, maxlen, checkList, strParse, strReplace, strTail, strCount, reduceExpr, &
+             int2str, str2int, real2str, str2real, bool2str, str2bool
 
   IMPLICIT NONE
@@ -17 +17 @@
   PUBLIC :: addPhase,  delPhase,  getPhase,  getiPhase,  &      !--- FUNCTIONS RELATED TO THE PHASES
    nphases, old_phases, phases_sep, known_phases, phases_names  !--- + ASSOCIATED VARIABLES
-  PUBLIC :: fGetKey, fGetKeys, setDirectKeys                    !--- TOOLS TO GET/SET KEYS FROM/TO  tracers & isotopes TO BE REMOVED
 
   PUBLIC :: oldH2OIso, newH2OIso, old2newH2O, new2oldH2O        !--- H2O ISOTOPES BACKWARD COMPATIBILITY (OLD traceur.def)
   PUBLIC :: oldHNO3,   newHNO3                                  !--- HNO3 REPRO   BACKWARD COMPATIBILITY (OLD start.nc)
 
-  PUBLIC :: tran0, idxAncestor, ancestor                        !--- GENERATION 0 TRACER + TOOLS FOR GENERATIONS
+  PUBLIC :: tran0                                               !--- TRANSPORTING FLUID (USUALLY air)
 
   !=== FOR ISOTOPES: GENERAL
-  PUBLIC :: isot_type, readIsotopesFile, isoSelect, ixIso, nbIso!--- ISOTOPES READING ROUTINE + SELECTION + CLASS IDX & NUMBER
+  PUBLIC :: isot_type, processIsotopes, isoSelect, ixIso, nbIso !--- PROCESS [AND READ] & SELECT ISOTOPES + CLASS IDX & NUMBER
 
   !=== FOR ISOTOPES: H2O FAMILY ONLY
@@ -81 +80 @@
     INTEGER                            :: nzone = 0             !--- Number of geographic tagging zones
     INTEGER                            :: nphas = 0             !--- Number of phases
-    INTEGER,               ALLOCATABLE :: iqIsoPha(:,:)         !--- Idx in "tracers(1:nqtot)" = f(name(1:ntiso)),phas)
+    INTEGER,               ALLOCATABLE :: iqIsoPha(:,:)         !--- Idx in "tracers(1:nqtot)" = f(name(1:ntiso),phas)
                                                                 !---        (former name: "iqiso"
-    INTEGER,               ALLOCATABLE :: iqWIsoPha(:,:)        !--- Idx in "tracers(1:nqtot)" = f(name(1:ntiso)),phas)
-                                                                !---        (former name: "?????")
+    INTEGER,               ALLOCATABLE :: iqWIsoPha(:,:)        !--- Idx in "tracers(1:nqtot)" = f([H2O,name(1:ntiso)],phas)
     INTEGER,               ALLOCATABLE :: itZonIso(:,:)         !--- Idx in "trac(1:ntiso)" = f(zone, name(1:niso))
   END TYPE isot_type                                            !---        (former name: "index_trac")
@@ -94 +92 @@
 !------------------------------------------------------------------------------------------------------------------------------
   INTERFACE getKey
-    MODULE PROCEDURE getKeyByName_s1, getKeyByName_s1m, getKeyByName_sm, getKey_sm, &
-                     getKeyByName_i1, getKeyByName_i1m, getKeyByName_im, getKey_im, &
-                     getKeyByName_r1, getKeyByName_r1m, getKeyByName_rm, getKey_rm, &
-                     getKeyByName_l1, getKeyByName_l1m, getKeyByName_lm, getKey_lm
+    MODULE PROCEDURE &
+       getKeyByIndex_s111, getKeyByIndex_sm11, getKeyByIndex_s1m1, getKeyByIndex_smm1, getKeyByIndex_s1mm, getKeyByIndex_smmm, &
+       getKeyByIndex_i111, getKeyByIndex_im11, getKeyByIndex_i1m1, getKeyByIndex_imm1, getKeyByIndex_i1mm, getKeyByIndex_immm, &
+       getKeyByIndex_r111, getKeyByIndex_rm11, getKeyByIndex_r1m1, getKeyByIndex_rmm1, getKeyByIndex_r1mm, getKeyByIndex_rmmm, &
+       getKeyByIndex_l111, getKeyByIndex_lm11, getKeyByIndex_l1m1, getKeyByIndex_lmm1, getKeyByIndex_l1mm, getKeyByIndex_lmmm, &
+        getKeyByName_s111,  getKeyByName_sm11,  getKeyByName_s1m1,  getKeyByName_smm1,  getKeyByName_s1mm,  getKeyByName_smmm, &
+        getKeyByName_i111,  getKeyByName_im11,  getKeyByName_i1m1,  getKeyByName_imm1,  getKeyByName_i1mm,  getKeyByName_immm, &
+        getKeyByName_r111,  getKeyByName_rm11,  getKeyByName_r1m1,  getKeyByName_rmm1,  getKeyByName_r1mm,  getKeyByName_rmmm, &
+        getKeyByName_l111,  getKeyByName_lm11,  getKeyByName_l1m1,  getKeyByName_lmm1,  getKeyByName_l1mm,  getKeyByName_lmmm
   END INTERFACE getKey
 !------------------------------------------------------------------------------------------------------------------------------
@@ -105 +108 @@
   END INTERFACE addKey
 !------------------------------------------------------------------------------------------------------------------------------
-  INTERFACE    isoSelect;  MODULE PROCEDURE  isoSelectByIndex,  isoSelectByName; END INTERFACE isoSelect
-  INTERFACE  old2newH2O;   MODULE PROCEDURE  old2newH2O_1,  old2newH2O_m;        END INTERFACE old2newH2O
-  INTERFACE  new2oldH2O;   MODULE PROCEDURE  new2oldH2O_1,  new2oldH2O_m;        END INTERFACE new2oldH2O
-  INTERFACE fGetKey;       MODULE PROCEDURE fgetKeyIdx_s1, fgetKeyNam_s1;        END INTERFACE fGetKey
-  INTERFACE tracersSubset; MODULE PROCEDURE trSubset_Indx, trSubset_Name, trSubset_gen0Name; END INTERFACE tracersSubset
-  INTERFACE idxAncestor;   MODULE PROCEDURE idxAncestor_1, idxAncestor_m, idxAncestor_mt;    END INTERFACE idxAncestor
-  INTERFACE    ancestor;   MODULE PROCEDURE    ancestor_1,    ancestor_m,    ancestor_mt;    END INTERFACE    ancestor
-  INTERFACE        addTracer; MODULE PROCEDURE   addTracer_1, addTracer_1def;                   END INTERFACE addTracer
-  INTERFACE        delTracer; MODULE PROCEDURE   delTracer_1, delTracer_1def;                   END INTERFACE delTracer
-  INTERFACE    addPhase;   MODULE PROCEDURE   addPhase_s1,   addPhase_sm,   addPhase_i1,   addPhase_im; END INTERFACE addPhase
+  INTERFACE     isoSelect; MODULE PROCEDURE  isoSelectByIndex,  isoSelectByName; END INTERFACE isoSelect
+  INTERFACE    old2newH2O; MODULE PROCEDURE  old2newH2O_1,  old2newH2O_m;        END INTERFACE old2newH2O
+  INTERFACE    new2oldH2O; MODULE PROCEDURE  new2oldH2O_1,  new2oldH2O_m;        END INTERFACE new2oldH2O
+  INTERFACE     addTracer; MODULE PROCEDURE   addTracer_1, addTracer_1def;       END INTERFACE addTracer
+  INTERFACE     delTracer; MODULE PROCEDURE   delTracer_1, delTracer_1def;       END INTERFACE delTracer
+  INTERFACE      addPhase; MODULE PROCEDURE   addPhase_s1,  addPhase_sm,  addPhase_i1,  addPhase_im; END INTERFACE addPhase
+  INTERFACE tracersSubset; MODULE PROCEDURE trSubset_Indx,     trSubset_Name,     trSubset_gen0Name; END INTERFACE tracersSubset
 !------------------------------------------------------------------------------------------------------------------------------
 
@@ -154 +154 @@
                                             nphas, ntiso        !--- NUMBER OF PHASES AND ISOTOPES + ISOTOPIC TAGGING TRACERS
   INTEGER,                 SAVE, POINTER ::itZonIso(:,:), &     !--- INDEX IN "isoTrac" AS f(tagging zone idx,  isotope idx)
-                                           iqIsoPha(:,:), &     !--- INDEX IN "qx"      AS f(isotopic tracer idx, phase idx)
-                                           iqWIsoPha(:,:)       !--- INDEX IN "qx"      AS f(isotopic tracer idx, phase idx)
+                                           iqIsoPha(:,:), &     !--- INDEX IN "qx" AS f(isotopic tracer idx, phase idx)
+                                           iqWIsoPha(:,:)       !--- INDEX IN "qx" AS f(H2O + isotopic tracer idx, phase idx)
 
   !=== PARAMETERS FOR DEFAULT BEHAVIOUR
@@ -190 +190 @@
 !     * If you need to convert a %key/%val pair into a direct-access key, add the corresponding line in "setDirectKeys".
 !==============================================================================================================================
-LOGICAL FUNCTION readTracersFiles(type_trac, lRepr) RESULT(lerr)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=*),  INTENT(IN)  :: type_trac                        !--- List of components used
-  LOGICAL, OPTIONAL, INTENT(IN)  :: lRepr                            !--- Activate the HNNO3 exceptions for REPROBUS
+LOGICAL FUNCTION readTracersFiles(type_trac, tracs, lRepr) RESULT(lerr)
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=*),                               INTENT(IN)  :: type_trac     !--- List of components used
+  TYPE(trac_type), ALLOCATABLE, TARGET, OPTIONAL, INTENT(OUT) :: tracs(:)      !--- Tracers descriptor for external storage
+  LOGICAL,                              OPTIONAL, INTENT(IN)  :: lRepr         !--- Activate the HNO3 exceptions for REPROBUS
   CHARACTER(LEN=maxlen),  ALLOCATABLE :: s(:), sections(:), trac_files(:)
   CHARACTER(LEN=maxlen) :: str, fname, tname, pname, cname
   INTEGER               :: nsec, ierr, it, ntrac, ns, ip, ix, fType
+  INTEGER, ALLOCATABLE  :: iGen(:)
   LOGICAL :: lRep
   TYPE(keys_type), POINTER :: k
@@ -206 +208 @@
 
   !--- Required sections + corresponding files names (new style single section case) for tests
-  IF(test(testTracersFiles(modname, type_trac, fType, .FALSE., trac_files, sections), lerr)) RETURN
+  lerr = testTracersFiles(modname, type_trac, fType, .FALSE., trac_files, sections); IF(lerr) RETURN
   nsec = SIZE(sections)
 
   !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  SELECT CASE(fType)                         !--- Set %name, %genOName, %parent, %type, %phase, %component, %iGeneration, %keys
+  SELECT CASE(fType)                         !--- Set name, component, parent, phase, iGeneration, gen0Name, type
   !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     CASE(1)                                                          !=== OLD FORMAT "traceur.def"
     !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       !--- OPEN THE "traceur.def" FILE
-      OPEN(90, FILE="traceur.def", FORM='formatted', STATUS='old', IOSTAT=ierr)
+      OPEN(90, FILE="traceur.def", FORM='formatted', STATUS='old', POSITION='REWIND', IOSTAT=ierr)
 
       !--- GET THE TRACERS NUMBER
       READ(90,'(i3)',IOSTAT=ierr)ntrac                               !--- Number of lines/tracers
-      IF(test(fmsg('Invalid format for "'//TRIM(fname)//'"', modname, ierr /= 0), lerr)) RETURN
+      lerr = ierr/=0; IF(fmsg('Invalid format for "'//TRIM(fname)//'"', modname, lerr)) RETURN
 
       !--- READ THE REMAINING LINES: <hadv> <vadv> <tracer> [<transporting fluid>]
-      IF(ALLOCATED(tracers)) DEALLOCATE(tracers)
       ALLOCATE(tracers(ntrac))
-      DO it=1,ntrac                                                  !=== READ RAW DATA: loop on the line/tracer number
+      DO it = 1, ntrac                                               !=== READ RAW DATA: loop on the line/tracer number
         READ(90,'(a)',IOSTAT=ierr) str
-        IF(test(fmsg('Invalid format for "' //TRIM(fname)//'"', modname, ierr>0), lerr)) RETURN
-        IF(test(fmsg('Not enough lines in "'//TRIM(fname)//'"', modname, ierr<0), lerr)) RETURN
+        lerr = ierr>0; IF(fmsg('Invalid format for "' //TRIM(fname)//'"', modname, lerr)) RETURN
+        lerr = ierr<0; IF(fmsg('Not enough lines in "'//TRIM(fname)//'"', modname, lerr)) RETURN
         lerr = strParse(str, ' ', s, ns)
         CALL msg('This file is for air tracers only',           modname, ns == 3 .AND. it == 1)
@@ -237 +238 @@
         ix = strIdx(oldHNO3, s(3))
         IF(ix /= 0 .AND. lRep) tname = newHNO3(ix)                   !--- Exception for HNO3 (REPROBUS ONLY)
-        tracers(it)%name = tname                                     !--- Set %name
-        CALL addKey_s11('name', tname, k)                            !--- Set the name of the tracer
+        tracers(it)%name = tname                                     !--- Set the name of the tracer
+        CALL addKey('name', tname, k)                                !--- Set the name of the tracer
         tracers(it)%keys%name = tname                                !--- Copy tracers names in keys components
 
@@ -244 +245 @@
         cname = type_trac                                            !--- Name of the model component
         IF(ANY([(addPhase('H2O', ip), ip = 1, nphases)] == tname)) cname = 'lmdz'
-        tracers(it)%component = cname                                !--- Set %component
-        CALL addKey_s11('component', cname, k)                       !--- Set the name of the model component
+        tracers(it)%component = cname                                !--- Set component
+        CALL addKey('component', cname, k)                           !--- Set the name of the model component
 
         !=== NAME OF THE PARENT
@@ -254 +255 @@
           IF(ix /= 0 .AND. lRep) pname = newHNO3(ix)                 !--- Exception for HNO3 (REPROBUS ONLY)
         END IF
-        tracers(it)%parent = pname                                   !--- Set %parent
-        CALL addKey_s11('parent', pname, k)
+        tracers(it)%parent = pname                                   !--- Set the parent name
+        CALL addKey('parent', pname, k)
 
         !=== PHASE AND ADVECTION SCHEMES NUMBERS
-        tracers(it)%phase = known_phases(ip:ip)                      !--- Set %phase:  tracer phase (default: "g"azeous)
-        CALL addKey_s11('phase', known_phases(ip:ip), k)             !--- Set the phase  of the tracer (default: "g"azeous)
-        CALL addKey_s11('hadv', s(1),  k)                            !--- Set the horizontal advection schemes number
-        CALL addKey_s11('vadv', s(2),  k)                            !--- Set the vertical   advection schemes number
+        tracers(it)%phase = known_phases(ip:ip)                      !--- Set the phase of the tracer (default: "g"azeous)
+        CALL addKey('phase', known_phases(ip:ip), k)                 !--- Set the phase of the tracer (default: "g"azeous)
+        CALL addKey('hadv', s(1),  k)                                !--- Set the horizontal advection schemes number
+        CALL addKey('vadv', s(2),  k)                                !--- Set the vertical   advection schemes number
       END DO
       CLOSE(90)
-      IF(test(setGeneration(tracers), lerr)) RETURN                  !--- Set %iGeneration and %gen0Name
-      WHERE(tracers%iGeneration == 2) tracers(:)%type = 'tag'        !--- Set %type:        'tracer' or 'tag'
-      DO it=1,ntrac
-        CALL addKey_s11('type', tracers(it)%type, tracers(it)%keys)  !--- Set the type of tracer
-      END DO
-      IF(test(checkTracers(tracers, fname, fname), lerr)) RETURN     !--- Detect orphans and check phases
-      IF(test(checkUnique (tracers, fname, fname), lerr)) RETURN     !--- Detect repeated tracers
-      CALL sortTracers    (tracers)                                  !--- Sort the tracers
+      lerr = setGeneration(tracers); IF(lerr) RETURN                 !--- Set iGeneration and gen0Name
+      lerr = getKey('iGeneration', iGen, tracers(:)%keys)            !--- Generation number
+      WHERE(iGen == 2) tracers(:)%type = 'tag'                       !--- Set type:      'tracer' or 'tag'
+      CALL addKey('type', tracers(:)%type, tracers(:)%keys)          !--- Set the type of tracer
+      lerr = checkTracers(tracers, fname, fname); IF(lerr) RETURN    !--- Detect orphans and check phases
+      lerr = checkUnique (tracers, fname, fname); IF(lerr) RETURN    !--- Detect repeated tracers
+      CALL sortTracers   (tracers)                                   !--- Sort the tracers
     !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    CASE(2); IF(test(feedDBase(["tracer.def"], [type_trac], modname), lerr)) RETURN !=== SINGLE   FILE, MULTIPLE SECTIONS
+    CASE(2); lerr=feedDBase(["tracer.def"], [type_trac], modname); IF(lerr) RETURN  !=== SINGLE   FILE, MULTIPLE SECTIONS
     !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    CASE(3); IF(test(feedDBase(  trac_files  ,  sections,   modname), lerr)) RETURN !=== MULTIPLE FILES, SINGLE  SECTION
+    CASE(3); lerr=feedDBase(  trac_files  ,  sections,   modname); IF(lerr) RETURN  !=== MULTIPLE FILES, SINGLE  SECTION
   !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   END SELECT
   !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   IF(ALL([2,3] /= fType)) RETURN
-
-  IF(nsec  == 1) THEN; 
-    tracers = dBase(1)%trac
-  ELSE IF(lTracsMerge) THEN
-    CALL msg('The multiple required sections will be MERGED.',    modname)
-    IF(test(mergeTracers(dBase, tracers), lerr)) RETURN
-  ELSE
-    CALL msg('The multiple required sections will be CUMULATED.', modname)
-    IF(test(cumulTracers(dBase, tracers), lerr)) RETURN
+  IF(nsec == 1) tracers = dBase(1)%trac
+  IF(nsec /= 1) THEN
+    CALL msg('Multiple sections are MERGED',    modname,      lTracsMerge)
+    CALL msg('Multiple sections are CUMULATED', modname, .NOT.lTracsMerge)
+    IF(     lTracsMerge) lerr = cumulTracers(dBase, tracers)
+    IF(.NOT.lTracsMerge) lerr = cumulTracers(dBase, tracers)
+    IF(lerr) RETURN
   END IF
-  CALL setDirectKeys(tracers)                                        !--- Set %iqParent, %iqDescen, %nqDescen, %nqChildren
+  lerr = indexUpdate(tracers); IF(lerr) RETURN                       !--- Set iqParent, iqDescen, nqDescen, nqChildren
+
+  IF(PRESENT(tracs)) CALL MOVE_ALLOC(FROM=tracers, TO=tracs)
 END FUNCTION readTracersFiles
 !==============================================================================================================================
@@ -310 +310 @@
   !--- PARSE "type_trac" LIST AND DETERMINE THE TRACERS FILES NAMES (FOR CASE 3: MULTIPLE FILES, SINGLE SECTION PER FILE)
   !--- If type_trac is a scalar (case 1), "sections" and "trac_files" are not usable, but are meaningless for case 1 anyway.
-  IF(test(strParse(type_trac, '|', sections,  n=nsec), lerr)) RETURN !--- Parse "type_trac" list
+  lerr = strParse(type_trac, '|', sections, n=nsec); IF(lerr) RETURN !--- Parse "type_trac" list
   IF(PRESENT(sects)) sects = sections
   ALLOCATE(trac_files(nsec), ll(nsec))
@@ -324 +324 @@
   IF(.NOT.lD) RETURN                                                 !--- NO CHECKING/DISPLAY NEEDED: JUST GET type_trac,fType
   IF(ANY(ll) .AND. fType/=3) THEN                                    !--- MISSING FILES
-    IF(test(checkList(trac_files, .NOT.ll, 'Failed reading tracers description', 'files', 'missing'), lerr)) RETURN
+    lerr = checkList(trac_files, .NOT.ll, 'Failed reading tracers description', 'files', 'missing'); IF(lerr) RETURN
   END IF
 
@@ -355 +355 @@
   ll = strCount(snames, '|', ndb)                                    !--- Number of sections for each file
   ALLOCATE(ixf(SUM(ndb)))
-  DO i=1, SIZE(fnames)                                               !--- Set %name, %keys
-    IF(test(readSections(fnames(i), snames(i), 'default'), lerr)) RETURN
+  DO i=1, SIZE(fnames)                                               !--- Set name, keys
+    lerr = readSections(fnames(i), snames(i), 'default'); IF(lerr) RETURN
     ixf(1+SUM(ndb(1:i-1)):SUM(ndb(1:i))) = i                         !--- File index for each section of the expanded list
   END DO
@@ -364 +364 @@
     fnm = fnames(ixf(idb)); snm = dBase(idb)%name                    !--- FILE AND SECTION NAMES
     lerr = ANY([(dispTraSection('RAW CONTENT OF SECTION "'//TRIM(snm)//'"', snm, modname), idb=1, SIZE(dBase))])
-    IF(test(expandSection(dBase(idb)%trac, snm, fnm), lerr)) RETURN  !--- EXPAND NAMES ;  set %parent, %type, %component
-    IF(test(setGeneration(dBase(idb)%trac),           lerr)) RETURN  !---                 set %iGeneration,   %genOName
-    IF(test(checkTracers (dBase(idb)%trac, snm, fnm), lerr)) RETURN  !--- CHECK ORPHANS AND PHASES
-    IF(test(checkUnique  (dBase(idb)%trac, snm, fnm), lerr)) RETURN  !--- CHECK TRACERS UNIQUENESS
-    CALL expandPhases    (dBase(idb)%trac)                           !--- EXPAND PHASES ; set %phase
-    CALL sortTracers     (dBase(idb)%trac)                           !--- SORT TRACERS
+    lerr = expandSection(dBase(idb)%trac, snm, fnm); IF(lerr) RETURN !--- EXPAND NAMES ;  SET parent, type, component
+    lerr = setGeneration(dBase(idb)%trac);           IF(lerr) RETURN !---                 SET iGeneration,  genOName
+    lerr = checkTracers (dBase(idb)%trac, snm, fnm); IF(lerr) RETURN !--- CHECK ORPHANS AND PHASES
+    lerr = checkUnique  (dBase(idb)%trac, snm, fnm); IF(lerr) RETURN !--- CHECK TRACERS UNIQUENESS
+    lerr = expandPhases (dBase(idb)%trac);           IF(lerr) RETURN !--- EXPAND PHASES ; set phase
+    CALL sortTracers    (dBase(idb)%trac)                            !--- SORT TRACERS
     lerr = ANY([(dispTraSection('EXPANDED CONTENT OF SECTION "'//TRIM(snm)//'"', snm, modname), idb=1, SIZE(dBase))])
   !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -398 +398 @@
   ll = strParse(snam, '|', keys = sec)                               !--- Requested sections names
   ix = strIdx(dBase(:)%name, sec(:))                                 !--- Indexes of requested sections in database
-  IF(test(checkList(sec, ix == 0, 'In file "'//TRIM(fnam)//'"','section(s)', 'missing'), lerr)) RETURN
+  lerr = checkList(sec, ix == 0, 'In file "'//TRIM(fnam)//'"','section(s)', 'missing'); IF(lerr) RETURN
   tdb = dBase(:); dBase = [tdb(1:n0-1),tdb(PACK(ix, MASK=ix/=0))]    !--- Keep requested sections only
 
@@ -414 +414 @@
 !------------------------------------------------------------------------------------------------------------------------------
   IF(.NOT.ALLOCATED(dBase)) ALLOCATE(dBase(0))
-  OPEN(90, FILE=fnam, FORM='formatted', STATUS='old')
+  OPEN(90, FILE=fnam, FORM='formatted', POSITION='REWIND', STATUS='old')
   DO; str=''
     DO
@@ -427 +427 @@
     IF(str(1:1)=='#') CYCLE                                          !--- Skip comments lines
     CALL removeComment(str)                                          !--- Skip comments at the end of a line
+    IF(LEN_TRIM(str) == 0) CYCLE                                     !--- Empty line (probably end of file)
     IF(str     == '') CYCLE                                          !--- Skip empty line (probably at the end of the file)
     IF(str(1:1)=='&') THEN                                           !=== SECTION HEADER LINE
@@ -445 +446 @@
       tmp%name = v(1); tmp%keys = keys_type(v(1), s(:), v(:))        !--- Set %name and %keys
       dBase(ndb)%trac = [tt(:), tmp]
-      DEALLOCATE(tt)
+      DEALLOCATE(tt, tmp%keys%key, tmp%keys%val)
     END IF
   END DO
@@ -471 +472 @@
   ky => t(jd)%keys
   DO k = 1, SIZE(ky%key)                                             !--- Loop on the keys of the tracer named "defName"
-!   CALL addKey_m(ky%key(k), ky%val(k), t(:)%keys, .FALSE.)           !--- Add key to all the tracers (no overwriting)
+!   CALL addKey(ky%key(k), ky%val(k), t(:)%keys, .FALSE.)            !--- Add key to all the tracers (no overwriting)
     DO it = 1, SIZE(t); CALL addKey_s11(ky%key(k), ky%val(k), t(it)%keys, .FALSE.); END DO
   END DO
@@ -517 +518 @@
 !------------------------------------------------------------------------------------------------------------------------------
   TYPE(trac_type), ALLOCATABLE, INTENT(INOUT) :: tr(:)                 !--- Tracer derived type vector
-  CHARACTER(LEN=*),             INTENT(IN)    :: sname
-  CHARACTER(LEN=*), OPTIONAL,   INTENT(IN)    :: fname
+  CHARACTER(LEN=*),             INTENT(IN)    :: sname                 !--- Current section name
+  CHARACTER(LEN=*), OPTIONAL,   INTENT(IN)    :: fname                 !--- Tracers description file name
   TYPE(trac_type),       ALLOCATABLE :: ttr(:)
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: ta(:), pa(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: ta(:), pa(:), tname(:), parent(:), dType(:)
   CHARACTER(LEN=maxlen) :: msg1, modname
   INTEGER :: it, nt, iq, nq, itr, ntr, ipr, npr
@@ -527 +528 @@
   lerr = .FALSE.
   nt = SIZE(tr)
+  lerr = getKey('name',   tname,  tr(:)%keys);                 IF(lerr) RETURN
+  lerr = getKey('parent', parent, tr(:)%keys, def = tran0);    IF(lerr) RETURN
+  lerr = getKey('type',   dType,  tr(:)%keys, def = 'tracer'); IF(lerr) RETURN
   nq = 0
   !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -532 +536 @@
   !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     !--- Extract useful keys: parent name, type, component name
-    tr(it)%parent    = fgetKey(it, 'parent', tr(:)%keys,  tran0  )
-    tr(it)%type      = fgetKey(it, 'type'  , tr(:)%keys, 'tracer')
     tr(it)%component = sname
-!   CALL addKey_s1m('component', sname, tr(:)%keys)
-    DO iq=1,SIZE(tr); CALL addKey_s11('component', sname, tr(iq)%keys); END DO
+    CALL addKey('component', sname,  tr(it)%keys)
 
     !--- Determine the number of tracers and parents ; coherence checking
-    ll = strCount(tr(it)%name,   ',', ntr)
-    ll = strCount(tr(it)%parent, ',', npr)
+    ll = strCount( tname(it), ',', ntr)
+    ll = strCount(parent(it), ',', npr)
 
     !--- Tagging tracers only can have multiple parents
-    IF(test(npr/=1 .AND. TRIM(tr(it)%type)/='tag', lerr)) THEN
+    lerr = npr /=1 .AND. TRIM(dType(it)) /= 'tag'
+    IF(lerr) THEN
       msg1 = 'Check section "'//TRIM(sname)//'"'
-      IF(PRESENT(fname)) msg1=TRIM(msg1)//' in file "'//TRIM(fname)//'"'
-      CALL msg(TRIM(msg1)//': "'//TRIM(tr(it)%name)//'" has several parents but is not a tag', modname); RETURN
+      IF(PRESENT(fname)) msg1 = TRIM(msg1)//' in file "'//TRIM(fname)//'"'
+      CALL msg(TRIM(msg1)//': "'//TRIM(tname(it))//'" has several parents but is not a tag', modname); RETURN
     END IF
     nq = nq + ntr*npr                 
@@ -558 +560 @@
   DO it = 1, nt                                                      !=== EXPAND TRACERS AND PARENTS NAMES LISTS
   !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    ll = strParse(tr(it)%name,   ',', ta, ntr)                       !--- Number of tracers
-    ll = strParse(tr(it)%parent, ',', pa, npr)                       !--- Number of parents
-    DO ipr=1,npr                                                     !--- Loop on parents list elts
-      DO itr=1,ntr                                                   !--- Loop on tracers list elts
+    ll = strParse( tname(it), ',', ta, ntr)                          !--- Number of tracers
+    ll = strParse(parent(it), ',', pa, npr)                          !--- Number of parents
+    DO ipr = 1, npr                                                  !--- Loop on parents list elts
+      DO itr = 1, ntr                                                !--- Loop on tracers list elts
+        ttr(iq)%keys%name = TRIM(ta(itr))
         ttr(iq)%keys%key  = tr(it)%keys%key
         ttr(iq)%keys%val  = tr(it)%keys%val
-        ttr(iq)%keys%name = ta(itr)
-        ttr(iq)%name      = TRIM(ta(itr));    CALL addKey_s11('name',      ta(itr),          ttr(iq)%keys)
-        ttr(iq)%parent    = TRIM(pa(ipr));    CALL addKey_s11('parent',    pa(ipr),          ttr(iq)%keys)
-        ttr(iq)%type      = tr(it)%type;      CALL addKey_s11('type',      tr(it)%type,      ttr(iq)%keys)
-        ttr(iq)%component = tr(it)%component; CALL addKey_s11('component', tr(it)%component, ttr(iq)%keys)
-        iq = iq+1
+        ttr(iq)%name      = TRIM(ta(itr))
+        ttr(iq)%parent    = TRIM(pa(ipr))
+        ttr(iq)%type      = dType(it)
+        ttr(iq)%component = sname
+        CALL addKey('name',      ta(itr),   ttr(iq)%keys)
+        CALL addKey('parent',    pa(ipr),   ttr(iq)%keys)
+        CALL addKey('type',      dType(it), ttr(iq)%keys)
+        CALL addKey('component', sname,     ttr(iq)%keys)
+        iq = iq + 1
       END DO
     END DO
@@ -586 +592 @@
 !------------------------------------------------------------------------------------------------------------------------------
 ! Purpose: Determine, for each tracer of "tr(:)":
-!   * %iGeneration: the generation number 
-!   * %gen0Name:    the generation 0 ancestor name
-!          Check also for orphan tracers (tracers not descending on "tran0").
+!   * iGeneration: the generation number 
+!   * gen0Name:    the generation 0 ancestor name
+!          Check also for orphan tracers (tracers without parent).
 !------------------------------------------------------------------------------------------------------------------------------
   TYPE(trac_type),     INTENT(INOUT) :: tr(:)                        !--- Tracer derived type vector
   INTEGER                            :: iq, jq, ig
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: parent(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: parent(:), name(:)
+  CHARACTER(LEN=maxlen) :: gen0N
 !------------------------------------------------------------------------------------------------------------------------------
   CHARACTER(LEN=maxlen) :: modname
   modname = 'setGeneration'
-  IF(test(fmsg('missing "parent" attribute', modname, getKey('parent', parent, ky=tr(:)%keys)), lerr)) RETURN
+  lerr = getKey('name',   name,   ky=tr(:)%keys); IF(lerr) RETURN
+  lerr = getKey('parent', parent, ky=tr(:)%keys); IF(lerr) RETURN
   DO iq = 1, SIZE(tr)
     jq = iq; ig = 0
     DO WHILE(parent(jq) /= tran0)
-      jq = strIdx(tr(:)%name, parent(jq))
-      IF(test(fmsg('Orphan tracer "'//TRIM(tr(iq)%name)//'"', modname, jq == 0), lerr)) RETURN
+      jq = strIdx(name(:), parent(jq))
+      lerr = jq == 0
+      IF(fmsg('Orphan tracer "'//TRIM(name(iq))//'"', modname, lerr)) RETURN
       ig = ig + 1
     END DO
-    tr(iq)%gen0Name = tr(jq)%name; CALL addKey_s11('gen0Name',    tr(iq)%gen0Name,   tr(iq)%keys)
-    tr(iq)%iGeneration = ig;       CALL addKey_s11('iGeneration', TRIM(int2str(ig)), tr(iq)%keys)
+    tr(iq)%gen0Name = name(jq)
+    tr(iq)%iGeneration = ig
+    CALL addKey('iGeneration',   ig,  tr(iq)%keys)
+    CALL addKey('gen0Name', name(jq), tr(iq)%keys)
   END DO
 END FUNCTION setGeneration
@@ -615 +626 @@
 !------------------------------------------------------------------------------------------------------------------------------
 ! Purpose:
-!   * check for orphan tracers (without known parent)
-!   * check wether the phases are known or not ("g"aseous, "l"iquid or "s"olid so far)
+!   * check for orphan tracers (without parent)
+!   * check wether the phases are known or not (elements of "known_phases")
 !------------------------------------------------------------------------------------------------------------------------------
   TYPE(trac_type),            INTENT(IN) :: tr(:)                    !--- Tracer derived type vector
   CHARACTER(LEN=*),           INTENT(IN) :: sname                    !--- Section name
   CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: fname                    !--- File name
+  CHARACTER(LEN=1) :: p
   CHARACTER(LEN=maxlen) :: mesg
   CHARACTER(LEN=maxlen) :: bp(SIZE(tr, DIM=1)), pha                  !--- Bad phases list, phases of current tracer
-  CHARACTER(LEN=1) :: p
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tname(:)
+  INTEGER,               ALLOCATABLE ::  iGen(:)
   INTEGER :: ip, np, iq, nq
 !------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: modname
+  modname = 'checkTracers'
   nq = SIZE(tr,DIM=1)                                                !--- Number of tracers lines
   mesg = 'Check section "'//TRIM(sname)//'"'
   IF(PRESENT(fname)) mesg=TRIM(mesg)//' in file "'//TRIM(fname)//'"'
+  lerr = getKey('iGeneration', iGen, tr(:)%keys);               IF(lerr) RETURN
+  lerr = getKey('name',       tname, tr(:)%keys);               IF(lerr) RETURN
 
   !=== CHECK FOR ORPHAN TRACERS
-  IF(test(checkList(tr%name, tr%iGeneration==-1, mesg, 'tracers', 'orphan'), lerr)) RETURN
+  lerr = checkList(tname, iGen==-1, mesg, 'tracers', 'orphan'); IF(lerr) RETURN
 
   !=== CHECK PHASES
-  DO iq=1,nq; IF(tr(iq)%iGeneration/=0) CYCLE                        !--- Generation O only is checked
-    pha = fgetKey(iq, 'phases', tr(:)%keys, 'g')                     !--- Phases
+  DO iq = 1, nq; IF(iGen(iq) /= 0) CYCLE                             !--- Generation O only is checked
+    IF(getKey(['phases','phase '], pha, iq, tr(:)%keys, lDisp=.FALSE.)) pha = 'g'   !--- Phase
     np = LEN_TRIM(pha); bp(iq)=' '
-    DO ip=1,np; p = pha(ip:ip); IF(INDEX(known_phases,p)==0) bp(iq) = TRIM(bp(iq))//p; END DO
-    IF(TRIM(bp(iq)) /= '') bp(iq) = TRIM(tr(iq)%name)//': '//TRIM(bp(iq))
+    DO ip = 1, np; p = pha(ip:ip); IF(INDEX(known_phases, p) == 0) bp(iq) = TRIM(bp(iq))//p; END DO
+    IF(TRIM(bp(iq)) /= '') bp(iq) = TRIM(tname(iq))//': '//TRIM(bp(iq))
   END DO
-  lerr = checkList(bp, tr%iGeneration==0 .AND. bp/='', mesg, 'tracers phases', 'unknown')
+  lerr = checkList(bp, iGen == 0 .AND. bp /= '', mesg, 'tracers phases', 'unknown')
 END FUNCTION checkTracers
 !==============================================================================================================================
@@ -656 +673 @@
   INTEGER :: ip, np, iq, nq, k
   LOGICAL, ALLOCATABLE  :: ll(:)
-  CHARACTER(LEN=maxlen) :: mesg, tnam, tdup(SIZE(tr,DIM=1))
-  CHARACTER(LEN=1)      :: p
-!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: mesg, phase, tdup(SIZE(tr,DIM=1))
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tname(:), dType(:)
+  INTEGER,               ALLOCATABLE :: iGen(:)
+  CHARACTER(LEN=1) :: p
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: modname
+  modname = 'checkUnique'
   mesg = 'Check section "'//TRIM(sname)//'"'
   IF(PRESENT(fname)) mesg=TRIM(mesg)//' in file "'//TRIM(fname)//'"'
   nq=SIZE(tr,DIM=1); lerr=.FALSE.                                    !--- Number of lines ; error flag
   tdup(:) = ''
-  DO iq=1,nq; IF(tr(iq)%type == 'tag') CYCLE                         !--- Tags can be repeated
-    tnam = TRIM(tr(iq)%name)
-    ll = tr(:)%name==TRIM(tnam)                                      !--- Mask for current tracer name
-    IF(COUNT(ll)==1 ) CYCLE                                          !--- Tracer is not repeated
-    IF(tr(iq)%iGeneration>0) THEN
-      tdup(iq) = tnam                                                !--- gen>0: MUST be unique
+  lerr = getKey('name',       tname, tr%keys); IF(lerr) RETURN
+  lerr = getKey('type',       dType, tr%keys); IF(lerr) RETURN
+  lerr = getKey('iGeneration', iGen, tr%keys); IF(lerr) RETURN
+  DO iq = 1, nq
+    IF(dType(iq) == 'tag') CYCLE                                     !--- Tags can be repeated
+    ll = tname==TRIM(tname(iq))                                      !--- Mask for current tracer name
+    IF(COUNT(ll) == 1) CYCLE                                         !--- Tracer is not repeated
+    IF(iGen(iq) > 0) THEN
+      tdup(iq) = tname(iq)                                           !--- gen>0: MUST be unique
     ELSE
-      DO ip=1,nphases; p=known_phases(ip:ip)                         !--- Loop on known phases
-        !--- Number of appearances of the current tracer with known phase "p"
-        np = COUNT( PACK( [(INDEX(fgetKey(k, 'phases', tr(:)%keys, 'g'),p), k=1, nq)] /=0 , MASK=ll ) )
-        IF(np <=1) CYCLE
-        tdup(iq) = TRIM(tdup(iq))//TRIM(phases_names(ip))
+      DO ip = 1, nphases; p = known_phases(ip:ip)                    !--- Loop on known phases
+        np = 0
+        DO k = 1, nq
+          IF(.NOT.ll(k)) CYCLE                                       !--- Skip tracers different from current one
+          IF(getKey(['phases','phase '], phase, k, tr%keys, lDisp=.FALSE.)) phase='g'!--- Get current phases
+          IF(INDEX(phase, p) /= 0) np = np + 1                       !--- One more appearance of current tracer with phase "p"
+        END DO
+        IF(np <= 1) CYCLE                                            !--- Regular case: no or a single appearance
+        tdup(iq) = TRIM(tdup(iq))//TRIM(phases_names(ip))            !--- Repeated phase
         IF(ANY(tdup(1:iq-1) == tdup(iq))) tdup(iq)=''                !--- Avoid repeating same messages
       END DO
     END IF
-    IF(tdup(iq) /= '') tdup(iq)=TRIM(tnam)//' in '//TRIM(tdup(iq))//' phase(s)'
+    IF(tdup(iq) /= '') tdup(iq)=TRIM(tname(iq))//' in '//TRIM(tdup(iq))//' phase(s)'
   END DO
   lerr = checkList(tdup, tdup/='', mesg, 'tracers', 'duplicated')
@@ -686 +714 @@
 
 !==============================================================================================================================
-SUBROUTINE expandPhases(tr)
+LOGICAL FUNCTION expandPhases(tr) RESULT(lerr)
 !------------------------------------------------------------------------------------------------------------------------------
 ! Purpose: Expand the phases in the tracers descriptor "tr". Phases are not repeated for a tracer, thanks to "checkUnique".
@@ -692 +720 @@
   TYPE(trac_type), ALLOCATABLE, INTENT(INOUT) :: tr(:)               !--- Tracer derived type vector
 !------------------------------------------------------------------------------------------------------------------------------
-  TYPE(trac_type), ALLOCATABLE :: ttr(:)
-  INTEGER,   ALLOCATABLE ::  i0(:)
-  CHARACTER(LEN=maxlen)  :: nam, pha, tname
+  TYPE(trac_type),       ALLOCATABLE :: ttr(:)
+  INTEGER,               ALLOCATABLE ::  i0(:), iGen(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tname(:), gen0N(:), phase(:), parents(:), dType(:)
+  CHARACTER(LEN=maxlen)              ::  nam,     gen0Nm,   pha,      parent,      typ
   CHARACTER(LEN=1) :: p
   INTEGER :: ip, np, iq, jq, nq, it, nt, nc, i, n
   LOGICAL :: lTag, lExt
 !------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: modname
+  modname = 'expandPhases'
   nq = SIZE(tr, DIM=1)
   nt = 0
+  lerr = getKey('name',       tname, tr%keys); IF(lerr) RETURN       !--- Names of the tracers
+  lerr = getKey('gen0Name',   gen0N, tr%keys); IF(lerr) RETURN       !--- Names of the tracers of first generation
+  lerr = getKey('iGeneration', iGen, tr%keys); IF(lerr) RETURN       !--- Generation number
+  lerr = getKey('phases',     phase, tr%keys); IF(lerr) RETURN       !--- Phases names
+  lerr = getKey('parent',   parents, tr%keys); IF(lerr) RETURN       !--- Parents names
+  lerr = getKey('type',       dType, tr%keys); IF(lerr) RETURN       !--- Tracers types ('tracer' or 'tag')
   DO iq = 1, nq                                                      !--- GET THE NUMBER OF TRACERS
-    IF(tr(iq)%iGeneration /= 0) CYCLE                                !--- Only deal with generation 0 tracers
-    nc = COUNT(tr(:)%gen0Name==tr(iq)%name .AND. tr%iGeneration/=0)  !--- Number of children of tr(iq)
-    tr(iq)%phase = fgetKey(iq, 'phases', tr(:)%keys)                 !--- Phases list        of tr(iq)
-    np = LEN_TRIM(tr(iq)%phase)                                      !--- Number of phases   of tr(iq)
+    IF(iGen(iq) /= 0) CYCLE                                          !--- Only deal with generation 0 tracers
+    nc = COUNT(gen0N == tname(iq) .AND. iGen /= 0)                   !--- Number of children of tr(iq)
+    np = LEN_TRIM(phase(iq))                                         !--- Number of phases   of tr(iq)
     nt = nt + (1+nc) * np                                            !--- Number of tracers after expansion
   END DO
@@ -711 +747 @@
   it = 1                                                             !--- Current "ttr(:)" index
   DO iq = 1, nq                                                      !--- Loop on "tr(:)" indexes
-    lTag = tr(iq)%type=='tag'                                        !--- Current tracer is a tag
-    i0 = strFind(tr(:)%name, TRIM(tr(iq)%gen0Name), n)               !--- Indexes of first generation ancestor copies
-    np = SUM([( LEN_TRIM(tr(i0(i))%phase),i=1,n )], 1)               !--- Number of phases for current tracer tr(iq)
-    lExt = np>1                                                      !--- Phase suffix only required if phases number is > 1
-    IF(lTag) lExt = lExt .AND. tr(iq)%iGeneration>0                  !--- No phase suffix for generation 0 tags
-    DO i=1,n                                                         !=== LOOP ON GENERATION 0 ANCESTORS
+    lTag = dType(iq)=='tag'                                          !--- Current tracer is a tag
+    i0 = strFind(tname, TRIM(gen0N(iq)), n)                          !--- Indexes of first generation ancestor copies
+    np = SUM([( LEN_TRIM(phase(i0(i))), i = 1, n )], 1)              !--- Number of phases for current tracer tr(iq)
+    lExt = np > 1                                                    !--- Phase suffix only required if phases number is > 1
+    IF(lTag) lExt = lExt .AND. iGen(iq) > 0                          !--- No phase suffix for generation 0 tags
+    DO i = 1, n                                                      !=== LOOP ON GENERATION 0 ANCESTORS
       jq = i0(i)                                                     !--- tr(jq): ith tracer with same gen 0 ancestor as tr(iq)
-      IF(tr(iq)%iGeneration==0) jq=iq                                !--- Generation 0: count the current tracer phases only
-      pha = tr(jq)%phase                                             !--- Phases list for tr(jq)
+      IF(iGen(iq) == 0) jq = iq                                      !--- Generation 0: count the current tracer phases only
+      pha = phase(jq)                                                !--- Phases list for tr(jq)
       DO ip = 1, LEN_TRIM(pha)                                       !=== LOOP ON PHASES LISTS
         p = pha(ip:ip)
-        tname = TRIM(tr(iq)%name); nam = tname                       !--- Tracer name (regular case)
-        IF(lTag) nam = TRIM(tr(iq)%parent)                           !--- Parent name (tagging case)
+        nam = tname(iq)                                              !--- Tracer name (regular case)
+        IF(lTag) nam = TRIM(parents(iq))                             !--- Parent name (tagging case)
         IF(lExt) nam = addPhase(nam, p )                             !--- Phase extension needed
-        IF(lTag) nam = TRIM(nam)//'_'//TRIM(tname)                   !--- <parent>_<name> for tags
+        IF(lTag) nam = TRIM(nam)//'_'//TRIM(tname(iq))               !--- <parent>_<name> for tags
         ttr(it) = tr(iq)                                             !--- Same <key>=<val> pairs
         ttr(it)%name      = TRIM(nam)                                !--- Name with possibly phase suffix
         ttr(it)%keys%name = TRIM(nam)                                !--- Name inside the keys decriptor
         ttr(it)%phase     = p                                        !--- Single phase entry
-        CALL addKey_s11('name', nam, ttr(it)%keys)
-        CALL addKey_s11('phase', p,  ttr(it)%keys)
-        IF(lExt .AND. tr(iq)%iGeneration>0) THEN
-          ttr(it)%parent   = addPhase(tr(iq)%parent,   p)
-          ttr(it)%gen0Name = addPhase(tr(iq)%gen0Name, p)
-          CALL addKey_s11('parent',   ttr(it)%parent,   ttr(it)%keys)
-          CALL addKey_s11('gen0Name', ttr(it)%gen0Name, ttr(it)%keys)
+        CALL addKey('name', nam, ttr(it)%keys)
+        CALL addKey('phase', p,  ttr(it)%keys)
+        IF(lExt) THEN
+          parent = parents(iq); IF(iGen(iq) > 0) parent = addPhase(parent, p)
+          gen0Nm =   gen0N(iq); IF(iGen(iq) > 0) gen0Nm = addPhase(gen0Nm, p)
+          ttr(it)%parent   = parent
+          ttr(it)%gen0Name = gen0Nm
+          CALL addKey('parent',   parent, ttr(it)%keys)
+          CALL addKey('gen0Name', gen0Nm, ttr(it)%keys)
         END IF
         it = it+1
       END DO
-      IF(tr(iq)%iGeneration==0) EXIT                                 !--- Break phase loop for gen 0
+      IF(iGen(iq) == 0) EXIT                                         !--- Break phase loop for gen 0
     END DO
   END DO
@@ -746 +784 @@
   CALL delKey(['phases'],tr)                                         !--- Remove few keys entries
 
-END SUBROUTINE expandPhases
+END FUNCTION expandPhases
 !==============================================================================================================================
 
@@ -759 +797 @@
 !   TO BE ADDED IF NECESSARY: HIGHER MOMENTS AT THE END
 !------------------------------------------------------------------------------------------------------------------------------
-  TYPE(trac_type), ALLOCATABLE, INTENT(INOUT) :: tr(:)         !--- Tracer derived type vector
-!------------------------------------------------------------------------------------------------------------------------------
-  TYPE(trac_type), ALLOCATABLE        :: tr2(:)
-  INTEGER,         ALLOCATABLE        :: iy(:), iz(:)
-  INTEGER                             :: ig, ng, iq, jq, ip, nq, n, ix(SIZE(tr)), k
+  TYPE(trac_type), INTENT(INOUT) :: tr(:)                            !--- Tracer derived type vector
+!------------------------------------------------------------------------------------------------------------------------------
+  TYPE(trac_type),       ALLOCATABLE :: tr2(:)
+  INTEGER,               ALLOCATABLE :: iy(:), iz(:)
+  INTEGER,               ALLOCATABLE ::  iGen(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tname(:), gen0N(:)
+  INTEGER :: ig, ng, iq, jq, ip, nq, n, ix(SIZE(tr)), k
+  LOGICAL :: lerr
 !  tr2 is introduced in order to cope with a bug in gfortran 4.8.5 compiler
 !------------------------------------------------------------------------------------------------------------------------------
+  lerr = getKey('iGeneration', iGen, tr%keys); IF(lerr) RETURN       !--- Generation number
   nq = SIZE(tr)
   DO ip = nphases, 1, -1
-    iq = strIdx(tr(:)%name, addPhase('H2O', ip))
+    lerr = getKey('name',     tname, tr%keys); IF(lerr) RETURN       !--- Names of the tracers of first generation
+    iq = strIdx(tname, addPhase('H2O', ip))
     IF(iq == 0) CYCLE
     tr2 = tr(:)
@@ -775 +818 @@
   IF(lSortByGen) THEN
     iq = 1
-    ng = MAXVAL(tr(:)%iGeneration, MASK=.TRUE., DIM=1)               !--- Number of generations
+    ng = MAXVAL(iGen, MASK=.TRUE., DIM=1)                            !--- Number of generations
     DO ig = 0, ng                                                    !--- Loop on generations
-      iy = PACK([(k, k=1, nq)], MASK=tr(:)%iGeneration==ig)          !--- Generation ig tracers indexes
+      iy = PACK([(k, k=1, nq)], MASK=iGen(:) == ig)                  !--- Generation ig tracers indexes
       n = SIZE(iy)
       ix(iq:iq+n-1) = iy                                             !--- Stack growing generations idxs
@@ -783 +826 @@
     END DO
   ELSE
-    iq = 1
+    lerr = getKey('gen0Name',   gen0N, tr%keys); IF(lerr) RETURN     !--- Names of the tracers    iq = 1
     DO jq = 1, nq                                                    !--- Loop on generation 0 tracers
-      IF(tr(jq)%iGeneration /= 0) CYCLE                              !--- Skip generations /= 0
+      IF(iGen(jq) /= 0) CYCLE                                        !--- Skip generations /= 0
       ix(iq) = jq                                                    !--- Generation 0 ancestor index first
       iq = iq + 1                                                    !--- Next "iq" for next generations tracers
-      iy = strFind(tr(:)%gen0Name, TRIM(tr(jq)%name))                !--- Indexes of "tr(jq)" children in "tr(:)"
-      ng = MAXVAL(tr(iy)%iGeneration, MASK=.TRUE., DIM=1)            !--- Number of generations of the "tr(jq)" family
+      iy = strFind(gen0N(:), TRIM(tname(jq)))                        !--- Indices of "tr(jq)" children in "tr(:)"
+      ng = MAXVAL(iGen(iy), MASK=.TRUE., DIM=1)                      !--- Number of generations of the "tr(jq)" family
       DO ig = 1, ng                                                  !--- Loop   on generations of the "tr(jq)" family
-        iz = find(tr(iy)%iGeneration, ig, n)                         !--- Indexes of the tracers "tr(iy(:))" of generation "ig"
+        iz = find(iGen(iy), ig, n)                                   !--- Indices of the tracers "tr(iy(:))" of generation "ig"
         ix(iq:iq+n-1) = iy(iz)                                       !--- Same indexes in "tr(:)"
         iq = iq + n
@@ -807 +850 @@
   TYPE(trac_type), ALLOCATABLE, INTENT(OUT) ::       tr(:)
   TYPE(trac_type), POINTER ::   t1(:),   t2(:)
+  TYPE(keys_type), POINTER ::   k1(:),   k2(:)
   INTEGER,     ALLOCATABLE :: ixct(:), ixck(:)
-  INTEGER :: is, k1, k2, nk2, i1, i2, nt2
+  INTEGER :: is, ik, ik1, ik2, nk2, i1, i2, nt2
   CHARACTER(LEN=maxlen) :: s1, v1, v2, tnam, knam, modname
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: keys(:), n1(:), n2(:)
   modname = 'mergeTracers'
   lerr = .FALSE.
-  t1 => sections(1)%trac(:)                                          !--- Alias: first tracers section
+  keys = ['parent     ', 'type       ', 'iGeneration']               !--- Mandatory keys
+  t1 => sections(1)%trac(:); k1 => t1(:)%keys                        !--- Alias: first tracers section, corresponding keys
+  lerr = getKey('name', n1, k1); IF(lerr) RETURN                     !--- Names of the tracers
   tr = t1
   !----------------------------------------------------------------------------------------------------------------------------
@@ -818 +865 @@
   !----------------------------------------------------------------------------------------------------------------------------
     t2  => sections(is)%trac(:)                                      !--- Alias: current tracers section
+    k2  => t2(:)%keys
+    lerr = getKey('name', n2, k2); IF(lerr) RETURN                   !--- Names of the tracers
     nt2  = SIZE(t2(:), DIM=1)                                        !--- Number of tracers in section
-    ixct = strIdx(t1(:)%name, t2(:)%name)                            !--- Indexes of common tracers
+    ixct = strIdx(n1(:), n2(:))                                      !--- Indexes of common tracers
     tr = [tr, PACK(t2, MASK= ixct==0)]                               !--- Append with new tracers
     IF( ALL(ixct == 0) ) CYCLE                                       !--- No common tracers => done
     CALL msg('Tracers defined in previous sections and duplicated in "'//TRIM(sections(is)%name)//'":', modname)
-    CALL msg(t1(PACK(ixct, MASK = ixct/=0))%name, modname, nmax=128) !--- Display duplicates (the 128 first at most)
+    CALL msg(n1(PACK(ixct, MASK = ixct/=0)), modname, nmax=128)      !--- Display duplicates (the 128 first at most)
     !--------------------------------------------------------------------------------------------------------------------------
     DO i2=1,nt2; tnam = TRIM(t2(i2)%name)                            !=== LOOP ON COMMON TRACERS
@@ -831 +880 @@
       !=== CHECK WETHER ESSENTIAL KEYS ARE IDENTICAL OR NOT
       s1=' of "'//TRIM(tnam)//'" in "'//TRIM(sections(is)%name)//'" not matching previous value'
-      
-      IF(test(fmsg('Parent name'//TRIM(s1), modname, t1(i1)%parent      /= t2(i2)%parent),      lerr)) RETURN
-      IF(test(fmsg('Type'       //TRIM(s1), modname, t1(i1)%type        /= t2(i2)%type),        lerr)) RETURN
-      IF(test(fmsg('Generation' //TRIM(s1), modname, t1(i1)%iGeneration /= t2(i2)%iGeneration), lerr)) RETURN
-
-      !=== APPEND <key>=<val> PAIRS NOT PREVIOULSLY DEFINED
-      nk2  = SIZE(t2(i2)%keys%key(:))                                !--- Keys number in current section
-      ixck = strIdx(t1(i1)%keys%key(:), t2(i2)%keys%key(:))          !--- Common keys indexes
-
-      !=== APPEND NEW KEYS
+      DO ik = 1, SIZE(keys)
+        lerr = getKey(keys(ik), v1, i1, k1)
+        lerr = getKey(keys(ik), v2, i2, k2)
+        lerr = v1 /= v2; IF(fmsg(TRIM(keys(ik))//TRIM(s1), modname, lerr)) RETURN
+      END DO
+
+      !=== GET THE INDICES IN tr(i2)%keys%key(:) OF THE KEYS ALSO PRESENT IN tr(i1)%keys%key(:)
+      nk2  =   SIZE(k2(i2)%key(:))                                   !--- Keys number in current section
+      ixck = strIdx(k1(i1)%key(:), k2(i2)%key(:))                    !--- Common keys indexes
+      !--- APPEND THE NEW KEYS PAIRS IN tr(i1)%keys%key(:)
       tr(i1)%keys%key = [ tr(i1)%keys%key, PACK(tr(i2)%keys%key, MASK = ixck==0)]
       tr(i1)%keys%val = [ tr(i1)%keys%val, PACK(tr(i2)%keys%val, MASK = ixck==0)]
 
-      !--- KEEP TRACK OF THE COMPONENTS NAMES
-      tr(i1)%component = TRIM(tr(i1)%component)//','//TRIM(tr(i2)%component)
-
-      !--- SELECT COMMON TRACERS WITH DIFFERING KEYS VALUES (PREVIOUS VALUE IS KEPT)
-      DO k2=1,nk2
-        k1 = ixck(k2); IF(k1 == 0) CYCLE
-        IF(t1(i1)%keys%val(k1) == t2(i2)%keys%val(k2)) ixck(k2)=0
+      !=== KEEP TRACK OF THE COMPONENTS NAMES: COMA-SEPARATED LIST
+      lerr = getKey('component', v1, i1, k1)
+      lerr = getKey('component', v2, i2, k2)
+      tr(i1)%component = TRIM(v1)//','//TRIM(v2)
+      CALL addKey_s11('component', TRIM(v1)//','//TRIM(v2), tr(i1)%keys)
+
+      !=== FOR TRACERS COMMON TO PREVIOUS AND CURRENT SECTIONS: CHECK WETHER SOME KEYS HAVE DIFFERENT VALUES ; KEEP OLD ONE
+      DO ik2 = 1, nk2                                                !--- Collect the corresponding indices
+        ik1 = ixck(ik2); IF(ik1 == 0) CYCLE
+        IF(k1(i1)%val(ik1) == k2(i2)%val(ik2)) ixck(ik2)=0
       END DO
-      IF(ALL(ixck==0)) CYCLE                                         !--- No identical keys with /=values
-
-      !--- DISPLAY INFORMATION: OLD VALUES ARE KEPT FOR THE KEYS FOUND IN PREVIOUS AND CURRENT SECTIONS
-      CALL msg('Key(s)'//TRIM(s1), modname)
-      DO k2 = 1, nk2                                                 !--- Loop on keys found in both t1(:) and t2(:)
-        knam = t2(i2)%keys%key(k2)                                   !--- Name of the current key
-        k1 = ixck(k2)                                                !--- Corresponding index in t1(:)
-        IF(k1 == 0) CYCLE                                            !--- New keys are skipped
-        v1 = t1(i1)%keys%val(k1); v2 = t2(i2)%keys%val(k2)           !--- Key values in t1(:) and t2(:)
+      IF(ALL(ixck==0)) CYCLE                                         !--- No identical keys with /=values => nothing to display
+      CALL msg('Key(s)'//TRIM(s1), modname)                          !--- Display the  keys with /=values (names list)
+      DO ik2 = 1, nk2                                                !--- Loop on keys found in both t1(:) and t2(:)
+        knam = k2(i2)%key(ik2)                                       !--- Name of the current key
+        ik1 = ixck(ik2)                                              !--- Corresponding index in t1(:)
+        IF(ik1 == 0) CYCLE                                           !--- New keys are skipped
+        v1 = k1(i1)%val(ik1); v2 = k2(i2)%val(ik2)                   !--- Key values in t1(:) and t2(:)
         CALL msg(' * '//TRIM(knam)//'='//TRIM(v2)//' ; previous value kept:'//TRIM(v1), modname)
       END DO
@@ -873 +923 @@
 
 !==============================================================================================================================
-LOGICAL FUNCTION cumulTracers(sections, tr) RESULT(lerr)
+LOGICAL FUNCTION cumulTracers(sections, tr, lRename) RESULT(lerr)
   TYPE(dataBase_type),  TARGET, INTENT(IN)  :: sections(:)
   TYPE(trac_type), ALLOCATABLE, INTENT(OUT) ::       tr(:)
-  TYPE(trac_type), POINTER     :: t(:)
-  INTEGER,   ALLOCATABLE :: nt(:)
-  CHARACTER(LEN=maxlen)  :: tnam, tnam_new
-  INTEGER :: iq, nq, is, ns, nsec
-  lerr = .FALSE.                                                     !--- Can't fail ; kept to match "mergeTracer" interface.
-  nsec =  SIZE(sections)
-  tr = [(      sections(is)%trac(:) , is=1, nsec )]                  !--- Concatenated tracers vector
-  nt = [( SIZE(sections(is)%trac(:)), is=1, nsec )]                  !--- Number of tracers in each section
+  LOGICAL,            OPTIONAL, INTENT(IN)  :: lRename               !--- .TRUE.: add a section suffix to identical names
+  CHARACTER(LEN=maxlen)  :: tnam, tnam_new, modname
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tname(:), parent(:), comp(:)
+  INTEGER :: iq, jq, is
+  modname = 'cumulTracers'
+  lerr = .FALSE.
+  tr = [( sections(is)%trac(:), is = 1, SIZE(sections) )]            !--- Concatenated tracers vector
+  IF(PRESENT(lRename)) THEN; IF(lRename) RETURN; END IF              !--- No renaming: finished
+  lerr = getKey('name',     tname, tr%keys); IF(lerr) RETURN         !--- Names
+  lerr = getKey('parent',  parent, tr%keys); IF(lerr) RETURN         !--- Parents
+  lerr = getKey('component', comp, tr%keys); IF(lerr) RETURN         !--- Component name
   !----------------------------------------------------------------------------------------------------------------------------
-  DO is=1, nsec                                                      !=== LOOP ON SECTIONS
+  DO iq = 1, SIZE(tr); IF(COUNT(tname == tname(iq)) == 1) CYCLE      !=== LOOP ON TRACERS
   !----------------------------------------------------------------------------------------------------------------------------
-    t => sections(is)%trac(:)
+    tnam_new = TRIM(tname(iq))//'_'//TRIM(comp(iq))                  !--- Same with section extension
+    CALL addKey('name', tnam_new, tr(iq)%keys)                       !--- Modify tracer name
+    tr(iq)%name = TRIM(tnam_new)                                     !--- Modify tracer name
     !--------------------------------------------------------------------------------------------------------------------------
-    DO iq=1, nt(is)                                                  !=== LOOP ON TRACERS
+    DO jq = 1, SIZE(tr); IF(parent(jq) /= tname(iq)) CYCLE           !=== LOOP ON TRACERS PARENTS
     !--------------------------------------------------------------------------------------------------------------------------
-      tnam = TRIM(t(iq)%name)                                        !--- Original name
-      IF(COUNT(t%name == tnam) == 1) CYCLE                           !--- Current tracer is not duplicated: finished
-      tnam_new = TRIM(tnam)//'_'//TRIM(sections(is)%name)            !--- Same with section extension
-      nq = SUM(nt(1:is-1))                                           !--- Number of tracers in previous sections
-      ns = nt(is)                                                    !--- Number of tracers in the current section
-      tr(iq + nq)%name = TRIM(tnam_new)                              !--- Modify tracer name
-      WHERE(tr(1+nq:ns+nq)%parent==tnam) tr(1+nq:ns+nq)%parent=tnam_new  !--- Modify parent name
+      CALL addKey('parent', tnam_new, tr(jq)%keys)                   !--- Modify tracer name
+      tr(jq)%parent = TRIM(tnam_new)                                 !--- Modify tracer name
     !--------------------------------------------------------------------------------------------------------------------------
     END DO
@@ -907 +957 @@
 !==============================================================================================================================
 
-!==============================================================================================================================
-SUBROUTINE setDirectKeys(tr)
+
+!==============================================================================================================================
+LOGICAL  FUNCTION  dispTraSection(message, sname, modname) RESULT(lerr)
+  CHARACTER(LEN=*), INTENT(IN) :: message, sname, modname
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: s(:,:), n(:), tmp(:)
+  CHARACTER(LEN=maxlen) :: p
+  INTEGER :: idb, iq, nq
+  idb = strIdx(dBase(:)%name, sname); IF(idb == 0) RETURN
+  nq = SIZE(dBase(idb)%trac)
+  p = ''
+  CALL append(['iq'],             .TRUE. ); IF(lerr) RETURN
+  CALL append(['name'],           .TRUE. ); IF(lerr) RETURN
+  CALL append(['phases','phase'], .FALSE., 'pha'); IF(lerr) RETURN
+  CALL append(['hadv'],           .TRUE. ); IF(lerr) RETURN
+  CALL append(['vadv'],           .TRUE. ); IF(lerr) RETURN
+  CALL append(['parent'],         .FALSE.); IF(lerr) RETURN
+  CALL append(['iGen'],           .FALSE.); IF(lerr) RETURN
+  CALL msg(TRIM(message)//':', modname)
+  lerr = dispTable(p, n, s, nColMax=maxTableWidth, nHead=2, sub=modname); IF(lerr) RETURN
+
+CONTAINS
+
+SUBROUTINE append(nam, lMandatory, snam)
+! Test whether key named "nam(:)" is available.
+!  * yes: - get its value for all species in "tmp(:)" and append table "s(:,:)" with it
+!         - append titles list with "nam(1)" (or, if specified, "snam", usually a short name).
+!  * no:  return to calling routine with an error flag if the required key is mandatory
+  CHARACTER(LEN=*),           INTENT(IN) :: nam(:)
+  LOGICAL,                    INTENT(IN) :: lMandatory
+  CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: snam
+  INTEGER :: m
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: s0(:,:), n0(:)
+  CHARACTER(LEN=maxlen) :: nm
+  lerr = .FALSE.
+  IF(nam(1) == 'iq') THEN
+    tmp = int2str([(iq, iq=1, nq)])
+  ELSE
+    lerr = getKey(nam, tmp, dBase(idb)%trac(:)%keys, lDisp=lMandatory)
+  END IF
+  IF(lerr) THEN; lerr = lMandatory; RETURN; END IF
+  nm = nam(1); IF(PRESENT(snam)) nm = snam
+  p = TRIM(p)//'s'
+  IF(ALLOCATED(s)) THEN; s = cat(s, tmp); ELSE; ALLOCATE(s(nq,1)); s(:,1) = tmp; END IF
+  IF(ALLOCATED(n)) THEN; m = SIZE(n); ALLOCATE(n0(m+1)); n0(1:m)=n; n0(m+1)=nm; CALL MOVE_ALLOC(FROM=n0, TO=n)
+  ELSE; n=nam(1:1); END IF
+END SUBROUTINE append
+
+END FUNCTION dispTraSection
+!==============================================================================================================================
+
+
+!==============================================================================================================================
+!=== CREATE TRACER(S) ALIAS: SCALAR/VECTOR FROM NAME(S) OR INDICE(S) ==========================================================
+!==============================================================================================================================
+LOGICAL FUNCTION aliasTracer(tname, trac, alias) RESULT(lerr)                  !=== TRACER NAMED "tname" - SCALAR
+  CHARACTER(LEN=*),         INTENT(IN)  :: tname
+  TYPE(trac_type), TARGET,  INTENT(IN)  :: trac(:)
+  TYPE(trac_type), POINTER, INTENT(OUT) :: alias
+  INTEGER :: it
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tnames(:)
+  alias => NULL()
+  lerr = getKey('name', tnames, trac(:)%keys)
+  it = strIdx(tnames, tname)
+  lerr = it /= 0; IF(.NOT.lerr) alias => trac(it)
+END FUNCTION aliasTracer
+!==============================================================================================================================
+LOGICAL FUNCTION trSubset_Indx(trac, idx, alias) RESULT(lerr)                  !=== TRACERS WITH INDICES "idx(:)" - VECTOR
+  TYPE(trac_type), ALLOCATABLE, INTENT(IN)  ::  trac(:)
+  INTEGER,                      INTENT(IN)  ::   idx(:)
+  TYPE(trac_type), ALLOCATABLE, INTENT(OUT) :: alias(:)
+  alias = trac(idx)
+  lerr = indexUpdate(alias)
+END FUNCTION trSubset_Indx
+!------------------------------------------------------------------------------------------------------------------------------
+LOGICAL FUNCTION trSubset_Name(trac, tname, alias) RESULT(lerr)                !=== TRACERS NAMED "tname(:)" - VECTOR
+  TYPE(trac_type), ALLOCATABLE, INTENT(IN)  ::  trac(:)
+  CHARACTER(LEN=*),             INTENT(IN)  :: tname(:)
+  TYPE(trac_type), ALLOCATABLE, INTENT(OUT) :: alias(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tnames(:)
+  lerr = getKey('name', tnames, trac(:)%keys)
+  alias = trac(strIdx(tnames, tname))
+  lerr = indexUpdate(alias)
+END FUNCTION trSubset_Name
+!==============================================================================================================================
+LOGICAL FUNCTION trSubset_gen0Name(trac, gen0Nm, alias) RESULT(lerr)           !=== TRACERS OF COMMON 1st GENERATION ANCESTOR
+  TYPE(trac_type), ALLOCATABLE, INTENT(IN)  :: trac(:)
+  CHARACTER(LEN=*),             INTENT(IN)  :: gen0Nm
+  TYPE(trac_type), ALLOCATABLE, INTENT(OUT) :: alias(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: gen0N(:)
+  lerr = getKey('gen0Name', gen0N, trac(:)%keys)
+  alias = trac(strFind(delPhase(gen0N), gen0Nm))
+  lerr = indexUpdate(alias)
+END FUNCTION trSubset_gen0Name
+!==============================================================================================================================
+
+
+!==============================================================================================================================
+!=== UPDATE THE INDEXES iqParent, iqDescend AND iGeneration IN THE TRACERS DESCRIPTOR LIST "tr" (USEFULL FOR SUBSETS) =========
+!==============================================================================================================================
+LOGICAL FUNCTION indexUpdate(tr) RESULT(lerr)
   TYPE(trac_type), INTENT(INOUT) :: tr(:)
-
-  !--- Update %iqParent, %iqDescen, %nqDescen, %nqChildren
-  CALL indexUpdate(tr)
-
-  !--- Extract some direct-access keys
-!  DO iq = 1, SIZE(tr)
-!    tr(iq)%keys%<key> = getKey_prv(it, "<key>", tr%keys, <default_value> )
-!  END DO
-END SUBROUTINE setDirectKeys
-!==============================================================================================================================
-
-!==============================================================================================================================
-LOGICAL FUNCTION dispTraSection(message, sname, modname) RESULT(lerr)
-  CHARACTER(LEN=*), INTENT(IN) :: message, sname, modname
-  INTEGER :: idb, iq, nq
-  INTEGER, ALLOCATABLE :: hadv(:), vadv(:)
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: phas(:), prnt(:)
-  TYPE(trac_type), POINTER :: tm(:)
-  lerr = .FALSE.
-  idb = strIdx(dBase(:)%name, sname); IF(idb == 0) RETURN
-  tm => dBase(idb)%trac
-  nq = SIZE(tm)
-  !--- BEWARE ! Can't use the "getKeyByName" functions yet.
-  !             Names must first include the phases for tracers defined on multiple lines.
-  hadv = str2int(fgetKeys('hadv',  tm(:)%keys, '10'))
-  vadv = str2int(fgetKeys('vadv',  tm(:)%keys, '10'))
-  prnt =         fgetKeys('parent',tm(:)%keys,  '' )
-  IF(getKey('phases', phas, ky=tm(:)%keys)) phas = fGetKeys('phase', tm(:)%keys, 'g')
-  CALL msg(TRIM(message)//':', modname)
-  IF(ALL(prnt == 'air')) THEN
-    IF(test(dispTable('iiiss',   ['iq    ','hadv  ','vadv  ','name  ','phase '],                   cat(tm%name,       phas),  &
-                 cat([(iq, iq=1, nq)], hadv, vadv),                 nColMax=maxTableWidth, nHead=2, sub=modname), lerr)) RETURN
-  ELSE IF(ALL(tm%iGeneration == -1)) THEN
-    IF(test(dispTable('iiisss', ['iq    ','hadv  ','vadv  ','name  ','parent','phase '],           cat(tm%name, prnt, phas),  &
-                 cat([(iq, iq=1, nq)], hadv, vadv),                 nColMax=maxTableWidth, nHead=2, sub=modname), lerr)) RETURN
-  ELSE
-    IF(test(dispTable('iiissis', ['iq    ','hadv  ','vadv  ','name  ','parent','igen  ','phase '], cat(tm%name, prnt, phas),  &
-                 cat([(iq, iq=1, nq)], hadv, vadv, tm%iGeneration), nColMax=maxTableWidth, nHead=2, sub=modname), lerr)) RETURN
-  END IF
-END FUNCTION dispTraSection
-!==============================================================================================================================
-
-
-!==============================================================================================================================
-!== CREATE A SCALAR ALIAS OF THE COMPONENT OF THE TRACERS DESCRIPTOR "t" NAMED "tname" ========================================
-!==============================================================================================================================
-FUNCTION aliasTracer(tname, t) RESULT(out)
-  TYPE(trac_type),         POINTER    :: out
-  CHARACTER(LEN=*),        INTENT(IN) :: tname
-  TYPE(trac_type), TARGET, INTENT(IN) :: t(:)
-  INTEGER :: it
-  it = strIdx(t(:)%name, tname)
-  out => NULL(); IF(it /= 0) out => t(it)
-END FUNCTION aliasTracer
-!==============================================================================================================================
-
-
-!==============================================================================================================================
-!=== FROM A LIST OF INDEXES OR NAMES, CREATE A SUBSET OF THE TRACERS DESCRIPTORS LIST "trac" ==================================
-!==============================================================================================================================
-FUNCTION trSubset_Indx(trac,idx) RESULT(out)
-  TYPE(trac_type), ALLOCATABLE             ::  out(:)
-  TYPE(trac_type), ALLOCATABLE, INTENT(IN) :: trac(:)
-  INTEGER,                      INTENT(IN) ::  idx(:)
-  out = trac(idx)
-  CALL indexUpdate(out)
-END FUNCTION trSubset_Indx
-!------------------------------------------------------------------------------------------------------------------------------
-FUNCTION trSubset_Name(trac,nam) RESULT(out)
-  TYPE(trac_type), ALLOCATABLE             ::  out(:)
-  TYPE(trac_type), ALLOCATABLE, INTENT(IN) :: trac(:)
-  CHARACTER(LEN=*),             INTENT(IN) ::  nam(:)
-  out = trac(strIdx(trac(:)%name, nam))
-  CALL indexUpdate(out)
-END FUNCTION trSubset_Name
-!==============================================================================================================================
-
-
-!==============================================================================================================================
-!=== CREATE THE SUBSET OF THE TRACERS DESCRIPTORS LIST "trac" HAVING THE FIRST GENERATION ANCESTOR NAMED "nam" ================
-!==============================================================================================================================
-FUNCTION trSubset_gen0Name(trac,nam) RESULT(out)
-  TYPE(trac_type), ALLOCATABLE             ::  out(:)
-  TYPE(trac_type), ALLOCATABLE, INTENT(IN) :: trac(:)
-  CHARACTER(LEN=*),             INTENT(IN) ::  nam
-  out = trac(strFind(delPhase(trac(:)%gen0Name), nam))
-  CALL indexUpdate(out)
-END FUNCTION trSubset_gen0Name
-!==============================================================================================================================
-
-
-!==============================================================================================================================
-!=== UPDATE THE INDEXES iqParent, iqDescend AND iGeneration IN THE TRACERS DESCRIPTOR LIST "tr" (USEFULL FOR SUBSETS) =========
-!==============================================================================================================================
-SUBROUTINE indexUpdate(tr)
-  TYPE(trac_type), INTENT(INOUT) :: tr(:)
-  INTEGER :: iq, ig, igen, ngen, ix(SIZE(tr))
-  tr(:)%iqParent = strIdx( tr(:)%name, tr(:)%parent )                !--- Parent index
-  DO iq = 1, SIZE(tr); CALL addKey_s11('iqParent', int2str(tr(iq)%iqParent), tr(iq)%keys); END DO
-  ngen = MAXVAL(tr(:)%iGeneration, MASK=.TRUE.)
-  DO iq = 1, SIZE(tr)
-    ig = tr(iq)%iGeneration
-    IF(ALLOCATED(tr(iq)%iqDescen)) DEALLOCATE(tr(iq)%iqDescen)
-    ALLOCATE(tr(iq)%iqDescen(0))
-    CALL idxAncestor(tr, ix, ig)                                     !--- Ancestor of generation "ng" for each tr
-    DO igen = ig+1, ngen
-      tr(iq)%iqDescen = [tr(iq)%iqDescen, find(ix==iq .AND. tr%iGeneration==igen)]
-      tr(iq)%nqDescen = SIZE(tr(iq)%iqDescen)
-      IF(igen == ig+1) THEN
-        tr(iq)%nqChildren = tr(iq)%nqDescen
-        CALL addKey_s11('nqChildren', int2str(tr(iq)%nqChildren), tr(iq)%keys)
-      END IF
+  INTEGER :: iq, jq, nq, ig, nGen
+  INTEGER,               ALLOCATABLE :: iqDescen(:), ix(:), iy(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tnames(:), parent(:)
+  INTEGER,       DIMENSION(SIZE(tr)) :: iqParent, iGen, nqChildren, nqDescen
+  lerr = getKey('name',   tnames, tr%keys); IF(lerr) RETURN          !--- Names
+  lerr = getKey('parent', parent, tr%keys); IF(lerr) RETURN          !--- Parents
+  nq = SIZE(tr)
+
+  !=== iqParent
+  DO iq = 1, nq; iqParent(iq) = strIdx(tnames, parent(iq)); END DO
+  CALL addKey('iqParent', iqParent, tr(:)%keys)
+
+  !=== iGeneration
+  DO iq = 1, nq; iGen(iq) = 0; jq = iq
+    DO; jq = strIdx(tnames, parent(jq)); IF(jq == 0) EXIT; iGen(iq) = iGen(iq) + 1; END DO
+  END DO
+  CALL addKey('iGeneration', iGen, tr(:)%keys)
+
+  !=== iqDescen
+  nGen = MAXVAL(iGen, MASK=.TRUE.)
+  DO iq = 1, nq
+    ix = [iq]; ALLOCATE(iqDescen(0))
+    DO ig = iGen(iq)+1, nGen
+      iy = find(iqParent, ix); iqDescen = [iqDescen, iy]; ix = iy
+      IF(ig /= iGen(iq)+1) CYCLE
+      CALL addKey('nqChildren', SIZE(iqDescen), tr(iq)%keys)
+      tr(iq)%nqChildren = SIZE(iqDescen)
     END DO
-    CALL addKey_s11('iqDescen', strStack(int2str(tr(iq)%iqDescen)), tr(iq)%keys)
-    CALL addKey_s11('nqDescen',          int2str(tr(iq)%nqDescen) , tr(iq)%keys)
+    CALL addKey('iqDescen', strStack(int2str(iqDescen)), tr(iq)%keys)
+    CALL addKey('nqDescen',             SIZE(iqDescen),  tr(iq)%keys)
+    tr(iq)%iqDescen =      iqDescen
+    tr(iq)%nqDescen = SIZE(iqDescen)
+    DEALLOCATE(iqDescen)
   END DO
-END SUBROUTINE indexUpdate
+END FUNCTION indexUpdate
 !==============================================================================================================================
   
@@ -1035 +1101 @@
 !===  * For each isotopes class, the <key>=<val> vector of each tracer is moved into the isotopes descriptor "isot"        ====
 !=== NOTES:                                                                                                                ====
-!===  * Most of the "isot" components have been defined in the calling routine (readIsotopes):                             ====
+!===  * Most of the "isot" components have been defined in the calling routine (processIsotopes):                          ====
 !===      parent,  nzone, zone(:),  niso, keys(:)%name,  ntiso, trac(:),  nphas, phas,  iqIsoPha(:,:),  itZonPhi(:,:)      ====
 !===  * Same syntax for isotopes file and "tracer.def": a tracers section contains one line for each of its isotopes       ====
@@ -1043 +1109 @@
 !===  * The routine gives an error if a required isotope is not available in the database stored in "fnam"                 ====
 !==============================================================================================================================
-LOGICAL FUNCTION readIsotopesFile_prv(fnam, isot) RESULT(lerr)
+LOGICAL FUNCTION readIsotopesFile(fnam, isot) RESULT(lerr)
   CHARACTER(LEN=*),        INTENT(IN)    :: fnam                     !--- Input file name
   TYPE(isot_type), TARGET, INTENT(INOUT) :: isot(:)                  !--- Isotopes descriptors (field %parent must be defined!)
@@ -1060 +1126 @@
   !--- READ THE FILE SECTIONS, ONE EACH PARENT TRACER
   nb0 = SIZE(dBase, DIM=1)+1                                         !--- Next database element index
-  IF(test(readSections(fnam,strStack(isot(:)%parent,'|')),lerr)) RETURN !--- Read sections, one each parent tracer
+  lerr = readSections(fnam,strStack(isot(:)%parent,'|')); IF(lerr) RETURN !--- Read sections, one each parent tracer
   ndb = SIZE(dBase, DIM=1)                                           !--- Current database size
   DO idb = nb0, ndb
@@ -1078 +1144 @@
       is = strIdx(isot(iis)%keys(:)%name, t%name)                    !--- Index in "isot(iis)%keys(:)%name" of isotope "t%name"
       IF(is == 0) CYCLE
-      IF(test(ANY(reduceExpr(t%keys%val, vals)), lerr)) RETURN       !--- Reduce expressions ; detect non-numerical elements
+      lerr = ANY(reduceExpr(t%keys%val, vals)); IF(lerr) RETURN      !--- Reduce expressions ; detect non-numerical elements
       isot(iis)%keys(is)%key = t%keys%key
       isot(iis)%keys(is)%val = vals
@@ -1084 +1150 @@
 
     !--- CHECK FOR MISSING ISOTOPES (NO KEYS ALLOCATED)
-    IF(test(checkList(isot(iis)%keys(:)%name, .NOT.[( ALLOCATED(isot(iis)%keys(is)%key), is=1, SIZE(isot(iis)%keys) )], &
-      'Check file "'//TRIM(fnam)//'" in section "'//TRIM(dBase(idb)%name)//'"', 'isotopes', 'missing'), lerr)) RETURN
+    lerr = checkList(isot(iis)%keys(:)%name, .NOT.[( ALLOCATED(isot(iis)%keys(is)%key), is=1, SIZE(isot(iis)%keys) )], &
+                     'Check file "'//TRIM(fnam)//'" in section "'//TRIM(dBase(idb)%name)//'"', 'isotopes', 'missing')
+    IF(lerr) RETURN
   END DO
 
@@ -1120 +1187 @@
       END DO
     END DO
-    IF(test(fmsg('Problem with the table content', modname, dispTable(prf, ttl, val, &
-            cat([(it,it=1,nt)]), rFmt='(EN8.4)', nColMax=maxTableWidth, nHead=2, sub=modname)), lerr)) RETURN
+    lerr = dispTable(prf, ttl, val, cat([(it,it=1,nt)]), rFmt='(EN8.4)', nColMax=maxTableWidth, nHead=2, sub=modname)
+    IF(fmsg('Problem with the table content', modname, lerr)) RETURN
     DEALLOCATE(ttl, val)
   END DO        
@@ -1127 +1194 @@
 !------------------------------------------------------------------------------------------------------------------------------
 
-END FUNCTION readIsotopesFile_prv
+END FUNCTION readIsotopesFile
 !==============================================================================================================================
 
@@ -1135 +1202 @@
 !===    * COMPUTE MOST OF THE RELATED QUANTITIES ("isot" COMPONENTS).                                                       ===
 !===    * COMPUTE FEW ISOTOPES-DEDICATED "trac" COMPONENTS                                                                  ===
-!===    * CALL readIsotopesFile_prv TO GET PHYSICAL QUANTITIES (<key>=<val> PAIRS)                                          ===
+!===    * CALL readIsotopesFile TO GET PHYSICAL QUANTITIES (<key>=<val> PAIRS)                                              ===
 !===      NOTE: THIS IS DONE HERE (IN A ROUTINE CALLED BY THE DYNAMIC), BECAUSE THE DYNAMIC NEEDS FEW PHYSICAL PARAMETERS.  ===
 !==============================================================================================================================
-LOGICAL FUNCTION readIsotopesFile(iNames) RESULT(lerr)
+LOGICAL FUNCTION processIsotopes(iNames) RESULT(lerr)
   CHARACTER(LEN=maxlen), TARGET, OPTIONAL, INTENT(IN)  :: iNames(:)
   CHARACTER(LEN=maxlen), ALLOCATABLE :: p(:), str(:)                 !--- Temporary storage
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tname(:), parent(:), dType(:), phase(:), gen0N(:)
   CHARACTER(LEN=maxlen) :: iName, modname
   CHARACTER(LEN=1)   :: ph                                           !--- Phase
+  INTEGER, ALLOCATABLE ::  iGen(:)
   INTEGER :: ic, ip, iq, it, iz
   LOGICAL, ALLOCATABLE :: ll(:)                                      !--- Mask
   TYPE(trac_type), POINTER   ::  t(:), t1
   TYPE(isot_type), POINTER   ::  i
+
   lerr = .FALSE.
   modname = 'readIsotopesFile'
@@ -1152 +1222 @@
   t => tracers
 
+  lerr = getKey('name',       tname, t%keys); IF(lerr) RETURN       !--- Names
+  lerr = getKey('parent',    parent, t%keys); IF(lerr) RETURN       !--- Parents
+  lerr = getKey('type',       dType, t%keys); IF(lerr) RETURN       !--- Tracer type
+  lerr = getKey('phase',      phase, t%keys); IF(lerr) RETURN       !--- Phase
+  lerr = getKey('gen0Name',   gen0N, t%keys); IF(lerr) RETURN       !--- 1st generation ancestor name
+  lerr = getKey('iGeneration', iGen, t%keys); IF(lerr) RETURN       !--- Generation number
+
   !--- GET FROM "tracers" THE FULL LIST OF AVAILABLE ISOTOPES CLASSES
-  p = PACK(delPhase(t%parent), MASK = t%type=='tracer' .AND. t%iGeneration==1)
+  p = PACK(delPhase(parent), MASK = dType=='tracer' .AND. iGen==1)
   CALL strReduce(p, nbIso)
 
@@ -1159 +1236 @@
   IF(PRESENT(iNames)) THEN
     DO it = 1, SIZE(iNames)
-      IF(test(fmsg('No isotopes class "'//TRIM(iNames(it))//'" found among tracers', modname, ALL(p /= iNames(it))), lerr)) RETURN
+      lerr = ALL(p /= iNames(it))
+      IF(fmsg('No isotopes class "'//TRIM(iNames(it))//'" found among tracers', modname, lerr)) RETURN
     END DO
     p = iNames; nbIso = SIZE(p)
@@ -1175 +1253 @@
 
     !=== Isotopes children of tracer "iname": mask, names, number (same for each phase of "iname")
-    ll = t(:)%type=='tracer' .AND. delPhase(t(:)%parent) == iname .AND. t(:)%phase == 'g'
-    str = PACK(delPhase(t(:)%name), MASK = ll)                       !--- Effectively found isotopes of "iname"
+    ll = dType=='tracer' .AND. delPhase(parent) == iname .AND. phase == 'g'
+    str = PACK(delPhase(tname), MASK = ll)                           !--- Effectively found isotopes of "iname"
     i%niso = SIZE(str)                                               !--- Number of "effectively found isotopes of "iname"
     ALLOCATE(i%keys(i%niso))
@@ -1182 +1260 @@
 
     !=== Geographic tagging tracers descending on tracer "iname": mask, names, number
-    ll = t(:)%type=='tag'    .AND. delPhase(t(:)%gen0Name) == iname .AND. t(:)%iGeneration == 2
-    i%zone = PACK(strTail(t(:)%name,'_',.TRUE.), MASK = ll)          !--- Tagging zones names  for isotopes category "iname"
+    ll = dType=='tag'    .AND. delPhase(gen0N) == iname .AND. iGen == 2
+    i%zone = PACK(strTail(tname,'_',.TRUE.), MASK = ll)              !--- Tagging zones names  for isotopes category "iname"
     CALL strReduce(i%zone)
     i%nzone = SIZE(i%zone)                                           !--- Tagging zones number for isotopes category "iname"
@@ -1189 +1267 @@
     !=== Geographic tracers of the isotopes children of tracer "iname" (same for each phase of "iname")
     !    NOTE: One might like to create a similar variable for 2nd generation tagging tracers (tagging the gen1 tracers)
-    str = PACK(delPhase(t(:)%name), MASK=ll)
+    str = PACK(delPhase(tname), MASK=ll)
     CALL strReduce(str)
     i%ntiso = i%niso + SIZE(str)                                     !--- Number of isotopes + their geographic tracers [ntiso]
@@ -1226 +1304 @@
 
   !=== READ PHYSICAL PARAMETERS FROM isoFile FILE
-!  IF(test(readIsotopesFile_prv(isoFile, isotopes), lerr)) RETURN! on commente pour ne pas chercher isotopes_params.def
+!  lerr = readIsotopesFile(isoFile, isotopes); IF(lerr) RETURN! on commente pour ne pas chercher isotopes_params.def
+
+  !--- GET THE isoCheck ENTRY FROM THE *.DEF FILES (MIGHT BE CHANGED TO A CLASS-DEPENDANT KEYWORD)
+  CALL get_in('ok_iso_verif', isoCheck, .TRUE.)
 
   !=== CHECK CONSISTENCY
-  IF(test(testIsotopes(), lerr)) RETURN
-
-  !=== SELECT FIRST ISOTOPES CLASS OR, IF POSSIBLE, WATER CLASS
-  IF(.NOT.test(isoSelect(1, .TRUE.), lerr)) THEN; IF(isotope%parent == 'H2O') iH2O = ixIso; END IF
+  lerr = testIsotopes(); IF(lerr) RETURN
+
+  !=== SELECT WATER ISOTOPES CLASS OR, IF UNFOUND, THE FIRST ISOTOPES CLASS
+  IF(isoSelect('H2O', .TRUE.)) THEN; iH2O = ixIso; ELSE; lerr = isoSelect(1, .TRUE.); END IF
 
 CONTAINS
@@ -1239 +1320 @@
 LOGICAL FUNCTION testIsotopes() RESULT(lerr)     !--- MAKE SURE MEMBERS OF AN ISOTOPES FAMILY ARE PRESENT IN THE SAME PHASES
 !------------------------------------------------------------------------------------------------------------------------------
-  INTEGER :: ix, it, ip, np, iz, nz
+  INTEGER :: ix, it, ip, np, iz, nz, npha, nzon
+  CHARACTER(LEN=maxlen) :: s
   TYPE(isot_type), POINTER :: i
   DO ix = 1, nbIso
     i => isotopes(ix)
     !--- Check whether each isotope and tagging isotopic tracer is present in the same number of phases
-    DO it = 1, i%ntiso
-      np = SUM([(COUNT(tracers(:)%name == addPhase(i%trac(it), i%phase(ip:ip))), ip=1, i%nphas)])
-      IF(test(fmsg(TRIM(int2str(np))//' phases instead of '//TRIM(int2str(i%nphas))//' for '//TRIM(i%trac(it)), &
-        modname, np /= i%nphas), lerr)) RETURN
+    DO it = 1, i%ntiso; npha = i%nphas
+      np = SUM([(COUNT(tracers(:)%name == addPhase(i%trac(it), i%phase(ip:ip))), ip=1, npha)])
+      lerr = np /= npha
+      CALL msg(TRIM(int2str(np))//' phases instead of '//TRIM(int2str(npha))//' for '//TRIM(i%trac(it)), modname, lerr)
+      IF(lerr) RETURN
     END DO
-    DO it = 1, i%niso
-      nz = SUM([(COUNT(i%trac == TRIM(i%trac(it))//'_'//i%zone(iz)), iz=1, i%nzone)])
-      IF(test(fmsg(TRIM(int2str(nz))//' tagging zones instead of '//TRIM(int2str(i%nzone))//' for '//TRIM(i%trac(it)), &
-        modname, nz /= i%nzone), lerr)) RETURN
+    DO it = 1, i%niso; nzon = i%nzone
+      nz = SUM([(COUNT(i%trac == TRIM(i%trac(it))//'_'//i%zone(iz)), iz=1, nzon)])
+      lerr = nz /= nzon
+      CALL msg(TRIM(int2str(nz))//' tagging zones instead of '//TRIM(int2str(nzon))//' for '//TRIM(i%trac(it)), modname, lerr)
+      IF(lerr) RETURN
     END DO
   END DO
@@ -1258 +1342 @@
 !------------------------------------------------------------------------------------------------------------------------------
 
-END FUNCTION readIsotopesFile
+END FUNCTION processIsotopes
 !==============================================================================================================================
 
@@ -1274 +1358 @@
    lV = .FALSE.; IF(PRESENT(lVerbose)) lV = lVerbose
    iIso = strIdx(isotopes(:)%parent, iName)
-   IF(test(iIso == 0, lerr)) THEN
+   lerr = iIso == 0
+   IF(lerr) THEN
       niso = 0; ntiso = 0; nzone = 0; nphas = 0; isoCheck=.FALSE.
       CALL msg('no isotope family named "'//TRIM(iName)//'"', ll=lV)
@@ -1368 +1453 @@
 !------------------------------------------------------------------------------------------------------------------------------
   INTEGER :: itr
-  DO itr = 1, SIZE(ky)
-    CALL addKey_s11(key, sval, ky(itr), lOverWrite)
-  END DO
+  DO itr = 1, SIZE(ky); CALL addKey_s11(key, sval, ky(itr), lOverWrite); END DO
 END SUBROUTINE addKey_s1m
 !==============================================================================================================================
@@ -1380 +1463 @@
 !------------------------------------------------------------------------------------------------------------------------------
   INTEGER :: itr
-  DO itr = 1, SIZE(ky)
-    CALL addKey_s11(key, int2str(ival), ky(itr), lOverWrite)
-  END DO
+  DO itr = 1, SIZE(ky); CALL addKey_s11(key, int2str(ival), ky(itr), lOverWrite); END DO
 END SUBROUTINE addKey_i1m
 !==============================================================================================================================
@@ -1392 +1473 @@
 !------------------------------------------------------------------------------------------------------------------------------
   INTEGER :: itr
-  DO itr = 1, SIZE(ky)
-    CALL addKey_s11(key, real2str(rval), ky(itr), lOverWrite)
-  END DO
+  DO itr = 1, SIZE(ky); CALL addKey_s11(key, real2str(rval), ky(itr), lOverWrite); END DO
 END SUBROUTINE addKey_r1m
 !==============================================================================================================================
@@ -1404 +1483 @@
 !------------------------------------------------------------------------------------------------------------------------------
   INTEGER :: itr
-  DO itr = 1, SIZE(ky)
-    CALL addKey_s11(key, bool2str(lval), ky(itr), lOverWrite)
-  END DO
+  DO itr = 1, SIZE(ky); CALL addKey_s11(key, bool2str(lval), ky(itr), lOverWrite); END DO
 END SUBROUTINE addKey_l1m
 !==============================================================================================================================
@@ -1498 +1575 @@
 
 !==============================================================================================================================
-!================ GET THE VALUE OF A KEY FROM A "keys_type" DERIVED TYPE ; THE RESULT IS THE RETURNED VALUE ===================
-!==============================================================================================================================
-CHARACTER(LEN=maxlen) FUNCTION fgetKeyIdx_s1(itr, keyn, ky, def_val, lerr) RESULT(val)
+!===   INTERNAL FUNCTION: GET THE VALUE OF A KEY FOR "itr"th TRACER FROM A "keys_type" DERIVED TYPE AND RETURN THE RESULT   ===
+!===   IF keyn CONTAINS SEVERAL ELEMENTS, TRY WITH EACH ELEMENT ONE AFTER THE OTHER                                         ===
+!==============================================================================================================================
+CHARACTER(LEN=maxlen) FUNCTION fgetKeyIdx(itr, keyn, ky, lerr) RESULT(val)
   INTEGER,                    INTENT(IN)  :: itr
-  CHARACTER(LEN=*),           INTENT(IN)  :: keyn
+  CHARACTER(LEN=*),           INTENT(IN)  :: keyn(:)
   TYPE(keys_type),            INTENT(IN)  :: ky(:)
-  CHARACTER(LEN=*), OPTIONAL, INTENT(IN)  :: def_val
   LOGICAL,          OPTIONAL, INTENT(OUT) :: lerr
 !------------------------------------------------------------------------------------------------------------------------------
+  INTEGER :: ik
+  LOGICAL :: ler
+  ler = .TRUE.
+  DO ik = 1, SIZE(keyn)
+    CALL getKeyIdx(keyn(ik)); IF(.NOT.ler) EXIT
+  END DO
+  IF(PRESENT(lerr)) lerr = ler
+
+CONTAINS
+
+SUBROUTINE getKeyIdx(keyn)
+  CHARACTER(LEN=*), INTENT(IN) :: keyn
+!------------------------------------------------------------------------------------------------------------------------------
   INTEGER :: iky
-  LOGICAL :: ler
   iky = 0; val = ''
-  IF(.NOT.test(itr <= 0 .OR. itr > SIZE(ky), ler)) iky = strIdx(ky(itr)%key(:), keyn)    !--- Correct index
-  IF(.NOT.test(iky == 0, ler))                     val = ky(itr)%val(iky)                !--- Found key
-  IF(iky == 0) THEN
-    IF(.NOT.test(.NOT.PRESENT(def_val), ler))      val = def_val                         !--- Default value
-  END IF
-  IF(PRESENT(lerr)) lerr = ler
-END FUNCTION fgetKeyIdx_s1
-!==============================================================================================================================
-CHARACTER(LEN=maxlen) FUNCTION fgetKeyNam_s1(tname, keyn, ky, def_val, lerr) RESULT(val)
-  CHARACTER(LEN=*),           INTENT(IN)  :: tname, keyn
-  TYPE(keys_type),            INTENT(IN)  :: ky(:)
-  CHARACTER(LEN=*), OPTIONAL, INTENT(IN)  :: def_val
-  LOGICAL,          OPTIONAL, INTENT(OUT) :: lerr
-!------------------------------------------------------------------------------------------------------------------------------
-  val = fgetKeyIdx_s1(strIdx(ky(:)%name, tname), keyn, ky, def_val, lerr)
-END FUNCTION fgetKeyNam_s1
-!==============================================================================================================================
-FUNCTION fgetKeys(keyn, ky, def_val, lerr) RESULT(val)
-CHARACTER(LEN=maxlen),        ALLOCATABLE :: val(:)
-  CHARACTER(LEN=*),           INTENT(IN)  :: keyn
-  TYPE(keys_type),            INTENT(IN)  :: ky(:)
-  CHARACTER(LEN=*), OPTIONAL, INTENT(IN)  :: def_val
-  LOGICAL,          OPTIONAL, INTENT(OUT) :: lerr
-!------------------------------------------------------------------------------------------------------------------------------
-  LOGICAL :: ler(SIZE(ky))
-  INTEGER :: it
-  val = [(fgetKeyIdx_s1(it, keyn, ky, def_val, ler(it)), it = 1, SIZE(ky))]
-  IF(PRESENT(lerr)) lerr = ANY(ler)
-END FUNCTION fgetKeys
-!==============================================================================================================================
-
-
-!==============================================================================================================================
-!========== GET THE VALUE OF A KEY FROM A "keys_type" DERIVED TYPE ; THE RETURNED VALUE IS THE ERROR CODE        ==============
-!==========  The key "keyn" is searched in: 1)           "ky(:)%name" (if given)                                 ==============
-!==========                                 2)      "tracers(:)%name"                                            ==============
-!==========                                 3) "isotope%keys(:)%name"                                            ==============
-!==========  for the tracer[s] "tname[(:)]" (if given) or all the available tracers from the used set otherwise. ==============
-!==========  The type of the returned value(s) can be string, integer or real, scalar or vector                  ==============
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_s1(keyn, val, tname, ky) RESULT(lerr)
+  ler = itr <= 0 .OR. itr > SIZE(ky); IF(ler) RETURN
+  iky = strIdx(ky(itr)%key(:), keyn)
+  ler = iky == 0;                     IF(ler) RETURN
+  val = ky(itr)%val(iky)
+END SUBROUTINE getKeyIdx
+
+END FUNCTION fgetKeyIdx
+!==============================================================================================================================
+
+
+!==============================================================================================================================
+!===                                          GET KEYS VALUES FROM TRACERS INDICES                                          ===
+!==============================================================================================================================
+!=== TRY TO GET THE KEY NAMED "key" FOR THE "itr"th TRACER IN:                                                              ===
+!===  * ARGUMENT "ky" DATABASE IF SPECIFIED ; OTHERWISE:                                                                    ===
+!===  * IN INTERNAL TRACERS DATABASE "tracers(:)%keys" (IF UNFOUND, IN INTERNAL ISOTOPES DATABASE "isotope%keys(:)")        ===
+!=== THE RETURNED VALUE (STRING, AN INTEGER, A REAL OR A LOGICAL) CAN BE EITHER:                                            ===
+!===  * A SCALAR                                                                                                            ===
+!===  * A VECTOR, WHICH IS THE FOUND VALUE PARSED WITH THE SEPARATOR ","                                                    ===
+!===                                                                                                                        ===
+!=== SYNTAX:       lerr = getKeyByIndex_{sirl}{1m}{1m}1(keyn[(:)], val[(:)], itr[, ky(:)]          [, def][, lDisp])        ===
+!==============================================================================================================================
+!=== IF "itr" IS NOT PRESENT, VALUES FOR ALL THE TRACERS OF THE SELECTED DATABASE ARE STORED IN THE VECTOR "val(:)"         ===
+!=== THE NAME OF THE TRACERS FOUND IN THE EFFECTIVELY USED DATABASE CAN BE RETURNED OPTIONALLY IN "nam(:)"                  ===
+!=== SYNTAX        lerr = getKeyByIndex_{sirl}{1m}mm   (keyn[(:)], val (:)      [, ky(:)][, nam(:)][, def][, lDisp])        ===
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_s111(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
   CHARACTER(LEN=*),          INTENT(IN)  :: keyn
   CHARACTER(LEN=maxlen),     INTENT(OUT) :: val
-  CHARACTER(LEN=*),          INTENT(IN)  :: tname
+  INTEGER,                   INTENT(IN)  :: itr
   TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen) :: tnam
-  tnam = strHead(delPhase(tname),'_',.TRUE.)                                             !--- Remove phase and tag
-  IF(PRESENT(ky)) THEN                                                                   !=== KEY FROM "ky"
-               val = fgetKeyNam_s1(tname, keyn, ky,           lerr=lerr)                 !--- "ky" and "tname"
-    IF( lerr ) val = fgetKeyNam_s1(tnam,  keyn, ky,           lerr=lerr)                 !--- "ky" and "tnam"
-  ELSE
-    IF(         .NOT.test(.NOT.ALLOCATED(tracers ), lerr)) lerr = SIZE(tracers ) == 0    !=== KEY FROM "tracers"
-    IF(.NOT.lerr) THEN
-               val = fgetKeyNam_s1(tname, keyn, tracers%keys, lerr=lerr)                 !--- "ky" and "tname"
-      IF(lerr) val = fgetKeyNam_s1(tnam,  keyn, tracers%keys, lerr=lerr)                 !--- "ky" and "tnam"
-    END IF
-    IF(lerr.AND..NOT.test(.NOT.ALLOCATED(isotopes), lerr)) lerr = SIZE(isotopes) == 0    !=== KEY FROM "isotope"
-    IF(.NOT.lerr) THEN
-               val = fgetKeyNam_s1(tname, keyn, isotope%keys, lerr=lerr)                 !--- "ky" and "tname"
-      IF(lerr) val = fgetKeyNam_s1(tnam,  keyn, isotope%keys, lerr=lerr)                 !--- "ky" and "tnam"
-    END IF
+  CHARACTER(LEN=*),OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByIndex_sm11([keyn], val, itr, ky, def, lDisp)
+END FUNCTION getKeyByIndex_s111
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_i111(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
+  INTEGER,                   INTENT(OUT) :: val
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByIndex_im11([keyn], val, itr, ky, def, lDisp)
+END FUNCTION getKeyByIndex_i111
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_r111(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
+  REAL   ,                   INTENT(OUT) :: val
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByIndex_rm11([keyn], val, itr, ky, def, lDisp)
+END FUNCTION getKeyByIndex_r111
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_l111(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
+  LOGICAL,                   INTENT(OUT) :: val
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByIndex_lm11([keyn], val, itr, ky, def, lDisp)
+END FUNCTION getKeyByIndex_l111
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_sm11(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:)
+  CHARACTER(LEN=maxlen),     INTENT(OUT) :: val
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  CHARACTER(LEN=*),OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s
+  LOGICAL :: lD
+  lD = .TRUE.; IF(PRESENT(lDisp)) lD = lDisp
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" for tracer nr. '//TRIM(int2str(itr))
+  lerr = .TRUE.
+  IF(lerr .AND. PRESENT(ky))         val = fgetKey(ky)                                   !--- "ky"
+  IF(lerr .AND. ALLOCATED (tracers)) val = fgetKey(tracers(:)%keys)                      !--- "tracers"
+  IF(lerr .AND. ASSOCIATED(isotope)) val = fgetKey(isotope%keys(:))                      !--- "isotope"
+  IF(lerr .AND. PRESENT(def)) THEN
+     val = def; lerr = .NOT.PRESENT(def)
+     CALL msg('Using defaut value of '//TRIM(s)//': '//TRIM(def), modname, lD)
   END IF
-END FUNCTION getKeyByName_s1
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_s1m(keyn, val, tname, ky) RESULT(lerr)
+  CALL msg('No '//TRIM(s)//' or out of bounds index', modname, lD .AND. lerr)
+
+CONTAINS
+
+CHARACTER(LEN=maxlen) FUNCTION fgetKey(ky) RESULT(val)
+  TYPE(keys_type),  INTENT(IN)  :: ky(:)
+  lerr = SIZE(ky) == 0; IF(lerr) RETURN
+  val = fgetKeyIdx(itr, keyn(:), ky, lerr)
+END FUNCTION fgetKey
+
+END FUNCTION getKeyByIndex_sm11
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_im11(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:)
+  INTEGER,                   INTENT(OUT) :: val
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: sval, s
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, int2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  val = str2int(sval)
+  lerr = val == -HUGE(1)
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' an integer: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByIndex_im11
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_rm11(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:)
+  REAL   ,                   INTENT(OUT) :: val
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: sval, s
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, real2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  val = str2real(sval)
+  lerr = val == -HUGE(1.)
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' a real: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByIndex_rm11
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_lm11(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:)
+  LOGICAL,                   INTENT(OUT) :: val
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: sval, s
+  INTEGER               :: ival
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, bool2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  ival = str2bool(sval)
+  lerr = ival == -1
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' a boolean: '//TRIM(sval), modname, lerr)
+  IF(.NOT.lerr) val = ival == 1
+END FUNCTION getKeyByIndex_lm11
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_s1m1(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
   CHARACTER(LEN=*),                   INTENT(IN)  :: keyn
   CHARACTER(LEN=maxlen), ALLOCATABLE, INTENT(OUT) :: val(:)
-  CHARACTER(LEN=*),                   INTENT(IN)  :: tname
+  INTEGER,                            INTENT(IN)  :: itr
   TYPE(keys_type),          OPTIONAL, INTENT(IN)  :: ky(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen) :: sval
-  lerr = getKeyByName_s1(keyn, sval, tname, ky)
-  IF(test(fmsg('missing key "'//TRIM(keyn)//'" for tracer "'//TRIM(tname)//'"', modname, lerr), lerr)) RETURN
+  CHARACTER(LEN=*),         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,                  OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval
+  lerr = getKeyByIndex_sm11([keyn], sval, itr, ky, def, lDisp); IF(lerr) RETURN
   lerr = strParse(sval, ',', val)
-END FUNCTION getKeyByName_s1m
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_sm(keyn, val, tname, ky, nam) RESULT(lerr)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+END FUNCTION getKeyByIndex_s1m1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_i1m1(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
+  INTEGER,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11([keyn], sval, itr, ky, int2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11([keyn], sval, itr, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  val = str2int(svals)
+  lerr = ANY(val == -HUGE(1))
+  s = 'key "'//TRIM(keyn)//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' an integer: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByIndex_i1m1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_r1m1(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
+  REAL,         ALLOCATABLE, INTENT(OUT) :: val(:)
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11([keyn], sval, itr, ky, real2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11([keyn], sval, itr, ky, lDisp=lDisp)
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  val = str2real(svals)
+  lerr = ANY(val == -HUGE(1.))
+  s = 'key "'//TRIM(keyn)//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' a real: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByIndex_r1m1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_l1m1(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
+  LOGICAL,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  INTEGER,               ALLOCATABLE :: ivals(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11([keyn], sval, itr, ky, bool2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11([keyn], sval, itr, ky, lDisp=lDisp)
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  ivals = str2bool(svals)
+  lerr = ANY(ivals == -1)
+  s = 'key "'//TRIM(keyn)//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' a boolean: '//TRIM(sval), modname, lerr)
+  IF(.NOT.lerr) val = ivals == 1
+END FUNCTION getKeyByIndex_l1m1
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_smm1(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                   INTENT(IN)  :: keyn(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE, INTENT(OUT) :: val(:)
+  INTEGER,                            INTENT(IN)  :: itr
+  TYPE(keys_type),          OPTIONAL, INTENT(IN)  :: ky(:)
+  CHARACTER(LEN=*),         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,                  OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, def, lDisp); IF(lerr) RETURN
+  lerr = strParse(sval, ',', val)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+END FUNCTION getKeyByIndex_smm1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_imm1(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:)
+  INTEGER,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, int2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  val = str2int(svals)
+  lerr = ANY(val == -HUGE(1))
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' an integer: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByIndex_imm1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_rmm1(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:)
+  REAL,         ALLOCATABLE, INTENT(OUT) :: val(:)
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, real2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  val = str2real(svals)
+  lerr = ANY(val == -HUGE(1.))
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' a real: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByIndex_rmm1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_lmm1(keyn, val, itr, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:)
+  LOGICAL,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  INTEGER,                   INTENT(IN)  :: itr
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  INTEGER,               ALLOCATABLE :: ivals(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, bool2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_sm11(keyn, sval, itr, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  ivals = str2bool(svals)
+  lerr = ANY(ivals == -1)
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of tracer nr. '//TRIM(int2str(itr))//' is not'
+  CALL msg(TRIM(s)//' a boolean: '//TRIM(sval), modname, lerr)
+  IF(.NOT.lerr) val = ivals == 1
+END FUNCTION getKeyByIndex_lmm1
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_s1mm(keyn, val, ky, nam, def, lDisp) RESULT(lerr)
   CHARACTER(LEN=*),                             INTENT(IN)  :: keyn
   CHARACTER(LEN=maxlen),           ALLOCATABLE, INTENT(OUT) :: val(:)
-  CHARACTER(LEN=*),                             INTENT(IN)  :: tname(:)
-  TYPE(keys_type),       OPTIONAL, TARGET,      INTENT(IN)  :: ky(:)
+  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::  ky(:)
   CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) :: nam(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  TYPE(keys_type), POINTER ::  keys(:)
-  LOGICAL :: lk, lt, li
-  INTEGER :: iq, nq
-
-  !--- DETERMINE THE DATABASE TO BE USED (ky, tracers or isotope)
-  lk = PRESENT(ky)
-  lt = .NOT.lk .AND. ALLOCATED(tracers);  IF(lt) lt = SIZE(tracers)  /= 0; IF(lt) lt = ANY(tracers(1)%keys%key(:) == keyn)
-  li = .NOT.lt .AND. ALLOCATED(isotopes); IF(li) li = SIZE(isotopes) /= 0; IF(li) li = ANY(isotope%keys(1)%key(:) == keyn)
-
-  !--- LINK "keys" TO THE RIGHT DATABASE
-  IF(test(.NOT.ANY([lk,lt,li]), lerr)) RETURN
-  IF(lk) keys => ky(:)
-  IF(lt) keys => tracers(:)%keys
-  IF(li) keys => isotope%keys(:)
-
-  !--- GET THE DATA
-  nq = SIZE(tname)
-  ALLOCATE(val(nq))
-  lerr = ANY([(getKeyByName_s1(keyn, val(iq), tname(iq), keys(:)), iq=1, nq)])
-  IF(PRESENT(nam)) nam = tname(:)
-
-END FUNCTION getKeyByName_sm
-!==============================================================================================================================
-LOGICAL FUNCTION getKey_sm(keyn, val, ky, nam) RESULT(lerr)
+  CHARACTER(LEN=*),      OPTIONAL,              INTENT(IN)  :: def
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: lDisp
+  lerr = getKeyByIndex_smmm([keyn], val, ky, nam, def, lDisp)
+END FUNCTION getKeyByIndex_s1mm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_i1mm(keyn, val, ky, nam, def, lDisp) RESULT(lerr)
   CHARACTER(LEN=*),                             INTENT(IN)  :: keyn
-  CHARACTER(LEN=maxlen),           ALLOCATABLE, INTENT(OUT) :: val(:)
-  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  :: ky(:)
+  INTEGER,                         ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::  ky(:)
   CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) :: nam(:)
-!------------------------------------------------------------------------------------------------------------------------------
-! Note: if names are repeated, getKeyByName_sm can't be used ; this routine, using indexes, must be used instead.
-  IF(PRESENT(ky)) THEN                                                                   !=== KEY FROM "ky"
-    val = fgetKeys(keyn, ky, lerr=lerr)
-    IF(PRESENT(nam)) nam = ky(:)%name
-  ELSE
-    IF(         .NOT.test(.NOT.ALLOCATED(tracers ), lerr)) lerr = SIZE(tracers ) == 0    !=== KEY FROM "tracers"
-    IF(.NOT.lerr) val = fgetKeys(keyn, tracers%keys, lerr=lerr)
-    IF(.NOT.lerr.AND.PRESENT(nam)) nam = tracers(:)%keys%name
-    IF(lerr.AND..NOT.test(.NOT.ALLOCATED(isotopes), lerr)) lerr = SIZE(isotopes) == 0    !=== KEY FROM "isotope"
-    IF(.NOT.lerr) val = fgetKeys(keyn, isotope%keys, lerr=lerr)
-    IF(.NOT.lerr.AND.PRESENT(nam)) nam = isotope%keys(:)%name
+  INTEGER,               OPTIONAL,              INTENT(IN)  :: def
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: lDisp
+  lerr = getKeyByIndex_immm([keyn], val, ky, nam, def, lDisp)
+END FUNCTION getKeyByIndex_i1mm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_r1mm(keyn, val, ky, nam, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn
+  REAL,                            ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::  ky(:)
+  CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) :: nam(:)
+  REAL,                  OPTIONAL,              INTENT(IN)  :: def
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: lDisp
+  lerr = getKeyByIndex_rmmm([keyn], val, ky, nam, def, lDisp)
+END FUNCTION getKeyByIndex_r1mm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_l1mm(keyn, val, ky, nam, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn
+  LOGICAL,                         ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::  ky(:)
+  CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) :: nam(:)
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: def
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: lDisp
+  lerr = getKeyByIndex_lmmm([keyn], val, ky, nam, def, lDisp)
+END FUNCTION getKeyByIndex_l1mm
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_smmm(keyn, val, ky, nam, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn(:)
+  CHARACTER(LEN=maxlen),           ALLOCATABLE, INTENT(OUT) ::  val(:)
+  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::   ky(:)
+  CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) ::  nam(:)
+  CHARACTER(LEN=*),      OPTIONAL,              INTENT(IN)  ::  def
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tname(:)
+  INTEGER :: iq, nq(3), k
+  LOGICAL :: lD, l(3)
+  lD = .TRUE.; IF(PRESENT(lDisp)) lD = lDisp
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'"'
+  lerr = .TRUE.
+  IF(PRESENT(ky)) THEN;                 val = fgetKey(ky)                                !--- "ky"
+  ELSE IF(ALLOCATED(tracers)) THEN;     val = fgetKey(tracers(:)%keys)                   !--- "tracers"
+     IF(lerr .AND. ASSOCIATED(isotope)) val = fgetKey(isotope%keys(:))                   !--- "isotope"
   END IF
-END FUNCTION getKey_sm
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_i1(keyn, val, tname, ky) RESULT(lerr)
-  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
-  INTEGER,                   INTENT(OUT) :: val
-  CHARACTER(LEN=*),          INTENT(IN)  :: tname
-  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen) :: sval
-  INTEGER :: ierr
-  lerr = getKeyByName_s1(keyn, sval, tname, ky)
-  IF(test(fmsg('key "'//TRIM(keyn)//'" or tracer "'//TRIM(tname)//'" is missing', modname, lerr), lerr)) RETURN
-  READ(sval, *, IOSTAT=ierr) val
-  IF(test(fmsg('key "'//TRIM(keyn)//'" of tracer "'//TRIM(tname)//'" is not an integer', modname, ierr/=0), lerr)) RETURN
-END FUNCTION getKeyByName_i1
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_i1m(keyn, val, tname, ky) RESULT(lerr)
-  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
-  INTEGER,      ALLOCATABLE, INTENT(OUT) :: val(:)
-  CHARACTER(LEN=*),          INTENT(IN)  :: tname
-  TYPE(keys_type), OPTIONAL, INTENT(IN)  ::  ky(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:)
-  INTEGER :: ierr, iq, nq
-  IF(test(getKeyByName_s1m(keyn, sval, tname, ky), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  lerr = .FALSE.; DO iq=1, nq; READ(sval(iq), *, IOSTAT=ierr) val(iq); lerr = lerr .OR. ierr /= 0; END DO
-  IF(test(fmsg('key "'//TRIM(keyn)//'" of tracer "'//TRIM(tname)//'" is not an integer', modname, lerr), lerr)) RETURN
-END FUNCTION getKeyByName_i1m
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_im(keyn, val, tname, ky, nam) RESULT(lerr)
-  CHARACTER(LEN=*),                             INTENT(IN)  ::  keyn
-  INTEGER,                         ALLOCATABLE, INTENT(OUT) ::   val(:)
-  CHARACTER(LEN=*),                             INTENT(IN)  :: tname(:)
-  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::    ky(:)
-  CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) ::   nam(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:), names(:)
-  INTEGER :: ierr, iq, nq
-  IF(test(getKeyByName_sm(keyn, sval, tname, ky, names), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  DO iq = 1, nq                                                      !--- CONVERT THE KEYS TO INTEGERS
-    READ(sval(iq), *, IOSTAT=ierr) val(iq)
-    IF(test(fmsg('key "'//TRIM(keyn)//'" of tracer "'//TRIM(names(iq))//'" is not an integer', modname, ierr/=0), lerr)) RETURN
-  END DO
-  IF(PRESENT(nam)) nam = names(:)
-END FUNCTION getKeyByName_im
-!==============================================================================================================================
-LOGICAL FUNCTION getKey_im(keyn, val, ky, nam) RESULT(lerr)
-  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn
+  IF(.NOT.lerr) THEN; IF(PRESENT(nam)) nam = tname; RETURN; END IF
+  IF(.NOT.PRESENT(def)) THEN; CALL msg('No '//TRIM(s)//' found', modname, lD); RETURN; END IF
+
+  !--- DEFAULT VALUE
+  l = [PRESENT(ky), ALLOCATED(tracers), ASSOCIATED(isotope)]; nq(:) = 0
+  IF(l(1)) nq(1) = SIZE(ky)
+  IF(l(2)) nq(2) = SIZE(tracers)
+  IF(l(3)) nq(3) = SIZE(isotope%keys)
+  DO k = 1, 3; IF(l(k) .AND. nq(k) /= 0) THEN; val = [(def, iq = 1, nq(k))]; EXIT; END IF; END DO
+  lerr = k == 4
+  CALL msg('Using defaut value for '//TRIM(s)//': '//TRIM(def), modname, lD .AND. .NOT.lerr)
+  CALL msg('No '//TRIM(s), modname, lD .AND. lerr)
+
+CONTAINS
+
+FUNCTION fgetKey(ky) RESULT(val)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: val(:)
+  TYPE(keys_type),       INTENT(IN)  :: ky(:)
+  LOGICAL :: ler(SIZE(ky))
+  INTEGER :: iq
+  lerr = SIZE(ky) == 0; IF(lerr) RETURN
+  tname = ky%name
+  val = [(fgetKeyIdx(iq, keyn(:), ky, ler(iq)), iq = 1, SIZE(ky))]
+  lerr = ANY(ler)
+END FUNCTION fgetKey
+
+END FUNCTION getKeyByIndex_smmm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_immm(keyn, val, ky, nam, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn(:)
   INTEGER,                         ALLOCATABLE, INTENT(OUT) ::  val(:)
   TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::   ky(:)
   CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) ::  nam(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:), names(:)
-  INTEGER :: ierr, iq, nq
-  IF(test(getKey_sm(keyn, sval, ky, names), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  DO iq = 1, nq
-    READ(sval(iq), *, IOSTAT=ierr) val(iq)
-    IF(test(fmsg('key "'//TRIM(keyn)//'" of tracer "'//TRIM(names(iq))//'" is not an integer', modname, ierr/=0), lerr)) RETURN
-  END DO
-  IF(PRESENT(nam)) nam = names
-END FUNCTION getKey_im
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_r1(keyn, val, tname, ky) RESULT(lerr)
-  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
-  REAL,                      INTENT(OUT) :: val
-  CHARACTER(LEN=*),          INTENT(IN)  :: tname
-  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen) :: sval
-  INTEGER :: ierr
-  lerr = getKeyByName_s1(keyn, sval, tname, ky)
-  IF(test(fmsg('key "'//TRIM(keyn)//'" or tracer "'//TRIM(tname)//'" is missing',    modname, lerr), lerr)) RETURN
-  READ(sval, *, IOSTAT=ierr) val
-  IF(test(fmsg('key "'//TRIM(keyn)//'" of tracer "'//TRIM(tname)//'" is not a real', modname, ierr/=0), lerr)) RETURN
-END FUNCTION getKeyByName_r1
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_r1m(keyn, val, tname, ky) RESULT(lerr)
-  CHARACTER(LEN=*),           INTENT(IN)  :: keyn
-  REAL,          ALLOCATABLE, INTENT(OUT) :: val(:)
-  CHARACTER(LEN=*),           INTENT(IN)  :: tname
-  TYPE(keys_type),  OPTIONAL, INTENT(IN)  ::  ky(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:)
-  INTEGER :: ierr, iq, nq
-  IF(test(getKeyByName_s1m(keyn, sval, tname, ky), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  lerr = .FALSE.; DO iq=1, nq; READ(sval(iq), *, IOSTAT=ierr) val(iq); lerr = lerr .OR. ierr /= 0; END DO
-  IF(test(fmsg('key "'//TRIM(keyn)//'" of tracer "'//TRIM(tname)//'" is not a vector of reals', modname, lerr), lerr)) RETURN
-END FUNCTION getKeyByName_r1m
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_rm(keyn, val, tname, ky, nam) RESULT(lerr)
-  CHARACTER(LEN=*),                             INTENT(IN)  ::  keyn
-  REAL,                            ALLOCATABLE, INTENT(OUT) ::   val(:)
-  CHARACTER(LEN=*),                             INTENT(IN)  :: tname(:)
-  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::    ky(:)
-  CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) ::   nam(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:), names(:)
-  INTEGER :: ierr, iq, nq
-  IF(test(getKeyByName_sm(keyn, sval, tname, ky, names), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  DO iq = 1, nq                                                      !--- CONVERT THE KEYS TO INTEGERS
-    READ(sval(iq), *, IOSTAT=ierr) val(iq)
-    IF(test(fmsg('key "'//TRIM(keyn)//'" of tracer "'//TRIM(names(iq))//'" is not a real', modname, ierr/=0), lerr)) RETURN
-  END DO
-  IF(PRESENT(nam)) nam = names
-END FUNCTION getKeyByName_rm
-!==============================================================================================================================
-LOGICAL FUNCTION getKey_rm(keyn, val, ky, nam) RESULT(lerr)
-  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn
+  INTEGER,               OPTIONAL,              INTENT(IN)  ::  def
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:), tname(:)
+  LOGICAL,               ALLOCATABLE ::    ll(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_smmm(keyn, svals, ky, tname, int2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_smmm(keyn, svals, ky, tname, lDisp=lDisp)
+  IF(lerr) RETURN
+  val = str2int(svals)
+  ll = val == -HUGE(1)
+  lerr = ANY(ll); IF(.NOT.lerr) THEN; IF(PRESENT(nam)) nam = tname; RETURN; END IF
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(strStack(PACK(tname, MASK=ll)))//' is not'
+  CALL msg(TRIM(s)//' an integer: '//TRIM(strStack(svals, MASK=ll)), modname, lerr)
+  IF(.NOT.lerr .AND. PRESENT(nam)) nam = tname
+END FUNCTION getKeyByIndex_immm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_rmmm(keyn, val, ky, nam, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn(:)
   REAL,                            ALLOCATABLE, INTENT(OUT) ::  val(:)
   TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::   ky(:)
   CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) ::  nam(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:), names(:)
-  INTEGER :: ierr, iq, nq
-  IF(test(getKey_sm(keyn, sval, ky, names), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  DO iq = 1, nq                                                      !--- CONVERT THE KEYS TO INTEGERS
-    READ(sval(iq), *, IOSTAT=ierr) val(iq)
-    IF(test(fmsg('key "'//TRIM(keyn)//'" of tracer "'//TRIM(names(iq))//'" is not a real', modname, ierr/=0), lerr)) RETURN
-  END DO
-  IF(PRESENT(nam)) nam = names
-END FUNCTION getKey_rm
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_l1(keyn, val, tname, ky) RESULT(lerr)
-  USE strings_mod, ONLY: str2bool
-  CHARACTER(LEN=*),          INTENT(IN)  :: keyn
-  LOGICAL,                   INTENT(OUT) :: val
-  CHARACTER(LEN=*),          INTENT(IN)  :: tname
-  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen) :: sval
-  lerr = getKeyByName_s1(keyn, sval, tname, ky)
-  IF(test(fmsg('key "'//TRIM(keyn)//'" or tracer "'//TRIM(tname)//'" is missing', modname, lerr), lerr)) RETURN
-  val = str2bool(sval)
-END FUNCTION getKeyByName_l1
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_l1m(keyn, val, tname, ky) RESULT(lerr)
-  USE strings_mod, ONLY: str2bool
-  CHARACTER(LEN=*),           INTENT(IN)  :: keyn
-  LOGICAL,       ALLOCATABLE, INTENT(OUT) :: val(:)
-  CHARACTER(LEN=*),           INTENT(IN)  :: tname
-  TYPE(keys_type),  OPTIONAL, INTENT(IN)  ::  ky(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:)
-  INTEGER :: iq, nq
-  IF(test(getKeyByName_s1m(keyn, sval, tname, ky), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  lerr = .FALSE.; DO iq=1, nq; val(iq)=str2bool(sval(iq)); END DO
-END FUNCTION getKeyByName_l1m
-!==============================================================================================================================
-LOGICAL FUNCTION getKeyByName_lm(keyn, val, tname, ky, nam) RESULT(lerr)
-  USE strings_mod, ONLY: str2bool
-  CHARACTER(LEN=*),                             INTENT(IN)  ::  keyn
-  LOGICAL,                         ALLOCATABLE, INTENT(OUT) ::   val(:)
-  CHARACTER(LEN=*),                             INTENT(IN)  :: tname(:)
-  TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::    ky(:)
-  CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) ::   nam(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:)
-  INTEGER :: iq, nq
-  IF(test(getKeyByName_sm(keyn, sval, tname, ky, nam), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  lerr = .FALSE.; DO iq=1, nq; val(iq)=str2bool(sval(iq)); END DO
-END FUNCTION getKeyByName_lm
-!==============================================================================================================================
-LOGICAL FUNCTION getKey_lm(keyn, val, ky, nam) RESULT(lerr)
-  USE strings_mod, ONLY: str2bool
-  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn
+  REAL,                  OPTIONAL,              INTENT(IN)  ::  def
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:), tname(:)
+  LOGICAL,               ALLOCATABLE ::    ll(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_smmm(keyn, svals, ky, tname, real2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_smmm(keyn, svals, ky, tname, lDisp=lDisp)
+  IF(lerr) RETURN
+  val = str2real(svals)
+  ll = val == -HUGE(1.)
+  lerr = ANY(ll); IF(.NOT.lerr) THEN; IF(PRESENT(nam)) nam = tname; RETURN; END IF
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(strStack(PACK(tname, MASK=ll)))//' is not a'
+  CALL msg(TRIM(s)//' a real: '//TRIM(strStack(svals, MASK=ll)), modname)
+END FUNCTION getKeyByIndex_rmmm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByIndex_lmmm(keyn, val, ky, nam, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                             INTENT(IN)  :: keyn(:)
   LOGICAL,                         ALLOCATABLE, INTENT(OUT) ::  val(:)
   TYPE(keys_type),       OPTIONAL,              INTENT(IN)  ::   ky(:)
   CHARACTER(LEN=maxlen), OPTIONAL, ALLOCATABLE, INTENT(OUT) ::  nam(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  CHARACTER(LEN=maxlen), ALLOCATABLE :: sval(:)
+  LOGICAL,               OPTIONAL,              INTENT(IN)  ::  def
+  LOGICAL,               OPTIONAL,              INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:), tname(:)
+  LOGICAL,               ALLOCATABLE ::    ll(:)
+  INTEGER,               ALLOCATABLE :: ivals(:)
+  IF(     PRESENT(def)) lerr = getKeyByIndex_smmm(keyn, svals, ky, tname, bool2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByIndex_smmm(keyn, svals, ky, tname, lDisp=lDisp)
+  IF(lerr) RETURN
+  ivals = str2bool(svals)
+  ll = ivals == -1
+  lerr = ANY(ll); IF(.NOT.lerr) THEN; val = ivals == 1; IF(PRESENT(nam)) nam = tname; RETURN; END IF
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(strStack(tname, MASK=ll))//' is not'
+  CALL msg(TRIM(s)//' a boolean: '//TRIM(strStack(svals, MASK=ll)), modname)
+END FUNCTION getKeyByIndex_lmmm
+!==============================================================================================================================
+
+
+
+!==============================================================================================================================
+!===                                           GET KEYS VALUES FROM TRACERS NAMES                                           ===
+!==============================================================================================================================
+!=== TRY TO GET THE KEY NAMED "key" FOR THE TRACER NAMED "tname" IN:                                                        ===
+!===  * ARGUMENT "ky" DATABASE IF SPECIFIED ; OTHERWISE:                                                                    ===
+!===  * IN INTERNAL TRACERS DATABASE "tracers(:)%keys" (IF UNFOUND, IN INTERNAL ISOTOPES DATABASE "isotope%keys(:)")        ===
+!=== THE RETURNED VALUE (STRING, AN INTEGER, A REAL OR A LOGICAL) CAN BE EITHER:                                            ===
+!===  * A SCALAR                                                                                                            ===
+!===  * A VECTOR, WHICH IS THE FOUND VALUE PARSED WITH THE SEPARATOR ","                                                    ===
+!===                                                                                                                        ===
+!=== SYNTAX:       lerr = getKeyByName_{sirl}{1m}{1m}1(keyn[(:)], val[(:)], tname  [, ky(:)][, def][, lDisp])               ===
+!==============================================================================================================================
+!=== IF "tname(:)" IS A VECTOR, THE RETURNED VALUES (ONE EACH "tname(:)" ELEMENT) ARE STORED IN THE VECTOR "val(:)"         ===
+!===                                                                                                                        ===
+!=== SYNTAX        lerr = getKeyByName_{sirl}{1m}mm   (keyn[(:)], val (:), tname(:)[, ky(:)][, def][, lDisp])               ===
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_s111(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname
+  CHARACTER(LEN=maxlen),     INTENT(OUT) :: val
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  CHARACTER(LEN=*),OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByName_sm11([keyn], val, tname, ky, def, lDisp)
+END FUNCTION getKeyByName_s111
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_i111(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname
+  INTEGER,                   INTENT(OUT) :: val
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByName_im11([keyn], val, tname, ky, def, lDisp)
+END FUNCTION getKeyByName_i111
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_r111(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname
+  REAL   ,                   INTENT(OUT) :: val
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByName_rm11([keyn], val, tname, ky, def, lDisp)
+END FUNCTION getKeyByName_r111
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_l111(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname
+  LOGICAL,                   INTENT(OUT) :: val
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByName_lm11([keyn], val, tname, ky, def, lDisp)
+END FUNCTION getKeyByName_l111
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_sm11(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname
+  CHARACTER(LEN=maxlen),     INTENT(OUT) :: val
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  CHARACTER(LEN=*),OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s, tnam
+  LOGICAL :: lD
+  lD = .TRUE.; IF(PRESENT(lDisp)) lD = lDisp
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" for "'//TRIM(tname)//'"'
+  lerr = .TRUE.
+  tnam = strHead(delPhase(tname),'_',.TRUE.)                                             !--- Remove phase and tag
+  IF(lerr .AND. PRESENT(ky))         val = fgetKey(ky)                                   !--- "ky"
+  IF(lerr .AND. ALLOCATED (tracers)) val = fgetKey(tracers(:)%keys)                      !--- "tracers"
+  IF(lerr .AND. ASSOCIATED(isotope)) val = fgetKey(isotope%keys(:))                      !--- "isotope"
+  IF(lerr .AND. PRESENT(def)) THEN
+     val = def; lerr = .NOT.PRESENT(def)
+     CALL msg('Using defaut value of '//TRIM(s)//': '//TRIM(def), modname, lD)
+  END IF
+  CALL msg('No '//TRIM(s)//' or out of bounds index', modname, lD .AND. lerr)
+
+CONTAINS
+
+ CHARACTER(LEN=maxlen) FUNCTION fgetKey(ky) RESULT(val)
+  TYPE(keys_type),  INTENT(IN)  :: ky(:)
+  lerr = SIZE(ky) == 0
+  IF(lerr) RETURN
+           val = fgetKeyIdx(strIdx(ky%name, tname), [keyn], ky, lerr)
+  IF(lerr) val = fgetKeyIdx(strIdx(ky%name, tnam ), [keyn], ky, lerr)
+
+END FUNCTION fgetKey
+
+END FUNCTION getKeyByName_sm11
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_im11(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname
+  INTEGER,                   INTENT(OUT) :: val
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: sval, s
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, int2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  val = str2int(sval)
+  lerr = val == -HUGE(1)
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' an integer: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByName_im11
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_rm11(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname
+  REAL   ,                   INTENT(OUT) :: val
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: sval, s
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, real2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  val = str2real(sval)
+  lerr = val == -HUGE(1.)
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' a real: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByName_rm11
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_lm11(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname
+  LOGICAL,                   INTENT(OUT) :: val
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: sval, s
+  INTEGER               :: ival
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, bool2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  ival = str2bool(sval)
+  lerr = ival == -1
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' a boolean: '//TRIM(sval), modname, lerr)
+  IF(.NOT.lerr) val = ival == 1
+END FUNCTION getKeyByName_lm11
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_s1m1(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                   INTENT(IN)  :: keyn, tname
+  CHARACTER(LEN=maxlen), ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type),          OPTIONAL, INTENT(IN)  :: ky(:)
+  CHARACTER(LEN=*),         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,                  OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval
+  lerr = getKeyByName_sm11([keyn], sval, tname, ky, def, lDisp); IF(lerr) RETURN
+  lerr = strParse(sval, ',', val)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+END FUNCTION getKeyByName_s1m1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_i1m1(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname
+  INTEGER,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11([keyn], sval, tname, ky, int2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11([keyn], sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  val = str2int(svals)
+  lerr = ANY(val == -HUGE(1))
+  s = 'key "'//TRIM(keyn)//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' an integer: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByName_i1m1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_r1m1(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname
+  REAL,         ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11([keyn], sval, tname, ky, real2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11([keyn], sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  val = str2real(svals)
+  lerr = ANY(val == -HUGE(1.))
+  s = 'key "'//TRIM(keyn)//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' a real: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByName_r1m1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_l1m1(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname
+  LOGICAL,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  INTEGER,               ALLOCATABLE :: ivals(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11([keyn], sval, tname, ky, bool2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11([keyn], sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  ivals = str2bool(svals)
+  lerr = ANY(ivals == -1)
+  s = 'key "'//TRIM(keyn)//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' a boolean: '//TRIM(sval), modname, lerr)
+  IF(.NOT.lerr) val = ivals == 1
+END FUNCTION getKeyByName_l1m1
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_smm1(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                   INTENT(IN)  :: keyn(:), tname
+  CHARACTER(LEN=maxlen), ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type),          OPTIONAL, INTENT(IN)  :: ky(:)
+  CHARACTER(LEN=*),         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,                  OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  lerr = getKeyByName_sm11(keyn, sval, tname, ky, def, lDisp); IF(lerr) RETURN
+  lerr = strParse(sval, ',', val)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+END FUNCTION getKeyByName_smm1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_imm1(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname
+  INTEGER,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, int2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  val = str2int(svals)
+  lerr = ANY(val == -HUGE(1))
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' an integer: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByName_imm1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_rmm1(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname
+  REAL,         ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, real2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  val = str2real(svals)
+  lerr = ANY(val == -HUGE(1.))
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' a real: '//TRIM(sval), modname, lerr)
+END FUNCTION getKeyByName_rmm1
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_lmm1(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname
+  LOGICAL,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  :: ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen)              :: sval, s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  INTEGER,               ALLOCATABLE :: ivals(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, bool2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_sm11(keyn, sval, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  lerr = strParse(sval, ',', svals)
+  IF(fmsg('can''t parse '//TRIM(sval), modname, lerr)) RETURN
+  ivals = str2bool(svals)
+  lerr = ANY(ivals == -1)
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(tname)//' is not'
+  CALL msg(TRIM(s)//' a boolean: '//TRIM(sval), modname, lerr)
+  IF(.NOT.lerr) val = ivals == 1
+END FUNCTION getKeyByName_lmm1
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_s1mm(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                   INTENT(IN)  :: keyn, tname(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type),       OPTIONAL,    INTENT(IN)  ::  ky(:)
+  CHARACTER(LEN=*),      OPTIONAL,    INTENT(IN)  :: def
+  LOGICAL,               OPTIONAL,    INTENT(IN)  :: lDisp
+  lerr = getKeyByName_smmm([keyn], val, tname, ky, def, lDisp)
+END FUNCTION getKeyByName_s1mm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_i1mm(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname(:)
+  INTEGER,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  ::  ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByName_immm([keyn], val, tname, ky, def, lDisp)
+END FUNCTION getKeyByName_i1mm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_r1mm(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname(:)
+  REAL,         ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  ::  ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByName_rmmm([keyn], val, tname, ky, def, lDisp)
+END FUNCTION getKeyByName_r1mm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_l1mm(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn, tname(:)
+  LOGICAL,      ALLOCATABLE, INTENT(OUT) :: val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  ::  ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+  lerr = getKeyByName_lmmm([keyn], val, tname, ky, def, lDisp)
+END FUNCTION getKeyByName_l1mm
+!==============================================================================================================================
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_smmm(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),                   INTENT(IN)  :: keyn(:), tname(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE, INTENT(OUT) ::  val(:)
+  TYPE(keys_type),       OPTIONAL,    INTENT(IN)  ::   ky(:)
+  CHARACTER(LEN=*),      OPTIONAL,    INTENT(IN)  ::   def
+  LOGICAL,               OPTIONAL,    INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s
   INTEGER :: iq, nq
-  IF(test(getKey_sm(keyn, sval, ky, nam), lerr)) RETURN
-  nq = SIZE(sval); ALLOCATE(val(nq))
-  lerr = .FALSE.; DO iq=1, nq; val(iq)=str2bool(sval(iq)); END DO
-END FUNCTION getKey_lm
+  LOGICAL :: lD
+  nq = SIZE(tname); ALLOCATE(val(nq))
+  lD = .TRUE.; IF(PRESENT(lDisp)) lD = lDisp
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'"'
+  lerr = .TRUE.
+  IF(PRESENT(ky)) THEN;                 val = fgetKey(ky)                                !--- "ky"
+  ELSE IF(ALLOCATED(tracers)) THEN;     val = fgetKey(tracers(:)%keys)                   !--- "tracers"
+     IF(lerr .AND. ASSOCIATED(isotope)) val = fgetKey(isotope%keys(:))                   !--- "isotope"
+  END IF
+  IF(.NOT.PRESENT(def)) THEN; CALL msg('No '//TRIM(s)//' found', modname, lD); RETURN; END IF
+
+  !--- DEFAULT VALUE
+  val = [(def, iq = 1, SIZE(tname))]
+  CALL msg('Using defaut value for '//TRIM(s)//': '//TRIM(def), modname, lD)
+
+CONTAINS
+
+FUNCTION fgetKey(ky) RESULT(val)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: val(:)
+  TYPE(keys_type),       INTENT(IN)  :: ky(:)
+  LOGICAL,               ALLOCATABLE :: ler(:)
+  lerr = SIZE(ky) == 0; IF(lerr) RETURN
+  ALLOCATE(ler(SIZE(tname)))
+  val = [(fgetKeyIdx(strIdx(ky(:)%name, tname(iq)), keyn, ky, ler(iq)), iq = 1, SIZE(tname))]
+  lerr = ANY(ler)
+END FUNCTION fgetKey
+
+END FUNCTION getKeyByName_smmm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_immm(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname(:)
+  INTEGER,      ALLOCATABLE, INTENT(OUT) ::  val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  ::   ky(:)
+  INTEGER,         OPTIONAL, INTENT(IN)  ::  def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  LOGICAL,               ALLOCATABLE ::    ll(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_smmm(keyn, svals, tname, ky, int2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_smmm(keyn, svals, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  val = str2int(svals)
+  ll = val == -HUGE(1)
+  lerr = ANY(ll); IF(.NOT.lerr) RETURN
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(strStack(tname, MASK=ll))//' is not'
+  CALL msg(TRIM(s)//' an integer: '//TRIM(strStack(svals, MASK=ll)), modname)
+END FUNCTION getKeyByName_immm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_rmmm(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname(:)
+  REAL,         ALLOCATABLE, INTENT(OUT) ::  val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  ::   ky(:)
+  REAL,            OPTIONAL, INTENT(IN)  ::  def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  LOGICAL,               ALLOCATABLE ::    ll(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_smmm(keyn, svals, tname, ky, real2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_smmm(keyn, svals, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  val = str2real(svals)
+  ll = val == -HUGE(1.)
+  lerr = ANY(ll); IF(.NOT.lerr) RETURN
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(strStack(tname, MASK=ll))//' is not'
+  CALL msg(TRIM(s)//' a real: '//TRIM(strStack(svals, MASK=ll)), modname)
+END FUNCTION getKeyByName_rmmm
+!==============================================================================================================================
+LOGICAL FUNCTION getKeyByName_lmmm(keyn, val, tname, ky, def, lDisp) RESULT(lerr)
+  CHARACTER(LEN=*),          INTENT(IN)  :: keyn(:), tname(:)
+  LOGICAL,      ALLOCATABLE, INTENT(OUT) ::  val(:)
+  TYPE(keys_type), OPTIONAL, INTENT(IN)  ::   ky(:)
+  LOGICAL,         OPTIONAL, INTENT(IN)  ::  def
+  LOGICAL,         OPTIONAL, INTENT(IN)  :: lDisp
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: s, sval
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: svals(:)
+  LOGICAL,               ALLOCATABLE ::    ll(:)
+  INTEGER,               ALLOCATABLE :: ivals(:)
+  IF(     PRESENT(def)) lerr = getKeyByName_smmm(keyn, svals, tname, ky, bool2str(def), lDisp)
+  IF(.NOT.PRESENT(def)) lerr = getKeyByName_smmm(keyn, svals, tname, ky, lDisp=lDisp)
+  IF(lerr) RETURN
+  ivals = str2bool(svals)
+  ll = ivals == -1
+  lerr = ANY(ll); IF(.NOT.lerr) THEN; val = ivals == 1; RETURN; END IF
+  s = 'key "'//TRIM(strStack(keyn, '/'))//'" of '//TRIM(strStack(tname, MASK=ll))//' is not'
+  CALL msg(TRIM(s)//' a boolean: '//TRIM(strStack(svals, MASK=ll)), modname)
+END FUNCTION getKeyByName_lmmm
 !==============================================================================================================================
 
@@ -1925 +2607 @@
 !=== APPEND TRACERS DATABASE "tracs" WITH TRACERS/KEYS "tname"/"keys" ; SAME FOR INTERNAL DATABASE "tracers" ==================
 !==============================================================================================================================
-SUBROUTINE addTracer_1(tname, keys, tracs)
+LOGICAL FUNCTION addTracer_1(tname, keys, tracs) RESULT(lerr)
   CHARACTER(LEN=*),             INTENT(IN)    :: tname
   TYPE(keys_type),              INTENT(IN)    ::  keys
   TYPE(trac_type), ALLOCATABLE, INTENT(INOUT) :: tracs(:)
   TYPE(trac_type), ALLOCATABLE :: tr(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tnames(:)
   INTEGER :: nt, ix
   IF(ALLOCATED(tracs)) THEN
+     lerr = getKey('name', tnames, ky=tracs(:)%keys); IF(lerr) RETURN
      nt = SIZE(tracs)
-     ix = strIdx(tracs(:)%name, tname)
+     ix = strIdx(tnames, tname)
      CALL msg('Modifying existing tracer "'//TRIM(tname)//'"', modname, ix /= 0)
      CALL msg('Appending with tracer "'    //TRIM(tname)//'"', modname, ix == 0)
@@ -1943 +2627 @@
      ix = 1; ALLOCATE(tracs(1))
   END IF
+  CALL addKey('name', tname, tracs(ix)%keys)
   tracs(ix)%name = tname
   tracs(ix)%keys = keys
-END SUBROUTINE addTracer_1
-!==============================================================================================================================
-SUBROUTINE addTracer_1def(tname, keys)
+
+END FUNCTION addTracer_1
+!==============================================================================================================================
+LOGICAL FUNCTION addTracer_1def(tname, keys) RESULT(lerr)
   CHARACTER(LEN=*),             INTENT(IN)    :: tname
   TYPE(keys_type),              INTENT(IN)    ::  keys
-  CALL addTracer_1(tname, keys, tracers)
-END SUBROUTINE addTracer_1def
-!==============================================================================================================================
-
-
-!==============================================================================================================================
-LOGICAL FUNCTION delTracer_1(tname, tracs)  RESULT(lerr)
+  lerr = addTracer_1(tname, keys, tracers)
+END FUNCTION addTracer_1def
+!==============================================================================================================================
+
+
+!==============================================================================================================================
+LOGICAL FUNCTION delTracer_1(tname, tracs) RESULT(lerr)
   CHARACTER(LEN=*),                     INTENT(IN)    :: tname
   TYPE(trac_type), ALLOCATABLE, TARGET, INTENT(INOUT) :: tracs(:)
   TYPE(trac_type), ALLOCATABLE :: tr(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: tnames(:)
   INTEGER :: nt, ix
   lerr = .NOT.ALLOCATED(tracs)
   IF(fmsg('Can''t remove tracer "'//TRIM(tname)//'" from an empty tracers descriptor', modname, lerr)) RETURN
   nt = SIZE(tracs)
-  ix = strIdx(tracs(:)%name, tname)
+  lerr = getKey('name', tnames, ky=tracs(:)%keys); IF(lerr) RETURN
+  ix = strIdx(tnames, tname)
   CALL msg('Removing tracer "'             //TRIM(tname)//'"', modname, ix /= 0)
   CALL msg('Can''t remove unknown tracer "'//TRIM(tname)//'"', modname, ix == 0)
@@ -2076 +2764 @@
 !==============================================================================================================================
 
-
-!==============================================================================================================================
-!=== GET THE NAME(S) OF THE ANCESTOR(S) OF TRACER(S) "tname" AT GENERATION "igen"  IN THE TRACERS DESCRIPTORS LIST "tr" =======
-!==============================================================================================================================
-SUBROUTINE ancestor_1(t, out, tname, igen)
-  TYPE(trac_type),       INTENT(IN)  :: t(:)
-  CHARACTER(LEN=maxlen), INTENT(OUT) :: out
-  CHARACTER(LEN=*),      INTENT(IN)  :: tname
-  INTEGER,     OPTIONAL, INTENT(IN)  :: igen
-!------------------------------------------------------------------------------------------------------------------------------
-  INTEGER :: ix
-  CALL idxAncestor_1(t, ix, tname, igen)
-  out = ''; IF(ix /= 0) out = t(ix)%name
-END SUBROUTINE ancestor_1
-!==============================================================================================================================
-SUBROUTINE ancestor_mt(t, out, tname, igen)
-  TYPE(trac_type),       INTENT(IN)  :: t(:)
-  CHARACTER(LEN=*),      INTENT(IN)  :: tname(:)
-  CHARACTER(LEN=maxlen), INTENT(OUT) :: out(SIZE(tname))
-  INTEGER,     OPTIONAL, INTENT(IN)  :: igen
-!------------------------------------------------------------------------------------------------------------------------------
-  INTEGER :: ix(SIZE(tname))
-  CALL idxAncestor_mt(t, ix, tname, igen)
-  out(:) = ''; WHERE(ix /= 0) out = t(ix)%name
-END SUBROUTINE ancestor_mt
-!==============================================================================================================================
-SUBROUTINE ancestor_m(t, out, igen)
-  TYPE(trac_type),       INTENT(IN)  :: t(:)
-  CHARACTER(LEN=maxlen), INTENT(OUT) :: out(SIZE(t))
-  INTEGER,     OPTIONAL, INTENT(IN)  :: igen
-!------------------------------------------------------------------------------------------------------------------------------
-  INTEGER :: ix(SIZE(t))
-  CALL idxAncestor_m(t, ix, igen)
-  out(:) = ''; WHERE(ix /= 0) out = t(ix)%name
-END SUBROUTINE ancestor_m
-!==============================================================================================================================
-
-
-!==============================================================================================================================
-!=== GET THE INDEX(ES) OF THE GENERATION "igen" ANCESTOR(S) OF "tname" (t%name IF UNSPECIFIED) IN THE "t" LIST ================
-!==============================================================================================================================
-SUBROUTINE idxAncestor_1(t, idx, tname, igen)
-  TYPE(trac_type),   INTENT(IN)  :: t(:)
-  INTEGER,           INTENT(OUT) :: idx
-  CHARACTER(LEN=*),  INTENT(IN)  :: tname
-  INTEGER, OPTIONAL, INTENT(IN)  :: igen
-  INTEGER :: ig
-  ig = 0; IF(PRESENT(igen)) ig = igen
-  idx = strIdx(t(:)%name, tname)
-  IF(idx == 0)                 RETURN            !--- Tracer not found
-  IF(t(idx)%iGeneration <= ig) RETURN            !--- Tracer has a lower generation number than asked generation 'igen"
-  DO WHILE(t(idx)%iGeneration > ig); idx = strIdx(t(:)%name, t(idx)%parent); END DO
-END SUBROUTINE idxAncestor_1
-!------------------------------------------------------------------------------------------------------------------------------
-SUBROUTINE idxAncestor_mt(t, idx, tname, igen)
-  TYPE(trac_type),   INTENT(IN)  :: t(:)
-  CHARACTER(LEN=*),  INTENT(IN)  :: tname(:)
-  INTEGER,           INTENT(OUT) :: idx(SIZE(tname))
-  INTEGER, OPTIONAL, INTENT(IN)  :: igen
-  INTEGER :: ix
-  DO ix = 1, SIZE(tname); CALL idxAncestor_1(t, idx(ix), tname(ix), igen); END DO
-END SUBROUTINE idxAncestor_mt
-!------------------------------------------------------------------------------------------------------------------------------
-SUBROUTINE idxAncestor_m(t, idx, igen)
-  TYPE(trac_type),   INTENT(IN)  :: t(:)
-  INTEGER,           INTENT(OUT) :: idx(SIZE(t))
-  INTEGER, OPTIONAL, INTENT(IN)  :: igen
-  INTEGER :: ix
-  DO ix = 1, SIZE(t); CALL idxAncestor_1(t, idx(ix), t(ix)%name, igen); END DO
-END SUBROUTINE idxAncestor_m
-!==============================================================================================================================
-
-
 END MODULE readTracFiles_mod

LMDZ6/trunk/libf/misc/strings_mod.F90

@@ -10 +10 @@
   PUBLIC :: is_numeric, bool2str, int2str, real2str, dble2str
   PUBLIC :: reduceExpr, str2bool, str2int, str2real, str2dble
-  PUBLIC :: addQuotes, checkList, removeComment, test
+  PUBLIC :: addQuotes, checkList, removeComment
 
   INTERFACE get_in;     MODULE PROCEDURE getin_s,  getin_i,  getin_r,  getin_l;  END INTERFACE get_in
@@ -22 +22 @@
   INTERFACE strCount;   MODULE PROCEDURE  strCount_m1, strCount_11, strCount_1m; END INTERFACE strCount
   INTERFACE strReplace; MODULE PROCEDURE strReplace_1,             strReplace_m; END INTERFACE strReplace
-  INTERFACE cat;        MODULE PROCEDURE   horzcat_s1,  horzcat_i1,  horzcat_r1, &
-!                 horzcat_d1,  horzcat_dm,
-                                           horzcat_sm,  horzcat_im,  horzcat_rm; END INTERFACE cat
-  INTERFACE find;         MODULE PROCEDURE    strFind,    find_int,    find_boo; END INTERFACE find
+  INTERFACE cat;        MODULE PROCEDURE  horzcat_s00, horzcat_i00, horzcat_r00,  & !horzcat_d00, &
+                                          horzcat_s10, horzcat_i10, horzcat_r10,  & !horzcat_d10, &
+                                          horzcat_s11, horzcat_i11, horzcat_r11,  & !horzcat_d11, &
+                                          horzcat_s21, horzcat_i21, horzcat_r21; END INTERFACE cat !horzcat_d21
+  INTERFACE strFind;      MODULE PROCEDURE strFind_1, strFind_m;                 END INTERFACE strFind
+  INTERFACE find;         MODULE PROCEDURE strFind_1, strFind_m, intFind_1, intFind_m, booFind; END INTERFACE find
   INTERFACE dispOutliers; MODULE PROCEDURE dispOutliers_1, dispOutliers_2; END INTERFACE dispOutliers
   INTERFACE reduceExpr;   MODULE PROCEDURE   reduceExpr_1,   reduceExpr_m; END INTERFACE reduceExpr
@@ -36 +38 @@
 CONTAINS
 
-!==============================================================================================================================
-LOGICAL FUNCTION test(lcond, lout) RESULT(lerr)
-  LOGICAL, INTENT(IN)  :: lcond
-  LOGICAL, INTENT(OUT) :: lout
-  lerr = lcond; lout = lcond
-END FUNCTION test
-!==============================================================================================================================
-
 
 !==============================================================================================================================
 SUBROUTINE init_printout(lunout_, prt_level_)
+  IMPLICIT NONE
   INTEGER, INTENT(IN) :: lunout_, prt_level_
   lunout    = lunout_
@@ -58 +53 @@
 !==============================================================================================================================
 SUBROUTINE getin_s(nam, val, def)
-USE ioipsl_getincom, ONLY: getin
+  USE ioipsl_getincom, ONLY: getin
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN)    :: nam
   CHARACTER(LEN=*), INTENT(INOUT) :: val
@@ -67 +63 @@
 !==============================================================================================================================
 SUBROUTINE getin_i(nam, val, def)
-USE ioipsl_getincom, ONLY: getin
+  USE ioipsl_getincom, ONLY: getin
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN)    :: nam
   INTEGER,          INTENT(INOUT) :: val
@@ -76 +73 @@
 !==============================================================================================================================
 SUBROUTINE getin_r(nam, val, def)
-USE ioipsl_getincom, ONLY: getin
+  USE ioipsl_getincom, ONLY: getin
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN)    :: nam
   REAL,             INTENT(INOUT) :: val
@@ -85 +83 @@
 !==============================================================================================================================
 SUBROUTINE getin_l(nam, val, def)
-USE ioipsl_getincom, ONLY: getin
+  USE ioipsl_getincom, ONLY: getin
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN)    :: nam
   LOGICAL,          INTENT(INOUT) :: val
@@ -99 +98 @@
 !==============================================================================================================================
 SUBROUTINE msg_1(str, modname, ll, unit)
+  IMPLICIT NONE
   !--- Display a simple message "str". Optional parameters:
   !    * "modname": module name, displayed in front of the message (with ": " separator) if present.
@@ -118 +118 @@
 !==============================================================================================================================
 SUBROUTINE msg_m(str, modname, ll, unit, nmax)
+  IMPLICIT NONE
   !--- Same as msg_1 with multiple strings that are stacked (separator: coma) on up to "nmax" full lines.
   CHARACTER(LEN=*),           INTENT(IN) :: str(:)
@@ -138 +139 @@
 !==============================================================================================================================
 LOGICAL FUNCTION fmsg_1(str, modname, ll, unit) RESULT(l)
+  IMPLICIT NONE
   CHARACTER(LEN=*),           INTENT(IN) :: str
   CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: modname
@@ -152 +154 @@
 !==============================================================================================================================
 LOGICAL FUNCTION fmsg_m(str, modname, ll, unit, nmax) RESULT(l)
+  IMPLICIT NONE
   CHARACTER(LEN=*),           INTENT(IN)  :: str(:)
   CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: modname
@@ -173 +176 @@
 !==============================================================================================================================
 ELEMENTAL CHARACTER(LEN=maxlen) FUNCTION strLower(str) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN) :: str
   INTEGER :: k
@@ -182 +186 @@
 !==============================================================================================================================
 ELEMENTAL CHARACTER(LEN=maxlen) FUNCTION strUpper(str) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN) :: str
   INTEGER :: k
@@ -199 +204 @@
 !==============================================================================================================================
 CHARACTER(LEN=maxlen) FUNCTION strHead_1(str, sep, lBackward) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*),           INTENT(IN) :: str
   CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: sep
@@ -214 +220 @@
 !==============================================================================================================================
 FUNCTION strHead_m(str, sep, lBackward) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=maxlen),     ALLOCATABLE :: out(:)
   CHARACTER(LEN=*),           INTENT(IN) :: str(:)
@@ -235 +242 @@
 !==============================================================================================================================
 CHARACTER(LEN=maxlen) FUNCTION strTail_1(str, sep, lBackWard) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*),           INTENT(IN) :: str
   CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: sep
@@ -250 +258 @@
 !==============================================================================================================================
 FUNCTION strTail_m(str, sep, lBackWard) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=maxlen),     ALLOCATABLE :: out(:)
   CHARACTER(LEN=*),           INTENT(IN) :: str(:)
@@ -271 +280 @@
 !==============================================================================================================================
 FUNCTION strStack(str, sep, mask) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=:),          ALLOCATABLE :: out
   CHARACTER(LEN=*),           INTENT(IN) :: str(:)
@@ -292 +302 @@
 !==============================================================================================================================
 FUNCTION strStackm(str, sep, nmax) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=maxlen),     ALLOCATABLE :: out(:)
   CHARACTER(LEN=*),           INTENT(IN) :: str(:)
@@ -324 +335 @@
 !==============================================================================================================================
 SUBROUTINE strClean_1(str)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(INOUT) :: str
   INTEGER :: k, n, m
@@ -337 +349 @@
 !==============================================================================================================================
 SUBROUTINE strClean_m(str)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(INOUT) :: str(:)
   INTEGER :: k
@@ -349 +362 @@
 !==============================================================================================================================
 SUBROUTINE strReduce_1(str, nb)
+  IMPLICIT NONE
   CHARACTER(LEN=*), ALLOCATABLE, INTENT(INOUT) :: str(:)
   INTEGER,          OPTIONAL,    INTENT(OUT)   :: nb
@@ -366 +380 @@
 !==============================================================================================================================
 SUBROUTINE strReduce_2(str1, str2)
+  IMPLICIT NONE
   CHARACTER(LEN=*),   ALLOCATABLE, INTENT(INOUT) :: str1(:)
   CHARACTER(LEN=*),                INTENT(IN)    :: str2(:)
@@ -392 +407 @@
 !==============================================================================================================================
 INTEGER FUNCTION strIdx_1(str, s) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN) :: str(:), s
   DO out = 1, SIZE(str); IF(str(out) == s) EXIT; END DO
@@ -398 +414 @@
 !==============================================================================================================================
 FUNCTION strIdx_m(str, s, n) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*),  INTENT(IN)  :: str(:), s(:)
   INTEGER, OPTIONAL, INTENT(OUT) :: n
@@ -412 +429 @@
 !=== GET THE INDEX LIST OF THE ELEMENTS OF "str(:)" EQUAL TO "s" AND OPTIONALY, ITS LENGTH "n" ================================
 !==============================================================================================================================
-FUNCTION strFind(str, s, n) RESULT(out)
+FUNCTION strFind_1(str, s, n) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*),  INTENT(IN)  :: str(:), s
   INTEGER, OPTIONAL, INTENT(OUT) :: n
@@ -420 +438 @@
   out = PACK( [(k, k=1, SIZE(str(:), DIM=1))], MASK = str(:) == s )
   IF(PRESENT(n)) n = SIZE(out(:), DIM=1)
-END FUNCTION strFind
-!==============================================================================================================================
-FUNCTION find_int(i,j,n) RESULT(out)
+END FUNCTION strFind_1
+!==============================================================================================================================
+FUNCTION strFind_m(str, s, n) RESULT(out)
+  IMPLICIT NONE
+  CHARACTER(LEN=*),  INTENT(IN)  :: str(:), s(:)
+  INTEGER, OPTIONAL, INTENT(OUT) :: n
+  INTEGER,           ALLOCATABLE :: out(:)
+!------------------------------------------------------------------------------------------------------------------------------
+  INTEGER :: k
+  out = [(strFind_1(str, s(k)), k=1, SIZE(s))]
+  IF(PRESENT(n)) n = SIZE(out(:), DIM=1)
+END FUNCTION strFind_m
+!==============================================================================================================================
+FUNCTION intFind_1(i,j,n) RESULT(out)
+  IMPLICIT NONE
   INTEGER,           INTENT(IN)  :: i(:), j
   INTEGER, OPTIONAL, INTENT(OUT) :: n
@@ -430 +460 @@
   out = PACK( [(k, k=1, SIZE(i(:), DIM=1))], MASK = i(:) == j )
   IF(PRESENT(n)) n = SIZE(out(:), DIM=1)
-END FUNCTION find_int
-!==============================================================================================================================
-FUNCTION find_boo(l,n) RESULT(out)
-  LOGICAL,           INTENT(IN)  :: l(:)
+END FUNCTION intFind_1
+!==============================================================================================================================
+FUNCTION intFind_m(i,j,n) RESULT(out)
+  IMPLICIT NONE
+  INTEGER,           INTENT(IN)  :: i(:), j(:)
+  INTEGER, OPTIONAL, INTENT(OUT) :: n
+  INTEGER,           ALLOCATABLE :: out(:)
+!------------------------------------------------------------------------------------------------------------------------------
+  INTEGER :: k
+  out = [(intFind_1(i, j(k)), k=1, SIZE(j))]
+  IF(PRESENT(n)) n = SIZE(out(:), DIM=1)
+END FUNCTION intFind_m
+!==============================================================================================================================
+FUNCTION booFind(l,n) RESULT(out)
+   IMPLICIT NONE
+ LOGICAL,           INTENT(IN)  :: l(:)
   INTEGER, OPTIONAL, INTENT(OUT) :: n
   INTEGER,           ALLOCATABLE :: out(:)
@@ -440 +482 @@
   out = PACK( [(k, k=1, SIZE(l(:), DIM=1))], MASK = l(:) )
   IF(PRESENT(n)) n = SIZE(out(:), DIM=1)
-END FUNCTION find_boo
+END FUNCTION booFind
 !==============================================================================================================================
 
@@ -450 +492 @@
 !==============================================================================================================================
 LOGICAL FUNCTION strIdx_prv(rawList, del, ibeg, idx, idel, lSc) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),  INTENT(IN)  :: rawList                          !--- String in which delimiters have to be identified
   CHARACTER(LEN=*),  INTENT(IN)  :: del(:)                           !--- List of delimiters
@@ -469 +512 @@
   END IF
 
-  IF(test(idx == 1 .AND. INDEX('+-',del(idel)) /= 0, lerr)) RETURN   !--- The front delimiter is different from +/-: error
-  IF(     idx /= 1 .AND. is_numeric(rawList(ibeg:idx-1)))   RETURN   !--- The input string head is a valid number
+  lerr = idx == 1 .AND. INDEX('+-',del(idel)) /= 0; IF(lerr) RETURN  !--- The front delimiter is different from +/-: error
+  IF(    idx /= 1 .AND. is_numeric(rawList(ibeg:idx-1)))     RETURN  !--- The input string head is a valid number
 
   !=== The string part in front of the 1st delimiter is not a valid number: search for next delimiter index "idx"
@@ -503 +546 @@
 !==============================================================================================================================
 LOGICAL FUNCTION strCount_11(rawList, delimiter, nb, lSc) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),  INTENT(IN)  :: rawList
   CHARACTER(LEN=*),  INTENT(IN)  :: delimiter
@@ -514 +558 @@
 !==============================================================================================================================
 LOGICAL FUNCTION strCount_m1(rawList, delimiter, nb, lSc) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),     INTENT(IN)  :: rawList(:)
   CHARACTER(LEN=*),     INTENT(IN)  :: delimiter
@@ -530 +575 @@
 !==============================================================================================================================
 LOGICAL FUNCTION strCount_1m(rawList, delimiter, nb, lSc) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),  INTENT(IN)  :: rawList
   CHARACTER(LEN=*),  INTENT(IN)  :: delimiter(:)
@@ -560 +606 @@
 !==============================================================================================================================
 LOGICAL FUNCTION strParse(rawList, delimiter, keys, n, vals) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),                             INTENT(IN)  :: rawList, delimiter
   CHARACTER(LEN=maxlen), ALLOCATABLE,           INTENT(OUT) :: keys(:)
@@ -570 +617 @@
   r  = TRIM(ADJUSTL(rawList))
   nr = LEN_TRIM(r); IF(nr == 0) THEN; keys = ['']; RETURN; END IF
-  CALL strParse_prv(nk)                                              !--- COUNT THE ELEMENTS
-  ALLOCATE(keys(nk))
-  IF(PRESENT(vals)) THEN
-    ALLOCATE(vals(nk)); CALL strParse_prv(nk, keys, vals)            !--- PARSE THE KEYS
-  ELSE
-    CALL strParse_prv(nk, keys)                                      !--- PARSE THE KEYS
-  END IF
-  IF(PRESENT(n)) n = nk
+  nk = countK()                                                      !--- COUNT THE ELEMENTS
+  CALL parseK(keys)                                                  !--- PARSE THE KEYS
+  IF(PRESENT(vals)) CALL parseV(vals)                                !--- PARSE <key>=<val> PAIRS
+  IF(PRESENT(n)) n = nk                                              !--- RETURN THE NUMBER OF KEYS
+  IF(PRESENT(vals)) &
+print*,'key ; val = '//TRIM(strStack(keys))//' ; '//TRIM(strStack(vals))
 
 CONTAINS
 
 !------------------------------------------------------------------------------------------------------------------------------
-SUBROUTINE strParse_prv(nkeys, keys, vals)
-!--- * Get the number of elements after parsing ("nkeys" only is present)
-!--- * Parse the <key>=<val> pairs and store result in "keys" and "vals" (already allocated)
-  IMPLICIT NONE
-  INTEGER,                         INTENT(OUT) :: nkeys
-  CHARACTER(LEN=maxlen), OPTIONAL, INTENT(OUT) :: keys(:)
-  CHARACTER(LEN=maxlen), OPTIONAL, INTENT(OUT) :: vals(:)
-!------------------------------------------------------------------------------------------------------------------------------
-  INTEGER :: ib, ie
-  nkeys = 1; ib = 1
+INTEGER FUNCTION countK() RESULT(nkeys)
+!--- Get the number of elements after parsing.
+  IMPLICIT NONE
+!------------------------------------------------------------------------------------------------------------------------------
+  INTEGER :: ib, ie, nl
+  nkeys = 1; ib = 1; nl = LEN(delimiter)
   DO
     ie = INDEX(rawList(ib:nr), delimiter)+ib-1                       !--- Determine the next separator start index
     IF(ie == ib-1) EXIT
-    IF(PRESENT(keys)) keys(nkeys) = r(ib:ie-1)                       !--- Get the ikth key
-    IF(PRESENT(vals)) CALL parseKeys(keys(nkeys), vals(nkeys))       !--- Parse the ikth <key>=<val> pair
+    ib = ie + nl
+    DO WHILE(ANY([0, 9, 32] == IACHAR(r(ib:ib))) .AND. ib < nr)      !--- Skip blanks (ascii): NULL (0), TAB (9), SPACE (32)
+      ib = ib + 1
+    END DO     !--- Skip spaces before next chain
+    nkeys = nkeys+1
+  END DO
+END FUNCTION countK
+
+!------------------------------------------------------------------------------------------------------------------------------
+SUBROUTINE parseK(keys)
+!--- Parse the string separated by "delimiter" from "rawList" into "keys(:)"
+  IMPLICIT NONE
+  CHARACTER(LEN=maxlen), ALLOCATABLE, INTENT(OUT) :: keys(:)
+!------------------------------------------------------------------------------------------------------------------------------
+  INTEGER :: ib, ie, ik
+  ALLOCATE(keys(nk))
+  ib = 1
+  DO ik = 1, nk
+    ie = INDEX(rawList(ib:nr), delimiter)+ib-1                       !--- Determine the next separator start index
+    IF(ie == ib-1) EXIT
+    keys(ik) = r(ib:ie-1)                                            !--- Get the ikth key
     ib = ie + LEN(delimiter)
     DO WHILE(r(ib:ib) == ' ' .AND. ib < nr); ib = ib + 1; END DO     !--- Skip spaces before next chain
-    nkeys = nkeys+1
-  END DO
-  IF(PRESENT(keys)) keys(nkeys) = r(ib:nr)                           !--- Get the last key
-  IF(PRESENT(vals)) CALL parseKeys(keys(nkeys), vals(nkeys))         !--- Parse the last <key>=<val> pair
-END SUBROUTINE strParse_prv
-
-!------------------------------------------------------------------------------------------------------------------------------
-SUBROUTINE parseKeys(key, val)
-  CHARACTER(LEN=*), INTENT(INOUT) :: key
-  CHARACTER(LEN=*), INTENT(OUT)   :: val
-!------------------------------------------------------------------------------------------------------------------------------
-  INTEGER :: ix
-  ix = INDEX(key, '='); IF(ix == 0) RETURN                           !--- First "=" index in "key"
-  val = ADJUSTL(key(ix+1:LEN_TRIM(key)))
-  key = ADJUSTL(key(1:ix-1))
-END SUBROUTINE parseKeys
+  END DO
+  keys(ik) = r(ib:nr)                                                !--- Get the last key
+END SUBROUTINE parseK
+
+!------------------------------------------------------------------------------------------------------------------------------
+SUBROUTINE parseV(vals)
+!--- Parse the <key>=<val> pairs in "keys(:)" into "keys" and "vals"
+  IMPLICIT NONE
+  CHARACTER(LEN=maxlen), ALLOCATABLE, INTENT(OUT) :: vals(:)
+!------------------------------------------------------------------------------------------------------------------------------
+  CHARACTER(LEN=maxlen) :: key
+  INTEGER :: ik, ix
+  ALLOCATE(vals(nk))
+  DO ik = 1, nk; key = keys(ik)
+    vals(ik) = ''
+    ix = INDEX(key, '='); IF(ix == 0) CYCLE                          !--- First "=" index in "key"
+    vals(ik) = ADJUSTL(key(ix+1:LEN_TRIM(key)))
+    keys(ik) = ADJUSTL(key(1:ix-1))
+  END DO
+END SUBROUTINE parseV
 
 END FUNCTION strParse
 !==============================================================================================================================
 LOGICAL FUNCTION strParse_m(rawList, delimiter, keys, n, vals, lSc, id) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),                             INTENT(IN)  :: rawList, delimiter(:)
   CHARACTER(LEN=maxlen),           ALLOCATABLE, INTENT(OUT) :: keys(:)  !--- Parsed keys vector
@@ -630 +695 @@
   LOGICAL :: ll
   ll = .FALSE.; IF(PRESENT(lSc)) ll = lSc
-  IF(test(fmsg("Couldn't parse list: non-numerical strings were found", ll=strCount_1m(rawList, delimiter, nk, ll)),lerr)) RETURN
+  lerr = strCount_1m(rawList, delimiter, nk, ll)
+  CALL msg("Couldn't parse list: non-numerical strings were found", ll=lerr); IF(lerr) RETURN
 
   !--- FEW ALLOCATIONS
@@ -643 +709 @@
   ib = 1
   DO ik = 1, nk-1
-    IF(test(fmsg('Non-numeric values found', ll=strIdx_prv(r, delimiter, ib, ie, jd, ll)),lerr)) RETURN
+    lerr = strIdx_prv(r, delimiter, ib, ie, jd, ll)
+    CALL msg('Non-numeric values found', ll=lerr); IF(lerr) RETURN
     keys(ik) = r(ib:ie-1)
     IF(PRESENT(vals)) CALL parseKeys(keys(ik), vals(ik))             !--- Parse a <key>=<val> pair
@@ -657 +724 @@
 !------------------------------------------------------------------------------------------------------------------------------
 SUBROUTINE parseKeys(key, val)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(INOUT) :: key
   CHARACTER(LEN=*), INTENT(OUT)   :: val
@@ -674 +742 @@
 !==============================================================================================================================
 SUBROUTINE strReplace_1(str, key, val, lsurr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),  INTENT(INOUT) :: str        !--- Main string
   CHARACTER(LEN=*),  INTENT(IN)    :: key, val   !--- "key" will be replaced by "val"
@@ -700 +769 @@
 !==============================================================================================================================
 SUBROUTINE strReplace_m(str, key, val, lsurr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),  INTENT(INOUT) :: str(:)     !--- Main strings vector
   CHARACTER(LEN=*),  INTENT(IN)    :: key, val   !--- "key" will be replaced by "val"
@@ -714 +784 @@
 !=== Contatenate horizontally scalars/vectors of strings/integers/reals into a vector/array ===================================
 !==============================================================================================================================
-FUNCTION horzcat_s1(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9) RESULT(out)
-  CHARACTER(LEN=*),           TARGET, INTENT(IN) :: s0
+FUNCTION horzcat_s00(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9) RESULT(out)
+  IMPLICIT NONE
+  CHARACTER(LEN=*),                   INTENT(IN) :: s0
   CHARACTER(LEN=*), OPTIONAL, TARGET, INTENT(IN) :: s1, s2, s3, s4, s5, s6, s7, s8, s9
   CHARACTER(LEN=maxlen), ALLOCATABLE :: out(:)
-!------------------------------------------------------------------------------------------------------------------------------
   CHARACTER(LEN=maxlen), POINTER     :: s
-  LOGICAL :: lv(10)
-  INTEGER :: iv
-  lv = [   .TRUE.   , PRESENT(s1), PRESENT(s2), PRESENT(s3), PRESENT(s4) , &
-         PRESENT(s5), PRESENT(s6), PRESENT(s7), PRESENT(s8), PRESENT(s9) ]
-  ALLOCATE(out(COUNT(lv)))
-  DO iv=1, COUNT(lv)
-    SELECT CASE(iv)
-      CASE(1); s=> s0; CASE(2); s=> s1; CASE(3); s=> s2; CASE(4); s=> s3; CASE(5); s=> s4
-      CASE(6); s=> s5; CASE(7); s=> s6; CASE(8); s=> s7; CASE(9); s=> s8; CASE(10);s=> s9
+  INTEGER                            :: nrow, iv
+  LOGICAL                            :: pre(9)
+!------------------------------------------------------------------------------------------------------------------------------
+  pre(:) = [PRESENT(s1),PRESENT(s2),PRESENT(s3),PRESENT(s4),PRESENT(s5),PRESENT(s6),PRESENT(s7),PRESENT(s8),PRESENT(s9)]
+  nrow = 1+COUNT(pre)
+  ALLOCATE(out(nrow))
+  out(1) = s0
+  DO iv = 2, nrow; IF(.NOT.pre(iv-1)) CYCLE
+    SELECT CASE(iv-1)
+      CASE(1); s=> s1; CASE(2); s=> s2; CASE(3); s=> s3; CASE(4); s=> s4; CASE(5); s=> s5
+      CASE(6); s=> s6; CASE(7); s=> s7; CASE(8); s=> s8; CASE(9); s=> s9
     END SELECT
     out(iv) = s
   END DO
-END FUNCTION horzcat_s1
-!==============================================================================================================================
-FUNCTION horzcat_sm(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9) RESULT(out)
-  CHARACTER(LEN=*),           TARGET, DIMENSION(:), INTENT(IN) :: s0
-  CHARACTER(LEN=*), OPTIONAL, TARGET, DIMENSION(:), INTENT(IN) :: s1, s2, s3, s4, s5, s6, s7, s8, s9
+END FUNCTION horzcat_s00
+!==============================================================================================================================
+FUNCTION horzcat_s10(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9) RESULT(out)
+  IMPLICIT NONE
+  CHARACTER(LEN=*),           INTENT(IN) :: s0(:), s1
+  CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: s2, s3, s4, s5, s6, s7, s8, s9
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: out(:), tmp(:)
+  INTEGER :: nc
+  nc = SIZE(s0)
+  tmp = horzcat_s00(s0(nc), s1, s2, s3, s4, s5, s6, s7, s8, s9)
+  out = [s0(1:nc-1), tmp]
+END FUNCTION horzcat_s10
+!==============================================================================================================================
+FUNCTION horzcat_s11(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9) RESULT(out)
+  IMPLICIT NONE
+  CHARACTER(LEN=*),                   INTENT(IN) :: s0(:)
+  CHARACTER(LEN=*), OPTIONAL, TARGET, INTENT(IN) :: s1(:), s2(:), s3(:), s4(:), s5(:), s6(:), s7(:), s8(:), s9(:)
   CHARACTER(LEN=maxlen), ALLOCATABLE :: out(:,:)
-!------------------------------------------------------------------------------------------------------------------------------
   CHARACTER(LEN=maxlen), POINTER     :: s(:)
-  LOGICAL :: lv(10)
-  INTEGER :: nrow, ncol, iv, n
-  lv = [   .TRUE.   , PRESENT(s1), PRESENT(s2), PRESENT(s3), PRESENT(s4) , &
-         PRESENT(s5), PRESENT(s6), PRESENT(s7), PRESENT(s8), PRESENT(s9) ]
-  nrow = SIZE(s0); ncol=COUNT(lv)
+  INTEGER                            :: nrow, ncol, iv, n
+  LOGICAL                            :: pre(9)
+!------------------------------------------------------------------------------------------------------------------------------
+  pre(:) = [PRESENT(s1),PRESENT(s2),PRESENT(s3),PRESENT(s4),PRESENT(s5),PRESENT(s6),PRESENT(s7),PRESENT(s8),PRESENT(s9)]
+  nrow = SIZE(s0)
+  ncol = 1+COUNT(pre)
   ALLOCATE(out(nrow, ncol))
-  DO iv=1, ncol
-    SELECT CASE(iv)
-      CASE(1); s=> s0; CASE(2); s=> s1; CASE(3); s=> s2; CASE(4); s=> s3; CASE(5); s=> s4
-      CASE(6); s=> s5; CASE(7); s=> s6; CASE(8); s=> s7; CASE(9); s=> s8; CASE(10);s=> s9
+  out(:,1) = s0
+  DO iv = 2, ncol; IF(.NOT.pre(iv-1)) CYCLE
+    SELECT CASE(iv-1)
+      CASE(1); s=> s1; CASE(2); s=> s2; CASE(3); s=> s3; CASE(4); s=> s4; CASE(5); s=> s5
+      CASE(6); s=> s6; CASE(7); s=> s7; CASE(8); s=> s8; CASE(9); s=> s9
     END SELECT
     n = SIZE(s, DIM=1)
-    IF(n/=nrow) THEN; CALL msg("Can't concatenate vectors of differing lengths"); STOP; END IF
+    IF(n /= nrow) THEN; CALL msg("Can't concatenate vectors of differing lengths"); STOP; END IF
     out(:,iv) = s(:)
   END DO
-END FUNCTION horzcat_sm
-!==============================================================================================================================
-FUNCTION horzcat_i1(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) RESULT(out)
-  INTEGER,           TARGET, INTENT(IN) :: i0
+END FUNCTION horzcat_s11
+!==============================================================================================================================
+FUNCTION horzcat_s21(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9) RESULT(out)
+  IMPLICIT NONE
+  CHARACTER(LEN=*),           INTENT(IN) :: s0(:,:), s1(:)
+  CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: s2(:), s3(:), s4(:), s5(:), s6(:), s7(:), s8(:), s9(:)
+  CHARACTER(LEN=maxlen), ALLOCATABLE :: out(:,:), tmp(:,:)
+  INTEGER :: nc
+  nc  = SIZE(s0, 2)
+  tmp = horzcat_s11(s0(:,nc), s1, s2, s3, s4, s5, s6, s7, s8, s9)
+  out = RESHAPE([PACK(s0(:,1:nc-1), .TRUE.), PACK(tmp, .TRUE.)], SHAPE=[SIZE(s0, 1), nc + SIZE(tmp, 2)-1])
+END FUNCTION horzcat_s21
+!==============================================================================================================================
+FUNCTION horzcat_i00(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) RESULT(out)
+  IMPLICIT NONE
+  INTEGER,                   INTENT(IN) :: i0
   INTEGER, OPTIONAL, TARGET, INTENT(IN) :: i1, i2, i3, i4, i5, i6, i7, i8, i9
   INTEGER, ALLOCATABLE :: out(:)
-!------------------------------------------------------------------------------------------------------------------------------
   INTEGER, POINTER     :: i
-  LOGICAL :: lv(10)
-  INTEGER :: iv
-  lv = [   .TRUE.   , PRESENT(i1), PRESENT(i2), PRESENT(i3), PRESENT(i4) , &
-         PRESENT(i5), PRESENT(i6), PRESENT(i7), PRESENT(i8), PRESENT(i9) ]
-  ALLOCATE(out(COUNT(lv)))
-  DO iv=1, COUNT(lv)
-    SELECT CASE(iv)
-      CASE(1); i=> i0; CASE(2); i=> i1; CASE(3); i=> i2; CASE(4); i=> i3; CASE(5); i=> i4
-      CASE(6); i=> i5; CASE(7); i=> i6; CASE(8); i=> i7; CASE(9); i=> i8; CASE(10);i=> i9
+  INTEGER              :: ncol, iv
+  LOGICAL              :: pre(9)
+!------------------------------------------------------------------------------------------------------------------------------
+  pre(:) = [PRESENT(i1),PRESENT(i2),PRESENT(i3),PRESENT(i4),PRESENT(i5),PRESENT(i6),PRESENT(i7),PRESENT(i8),PRESENT(i9)]
+  ncol = SIZE(pre)
+  ALLOCATE(out(ncol))
+  out(1) = i0
+  DO iv = 2, ncol; IF(.NOT.pre(iv-1)) CYCLE
+    SELECT CASE(iv-1)
+      CASE(1); i=> i1; CASE(2); i=> i2; CASE(3); i=> i3; CASE(4); i=> i4; CASE(5); i=> i5
+      CASE(6); i=> i6; CASE(7); i=> i7; CASE(8); i=> i8; CASE(9); i=> i9
     END SELECT
     out(iv) = i
   END DO
-END FUNCTION horzcat_i1
-!==============================================================================================================================
-FUNCTION horzcat_im(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) RESULT(out)
-  INTEGER,           TARGET, DIMENSION(:), INTENT(IN) :: i0
-  INTEGER, OPTIONAL, TARGET, DIMENSION(:), INTENT(IN) :: i1, i2, i3, i4, i5, i6, i7, i8, i9
+END FUNCTION horzcat_i00
+!==============================================================================================================================
+FUNCTION horzcat_i10(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) RESULT(out)
+  IMPLICIT NONE
+  INTEGER,           INTENT(IN) :: i0(:), i1
+  INTEGER, OPTIONAL, INTENT(IN) :: i2, i3, i4, i5, i6, i7, i8, i9
+  INTEGER, ALLOCATABLE :: out(:), tmp(:)
+  INTEGER :: nc
+  nc = SIZE(i0)
+  tmp = horzcat_i00(i0(nc), i1, i2, i3, i4, i5, i6, i7, i8, i9)
+  out = [i0(1:nc-1), tmp]
+END FUNCTION horzcat_i10
+!==============================================================================================================================
+FUNCTION horzcat_i11(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) RESULT(out)
+  IMPLICIT NONE
+  INTEGER,                   INTENT(IN) :: i0(:)
+  INTEGER, OPTIONAL, TARGET, INTENT(IN) :: i1(:), i2(:), i3(:), i4(:), i5(:), i6(:), i7(:), i8(:), i9(:)
   INTEGER, ALLOCATABLE :: out(:,:)
-!------------------------------------------------------------------------------------------------------------------------------
   INTEGER, POINTER     :: i(:)
-  LOGICAL :: lv(10)
-  INTEGER :: nrow, ncol, iv, n
-  lv = [   .TRUE.   , PRESENT(i1), PRESENT(i2), PRESENT(i3), PRESENT(i4) , &
-         PRESENT(i5), PRESENT(i6), PRESENT(i7), PRESENT(i8), PRESENT(i9) ]
-  nrow = SIZE(i0); ncol=COUNT(lv)
+  INTEGER              :: nrow, ncol, iv, n
+  LOGICAL              :: pre(9)
+!------------------------------------------------------------------------------------------------------------------------------
+  pre(:) = [PRESENT(i1),PRESENT(i2),PRESENT(i3),PRESENT(i4),PRESENT(i5),PRESENT(i6),PRESENT(i7),PRESENT(i8),PRESENT(i9)]
+  nrow = SIZE(i0)
+  ncol = 1+COUNT(pre)
   ALLOCATE(out(nrow, ncol))
-  DO iv=1, ncol
-    SELECT CASE(iv)
-      CASE(1); i=> i0; CASE(2); i=> i1; CASE(3); i=> i2; CASE(4); i=> i3; CASE(5); i=> i4
-      CASE(6); i=> i5; CASE(7); i=> i6; CASE(8); i=> i7; CASE(9); i=> i8; CASE(10);i=> i9
+  out(:,1) = i0
+  DO iv = 2, ncol; IF(.NOT.pre(iv-1)) CYCLE
+    SELECT CASE(iv-1)
+      CASE(1); i=> i1; CASE(2); i=> i2; CASE(3); i=> i3; CASE(4); i=> i4; CASE(5); i=> i5
+      CASE(6); i=> i6; CASE(7); i=> i7; CASE(8); i=> i8; CASE(9); i=> i9
     END SELECT
     n = SIZE(i, DIM=1)
-    IF(n/=nrow) THEN; CALL msg("Can't concatenate vectors of differing lengths"); STOP; END IF
+    IF(n /= nrow) THEN; CALL msg("Can't concatenate vectors of differing lengths"); STOP; END IF
     out(:,iv) = i(:)
   END DO
-END FUNCTION horzcat_im
-!==============================================================================================================================
-FUNCTION horzcat_r1(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) RESULT(out)
-  REAL,           TARGET, INTENT(IN) :: r0
+END FUNCTION horzcat_i11
+!==============================================================================================================================
+FUNCTION horzcat_i21(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) RESULT(out)
+  IMPLICIT NONE
+  INTEGER,           INTENT(IN) :: i0(:,:), i1(:)
+  INTEGER, OPTIONAL, INTENT(IN) :: i2(:), i3(:), i4(:), i5(:), i6(:), i7(:), i8(:), i9(:)
+  INTEGER, ALLOCATABLE :: out(:,:), tmp(:,:)
+  INTEGER :: nc
+  nc  = SIZE(i0, 2)
+  tmp = horzcat_i11(i0(:,nc), i1, i2, i3, i4, i5, i6, i7, i8, i9)
+  out = RESHAPE([PACK(i0(:,1:nc-1), .TRUE.), PACK(tmp, .TRUE.)], SHAPE=[SIZE(i0, 1), nc + SIZE(tmp, 2)-1])
+END FUNCTION horzcat_i21
+!==============================================================================================================================
+FUNCTION horzcat_r00(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) RESULT(out)
+  IMPLICIT NONE
+  REAL,                   INTENT(IN) :: r0
   REAL, OPTIONAL, TARGET, INTENT(IN) :: r1, r2, r3, r4, r5, r6, r7, r8, r9
   REAL, ALLOCATABLE :: out(:)
-!------------------------------------------------------------------------------------------------------------------------------
   REAL, POINTER     :: r
-  LOGICAL :: lv(10)
-  INTEGER :: iv
-  lv = [   .TRUE.   , PRESENT(r1), PRESENT(r2), PRESENT(r3), PRESENT(r4) , &
-         PRESENT(r5), PRESENT(r6), PRESENT(r7), PRESENT(r8), PRESENT(r9) ]
-  ALLOCATE(out(COUNT(lv)))
-  DO iv=1, COUNT(lv)
-    SELECT CASE(iv)
-      CASE(1); r=> r0; CASE(2); r=> r1; CASE(3); r=> r2; CASE(4); r=> r3; CASE(5); r=> r4
-      CASE(6); r=> r5; CASE(7); r=> r6; CASE(8); r=> r7; CASE(9); r=> r8; CASE(10);r=> r9
+  INTEGER           :: ncol, iv
+  LOGICAL           :: pre(9)
+!------------------------------------------------------------------------------------------------------------------------------
+  pre(:) = [PRESENT(r1),PRESENT(r2),PRESENT(r3),PRESENT(r4),PRESENT(r5),PRESENT(r6),PRESENT(r7),PRESENT(r8),PRESENT(r9)]
+  ncol = 1+COUNT(pre)
+  ALLOCATE(out(ncol))
+  out(1) = r0
+  DO iv = 2, ncol; IF(.NOT.pre(iv-1)) CYCLE
+    SELECT CASE(iv-1)
+      CASE(1); r=> r1; CASE(2); r=> r2; CASE(3); r=> r3; CASE(4); r=> r4; CASE(5); r=> r5
+      CASE(6); r=> r6; CASE(7); r=> r7; CASE(8); r=> r8; CASE(9); r=> r9
     END SELECT
     out(iv) = r
   END DO
-END FUNCTION horzcat_r1
-!==============================================================================================================================
-FUNCTION horzcat_rm(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) RESULT(out)
-  REAL,           TARGET, DIMENSION(:), INTENT(IN) :: r0
-  REAL, OPTIONAL, TARGET, DIMENSION(:), INTENT(IN) :: r1, r2, r3, r4, r5, r6, r7, r8, r9
+END FUNCTION horzcat_r00
+!==============================================================================================================================
+FUNCTION horzcat_r10(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) RESULT(out)
+  IMPLICIT NONE
+  REAL,           INTENT(IN) :: r0(:), r1
+  REAL, OPTIONAL, INTENT(IN) :: r2, r3, r4, r5, r6, r7, r8, r9
+  REAL, ALLOCATABLE :: out(:), tmp(:)
+  INTEGER :: nc
+  nc  = SIZE(r0)
+  tmp = horzcat_r00(r0(nc), r1, r2, r3, r4, r5, r6, r7, r8, r9)
+  out = [r0(1:nc-1), tmp]
+END FUNCTION horzcat_r10
+!==============================================================================================================================
+FUNCTION horzcat_r11(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) RESULT(out)
+  IMPLICIT NONE
+  REAL,                   INTENT(IN) :: r0(:)
+  REAL, OPTIONAL, TARGET, INTENT(IN) :: r1(:), r2(:), r3(:), r4(:), r5(:), r6(:), r7(:), r8(:), r9(:)
   REAL, ALLOCATABLE :: out(:,:)
-!------------------------------------------------------------------------------------------------------------------------------
   REAL, POINTER     :: r(:)
-  LOGICAL :: lv(10)
-  INTEGER :: nrow, ncol, iv, n
-  lv = [   .TRUE.   , PRESENT(r1), PRESENT(r2), PRESENT(r3), PRESENT(r4) , &
-         PRESENT(r5), PRESENT(r6), PRESENT(r7), PRESENT(r8), PRESENT(r9) ]
-  nrow = SIZE(r0); ncol=COUNT(lv)
+  INTEGER           :: nrow, ncol, iv, n
+  LOGICAL           :: pre(9)
+!------------------------------------------------------------------------------------------------------------------------------
+  pre(:) = [PRESENT(r1),PRESENT(r2),PRESENT(r3),PRESENT(r4),PRESENT(r5),PRESENT(r6),PRESENT(r7),PRESENT(r8),PRESENT(r9)]
+  nrow = SIZE(r0)
+  ncol = 1+COUNT(pre)
   ALLOCATE(out(nrow, ncol))
-  DO iv=1, ncol
-    SELECT CASE(iv)
-      CASE(1); r=> r0; CASE(2); r=> r1; CASE(3); r=> r2; CASE(4); r=> r3; CASE(5); r=> r4
-      CASE(6); r=> r5; CASE(7); r=> r6; CASE(8); r=> r7; CASE(9); r=> r8; CASE(10);r=> r9
+  out(:,1) = r0
+  DO iv = 2, ncol; IF(.NOT.pre(iv-1)) CYCLE
+    SELECT CASE(iv-1)
+      CASE(1); r=> r1; CASE(2); r=> r2; CASE(3); r=> r3; CASE(4); r=> r4; CASE(5); r=> r5
+      CASE(6); r=> r5; CASE(7); r=> r7; CASE(8); r=> r8; CASE(9); r=> r9
     END SELECT
     n = SIZE(r, DIM=1)
-    IF(n/=nrow) THEN; CALL msg("Can't concatenate vectors of differing lengths"); STOP; END IF
+    IF(n /= nrow) THEN; CALL msg("Can't concatenate vectors of differing lengths"); STOP; END IF
     out(:,iv) = r(:)
   END DO
-END FUNCTION horzcat_rm
-!==============================================================================================================================
-FUNCTION horzcat_d1(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) RESULT(out)
-  DOUBLE PRECISION,           TARGET, INTENT(IN) :: d0
+END FUNCTION horzcat_r11
+!==============================================================================================================================
+FUNCTION horzcat_r21(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) RESULT(out)
+  IMPLICIT NONE
+  REAL,           INTENT(IN) :: r0(:,:), r1(:)
+  REAL, OPTIONAL, INTENT(IN) :: r2(:), r3(:), r4(:), r5(:), r6(:), r7(:), r8(:), r9(:)
+  REAL, ALLOCATABLE :: out(:,:), tmp(:,:)
+  INTEGER :: nc
+  nc  = SIZE(r0, 2)
+  tmp = horzcat_r11(r0(:,nc), r1, r2, r3, r4, r5, r6, r7, r8, r9)
+  out = RESHAPE([PACK(r0(:,1:nc-1), .TRUE.), PACK(tmp, .TRUE.)], SHAPE=[SIZE(r0, 1), nc + SIZE(tmp, 2)-1])
+END FUNCTION horzcat_r21
+!==============================================================================================================================
+FUNCTION horzcat_d00(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) RESULT(out)
+  IMPLICIT NONE
+  DOUBLE PRECISION,                   INTENT(IN) :: d0
   DOUBLE PRECISION, OPTIONAL, TARGET, INTENT(IN) :: d1, d2, d3, d4, d5, d6, d7, d8, d9
   DOUBLE PRECISION, ALLOCATABLE :: out(:)
-!------------------------------------------------------------------------------------------------------------------------------
   DOUBLE PRECISION, POINTER     :: d
-  LOGICAL :: lv(10)
-  INTEGER :: iv
-  lv = [   .TRUE.   , PRESENT(d1), PRESENT(d2), PRESENT(d3), PRESENT(d4) , &
-         PRESENT(d5), PRESENT(d6), PRESENT(d7), PRESENT(d8), PRESENT(d9) ]
-  ALLOCATE(out(COUNT(lv)))
-  DO iv=1, COUNT(lv)
-    SELECT CASE(iv)
-      CASE(1); d=> d0; CASE(2); d=> d1; CASE(3); d=> d2; CASE(4); d=> d3; CASE(5); d=> d4
-      CASE(6); d=> d5; CASE(7); d=> d6; CASE(8); d=> d7; CASE(9); d=> d8; CASE(10);d=> d9
+  INTEGER                       :: ncol, iv
+  LOGICAL                       :: pre(9)
+!------------------------------------------------------------------------------------------------------------------------------
+  pre(:) = [PRESENT(d1),PRESENT(d2),PRESENT(d3),PRESENT(d4),PRESENT(d5),PRESENT(d6),PRESENT(d7),PRESENT(d8),PRESENT(d9)]
+  ncol = 1+COUNT(pre)
+  ALLOCATE(out(ncol))
+  out(1) = d0
+  DO iv = 2, ncol; IF(.NOT.pre(iv-1)) CYCLE
+    SELECT CASE(iv-1)
+      CASE(1); d=> d1; CASE(2); d=> d2; CASE(3); d=> d3; CASE(4); d=> d4; CASE(5); d=> d5
+      CASE(6); d=> d6; CASE(7); d=> d7; CASE(8); d=> d8; CASE(9); d=> d9
     END SELECT
     out(iv) = d
   END DO
-END FUNCTION horzcat_d1
-!==============================================================================================================================
-FUNCTION horzcat_dm(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) RESULT(out)
-  DOUBLE PRECISION,           TARGET, DIMENSION(:), INTENT(IN) :: d0
-  DOUBLE PRECISION, OPTIONAL, TARGET, DIMENSION(:), INTENT(IN) :: d1, d2, d3, d4, d5, d6, d7, d8, d9
+END FUNCTION horzcat_d00
+!==============================================================================================================================
+FUNCTION horzcat_d10(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) RESULT(out)
+  IMPLICIT NONE
+  DOUBLE PRECISION,           INTENT(IN) :: d0(:), d1
+  DOUBLE PRECISION, OPTIONAL, INTENT(IN) :: d2, d3, d4, d5, d6, d7, d8, d9
+  DOUBLE PRECISION, ALLOCATABLE :: out(:), tmp(:)
+  INTEGER :: nc
+  nc = SIZE(d0)
+  tmp = horzcat_d00(d0(nc), d1, d2, d3, d4, d5, d6, d7, d8, d9)
+  out = [d0(1:nc-1), tmp]
+END FUNCTION horzcat_d10
+!==============================================================================================================================
+FUNCTION horzcat_d11(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) RESULT(out)
+  IMPLICIT NONE
+  DOUBLE PRECISION,                   INTENT(IN) :: d0(:)
+  DOUBLE PRECISION, OPTIONAL, TARGET, INTENT(IN) :: d1(:), d2(:), d3(:), d4(:), d5(:), d6(:), d7(:), d8(:), d9(:)
   DOUBLE PRECISION, ALLOCATABLE :: out(:,:)
-!------------------------------------------------------------------------------------------------------------------------------
   DOUBLE PRECISION, POINTER     :: d(:)
-  LOGICAL :: lv(10)
-  INTEGER :: nrow, ncol, iv, n
-  lv = [   .TRUE.   , PRESENT(d1), PRESENT(d2), PRESENT(d3), PRESENT(d4) , &
-         PRESENT(d5), PRESENT(d6), PRESENT(d7), PRESENT(d8), PRESENT(d9) ]
-  nrow = SIZE(d0); ncol=COUNT(lv)
+  INTEGER                       :: nrow, ncol, iv, n
+  LOGICAL                       :: pre(9)
+!------------------------------------------------------------------------------------------------------------------------------
+  nrow = SIZE(d0)
+  pre(:) = [PRESENT(d1),PRESENT(d2),PRESENT(d3),PRESENT(d4),PRESENT(d5),PRESENT(d6),PRESENT(d7),PRESENT(d8),PRESENT(d9)]
+  ncol = 1+COUNT(pre)
   ALLOCATE(out(nrow, ncol))
-  DO iv=1, ncol
-    SELECT CASE(iv)
-      CASE(1); d=> d0; CASE(2); d=> d1; CASE(3); d=> d2; CASE(4); d=> d3; CASE(5); d=> d4
-      CASE(6); d=> d5; CASE(7); d=> d6; CASE(8); d=> d7; CASE(9); d=> d8; CASE(10);d=> d9
+  DO iv = 2, ncol; IF(.NOT.pre(iv-1)) CYCLE
+    SELECT CASE(iv-1)
+      CASE(1); d=> d1; CASE(2); d=> d2; CASE(3); d=> d3; CASE(4); d=> d4; CASE(5); d=> d5
+      CASE(6); d=> d6; CASE(7); d=> d7; CASE(8); d=> d8; CASE(9); d=> d9
     END SELECT
     n = SIZE(d, DIM=1)
-    IF(n/=nrow) THEN; CALL msg("Can't concatenate vectors of differing lengths"); STOP; END IF
+    IF(n /= nrow) THEN; CALL msg("Can't concatenate vectors of differing lengths"); STOP; END IF
     out(:,iv) = d(:)
   END DO
-END FUNCTION horzcat_dm
+END FUNCTION horzcat_d11
+!==============================================================================================================================
+FUNCTION horzcat_d21(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) RESULT(out)
+  IMPLICIT NONE
+  DOUBLE PRECISION,           INTENT(IN) :: d0(:,:), d1(:)
+  DOUBLE PRECISION, OPTIONAL, INTENT(IN) :: d2(:), d3(:), d4(:), d5(:), d6(:), d7(:), d8(:), d9(:)
+  DOUBLE PRECISION, ALLOCATABLE :: out(:,:), tmp(:,:)
+  INTEGER :: nc
+  nc  = SIZE(d0, 2)
+  tmp = horzcat_d11(d0(:,nc), d1, d2, d3, d4, d5, d6, d7, d8, d9)
+  out = RESHAPE([PACK(d0(:,1:nc-1), .TRUE.), PACK(tmp, .TRUE.)], SHAPE=[SIZE(d0, 1), nc + SIZE(tmp, 2)-1])
+END FUNCTION horzcat_d21
 !==============================================================================================================================
 
@@ -896 +1069 @@
 !==============================================================================================================================
 LOGICAL FUNCTION dispTable(p, titles, s, i, r, rFmt, nRowMax, nColMax, nHead, unit, sub) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),           INTENT(IN)  :: p             !--- DISPLAY MAP: s/i/r
   CHARACTER(LEN=*),           INTENT(IN)  :: titles(:)     !--- TITLES (ONE EACH COLUMN)
@@ -1004 +1178 @@
 !==============================================================================================================================
 LOGICAL FUNCTION dispNamelist(unt, p, titles, s, i, r, rFmt, llast) RESULT(lerr)
+  IMPLICIT NONE
   INTEGER,                    INTENT(IN)  :: unt           !--- Output unit
   CHARACTER(LEN=*),           INTENT(IN)  :: p             !--- DISPLAY MAP: s/i/r
@@ -1086 +1261 @@
 !==============================================================================================================================
 LOGICAL FUNCTION dispOutliers_1(ll, a, n, err_msg, nam, subn, nRowmax, nColMax, nHead, unit) RESULT(lerr)
+  IMPLICIT NONE
 ! Display outliers list in tables
 ! If "nam" is supplied, it means the last index is for tracers => one table each tracer for rank > 2.
@@ -1115 +1291 @@
 
   rk = SIZE(n); nv = SIZE(vnm)
-  IF(test(fmsg('SIZE(nam) /= 1 and /= last "n" element', sub, nv /= 1 .AND. nv /= n(rk), unt),lerr)) RETURN
-  IF(test(fmsg('ll" and "a" sizes mismatch',             sub, SIZE(a) /= SIZE(ll),       unt),lerr)) RETURN
-  IF(test(fmsg('profile "n" does not match "a" and "ll', sub, SIZE(a) /= PRODUCT(n),     unt),lerr)) RETURN
+  lerr = nv/=1 .AND. nv/=n(rk); CALL msg('SIZE(nam) /= 1 and /= last "n" element', sub, lerr); IF(lerr) RETURN
+  lerr = SIZE(a) /=   SIZE(ll); CALL msg('ll" and "a" sizes mismatch',             sub, lerr); IF(lerr) RETURN
+  lerr = SIZE(a) /= PRODUCT(n); CALL msg('profile "n" does not match "a" and "ll', sub, lerr); IF(lerr) RETURN
   CALL msg(mes, sub, unit=unt)
 
@@ -1164 +1340 @@
 !==============================================================================================================================
 LOGICAL FUNCTION dispOutliers_2(ll, a, n, err_msg, nam, subn, nRowMax, nColMax, nHead, unit) RESULT(lerr)
+  IMPLICIT NONE
 ! Display outliers list in tables
 ! If "nam" is supplied and, it means the last index is for tracers => one table each tracer for rank > 2.
@@ -1221 +1398 @@
 !==============================================================================================================================
 LOGICAL FUNCTION reduceExpr_1(str, val) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),      INTENT(IN)  :: str
   CHARACTER(LEN=maxlen), INTENT(OUT) :: val
@@ -1254 +1432 @@
   DO WHILE(nl > 1)
     i = 1; DO WHILE(ip(i) /= 1 .OR. ip(i+1) /= 2); i = i + 1; END DO !IF(i > SIZE(ip)+1) EXIT;END DO
-    IF(test(reduceExpr_basic(vl(i+1), v), lerr)) RETURN
+    lerr = reduceExpr_basic(vl(i+1), v); IF(lerr) RETURN
     v = TRIM(vl(i))//TRIM(v); IF(i+2<=nl) v=TRIM(v)//TRIM(vl(i+2))
     vv = v//REPEAT(' ',768)
@@ -1270 +1448 @@
 !==============================================================================================================================
 LOGICAL FUNCTION reduceExpr_basic(str, val) RESULT(lerr)
+  IMPLICIT NONE
   CHARACTER(LEN=*),      INTENT(IN)  :: str
   CHARACTER(LEN=*),      INTENT(OUT) :: val
@@ -1284 +1463 @@
   op = ['^','/','*','+','-']                                                   !--- List of recognized operations
   s = str
-  IF(test(strParse_m(s, op, ky, lSc=.TRUE., id = id), lerr)) RETURN            !--- Parse the values
+  lerr = strParse_m(s, op, ky, lSc=.TRUE., id = id)                            !--- Parse the values
+  IF(lerr) RETURN                                                              !--- Problem with the parsing
   vl = str2dble(ky)                                                            !--- Conversion to doubles
   lerr = ANY(vl >= HUGE(1.d0))
-  IF(fmsg('Some values are non-numeric in: '//TRIM(s), ll=lerr)) RETURN        !--- Non-numerical values found
+  CALL msg('Some values are non-numeric in: '//TRIM(s), ll=lerr)
+  IF(lerr) RETURN                                                              !--- Non-numerical values found
   DO io = 1, SIZE(op)                                                          !--- Loop on known operators (order matters !)
     DO i = SIZE(id), 1, -1                                                     !--- Loop on found operators
@@ -1293 +1474 @@
       IF(id(i) /= io) CYCLE                                                    !--- Current found operator is not op(io)
       vm = vl(i); vp = vl(i+1)                                                 !--- Couple of values used for current operation
-      SELECT CASE(op(io))                                                          !--- Perform operation on the two values
+      SELECT CASE(op(io))                                                      !--- Perform operation on the two values
         CASE('^'); v = vm**vp
         CASE('/'); v = vm/vp
@@ -1311 +1492 @@
 !==============================================================================================================================
 FUNCTION reduceExpr_m(str, val) RESULT(lerr)
+  IMPLICIT NONE
   LOGICAL,               ALLOCATABLE              :: lerr(:)
   CHARACTER(LEN=*),                   INTENT(IN)  :: str(:)
@@ -1326 +1508 @@
 !==============================================================================================================================
 ELEMENTAL LOGICAL FUNCTION is_numeric(str) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN) :: str
   REAL    :: x
@@ -1357 +1540 @@
 !==============================================================================================================================
 ELEMENTAL INTEGER FUNCTION str2int(str) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN) :: str
   INTEGER :: ierr
@@ -1364 +1548 @@
 !==============================================================================================================================
 ELEMENTAL REAL FUNCTION str2real(str) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN) :: str
   INTEGER :: ierr
@@ -1371 +1556 @@
 !==============================================================================================================================
 ELEMENTAL DOUBLE PRECISION FUNCTION str2dble(str) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN) :: str
   INTEGER :: ierr
@@ -1378 +1564 @@
 !==============================================================================================================================
 ELEMENTAL CHARACTER(LEN=maxlen) FUNCTION bool2str(b) RESULT(out)
+  IMPLICIT NONE
   LOGICAL, INTENT(IN) :: b
   WRITE(out,*)b
@@ -1384 +1571 @@
 !==============================================================================================================================
 ELEMENTAL CHARACTER(LEN=maxlen) FUNCTION int2str(i, nDigits) RESULT(out)
+  IMPLICIT NONE
   INTEGER,           INTENT(IN) :: i
   INTEGER, OPTIONAL, INTENT(IN) :: nDigits
@@ -1394 +1582 @@
 !==============================================================================================================================
 ELEMENTAL CHARACTER(LEN=maxlen) FUNCTION real2str(r,fmt) RESULT(out)
+  IMPLICIT NONE
   REAL,                       INTENT(IN) :: r
   CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: fmt
@@ -1403 +1592 @@
 !==============================================================================================================================
 ELEMENTAL CHARACTER(LEN=maxlen) FUNCTION dble2str(d,fmt) RESULT(out)
+  IMPLICIT NONE
   DOUBLE PRECISION,           INTENT(IN) :: d
   CHARACTER(LEN=*), OPTIONAL, INTENT(IN) :: fmt
@@ -1412 +1602 @@
 !==============================================================================================================================
 ELEMENTAL SUBROUTINE cleanZeros(s)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(INOUT) :: s
   INTEGER :: ls, ix, i
@@ -1429 +1620 @@
 !==============================================================================================================================
 FUNCTION addQuotes_1(s) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN)  :: s
   CHARACTER(LEN=:), ALLOCATABLE :: out
@@ -1435 +1627 @@
 !==============================================================================================================================
 FUNCTION addQuotes_m(s) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN)  :: s(:)
   CHARACTER(LEN=:), ALLOCATABLE :: out(:)
@@ -1447 +1640 @@
 !==============================================================================================================================
 ELEMENTAL LOGICAL FUNCTION needQuotes(s) RESULT(out)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(IN) :: s
   CHARACTER(LEN=1) :: b, e
@@ -1461 +1655 @@
 !==============================================================================================================================
 LOGICAL FUNCTION checkList(str, lerr, message, items, reason, nmax) RESULT(out)
+  IMPLICIT NONE
 ! Purpose: Messages in case a list contains wrong elements (indicated by lerr boolean vector).
 ! Note:    Return value "out" is .TRUE. if there are errors (ie at least one element of "lerr" is TRUE).
@@ -1483 +1678 @@
 !==============================================================================================================================
 SUBROUTINE removeComment(str)
+  IMPLICIT NONE
   CHARACTER(LEN=*), INTENT(INOUT) :: str
   INTEGER :: ix