pycte 0.1.0__tar.gz

pycte-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: pycte
+Version: 0.1.0
+Summary: PYthon generiC inTerfacE
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pandas
+Requires-Dist: numpy
+Provides-Extra: extractdb
+Requires-Dist: charset-normalizer; extra == "extractdb"
+Provides-Extra: phreeqc
+Requires-Dist: phreeqpy; extra == "phreeqc"
+Requires-Dist: pycte[extractdb]; extra == "phreeqc"
+Provides-Extra: pflotran
+Requires-Dist: h5py; extra == "pflotran"
+Provides-Extra: comsol
+Requires-Dist: mph; extra == "comsol"
+Provides-Extra: gems
+Requires-Dist: pycte[extractdb]; extra == "gems"
+Provides-Extra: orchestra
+Requires-Dist: pycte[extractdb]; extra == "orchestra"
+Provides-Extra: all
+Requires-Dist: pycte[comsol,extractdb,pflotran,phreeqc]; extra == "all"
+
+PICCTS (Python Interface Coupling generiC Transport and Speciation) is distributed under the Apache 2.0 -style license that can be found in the LICENSE file. By using, distributing, or contributing to this project, you agree to the terms and conditions of this license.
+
+Three speciation solvers are currently coupled (PhreeqC, ORCHESTRA and xGEMS) with three transport solvers (COMSOL, PFLOTRAN, and a simple 1D transport code).
+
+Please run first the test cases (CationExchange based on ex.11 of PhreeqC from Appelo and al. 2013, calciteDolomite from Azad et al. 2016, AldicarbInfiltration from comsol batch) depending on your speciation and transport solvers.
+
+Do not hesitate to contact me ! (anatole.lafond [at] cea.fr)

pycte-0.1.0/README.md

@@ -0,0 +1,7 @@
+PICCTS (Python Interface Coupling generiC Transport and Speciation) is distributed under the Apache 2.0 -style license that can be found in the LICENSE file. By using, distributing, or contributing to this project, you agree to the terms and conditions of this license.
+
+Three speciation solvers are currently coupled (PhreeqC, ORCHESTRA and xGEMS) with three transport solvers (COMSOL, PFLOTRAN, and a simple 1D transport code).
+
+Please run first the test cases (CationExchange based on ex.11 of PhreeqC from Appelo and al. 2013, calciteDolomite from Azad et al. 2016, AldicarbInfiltration from comsol batch) depending on your speciation and transport solvers.
+
+Do not hesitate to contact me ! (anatole.lafond [at] cea.fr)

pycte-0.1.0/pycte/__init__.py

