simple test for o format working

pyerrors/input/sfcf.py

@@ -247,15 +247,12 @@ def read_sfcf_multi(path, prefix, name_list, quarks_list=['.*'], corr_type_list=
             idl.append(rep_idl)
             # here we have found all the files we need to look into.
             if i == 0:
-                if version == "0.0":
+                if version != "0.0" and compact:
-                    file = path + '/' + item + '/' + sub_ls[0] + '/' + name
-                else:
-                    if compact:
                     file = path + '/' + item + '/' + sub_ls[0]
-                    else:
-                        file = path + '/' + item + '/' + sub_ls[0] + '/' + name
 
                 for name in name_list:
+                    if version == "0.0" or not compact:
+                        file = path + '/' + item + '/' + sub_ls[0] + '/' + name
                     for quarks in quarks_list:
                         for off in noffset_list:
                             for w in wf_list:
@@ -271,7 +268,7 @@ def read_sfcf_multi(path, prefix, name_list, quarks_list=['.*'], corr_type_list=
                                     # preparing the datastructure
                                     # the correlators get parsed into...
                                     deltas = []
-                                    for j in range(T):
+                                    for j in range(intern[name]["T"]):
                                         deltas.append([])
                                     internal_ret_dict[name][quarks][str(off)][str(w)][str(w2)] = deltas
 
@@ -285,45 +282,53 @@ def read_sfcf_multi(path, prefix, name_list, quarks_list=['.*'], corr_type_list=
                                     for t in range(intern[name]["T"]):
                                         internal_ret_dict[name][quarks][str(off)][str(w)][str(w2)][t].append(rep_deltas[name][quarks][str(off)][str(w)][str(w2)][t])
             else:
-                for t in range(T):
+                for name in name_list:
-                    deltas[t].append(np.zeros(no_cfg))
+                    rep_data = []
                     for cnfg, subitem in enumerate(sub_ls):
-                    with open(path + '/' + item + '/' + subitem + '/' + name) as fp:
+                        for quarks in quarks_list:
-                        for k, line in enumerate(fp):
+                            for off in noffset_list:
-                            if (k >= start_read and k < start_read + T):
+                                for w in wf_list:
-                                floats = list(map(float, line.split()))
+                                    for w2 in wf2_list:
-                                if version == "0.0":
+                                        cfg_path = path + '/' + item + '/' + subitem
-                                    deltas[k - start_read][i][cnfg] = floats[im - single]
+                                        file_data = _read_o_file(cfg_path, name, intern, version, im)
-                                else:
+                                        rep_data.append(file_data)
-                                    deltas[k - start_read][i][cnfg] = floats[1 + im - single]
 
+                    for quarks in quarks_list:
+                        for off in noffset_list:
+                            for w in wf_list:
+                                for w2 in wf2_list:
+                                    for t in range(intern[name]["T"]):
+                                        internal_ret_dict[name][quarks][str(off)][str(w)][str(w2)][t].append([])
+                                        for cfg in range(no_cfg):
+                                            internal_ret_dict[name][quarks][str(off)][str(w)][str(w2)][t][i].append(rep_data[cfg][quarks][str(off)][str(w)][str(w2)][t])
     else:
+        for name in name_list:
             if "files" in kwargs:
                 ls = kwargs.get("files")
             else:
-            for exc in ls:
+                name_ls = ls
+                for exc in name_ls:
                     if not fnmatch.fnmatch(exc, prefix + '*.' + name):
-                    ls = list(set(ls) - set([exc]))
+                        name_ls = list(set(name_ls) - set([exc]))
-            ls = sort_names(ls)
+            name_ls = sort_names(name_ls)
-        for name in name_list:
             for quarks in quarks_list:
                 for off in noffset_list:
                     for w in wf_list:
                         for w2 in wf2_list:
                             pattern = _make_pattern(version, name, off, w, w2, intern[name]['b2b'], quarks)
                             deltas = []
-                            for rep, file in enumerate(ls):
+                            for rep, file in enumerate(name_ls):
                                 rep_idl = []
                                 filename = path + '/' + file
-                                T, rep_idl, rep_data = _read_append_rep(filename, pattern, intern[name]['b2b'], cfg_separator, im, single)
+                                T, rep_idl, rep_data = _read_append_rep(filename, pattern, intern[name]['b2b'], cfg_separator, im, intern[name]['single'])
-                                if 'T' not in intern[name]:
-                                    intern[name]['T'] = T
                                 if rep == 0:
-                                    for t in range(T):
+                                    intern[name]['T'] = T
+                                    for t in range(intern[name]['T']):
                                         deltas.append([])
-                                for t in range(T):
+                                for t in range(intern[name]['T']):
                                     deltas[t].append(rep_data[t])
                                 internal_ret_dict[name][quarks][str(off)][str(w)][str(w2)] = deltas
+                                if name == name_list[0]:
                                     idl.append(rep_idl)
 
     if kwargs.get("check_configs") is True:
@@ -358,6 +363,31 @@ def read_sfcf_multi(path, prefix, name_list, quarks_list=['.*'], corr_type_list=
     return result_dict
 
 
+def _read_o_file(cfg_path, name, intern, version, im):
+    file = cfg_path + '/' + name
+    return_vals = {}
+    with open(file) as fp:
+        lines = fp.readlines()
+        for quarks in intern[name]["spec"].keys():
+            return_vals[quarks] = {}
+            for off in intern[name]["spec"][quarks].keys():
+                return_vals[quarks][off] = {}
+                for w in intern[name]["spec"][quarks][off].keys():
+                    return_vals[quarks][off][w] = {}
+                    for w2 in intern[name]["spec"][quarks][off][w].keys():
+                        T = intern[name]["T"]
+                        start_read = intern[name]["spec"][quarks][off][w][w2]["start"]
+                        deltas = []
+                        for line in lines[start_read:start_read + T]:
+                            floats = list(map(float, line.split()))
+                            if version == "0.0":
+                                deltas.append(floats[im - intern[name]["single"]])
+                            else:
+                                deltas.append(floats[1 + im - intern[name]["single"]])
+                        return_vals[quarks][off][w][w2] = deltas
+    return return_vals
+
+
 def _extract_corr_type(corr_type):
     if corr_type == 'bb':
         b2b = True

pyerrors/input/utils.py

@@ -82,7 +82,7 @@ def check_idl(idl, che):
     return miss_str
 
 
-def check_params(path, param_hash, prefix, param_prefix = "parameters_"):
+def check_params(path, param_hash, prefix, param_prefix="parameters_"):
     """
     Check if, for sfcf, the parameter hashes at the end of the parameter files are in fact the expected one.
 

tests/sfcf_in_test.py

@@ -61,6 +61,45 @@ def test_o_bib(tmp_path):
     assert f_V0[2] == 683.6776090081005
 
 
+def test_simple_multi_o(tmp_path):
+    build_test_environment(str(tmp_path), "o", 5, 3)
+    f_V0 = sfin.read_sfcf_multi(str(tmp_path) + "/data_o", "test", ["F_V0"], quarks=["lquark lquark"], wf1_list=[0], wf2_list=[0], version="2.0", corr_type_list=["bib"], nice_output=True)
+    print(f_V0)
+    assert len(f_V0) == 3
+    assert list(f_V0[0].shape.keys()) == ["test_|r0", "test_|r1", "test_|r2"]
+    assert f_V0[0] == 683.6776090085115
+    assert f_V0[1] == 661.3188585582334
+    assert f_V0[2] == 683.6776090081005
+
+
+def test_dict_multi_o(tmp_path):
+    build_test_environment(str(tmp_path), "o", 5, 3)
+    corrs = sfin.read_sfcf_multi(str(tmp_path) + "/data_o", "test",
+                                 ["F_V0", "f_A", "f_1"], quarks_list=["lquark lquark"],
+                                 wf_list=[0], wf2_list=[0], version="2.0",
+                                 corr_type_list=["bib", "bi", "bb"], nice_output=False)
+    print(corrs)
+    f_1 = corrs["f_1"]['lquark lquark']['0']['0']['0']
+    f_A = corrs["f_A"]['lquark lquark']['0']['0']['0']
+    f_V0 = corrs["F_V0"]['lquark lquark']['0']['0']['0']
+
+    assert len(f_1) == 1
+    assert list(f_1[0].shape.keys()) == ["test_|r0", "test_|r1", "test_|r2"]
+    assert f_1[0].value == 351.1941525454502
+
+    assert len(f_A) == 3
+    assert list(f_A[0].shape.keys()) == ["test_|r0", "test_|r1", "test_|r2"]
+    assert f_A[0].value == 65.4711887279723
+    assert f_A[1].value == 1.0447210336915187
+    assert f_A[2].value == -41.025094911185185
+
+    assert len(f_V0) == 3
+    assert list(f_V0[0].shape.keys()) == ["test_|r0", "test_|r1", "test_|r2"]
+    assert f_V0[0] == 683.6776090085115
+    assert f_V0[1] == 661.3188585582334
+    assert f_V0[2] == 683.6776090081005
+
+
 def test_c_bb(tmp_path):
     build_test_environment(str(tmp_path), "c", 5, 3)
     f_1 = sfin.read_sfcf(str(tmp_path) + "/data_c", "data_c", "f_1", quarks="lquark lquark", wf=0, wf2=0, version="2.0c", corr_type="bb")
@@ -131,6 +170,72 @@ def test_dict_multi_c(tmp_path):
     assert f_V0[2] == 683.6776090081005
 
 
+def test_dict_multi_wf_c(tmp_path):
+    build_test_environment(str(tmp_path), "c", 5, 3)
+    corrs = sfin.read_sfcf_multi(str(tmp_path) + "/data_c", "data_c",
+                                 ["F_V0", "f_A", "f_1"], quarks_list=["lquark lquark"],
+                                 wf_list=[0, 1], wf2_list=[0, 1], version="2.0c",
+                                 corr_type_list=["bib", "bi", "bb"], nice_output=False)
+    rep_names = ["data_c_|r0", "data_c_|r1", "data_c_|r2"]
+    f_1_00 = corrs["f_1"]['lquark lquark']['0']['0']['0']
+    f_1_01 = corrs["f_1"]['lquark lquark']['0']['0']['1']
+    f_1_10 = corrs["f_1"]['lquark lquark']['0']['1']['0']
+    f_1_11 = corrs["f_1"]['lquark lquark']['0']['1']['1']
+
+    assert len(f_1_00) == 1
+    assert list(f_1_00[0].shape.keys()) == rep_names
+    assert f_1_00[0].value == 351.1941525454502
+
+    assert len(f_1_01) == 1
+    assert list(f_1_01[0].shape.keys()) == rep_names
+    assert f_1_01[0].value == 351.20703575855345
+
+    assert len(f_1_10) == 1
+    assert list(f_1_10[0].shape.keys()) == rep_names
+    assert f_1_10[0].value == 351.20703575855515
+
+    assert len(f_1_11) == 1
+    assert list(f_1_11[0].shape.keys()) == rep_names
+    assert f_1_11[0].value == 351.22001235609065
+
+    f_A = corrs["f_A"]['lquark lquark']['0']['0']['0']
+
+    assert len(f_A) == 3
+    assert list(f_A[0].shape.keys()) == rep_names
+    assert f_A[0].value == 65.4711887279723
+    assert f_A[1].value == 1.0447210336915187
+    assert f_A[2].value == -41.025094911185185
+
+    f_V0_00 = corrs["F_V0"]['lquark lquark']['0']['0']['0']
+    f_V0_01 = corrs["F_V0"]['lquark lquark']['0']['0']['1']
+    f_V0_10 = corrs["F_V0"]['lquark lquark']['0']['1']['0']
+    f_V0_11 = corrs["F_V0"]['lquark lquark']['0']['1']['1']
+
+    assert len(f_V0_00) == 3
+    assert list(f_V0_00[0].shape.keys()) == rep_names
+    assert f_V0_00[0].value == 683.6776090085115
+    assert f_V0_00[1].value == 661.3188585582334
+    assert f_V0_00[2].value == 683.6776090081005
+
+    assert len(f_V0_01) == 3
+    assert list(f_V0_01[0].shape.keys()) == rep_names
+    assert f_V0_01[0].value == 683.7028316879306
+    assert f_V0_01[1].value == 661.3432563640756
+    assert f_V0_01[2].value == 683.7028316875197
+
+    assert len(f_V0_10) == 3
+    assert list(f_V0_10[0].shape.keys()) == rep_names
+    assert f_V0_10[0].value == 683.7028316879289
+    assert f_V0_10[1].value == 661.343256364074
+    assert f_V0_10[2].value == 683.702831687518
+
+    assert len(f_V0_11) == 3
+    assert list(f_V0_11[0].shape.keys()) == rep_names
+    assert f_V0_11[0].value == 683.7280552978792
+    assert f_V0_11[1].value == 661.3676550700158
+    assert f_V0_11[2].value == 683.7280552974681
+
+
 def test_a_bb(tmp_path):
     build_test_environment(str(tmp_path), "a", 5, 3)
     f_1 = sfin.read_sfcf(str(tmp_path) + "/data_a", "data_a", "f_1", quarks="lquark lquark", wf=0, wf2=0, version="2.0a", corr_type="bb")
@@ -162,6 +267,45 @@ def test_a_bib(tmp_path):
     assert f_V0[2] == 683.6776090081005
 
 
+def test_simple_multi_a(tmp_path):
+    build_test_environment(str(tmp_path), "a", 5, 3)
+    f_V0 = sfin.read_sfcf_multi(str(tmp_path) + "/data_a", "data_a", ["F_V0"], quarks=["lquark lquark"], wf1_list=[0], wf2_list=[0], version="2.0a", corr_type_list=["bib"], nice_output=True)
+    print(f_V0)
+    assert len(f_V0) == 3
+    assert list(f_V0[0].shape.keys()) == ["data_a_|r0", "data_a_|r1", "data_a_|r2"]
+    assert f_V0[0] == 683.6776090085115
+    assert f_V0[1] == 661.3188585582334
+    assert f_V0[2] == 683.6776090081005
+
+
+def test_dict_multi_a(tmp_path):
+    build_test_environment(str(tmp_path), "a", 5, 3)
+    corrs = sfin.read_sfcf_multi(str(tmp_path) + "/data_a", "data_a",
+                                 ["F_V0", "f_A", "f_1"], quarks_list=["lquark lquark"],
+                                 wf_list=[0], wf2_list=[0], version="2.0a",
+                                 corr_type_list=["bib", "bi", "bb"], nice_output=False)
+    print(corrs)
+    f_1 = corrs["f_1"]['lquark lquark']['0']['0']['0']
+    f_A = corrs["f_A"]['lquark lquark']['0']['0']['0']
+    f_V0 = corrs["F_V0"]['lquark lquark']['0']['0']['0']
+
+    assert len(f_1) == 1
+    assert list(f_1[0].shape.keys()) == ["data_a_|r0", "data_a_|r1", "data_a_|r2"]
+    assert f_1[0].value == 351.1941525454502
+
+    assert len(f_A) == 3
+    assert list(f_A[0].shape.keys()) == ["data_a_|r0", "data_a_|r1", "data_a_|r2"]
+    assert f_A[0].value == 65.4711887279723
+    assert f_A[1].value == 1.0447210336915187
+    assert f_A[2].value == -41.025094911185185
+
+    assert len(f_V0) == 3
+    assert list(f_V0[0].shape.keys()) == ["data_a_|r0", "data_a_|r1", "data_a_|r2"]
+    assert f_V0[0] == 683.6776090085115
+    assert f_V0[1] == 661.3188585582334
+    assert f_V0[2] == 683.6776090081005
+
+
 def test_find_corr():
     pattern = 'name      ' + "f_A" + '\nquarks    ' + "lquark lquark" + '\noffset    ' + str(0) + '\nwf        ' + str(0)
     start_read, T = sfin._find_correlator("tests/data/sfcf_test/data_c/data_c_r0/data_c_r0_n1", "2.0c", pattern, False)
@@ -177,7 +321,7 @@ def test_find_corr():
         sfin._find_correlator("tests/data/sfcf_test/broken_data_c/data_c_r0/data_c_r0_n1", "2.0c", pattern, False)
 
 
-def test_read_compact_file(tmp_path):
+def test_read_compact_file():
     rep_path = "tests/data/sfcf_test/broken_data_c/data_c_r0/"
     config_file = "data_c_r0_n1"
     start_read = 469