pycte 0.1.0__py3-none-any.whl

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/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/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