@@ -0,0 +1,143 @@
+"""
+pycte — Python Interface Coupling generiC Transport and Speciation.
+
+Public API
+----------
+One dedicated function per setting pycte actually reads (generated
+from every `getattr(config, 'name', default)` call in engine.py — see
+_RECOGNIZED_SETTINGS below). Call the ones you need, in any order,
+before pycte.run():
+
+    import pycte
+
+    pycte.chemModule("phreeqc")
+    pycte.trsptModule("nativeTransport")
+    pycte.maxTime(72000)
+    pycte.timeStep(720)
+    pycte.dispersivity(0.002)
+    pycte.velocity(0.002 / 720)
+
+    if __name__ == "__main__":
+        pycte.run()
+
+Only these functions exist on the `pycte` module — nothing else. A
+typo (pycte.dispersivty(...)) fails immediately with AttributeError,
+instead of silently being ignored. A setting you never call keeps its
+documented default (same default as when it was an absent attribute on
+an old-style input script).
+
+run()                : run using whatever was declared via the setting
+                       functions above. If none were called at all,
+                       falls back to reading the calling script's own
+                       globals (the older `import pycte; ...;
+                       pycte.run()` style, kept for scripts that
+                       define chemModule/maxTime/... directly).
+
+run(config)           : advanced/escape hatch — pass an explicit config
+                       object or dict directly, bypassing the setting
+                       functions entirely.
+
+reset()               : clear every setting declared so far, without
+                       running (rarely needed — run() already clears
+                       after each call).
+
+run_from_file(path)   : legacy helper. Loads a standalone .py config
+                       script (old copy/paste style) and runs it.
+"""
+
+import sys
+import types
+
+from . import engine
+
+# Every keyword pycte.engine.main() actually reads, i.e. every name
+# that appears as getattr(config, 'name', default) in engine.py.
+# Keep this in sync with engine.py if settings are added/removed there.
+_RECOGNIZED_SETTINGS = (
+    "maxTime", "timeStep", "stepReprise", "dtpycte", "speciesChargeGeometry",
+    "fixpH", "intermediateOutput", "operatorSplitting", "chemModule", "trsptModule",
+    "system", "PIDnbr", "PIDextract", "systemSpeciation", "timeUnit", "geometry",
+    "firstStepEquilibrium", "nonTrivialDecomposition", "preliminarEquilibrium",
+    "PIDchem", "PIDtrspt", "MultiCompoundTransport", "initialConditions",
+    "crossDependencies", "description",
+    "chemPath", "trsptPath", "phases",
+    
+    "current", "SI", "mineralReversibility",
+    "cutoffAq", "cutoffPha", "cutoffEch", "cutoffSurf",
+    "masterSpecies", "solutionSpecies", "masterExchange", "exchangeSpecies",
+    "masterSurface", "surfaceSpecies", "kineticRates", "kinetics",
+    "userVarBool", "userVarList", "solMod", "step_divide", "speciesCharge",
+    "speciationCharge", "pHdefault", "tempDefault", "distAnodCathTotale",
+    "catholyte", "anolyte", "solModCharge", "acidicTrspt", "water",
+    "supplementarySolution", "surfaceCounterIons",
+    
+    "attributes", "firstIC", "primarySpeciesAq", "primarySpeciesPha",
+    "primarySpeciesSurf", "speciationEch", "primarySpeciesPhantom", "nrThreads",
+    "waterMass", "primarySpeciesEchSorbed", "couplingFormalism",
+    "transportedSpecies", "inputVariableOrchestra", "outputVariableOrchestra",
+    
+    "comsolComp", "comsolIntFonction", "comsolStudy", "comsolVTU",
+    "comsolCore", "outputComsol",
+
+    "velocity", "advection", "FickDiffusion", "porousTransport", "ADE",
+    "dispersivity", "firstBoundary", "secondBoundary", "boundaryConditions",
+    "porosity", "area", "diffCoeff", "meshing",
+
+)
+
+_settings = {}
+
+
+def _make_setter(_name):
+    def _setter(value):
+        _settings[_name] = value
+    _setter.__name__ = _name
+    _setter.__qualname__ = f"pycte.{_name}"
+    _setter.__doc__ = f"Set pycte' '{_name}' setting to `value` for the next pycte.run()."
+    return _setter
+
+
+for _name in _RECOGNIZED_SETTINGS:
+    globals()[_name] = _make_setter(_name)
+del _name, _make_setter
+
+
+def reset():
+    _settings.clear()
+
+
+def run(config=None):
+    """
+    - pycte.run() : pycte.<name>(value)
+or
+    - pycte.run(config) 
+    """
+    if config is not None:
+        if isinstance(config, dict):
+            config = types.SimpleNamespace(**config)
+        return engine.main(config)
+
+    if _settings:
+        cfg = types.SimpleNamespace(**_settings)
+        try:
+            return engine.main(cfg)
+        finally:
+            _settings.clear()
+
+    return engine.main(sys.modules['__main__'])
+
+
+def run_from_file(path):
+    """
+    Load a config from a standalone .py file (old style: a script that
+    just defines chemModule/trsptModule/maxTime/... as globals) and run
+    it. Useful while migrating existing scripts to `import pycte`.
+    """
+    import importlib.util
+    import os
+
+    module_name = os.path.splitext(os.path.basename(path))[0]
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    loaded = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(loaded)
+    return run(loaded)

pycte-0.1.0/pycte/comsol.py

@@ -0,0 +1,305 @@
+import time
+import pandas as pd
+import sys
+import importlib.util
+import os
+import numpy as np
+
+def writeTime(tps, arr=2):
+    if tps >= 3600 * 24:
+        return f"{tps / (3600 * 24):.{arr}f} d"
+    elif tps >= 3600:
+        return f"{tps / 3600:.{arr}f} h"
+    elif tps >= 60:
+        return f"{tps / 60:.{arr}f} min"
+    elif tps < 1:
+        return f"{tps*1000 :.{arr}f} msec"
+    else:
+        return f"{tps:.{arr}f} sec"
+
+def Convert_Species_PhreeqC_to_COMSOL(entry_list):
+    exit_list = []
+    for name in entry_list:
+        if name.startswith("("):
+            name = name.replace("(","")
+
+        name = name.replace("(", "_").replace(")", "_").replace(",", "_").replace(":", "_").replace('.','_')
+        name = name.replace("-7", "minus7")
+        name = name.replace("-6", "minus6")
+        name = name.replace("-5", "minus5")
+        name = name.replace("-4", "minus4")
+        name = name.replace("-3", "minus3")
+        name = name.replace("-2", "minus2")
+        name = name.replace("-", "minus")
+
+        name = name.replace("+7", "plus7")
+        name = name.replace("+6", "plus6")
+        name = name.replace("+5", "plus5")
+        name = name.replace("+4", "plus4")
+        name = name.replace("+3", "plus3")
+        name = name.replace("+2", "plus2")
+        name = name.replace("+", "plus")
+        exit_list.append(name)
+    return exit_list
+
+
+def initComsol(comsolDict):
+    """
+    Démarre le client COMSOL et charge le modèle UNE SEULE FOIS.
+
+    Le client / modèle / javamodel sont stockés dans comsolDict
+    ('comsolClient', 'comsolModel', 'comsolJavaModel') afin que
+    transportComsol() les réutilise à chaque pas de temps sans jamais
+    relancer COMSOL ni recharger le modèle. Cette fonction contient donc
+    toute la logique d'attente de licence, qui ne s'exécute plus qu'une
+    seule fois pour l'ensemble de la simulation.
+    """
+    import mph
+
+    scriptWarning = ""
+    warning = 0
+    waitingLicence = 0
+    init = 0
+
+    inputPath = os.path.join(comsolDict['inputPath'], 'inputTransport.txt')
+
+    licenceTaken = False
+    licence = False
+    startWaiting = 0
+    while not licence:
+        ref = time.perf_counter()
+        try:    
+            client = mph.start()
+            if comsolDict['comsolCore']: client = mph.Client(cores=comsolDict['comsolCore'])
+            model = client.load(f"{comsolDict['trsptPath']}")
+            javamodel = model.java
+            javamodel.component(f"{comsolDict['comsolTags'][0]}").func(f"{comsolDict['comsolTags'][1]}").set("filename", f"{inputPath}")
+            init += time.perf_counter() - ref
+            licence = True
+            if licenceTaken:
+                waitingLicence = time.perf_counter() - startWaiting 
+                print("Licence released :)", end=" ", flush=True)
+
+        except Exception as r:
+            if not licenceTaken:
+                startWaiting = time.time()
+                print(r)
+                print("Waiting for a licence ? ...", flush=True)
+                licenceTaken = True
+                scriptWarning += f"COMSOL waiting licence : {writeTime(waitingLicence)}\n"
+            if licenceTaken: time.sleep(3)
+
+    if licenceTaken:
+        warning += 1
+        print(f"({writeTime(waitingLicence)} of waiting)", flush=True)
+        scriptWarning += f"COMSOL init : {writeTime(waitingLicence)} of waiting \n"
+
+    comsolDict['comsolClient'] = client
+    comsolDict['comsolModel'] = model
+    comsolDict['comsolJavaModel'] = javamodel
+
+    return comsolDict, warning, scriptWarning, waitingLicence, init
+
+
+def closeComsol(comsolDict):
+    """
+    A appeler UNE SEULE FOIS, à la toute fin de la simulation (après le
+    dernier pas de temps), pour libérer le modèle et rendre la licence
+    COMSOL. Ne pas appeler entre deux pas de temps : ça obligerait à tout
+    recharger au pas suivant.
+    """
+    client = comsolDict.get('comsolClient')
+    if client is not None:
+        try:
+            client.clear()
+        except Exception as r:
+            print(f"Warning while closing COMSOL client: {r}")
+
+    comsolDict.pop('comsolClient', None)
+    comsolDict.pop('comsolModel', None)
+    comsolDict.pop('comsolJavaModel', None)
+
+    return comsolDict
+
+
+def transportComsol(comsolDict):
+
+    scriptWarning = ""
+    warning = 0
+    abort = False
+    calcTime = 0
+    init = 0
+    waitingLicence = 0
+
+    inputPath = os.path.join(comsolDict['inputPath'], 'inputTransport.txt')
+
+    comsolDict['commMtrx'].to_csv(inputPath, index=False, header=False, sep='\t')
+
+
+    if comsolDict.get('comsolClient') is None:
+        comsolDict, initWarning, initScriptWarning, waitingLicence, initTime = initComsol(comsolDict)
+        warning += initWarning
+        scriptWarning += initScriptWarning
+        init += initTime
+
+    client = comsolDict['comsolClient']
+    model = comsolDict['comsolModel']
+    javamodel = comsolDict['comsolJavaModel']
+
+    try:
+        ref = time.perf_counter()
+        javamodel.component(f"{comsolDict['comsolTags'][0]}").func(f"{comsolDict['comsolTags'][1]}").set("filename", f"{inputPath}")
+        javamodel.component(f"{comsolDict['comsolTags'][0]}").func(f"{comsolDict['comsolTags'][1]}").refresh()
+        init += time.perf_counter() - ref
+
+        if comsolDict['timeUnit'] == 'y': timeUnit = 'a'
+        else: timeUnit = comsolDict['timeUnit']
+
+        ref = time.perf_counter()
+        javamodel.study(f"{comsolDict['comsolTags'][2]}").feature("time").set("tunit", f"{timeUnit}")
+        javamodel.study(f"{comsolDict['comsolTags'][2]}").feature("time").set("tlist", f"range(0,{comsolDict['dtStep']},{comsolDict['dtStep']})")
+        init += time.perf_counter() - ref
+    except Exception as r:
+        print(r)
+        warning += 1
+        scriptWarning += f"COMSOL, time = {comsolDict['tStep']}{comsolDict['timeUnit']}, time-step n° {comsolDict['lStep']+1} : Fatal error occured : \n{r}\n"
+        abort = True
+
+    if not abort:
+        try:
+            ref = time.perf_counter()
+            model.solve()
+            calcTime += time.perf_counter() - ref
+        except Exception as r:
+            print(r)
+            with open("warning.log", "a") as warningLog: warningLog.write(f"COMSOL, t={comsolDict['tStep']}{comsolDict['timeUnit']}, time-step n° {comsolDict['lStep']} : {r}\n")
+            abort = True
+
+    if not abort:
+
+        #### appears to not work all the times ...
+        # spc = [s if s in comsolDict['transportedSpecies'] else s+'i' for s in comsolDict['systemSpeciation']]
+        # coord_values = model.evaluate(['x', 'y', 'z'][:comsolDict['geometry']],inner='last')
+        # coord = pd.DataFrame(
+        #     {name: values for name, values in zip(['x', 'y', 'z'], coord_values)})
+
+        # values = model.evaluate(Convert_Species_PhreeqC_to_COMSOL(spc), inner="last")
+        # commMtrx_Comsol = pd.DataFrame(
+        #     np.array(values).T/1000, # if you want to correct with the density, here it is
+        #     columns=comsolDict['systemSpeciation']
+        # )
+        # commMtrx_Comsol = pd.concat([coord,commMtrx_Comsol], axis=1)
+
+
+        outputPath = os.path.join(comsolDict['inputPath'], 'outputTransport.txt')
+        ref = time.perf_counter()
+        javamodel.result().export("data1").setIndex("looplevelinput", "last", 0);
+        javamodel.result().export("data1").set("exporttype", "text");
+        javamodel.result().export("data1").set("filename", f"{outputPath}");
+        javamodel.result().export("data1").run();
+        init += time.perf_counter() - ref
+
+
+        if comsolDict['outputComsol']:
+            for i,tag in enumerate(comsolDict['outputComsol']): # user defined variables ..
+                ref = time.perf_counter()
+                path = os.path.join(comsolDict['paths'][f'Transport{tag}'], f'COMSOL_{comsolDict["lStep"]+1}.txt')
+                javamodel.result().export(f"{tag}").setIndex("looplevelinput", "last", 0);
+                javamodel.result().export(f"{tag}").set("exporttype", "text");
+                javamodel.result().export(f"{tag}").set("filename", f"{path}");
+                javamodel.result().export(f"{tag}").run();
+                init += time.perf_counter() - ref
+                if comsolDict['lStep'] == 0:
+                    path = os.path.join(comsolDict['paths'][f'Transport{tag}'],'COMSOL_0.txt')
+                    ref = time.perf_counter()
+                    javamodel.result().export(f"{tag}").setIndex("looplevelinput", "first", 0);
+                    javamodel.result().export(f"{tag}").set("exporttype", "text");
+                    javamodel.result().export(f"{tag}").set("filename", f"{path}");
+                    javamodel.result().export(f"{tag}").run();
+                    init += time.perf_counter() - ref
+                if comsolDict['comsolVTU']:
+                    path = os.path.join(comsolDict['paths'][f'TransportVTU{tag}'],f'COMSOL_{comsolDict["lStep"]+1}.vtu')
+                    ref = time.perf_counter()
+                    javamodel.result().export(f"{tag}").setIndex("looplevelinput", "last", 0);
+                    javamodel.result().export(f"{tag}").set("exporttype", "vtu");
+                    javamodel.result().export(f"{tag}").set("filename", f"{path}");
+                    javamodel.result().export(f"{tag}").run();
+                    init += time.perf_counter() - ref
+                    if comsolDict['lStep'] == 0:
+                        path = os.path.join(comsolDict['paths'][f'TransportVTU{tag}'],'COMSOL_0.vtu')
+                        ref = time.perf_counter()
+                        javamodel.result().export(f"{tag}").setIndex("looplevelinput", "first", 0);
+                        javamodel.result().export(f"{tag}").set("exporttype", "vtu");
+                        javamodel.result().export(f"{tag}").set("filename", f"{path}");
+                        javamodel.result().export(f"{tag}").run();
+                        init += time.perf_counter() - ref
+
+
+
+        # col =  comsolDict["coord"] + comsolDict['systemSpeciation'] + (comsolDict['crossDependencies']['speciation']['total'] if comsolDict['crossDependencies'] and comsolDict['crossDependencies'].get('speciation') else [])
+        commMtrx_Comsol = pd.read_csv(outputPath,sep=r"\s+",comment="%",header=None, names=list(comsolDict['commMtrx'].columns))
+        # results = [commMtrx_Comsol, warning, scriptWarning,waitingLicence, abort,calcTime]
+
+
+
+
+        return commMtrx_Comsol, warning, scriptWarning,waitingLicence, abort,calcTime, init
+
+    else:
+        return pd.DataFrame(), warning, scriptWarning, waitingLicence, abort, 0, init
+
+def trspt(centralDict):
+    print("COMSOL", end=" ", flush=True)
+    startComsol = time.time()
+
+    comm, warning, scriptWarning,waitingLicence, abort, calcTime, init = transportComsol(centralDict)
+
+    if warning:
+        with open("warning.log", "a") as warningLog:
+            warningLog.write(f"COMSOL, time = {centralDict['tStep']}{centralDict['timeUnit']}, time step n°{centralDict['lStep']+1} : the {warning} following warnings occured ...\n {scriptWarning}")
+    if abort:
+        with open("warning.log", "a") as warningLog:
+            warningLog.write(f"COMSOL, time = {centralDict['tStep']}{centralDict['timeUnit']}, time step n°{centralDict['lStep']+1} : Fatal COMSOL error. Aborting run.")
+        print('Fatal COMSOL error. Aborting run.')
+        sys.exit()
+
+    try:
+        assert len(comm) == len(centralDict['commMtrx'])
+    except:
+        print('Mtrx post transport length different from input: post trspt: ', len(comm), ' input: ', len(centralDict['commMtrx']))
+        print('2nd try')
+        comm, warning, scriptWarning,waitingLicence, abort, calcTime, init = transportComsol(centralDict)
+
+        if warning:
+            with open("warning.log", "a") as warningLog:
+                warningLog.write(f"COMSOL, time = {centralDict['tStep']}{centralDict['timeUnit']}, time step n°{centralDict['lStep']+1} : the {warning} following warnings occured ...\n {scriptWarning}")
+        if abort:
+            with open("warning.log", "a") as warningLog:
+                warningLog.write(f"COMSOL, time = {centralDict['tStep']}{centralDict['timeUnit']}, time step n°{centralDict['lStep']+1} : Fatal COMSOL error. Aborting run.")
+            print('Fatal COMSOL error. Aborting run.')
+            sys.exit()
+
+        try:
+            assert len(comm) == len(centralDict['commMtrx'])
+        except:
+
+            print('Mtrx post transport length different from input: post trspt: ', len(comm), ' input: ', len(centralDict['commMtrx']))
+            print('aborting')
+            sys.exit()
+
+
+
+    centralDict.update({
+            "commMtrx": comm,
+            "waitingTime" : centralDict['waitingTime'] + waitingLicence,
+            "COMSOLCalcTime_WallClock": centralDict["COMSOLCalcTime_WallClock"] + calcTime,
+            "COMSOLCalcTime_ProcessorTime": centralDict["COMSOLCalcTime_ProcessorTime"] + calcTime, # not correct but i dont have access to that info (to my knowledge)
+            "COMSOLInterfTime_WallClock": centralDict['COMSOLInterfTime_WallClock'] + time.time() - startComsol - calcTime - init,
+            "COMSOLInitTime" : centralDict["COMSOLInitTime"] + init,
+            "COMSOLTotalTime" : centralDict["COMSOLTotalTime"] + time.time() - startComsol,
+            })
+
+
+    print(f"({writeTime((time.time()-startComsol))})")
+
+    return centralDict

pycte-0.1.0/pycte/crossDepenciesManager.py

@@ -0,0 +1,115 @@
+from itertools import product
+import sys
+
+def crossDep(centralDict, crossDependencies):
+    'link cross dependencies (CD) with respect to coupled modules'
+    'we need to differentiate input CD and output CD'
+
+    def fillCrossDepDic(coupledParam, inputOrOuput, crossDepDict, CD):
+        for cpld in coupledParam:
+            if isinstance(cpld, dict):
+                for key in cpld.keys():
+                    for cells in CD[inputOrOuput]:
+                        if key in cells:
+                            val = cpld[key]
+                            if isinstance(val, str):
+                                crossDepDict[inputOrOuput] += [f"{cells[0]}('{val}')"]
+                            elif any(isinstance(v, list) for v in val):
+                                val_normalized = [v if isinstance(v, list) else [v] for v in val]
+                                crossDepDict[inputOrOuput] += [
+                                    f'{cells[0]}(' + ','.join(f"'{item}'" for item in combo) + ')'
+                                    for combo in product(*val_normalized) ]
+                            else:
+                                crossDepDict[inputOrOuput] += [f"{cells[0]}('{v}')" for v in val]
+                            break
+            else:
+                for cells in CD[inputOrOuput]:
+                    if cpld in cells:
+                        crossDepDict[inputOrOuput] += [cells[0]]
+                        break
+        return crossDepDict
+
+
+    transportCD = {}
+    speciationCD = {}
+    
+    if centralDict["couplingInfo"][1] == 'PhreeqC':
+        'first cell of each CD is the phreeqpy command'
+        'second cell is the name of the CD variable'
+        'CD shall carry the same name across solvers ...'
+        
+        speciationCD = {
+            'input':  [
+            ['tk','temperature(K)','t','temp','tempK','tK','temperatureK','temperature'],
+            ['tc','temperature(C)','tC','tempC','temperatureC'],
+            ['DebyeLength', 'DebyeLength(m)', 'debyeLength'],
+            ['-la("H+")','ph','pH'],
+            ['-la("e-")','pe','Eh','eh']
+            ],
+            
+            "output" : [
+            ['tk','temperature(K)','t','temp','tempK','tK','temperatureK','temperature'],
+            ['tc','temperature(C)','tC','tempC','temperatureC'],
+            ['viscos','viscosity(mPa·s)','v','visc'],
+            ['mu','ionicStrength(mol/kgw)','IS','is'],
+            ['EDL','EDL_','edl'],
+            ['TOT','TotAq_','tot_aq'],
+            ['-la("H+")','ph','pH'],
+            ['-la("e-")','pe','Eh','eh']
+                ]},
+            
+    elif centralDict["couplingInfo"][1] == 'xGEMS':
+        speciationCD = {
+            'input':  [
+            ['temperature(K)','tk','t','temp','tempK','tK','temperatureK','temperature'],
+            ['temperature(C)','tc','tC','tempC','temperatureC'],
+            ['pressure','p','P'],
+            ],
+            
+            "output" : [
+            ['temperature(K)','tk','t','temp','tempK','tK','temperatureK','temperature'],
+            ['temperature(C)','tc','tC','tempC','temperatureC'],
+            ['pressure','p','P'],
+                ]}
+
+    if centralDict["couplingInfo"][2] == 'COMSOL':
+        transportCD = {'input' : [['dV']], 
+                    'output' : [['dV']]}
+    
+    elif centralDict["couplingInfo"][2] == 'PFLOTRAN':
+        transportCD = {
+                    'input':  [
+                    ['temperature(K)','tk','t','temp','tempK','tK','temperatureK','temperature'],
+                    ['temperature(C)','tc','tC','tempC','temperatureC'],
+                    ['pressure','p','P'],
+                    ['porosity'],
+                    ],
+                    
+                    "output" : [
+                    ['temperature(K)','tk','t','temp','tempK','tK','temperatureK','temperature'],
+                    ['temperature(C)','tc','tC','tempC','temperatureC'],
+                    ['pressure','p','P'],
+                    ['porosity'],
+                        ]}
+
+    crossDepSpc = {'input' : [], 'output' : []}
+    crossDepTrspt = {'input' : [], 'output' : []}
+
+    crossDepSpc = fillCrossDepDic(crossDependencies.get('speciation', []), 'input',  crossDepSpc, speciationCD)
+    crossDepSpc = fillCrossDepDic(crossDependencies.get('speciation', []), 'output', crossDepSpc, speciationCD)
+    
+    crossDepTrspt = fillCrossDepDic(crossDependencies.get('transport', []), 'input', crossDepTrspt, transportCD)
+    crossDepTrspt = fillCrossDepDic(crossDependencies.get('transport', []), 'output', crossDepTrspt, transportCD)
+
+    test = {'speciation' : {
+                            'input' : list(dict.fromkeys(crossDepSpc['input'])), 
+                            'output': list(dict.fromkeys(crossDepSpc['output'])),
+                            'total' : list(dict.fromkeys(crossDepSpc['input'] + crossDepSpc['output']))},
+            'transport': {
+                            'input': list(dict.fromkeys(crossDepTrspt['input'])),
+                            'output': list(dict.fromkeys(crossDepTrspt['output'])),
+                            'total': list(dict.fromkeys(crossDepTrspt['output']+crossDepTrspt['input'])) },
+            'totalCrossDep' : list(dict.fromkeys(crossDepTrspt['output']+crossDepTrspt['input']+crossDepSpc['input'] + crossDepSpc['output']))
+            }
+
+    return test