Changeset 8041 for trunk

Timestamp:

07/10/11 14:39:27 (8 months ago)

Author:

westram

Message:

merge from dev [7990] [7991] [7992] [7993] [7994] [7995] [7996] [7998] [8001] [8003] [8005] [8006] [8007] [8008] [8009] [8011] [8012] [8019]

• added a faked ecoli to ptserver test-db
• added unit-tests for gene-ptserver
• rename ptserver testdb
• ptserver db-cleanup
  • size of mapfile for SSUREF108 is reduced by 85% (3,4Gb -> 519Mb)
• ptserver
  • refactored
    • prefix tree builders
    • probe_input_data
  • removed ptnd_new_match (dead code)

Location:

trunk

Files:

• ARBDB/ad_prot.h (modified) (2 diffs)
• ARBDB/ad_save_load.cxx (modified) (2 diffs)
• ARBDB/admap.cxx (modified) (1 diff)
• ARBDB/adsocket.cxx (modified) (1 diff)
• ARBDB/adtcp.cxx (modified) (2 diffs)
• ARBDB/gb_memory.h (modified) (1 diff)
• Makefile (modified) (3 diffs)
• PROBE/Makefile (modified) (5 diffs)
• PROBE/PT_buildtree.cxx (modified) (10 diffs)
• PROBE/PT_debug.cxx (modified) (7 diffs)
• PROBE/PT_etc.cxx (modified) (4 diffs)
• PROBE/PT_family.cxx (modified) (12 diffs)
• PROBE/PT_findEx.cxx (modified) (4 diffs)
• PROBE/PT_io.cxx (modified) (7 diffs)
• PROBE/PT_main.cxx (modified) (10 diffs)
• PROBE/PT_match.cxx (modified) (14 diffs)
• PROBE/PT_new_design.cxx (modified) (27 diffs)
• PROBE/PT_prefixtree.cxx (modified) (16 diffs)
• PROBE/needs_libs (modified) (1 diff)
• PROBE/probe.h (modified) (6 diffs)
• PROBE/probe_tree.h (modified) (5 diffs)
• PROBE/pt_prototypes.h (modified) (6 diffs)
• SERVERCNTRL/servercntrl.cxx (modified) (1 diff)
• SL/Makefile (modified) (1 diff)
• SL/PTCLEAN (copied) (copied from branches/dev/SL/PTCLEAN) (1 prop)
• SL/PTCLEAN/Makefile (modified) (2 diffs)
• SL/PTCLEAN/ptclean.cxx (modified) (2 diffs)
• SL/PTCLEAN/ptclean.h (modified) (1 diff)
• SOURCE_TOOLS/dep.4dummy (modified) (2 diffs)
• SOURCE_TOOLS/dep.alltargets (modified) (1 diff)
• SOURCE_TOOLS/dep.libtargets (modified) (1 diff)
• SOURCE_TOOLS/generate_all_links.sh (modified) (1 diff)
• TOOLS/arb_probe.cxx (modified) (17 diffs)
• TOOLS/arb_test.cxx (modified) (4 diffs)
• UNIT_TESTER/TestEnvironment.cxx (modified) (5 diffs)
• UNIT_TESTER/run (modified) (1 prop)
• UNIT_TESTER/run/TEST_gpt.arb.expected (copied) (copied from branches/dev/UNIT_TESTER/run/TEST_gpt.arb.expected)
• UNIT_TESTER/run/TEST_gpt.arb.pt.expected (copied) (copied from branches/dev/UNIT_TESTER/run/TEST_gpt.arb.pt.expected)
• UNIT_TESTER/run/TEST_gpt_src.arb (copied) (copied from branches/dev/UNIT_TESTER/run/TEST_gpt_src.arb)
• UNIT_TESTER/run/TEST_pt.arb (deleted)
• UNIT_TESTER/run/TEST_pt_cleaned_expected.arb (copied) (copied from branches/dev/UNIT_TESTER/run/TEST_pt_cleaned_expected.arb) (3 diffs)
• UNIT_TESTER/run/TEST_pt_src.arb (copied) (copied from branches/dev/UNIT_TESTER/run/TEST_pt_src.arb)
• UNIT_TESTER/run/tools/arb_replace.in (copied) (copied from branches/dev/UNIT_TESTER/run/tools/arb_replace.in)
• UNIT_TESTER/run/tools/gene_probe.arb (deleted)
• UNIT_TESTER/run/tools/gene_probe_expected.arb (deleted)
• UNIT_TESTER/test_unit.h (modified) (2 diffs)
• lib/arb_tcp_org.dat (modified) (1 diff)
• util/arb_srclst.pl (modified) (2 diffs)

trunk/ARBDB/ad_prot.h

@@ -184 +184 @@
 #ifdef UNIT_TESTS
 #define TEST_SERVER_ID (-666)
+#define TEST_GENESERVER_ID (-667)
 #endif
 
@@ -393 +394 @@
 GB_ERROR GB_set_undo_mem(GBDATA *gbd, long memsize);
 
+/* admap.cxx */
+bool GB_supports_mapfile(void);
+
 /* adquery.cxx */
 const char *GB_get_GBDATA_path(GBDATA *gbd);

trunk/ARBDB/ad_save_load.cxx

@@ -1297 +1297 @@
 
 // #define TEST_AUTO_UPDATE // uncomment to auto-update binary and quicksave testfiles (needed once after changing ascii testfile or modify_db())
-#define TEST_copy(src, dst) TEST_ASSERT(system(GBS_global_string("cp '%s' '%s'", src, dst)) == 0)
 
 #define TEST_loadsave_CLEANUP() TEST_ASSERT(system("rm -f [ab]2[ab]*.* master.* slave.* renamed.* fast.* fast2b.* TEST_loadsave.ARF") == 0)
@@ -1373 +1372 @@
 
 #if defined(TEST_AUTO_UPDATE)
-        TEST_copy("a2b.a00", "TEST_loadsave_quick.a00");
+        TEST_COPY_FILE("a2b.a00", "TEST_loadsave_quick.a00");
 #endif // TEST_AUTO_UPDATE
 

trunk/ARBDB/admap.cxx

@@ -674 +674 @@
 }
 
+bool GB_supports_mapfile() {
+#if (MEMORY_TEST == 1)
+    return false;
+#else
+    return true;
+#endif
+}
+
 int gb_is_valid_mapfile(const char *path, gb_map_header *mheader, int verbose) {
     /* Test whether mapfile is valid

trunk/ARBDB/adsocket.cxx

@@ -1194 +1194 @@
     GB_ULONG usedmemsize = (MIN(net_memsize, max_malloc)*95)/100; // arb uses max. 95 % of available memory (was 70% in the past)
 
-#if defined(DEBUG)
+#if defined(DEBUG) && 0
     printf("- memsize(real)        = %20lu k\n", memsize);
     printf("- memsize(net)         = %20lu k\n", net_memsize);
     printf("- memsize(max_malloc)  = %20lu k\n", max_malloc);
+    printf("- memsize(used by ARB) = %20lu k\n", usedmemsize);
 #endif // DEBUG
-    printf("- memsize(used by ARB) = %20lu k\n", usedmemsize);
 
     arb_assert(usedmemsize != 0);

trunk/ARBDB/adtcp.cxx

@@ -304 +304 @@
 // AISC_MKPT_PROMOTE:#ifdef UNIT_TESTS
 // AISC_MKPT_PROMOTE:#define TEST_SERVER_ID (-666)
+// AISC_MKPT_PROMOTE:#define TEST_GENESERVER_ID (-667)
 // AISC_MKPT_PROMOTE:#endif
 
@@ -317 +318 @@
 const char *GBS_ptserver_tag(int id) {
 #ifdef UNIT_TESTS
-    if (id == TEST_SERVER_ID) {
-        return "ARB_TEST_PT_SERVER";
-    }
+    if (id == TEST_SERVER_ID) return "ARB_TEST_PT_SERVER";
+    if (id == TEST_GENESERVER_ID) return "ARB_TEST_PT_SERVER_GENE";
 #endif // UNIT_TESTS
     gb_assert(id >= 0);

trunk/ARBDB/gb_memory.h

@@ -27 +27 @@
 #if defined(UNIT_TESTS)
 #undef MEMORY_TEST
-#define MEMORY_TEST 0 // test mmapped-DB version in unittests
+#define MEMORY_TEST 0 // test mmapped-DB version in unittests (recommended setting)
 // #define MEMORY_TEST 1 // test DEBUG DB version in unittests
 #endif

trunk/Makefile

@@ -1039 +1039 @@
                 SERVERCNTRL/SERVERCNTRL.a \
                 SL/HELIX/HELIX.a \
+                SL/PTCLEAN/PTCLEAN.a \
 
 ARCHS_PROBE_LINK = \
@@ -1843 +1844 @@
         PHYLO/PHYLO.test \
         PRIMER_DESIGN/PRIMER_DESIGN.test \
-        PROBE/PROBE.test \
         PROBE_DESIGN/PROBE_DESIGN.test \
         ptpan/PROBE.test \
@@ -1911 +1911 @@
         CONVERTALN/CONVERTALN.test \
         SL/SEQIO/SEQIO.test \
+        SL/PTCLEAN/PTCLEAN.test \
+        PROBE/PROBE.test \
 
 TESTED_UNITS_MANUAL = \

trunk/PROBE/Makefile

@@ -27 +27 @@
 
 proto:
-        ../AISC_MKPTPS/aisc_mkpt -G -E -z -A -w pt_prototypes.h $(OBJECTS:.o=.cxx) probe_tree.h >pt_prototypes.h.tmp
+        ../AISC_MKPTPS/aisc_mkpt -P -G -E -z -A -w pt_prototypes.h $(OBJECTS:.o=.cxx) probe_tree.h >pt_prototypes.h.tmp
         ../SOURCE_TOOLS/mv_if_diff pt_prototypes.h.tmp pt_prototypes.h
 
@@ -57 +57 @@
 PT_buildtree.o: $(ARBHOME)/INCLUDE/arb_assert.h
 PT_buildtree.o: $(ARBHOME)/INCLUDE/arb_core.h
+PT_buildtree.o: $(ARBHOME)/INCLUDE/arb_defs.h
 PT_buildtree.o: $(ARBHOME)/INCLUDE/arb_error.h
 PT_buildtree.o: $(ARBHOME)/INCLUDE/arb_msg.h
@@ -73 +74 @@
 PT_buildtree.o: $(ARBHOME)/INCLUDE/static_assert.h
 PT_buildtree.o: $(ARBHOME)/INCLUDE/test_global.h
+PT_buildtree.o: $(ARBHOME)/INCLUDE/test_unit.h
 
 PT_debug.o: probe.h
@@ -202 +204 @@
 PT_main.o: $(ARBHOME)/INCLUDE/arb_assert.h
 PT_main.o: $(ARBHOME)/INCLUDE/arb_core.h
+PT_main.o: $(ARBHOME)/INCLUDE/arb_defs.h
 PT_main.o: $(ARBHOME)/INCLUDE/arb_error.h
 PT_main.o: $(ARBHOME)/INCLUDE/arb_msg.h
@@ -218 +221 @@
 PT_main.o: $(ARBHOME)/INCLUDE/PT_server.h
 PT_main.o: $(ARBHOME)/INCLUDE/PT_server_prototypes.h
+PT_main.o: $(ARBHOME)/INCLUDE/ptclean.h
 PT_main.o: $(ARBHOME)/INCLUDE/server.h
 PT_main.o: $(ARBHOME)/INCLUDE/servercntrl.h

trunk/PROBE/PT_buildtree.cxx

@@ -13 +13 @@
 #include "probe_tree.h"
 #include "pt_prototypes.h"
+#include "arb_defs.h"
 
 #include <arb_progress.h>
@@ -18 +19 @@
 #include <unistd.h>
 
-POS_TREE *build_pos_tree (POS_TREE *pt, int anfangs_pos, int apos, int RNS_nr, unsigned int end)
-{
-    static POS_TREE       *pthelp, *pt_next;
-    unsigned int i, j;
-    int          height = 0, anfangs_apos_ref, anfangs_rpos_ref, RNS_nr_ref;
-    pthelp = pt;
-    i = anfangs_pos;
-    while (PT_read_type(pthelp) == PT_NT_NODE) {    // now we got an inner node
-        if ((pt_next = PT_read_son_stage_1(psg.ptmain, pthelp, (PT_BASES)psg.data[RNS_nr].data[i])) == NULL) {
-                            // there is no son of that type -> simply add the new son to that path //
-            if (pthelp == pt) { // now we create a new root structure (size will change)
-                PT_create_leaf(psg.ptmain, &pthelp, (PT_BASES)psg.data[RNS_nr].data[i], anfangs_pos, apos, RNS_nr);
-                return pthelp;  // return the new root
-            }
-            else {
-                PT_create_leaf(psg.ptmain, &pthelp, (PT_BASES)psg.data[RNS_nr].data[i], anfangs_pos, apos, RNS_nr);
-                return pt;  // return the old root
-            }
+// AISC_MKPT_PROMOTE: class DataLoc;
+
+static POS_TREE *build_pos_tree(POS_TREE *const root, const DataLoc& loc) {
+    POS_TREE *at = root;
+    int       height = 0;
+
+    while (PT_read_type(at) == PT_NT_NODE) {    // now we got an inner node
+        POS_TREE *pt_next = PT_read_son_stage_1(at, loc[height]);
+        if (!pt_next) { // there is no son of that type -> simply add the new son to that path //
+            bool atRoot = (at == root);
+            PT_create_leaf(&at, loc[height], loc);
+            return atRoot ? at : root; // inside tree return old root, otherwise new root has been created
         }
         else {            // go down the tree
-            pthelp = pt_next;
+            at = pt_next;
             height++;
-            i++;
-            if (i >= end) {     // end of sequence reached -> change node to chain and add
-                        // should never be reached, because of the terminal symbol
-                        // of each sequence
-                if (PT_read_type(pthelp) == PT_NT_CHAIN)
-                    pthelp = PT_add_to_chain(psg.ptmain, pthelp, RNS_nr, apos, anfangs_pos);
+
+            if (loc.is_shorther_than(height)) {
+                // end of sequence reached -> change node to chain and add
+                // should never be reached, because of the terminal symbol of each sequence (@@@ this IS reached - even with unittestdb)
+                if (PT_read_type(at) == PT_NT_CHAIN) {
+                    PT_add_to_chain(at, loc);
+                }
                 // if type == node then forget it
-                return pt;
-            }
-        }
-    }
-            // type == leaf or chain
-    if (PT_read_type(pthelp) == PT_NT_CHAIN) {      // old chain reached
-        pthelp = PT_add_to_chain(psg.ptmain, pthelp, RNS_nr, apos, anfangs_pos);
-        return pt;
-    }
-    anfangs_rpos_ref = PT_read_rpos(psg.ptmain, pthelp); // change leave to node and create two sons
-    anfangs_apos_ref = PT_read_apos(psg.ptmain, pthelp);
-    RNS_nr_ref = PT_read_name(psg.ptmain, pthelp);
-    j = anfangs_rpos_ref + height;
-
-    while (psg.data[RNS_nr].data[i] == psg.data[RNS_nr_ref].data[j]) {  // creates nodes until sequences are different
-                                        // type != nt_node
-        if (PT_read_type(pthelp) == PT_NT_CHAIN) {          // break
-            pthelp = PT_add_to_chain(psg.ptmain, pthelp, RNS_nr, apos, anfangs_pos);
-            return pt;
+                return root;
+            }
+        }
+    }
+
+    // type == leaf or chain
+    if (PT_read_type(at) == PT_NT_CHAIN) {      // old chain reached
+        PT_add_to_chain(at, loc);
+        return root;
+    }
+
+    // change leave to node and create two sons
+
+    const DataLoc loc_ref(at);
+
+    while (loc[height] == loc_ref[height]) {  // creates nodes until sequences are different
+        // type != nt_node
+        if (PT_read_type(at) == PT_NT_CHAIN) { 
+            PT_add_to_chain(at, loc);
+            return root;
         }
         if (height >= PT_POS_TREE_HEIGHT) {
-            if (PT_read_type(pthelp) == PT_NT_LEAF) {
-                pthelp = PT_leaf_to_chain(psg.ptmain, pthelp);
-            }
-            pthelp = PT_add_to_chain(psg.ptmain, pthelp, RNS_nr, apos, anfangs_pos);
-            return pt;
-        }
-        if (((i + 1) >= end) && (j + 1 >= (unsigned)(psg.data[RNS_nr_ref].size))) { // end of both sequences
-            return pt;
-        }
-        pthelp = PT_change_leaf_to_node(psg.ptmain, pthelp); // change tip to node and append two new leafs
-        if (i + 1 >= end) {                 // end of source sequence reached
-            pthelp = PT_create_leaf(psg.ptmain, &pthelp, (PT_BASES)psg.data[RNS_nr_ref].data[j],
-                    anfangs_rpos_ref, anfangs_apos_ref, RNS_nr_ref);
-            return pt;
-        }
-        if (j + 1 >= (unsigned)(psg.data[RNS_nr_ref].size)) {       // end of reference sequence
-            pthelp = PT_create_leaf(psg.ptmain, &pthelp, (PT_BASES)psg.data[RNS_nr].data[i], anfangs_pos, apos, RNS_nr);
-            return pt;
-        }
-        pthelp = PT_create_leaf(psg.ptmain, &pthelp, (PT_BASES)psg.data[RNS_nr].data[i], anfangs_rpos_ref, anfangs_apos_ref, RNS_nr_ref);
-                    // dummy leaf just to create a new node; may become a chain
-        i++;
-        j++;
+            if (PT_read_type(at) == PT_NT_LEAF) {
+                at = PT_leaf_to_chain(at);
+            }
+            PT_add_to_chain(at, loc);
+            return root;
+        }
+
+        bool loc_done = loc.is_shorther_than(height+1);
+        bool ref_done = loc_ref.is_shorther_than(height+1);
+
+        if (ref_done && loc_done) return root; // end of both sequences
+
+        at = PT_change_leaf_to_node(at); // change tip to node and append two new leafs
+        if (loc_done) { // end of source sequence reached
+            PT_create_leaf(&at, loc_ref[height], loc_ref);
+            return root;
+        }
+        if (ref_done) { // end of reference sequence
+            PT_create_leaf(&at, loc[height], loc);
+            return root;
+        }
+        at = PT_create_leaf(&at, loc[height], loc_ref); // dummy leaf just to create a new node; may become a chain
         height++;
     }
+
+    
+    
     if (height >= PT_POS_TREE_HEIGHT) {
-        if (PT_read_type(pthelp) == PT_NT_LEAF)
-            pthelp = PT_leaf_to_chain(psg.ptmain, pthelp);
-        pthelp = PT_add_to_chain(psg.ptmain, pthelp, RNS_nr, apos, anfangs_pos);
-        return pt;
-    }
-    if (PT_read_type(pthelp) == PT_NT_CHAIN) {
-        pthelp = PT_add_to_chain(psg.ptmain, pthelp, RNS_nr, apos, anfangs_pos);
+        if (PT_read_type(at) == PT_NT_LEAF) at = PT_leaf_to_chain(at);
+        PT_add_to_chain(at, loc);
+        return root;
+    }
+    if (PT_read_type(at) == PT_NT_CHAIN) {
+        // not covered by test - but looks similar to case in top-loop
+        PT_add_to_chain(at, loc);
     }
     else {
-        pthelp = PT_change_leaf_to_node(psg.ptmain, pthelp); // Blatt loeschen
-        PT_create_leaf(psg.ptmain, &pthelp, (PT_BASES)psg.data[RNS_nr].data[i], anfangs_pos, apos, RNS_nr); // zwei neue Blaetter
-        PT_create_leaf(psg.ptmain, &pthelp, (PT_BASES)psg.data[RNS_nr_ref].data[j], anfangs_rpos_ref, anfangs_apos_ref, RNS_nr_ref);
-    }
-    return pt;
-}
+        at = PT_change_leaf_to_node(at);             // delete leaf
+        PT_create_leaf(&at, loc[height], loc); // two new leafs
+        PT_create_leaf(&at, loc_ref[height], loc_ref);
+    }
+    return root;
+}
+
 
 inline void get_abs_align_pos(char *seq, int &pos)
@@ -147 +147 @@
 }
 
-long PTD_save_partial_tree(FILE *out, PTM2 *ptmain, POS_TREE * node, char *partstring, int partsize, long pos, long *ppos, ARB_ERROR& error) {
+long PTD_save_partial_tree(FILE *out, POS_TREE * node, char *partstring, int partsize, long pos, long *ppos, ARB_ERROR& error) {
     if (partsize) {
-        POS_TREE *son = PT_read_son(ptmain, node, (PT_BASES)partstring[0]);
+        POS_TREE *son = PT_read_son(node, (PT_BASES)partstring[0]);
         if (son) {
-            pos = PTD_save_partial_tree(out, ptmain, son, partstring+1, partsize-1, pos, ppos, error);
+            pos = PTD_save_partial_tree(out, son, partstring+1, partsize-1, pos, ppos, error);
         }
     }
     else {
-        PTD_clear_fathers(ptmain, node);
+        PTD_clear_fathers(node);
         long r_pos;
         int blocked;
@@ -165 +165 @@
             fflush(stdout);
 #endif
-            r_pos = PTD_write_leafs_to_disk(out, ptmain, node, pos, ppos, &blocked, error);
+            r_pos = PTD_write_leafs_to_disk(out, node, pos, ppos, &blocked, error);
             if (r_pos > pos) pos = r_pos;
         }
@@ -221 +221 @@
             psg.ptmain->stage1 = 1;             // enter stage 1
 
-            pt = PT_create_leaf(psg.ptmain, NULL, PT_N, 0, 0, 0);  // create main node
-            pt = PT_change_leaf_to_node(psg.ptmain, pt);
+            pt = PT_create_leaf(NULL, PT_N, DataLoc(0, 0, 0));  // create main node
+            pt = PT_change_leaf_to_node(pt);
             psg.stat.cut_offs = 0;                  // statistic information
             GB_begin_transaction(psg.gb_main);
@@ -267 +267 @@
 
                     int abs_align_pos = psize-1;
-                    for (int j = psg.data[i].size - 1; j >= 0; j--, abs_align_pos--) {
+                    for (int j = psg.data[i].get_size() - 1; j >= 0; j--, abs_align_pos--) {
                         get_abs_align_pos(align_abs, abs_align_pos); // may result in neg. abs_align_pos (seems to happen if sequences are short < 214bp )
                         if (abs_align_pos < 0) break; // -> in this case abort
 
-                        if (partsize && (*partstring != psg.data[i].data[j] || strncmp(partstring, psg.data[i].data+j, partsize))) continue;
-                        if (ptd_string_shorter_than(psg.data[i].data+j, 9)) continue;
-
-                        pt = build_pos_tree(pt, j, abs_align_pos, i, psg.data[i].size);
+                        if (partsize && (*partstring != psg.data[i].get_data()[j] || strncmp(partstring, psg.data[i].get_data()+j, partsize))) continue;
+                        if (ptd_string_shorter_than(psg.data[i].get_data()+j, 9)) continue;
+
+                        pt = build_pos_tree(pt, DataLoc(i, abs_align_pos, j));
                     }
                     free(align_abs);
@@ -280 +280 @@
                     ++data_progress;
                 }
-                pos = PTD_save_partial_tree(out, psg.ptmain, pt, partstring, partsize, pos, &last_obj, error);
+                pos = PTD_save_partial_tree(out, pt, partstring, partsize, pos, &last_obj, error);
                 if (error) break;
 
@@ -292 +292 @@
             if (!error) {
                 if (partsize) {
-                    pos = PTD_save_partial_tree(out, psg.ptmain, pt, NULL, 0, pos, &last_obj, error);
+                    pos = PTD_save_partial_tree(out, pt, NULL, 0, pos, &last_obj, error);
 #ifdef PTM_DEBUG
                     PTM_debug_mem();
@@ -377 +377 @@
         }
         else {
-            error = PTD_read_leafs_from_disk(tname, psg.ptmain, &psg.pt);
+            error = PTD_read_leafs_from_disk(tname, &psg.pt);
             fclose(in);
         }
@@ -385 +385 @@
 }
 
+// --------------------------------------------------------------------------------
+
+#ifdef UNIT_TESTS
+#ifndef TEST_UNIT_H
+#include <test_unit.h>
+#endif
+
+int main(int argc, const char*argv[]);
+void NOTEST_SLOW_maybe_build_tree() {
+    // does only test sth if DB is present.
+
+    const char *dbarg      = "-D" "extra_pt_src.arb";
+    const char *testDB     = dbarg+2;
+    const char *resultPT   = "extra_pt_src.arb.pt";
+    const char *expectedPT = "extra_pt_src.arb_expected.pt";
+    bool        exists     = GB_is_regularfile(testDB);
+
+    if (exists) {
+        const char *argv[] = {
+            "fake_pt_server",
+            "-build",
+            dbarg,
+        };
+
+#if 1
+        // build
+        int res = main(ARRAY_ELEMS(argv), argv);
+        TEST_ASSERT_EQUAL(res, EXIT_SUCCESS);
+#endif
+
+// #define TEST_AUTO_UPDATE
+#if defined(TEST_AUTO_UPDATE)
+        TEST_COPY_FILE(resultPT, expectedPT);
+#else // !defined(TEST_AUTO_UPDATE)
+        TEST_ASSERT_FILES_EQUAL(resultPT, expectedPT);
+#endif
+    }
+}
+
+#endif // UNIT_TESTS
+
+// --------------------------------------------------------------------------------

trunk/PROBE/PT_debug.cxx

@@ -47 +47 @@
             basecnt = 0;
             for (i=PT_QU; i<PT_B_MAX; i++) {
-                if ((pt_help = PT_read_son(psg.ptmain, pt, (PT_BASES)i)))
+                if ((pt_help = PT_read_son(pt, (PT_BASES)i)))
                 {
                     basecnt++;
@@ -61 +61 @@
             ptds->chains[height]++;
             psg.height = 0;
-            PT_forwhole_chain(psg.ptmain, pt, PT_chain_count());
+            PT_forwhole_chain(pt, PT_chain_count());
             if (psg.height >= DEBUG_MAX_CHAIN_SIZE) psg.height = DEBUG_MAX_CHAIN_SIZE;
             ptds->chainsizes[psg.height][height]++;
@@ -68 +68 @@
             if (ptds->chaincount<20) {
                 printf("\n\n\n\n");
-                PT_forwhole_chain(psg.ptmain, pt, PTD_chain_print());
+                PT_forwhole_chain(pt, PTD_chain_print());
             }
             break;
@@ -140 +140 @@
         struct probe_input_data& data = psg.data[leaf.name];
 
-        PT_BASES b = (PT_BASES)data.data[leaf.rpos];
-
-        printf("%s[%c] %s apos=%i rpos=%i\n", prefix, PT_BASES_2_char(b), data.name, leaf.apos, leaf.rpos);
+        PT_BASES b = (PT_BASES)data.get_data()[leaf.rpos];
+
+        printf("%s[%c] %s apos=%i rpos=%i\n", prefix, PT_BASES_2_char(b), data.get_name(), leaf.apos, leaf.rpos);
         return 0;
     }
@@ -152 +152 @@
     switch (PT_read_type(pt)) {
         case PT_NT_NODE:
-            for (int i = PT_N; i<PT_B_MAX; i++) {
+            for (int i = PT_QU; i<PT_B_MAX; i++) {
                 PT_BASES  b   = PT_BASES(i);
-                POS_TREE *son = PT_read_son(psg.ptmain, pt, b);
+                POS_TREE *son = PT_read_son(pt, b);
                 if (son) {
-                    char *subPrefix = GBS_global_string_copy("%s%c", prefix, PT_BASES_2_char(b));
+                    char *subPrefix = GBS_global_string_copy("%s%c", prefix, b == PT_QU ? '.' : PT_BASES_2_char(b));
                     PT_dump_POS_TREE_recursive(son, subPrefix);
                     free(subPrefix);
@@ -163 +163 @@
             break;
         case PT_NT_LEAF: {
-            PT_dump_leaf dump_leaf(prefix);
-            dump_leaf(DataLoc(psg.ptmain, pt));
-            break;
-        }
-        case PT_NT_CHAIN:
-            PT_forwhole_chain(psg.ptmain, pt, PT_dump_leaf(prefix));
-            break;
+            char         *subPrefix = GBS_global_string_copy("{l} %s", prefix);
+            PT_dump_leaf  dump_leaf(subPrefix);
+            dump_leaf(DataLoc(pt));
+            free(subPrefix);
+            break;
+        }
+        case PT_NT_CHAIN: {
+            char *subPrefix = GBS_global_string_copy("{c} %s", prefix);
+            PT_forwhole_chain(pt, PT_dump_leaf(subPrefix));
+            free(subPrefix);
+            break;
+        }
         default:
             printf("%s [unhandled]\n", prefix);
@@ -183 +188 @@
     // Debug function for all stages
 #if defined(DEBUG)
-    long             i;
-    PTM2        *ptmain = psg.ptmain;
     if (!node) printf("Zero node\n");
-    PT_READ_PNTR(&node->data, i);
-    printf("node father 0x%lx\n", i);
+
+    {
+        long i;
+        PT_READ_PNTR(&node->data, i);
+        printf("node father 0x%lx\n", i);
+    }
+
     switch (PT_read_type(node)) {
-        case PT_NT_LEAF:
-            printf("leaf %i:%i,%i\n", PT_read_name(ptmain, node),
-                   PT_read_rpos(ptmain, node), PT_read_apos(ptmain, node));
-            break;
+        case PT_NT_LEAF: {
+            DataLoc loc(node);
+            printf("leaf %i:%i,%i\n", loc.name, loc.rpos, loc.apos);
+            break;
+        }
         case PT_NT_NODE:
-            for (i = 0; i < PT_B_MAX; i++) {
-                printf("%6li:0x%p\n", i, PT_read_son(ptmain, node, (PT_BASES)i));
+            for (long i = 0; i < PT_B_MAX; i++) {
+                printf("%6li:0x%p\n", i, PT_read_son(node, (PT_BASES)i));
             }
             break;
         case PT_NT_CHAIN:
             printf("chain:\n");
-            PT_forwhole_chain(ptmain, node, PTD_chain_print());
+            PT_forwhole_chain(node, PTD_chain_print());
             break;
         case PT_NT_SAVED:

trunk/PROBE/PT_etc.cxx

@@ -72 +72 @@
 }
 
-const char *virt_name(PT_probematch *ml)
+const char *virt_name(PT_probematch *ml) 
 {
     // get the name with a virtual function
     if (gene_flag) {
-        const gene_struct *gs = get_gene_struct_by_internal_gene_name(psg.data[ml->name].name);
+        const gene_struct *gs = get_gene_struct_by_internal_gene_name(psg.data[ml->name].get_name());
         return gs ? gs->get_arb_species_name() : "<cantResolveName>";
     }
     else {
-        pt_assert(psg.data[ml->name].name);
-        return psg.data[ml->name].name;
-    }
-}
-
-const char *virt_fullname(PT_probematch * ml)
+        pt_assert(psg.data[ml->name].get_name());
+        return psg.data[ml->name].get_name();
+    }
+}
+
+const char *virt_fullname(PT_probematch * ml) 
 {
     if (gene_flag) {
-        const gene_struct *gs = get_gene_struct_by_internal_gene_name(psg.data[ml->name].name);
+        const gene_struct *gs = get_gene_struct_by_internal_gene_name(psg.data[ml->name].get_name());
         return gs ? gs->get_arb_gene_name() : "<cantResolveGeneFullname>";
     }
     else {
-        return psg.data[ml->name].fullname ?  psg.data[ml->name].fullname : "<undefinedFullname>";
+        return psg.data[ml->name].get_fullname() ?  psg.data[ml->name].get_fullname() : "<undefinedFullname>";
     }
 }
@@ -163 +163 @@
     // clear 'is_group'
     for (int i = 0; i < psg.data_count; i++) {
-        psg.data[i].is_group = 0; // Note: probes are designed for species with is_group == 1
+        psg.data[i].set_group_state(0); // Note: probes are designed for species with is_group == 1
     }
     locs->group_count = 0;
@@ -212 +212 @@
                 const char *checksum = get_list_part(checksums, coff);
                 // if sequence checksum changed since pt server was updated -> not found
-                found                = atol(checksum) == psg.data[idx].checksum;
+                found                = atol(checksum) == psg.data[idx].get_checksum();
             }
             else {
@@ -219 +219 @@
 
             if (found) {
-                psg.data[idx].is_group = 1; // mark
+                psg.data[idx].set_group_state(1); // mark
                 locs->group_count++;
             }

trunk/PROBE/PT_family.cxx

@@ -22 +22 @@
 inline void aisc_link(dll_public *dll, PT_family_list *family)   { aisc_link(reinterpret_cast<dllpublic_ext*>(dll), reinterpret_cast<dllheader_ext*>(family)); }
 
+
+class HitCounter {
+    int    count;     // Counter for matches
+    double rel_count; // match_count / (seq_len - probe_len + 1)
+
+public:
+    HitCounter() : count(0), rel_count(0.0) {}
+
+    void inc() { count++; }
+    void calc_rel_match(int max_poss_matches) {
+        rel_count = max_poss_matches>0 ? double(count)/max_poss_matches : 0;
+    }
+
+    bool less_abs(const HitCounter& other) const { return count < other.count; }
+    bool less_rel(const HitCounter& other) const { return rel_count < other.rel_count; }
+
+    int get_match_count() const { return count; }
+    const double& get_rel_match_count() const { return rel_count; }
+};
+
+class FamilyStat : virtual Noncopyable {
+    size_t      size;
+    HitCounter *famstat;
+
+public:
+    FamilyStat(size_t size_) : size(size_), famstat(new HitCounter[size]) { }
+    ~FamilyStat() { delete [] famstat; }
+
+    void calc_rel_matches(int probe_len, int sequence_length)  {
+        for (size_t i = 0; i < size; i++) {
+            int max_poss_matches = std::min(psg.data[i].get_size(), sequence_length) - probe_len + 1;
+            famstat[i].calc_rel_match(max_poss_matches);
+        }
+    }
+
+    const HitCounter& hits(size_t idx) const { pt_assert(idx<size); return famstat[idx]; }
+
+    void count_match(size_t idx) { famstat[idx].inc(); }
+
+    bool less_abs(int a, int b) const { return famstat[a].less_abs(famstat[b]); }
+    bool less_rel(int a, int b) const { return famstat[a].less_rel(famstat[b]); }
+};
+
 class ProbeTraversal {
     static Range range;
 
-    static void count_match(const DataLoc& match) {
-        if (range.contains(match)) {
-            ++psg.data[match.name].stat.match_count;
-        }
-    }
-
-    // ----------------------------------------
-    
     const char *probe;
     int         height;
     int         needed_positions;
     int         accept_mismatches;
+    
+    FamilyStat& fam_stat;
+
+    void count_match(const DataLoc& match) const {
+        if (range.contains(match)) {
+            fam_stat.count_match(match.name);
+        }
+    }
 
     bool at_end() const { return *probe == PT_QU; }
@@ -55 +98 @@
 
     void match_rest_and_mark(const DataLoc& loc) {
-        do match_one_char(psg.data[loc.name].data[loc.rpos+height]); while (match_possible());
+        do match_one_char(psg.data[loc.name].get_data()[loc.rpos+height]); while (match_possible());
         if (did_match()) count_match(loc);
     }
@@ -69 +112 @@
         range  = Range(-1, -1, -1);
     }
-    
-    ProbeTraversal(const char *probe_, int needed_positions_, int accept_mismatches_)
+
+    ProbeTraversal(const char *probe_, int needed_positions_, int accept_mismatches_, FamilyStat& fam_stat_)
         : probe(probe_),
           height(0),
           needed_positions(needed_positions_),
-          accept_mismatches(accept_mismatches_)
+          accept_mismatches(accept_mismatches_),
+          fam_stat(fam_stat_)
     { }
 
@@ -100 +144 @@
     if (PT_read_type(pt) == PT_NT_NODE) {
         for (int base = PT_N; base < PT_B_MAX; base++) {
-            POS_TREE *pt_son = PT_read_son(psg.ptmain, pt, (PT_BASES)base);
+            POS_TREE *pt_son = PT_read_son(pt, (PT_BASES)base);
             if (pt_son && !at_end()) {
                 ProbeTraversal sub(*this);
@@ -112 +156 @@
     }
     else {
-        PT_withall_tips(psg.ptmain, pt, *this); // calls operator() 
+        PT_withall_tips(pt, *this); // calls operator() 
     }
 }
@@ -123 +167 @@
     if (PT_read_type(pt) == PT_NT_NODE) {
         for (int base = PT_N; base < PT_B_MAX; base++) {
-            POS_TREE *pt_son = PT_read_son(psg.ptmain, pt, (PT_BASES)base);
+            POS_TREE *pt_son = PT_read_son(pt, (PT_BASES)base);
             if (pt_son) mark_all(pt_son);
         }
     }
     else {
-        PT_withall_tips(psg.ptmain, pt, *this); // calls operator() 
-    }
-}
-
-
-static void clear_statistic() {
-    //! Clear all information in psg.data[i].stat
-
-    for (int i = 0; i < psg.data_count; i++) {
-        memset((char *) &psg.data[i].stat, 0, sizeof(probe_statistic));
-    }
-}
-
-
-
-static void make_match_statistic(int probe_len, int sequence_length) {
-    //! Calculate the statistic information for the family
-
-    // compute statistic for all species in family
-    for (int i = 0; i < psg.data_count; i++) {
-        int all_len = std::min(psg.data[i].size, sequence_length) - probe_len + 1;
-        if (all_len <= 0) {
-            psg.data[i].stat.rel_match_count = 0;
-        }
-        else {
-            psg.data[i].stat.rel_match_count = psg.data[i].stat.match_count / (double) (all_len);
-        }
+        PT_withall_tips(pt, *this); // calls operator() 
     }
 }
 
 struct cmp_probe_abs {
-    bool operator()(const struct probe_input_data* a, const struct probe_input_data* b) {
-        return b->stat.match_count < a->stat.match_count;
-    }
+    const FamilyStat& fam_stat;
+    cmp_probe_abs(const FamilyStat& fam_stat_) : fam_stat(fam_stat_) {}
+    bool operator()(int a, int b) { return fam_stat.less_abs(b, a); }
 };
 
 struct cmp_probe_rel {
-    bool operator()(const struct probe_input_data* a, const struct probe_input_data* b) {
-        return b->stat.rel_match_count < a->stat.rel_match_count;
-    }
-};
-
-static int make_PT_family_list(PT_family *ffinder) {
+    const FamilyStat& fam_stat;
+    cmp_probe_rel(const FamilyStat& fam_stat_) : fam_stat(fam_stat_) {}
+    bool operator()(int a, int b) { return fam_stat.less_rel(b, a); }
+};
+
+static int make_PT_family_list(PT_family *ffinder, const FamilyStat& famStat) {
     //!  Make sorted list of family members
 
+    // destroy old list
+    while (ffinder->fl) destroy_PT_family_list(ffinder->fl);
+
     // Sort the data
-    std::vector<struct probe_input_data*> my_list;
-    my_list.resize(psg.data_count);
-
-    for (int i = 0; i < psg.data_count; i++) {
-        my_list[i] = &psg.data[i];
-    }
+    std::vector<int> sorted;
+    sorted.resize(psg.data_count);
+
+    for (int i = 0; i < psg.data_count; i++) sorted[i] = i;
 
     bool sort_all = ffinder->sort_max == 0 || ffinder->sort_max >= psg.data_count;
@@ -185 +204 @@
     if (ffinder->sort_type == 0) {
         if (sort_all) {
-            std::sort(my_list.begin(), my_list.end(), cmp_probe_abs());
+            std::sort(sorted.begin(), sorted.end(), cmp_probe_abs(famStat));
         }
         else {
-            std::partial_sort(my_list.begin(), my_list.begin() + ffinder->sort_max, my_list.begin() + psg.data_count, cmp_probe_abs());
+            std::partial_sort(sorted.begin(), sorted.begin() + ffinder->sort_max, sorted.begin() + psg.data_count, cmp_probe_abs(famStat));
         }
     }
     else {
         if (sort_all) {
-            std::sort(my_list.begin(), my_list.begin() + psg.data_count, cmp_probe_rel());
+            std::sort(sorted.begin(), sorted.begin() + psg.data_count, cmp_probe_rel(famStat));
         }
         else {
-            std::partial_sort(my_list.begin(), my_list.begin() + ffinder->sort_max, my_list.begin() + psg.data_count, cmp_probe_rel());
-        }
-    }
-
-    // destroy old list
-    while (ffinder->fl) destroy_PT_family_list(ffinder->fl);
+            std::partial_sort(sorted.begin(), sorted.begin() + ffinder->sort_max, sorted.begin() + psg.data_count, cmp_probe_rel(famStat));
+        }
+    }
 
     // build new list
@@ -208 +224 @@
     int end = (sort_all) ? psg.data_count : ffinder->sort_max;
     for (int i = 0; i < end; i++) {
-        if (my_list[i]->stat.match_count != 0) {
+        probe_input_data& pid = psg.data[sorted[i]];
+        const HitCounter& ps  = famStat.hits(sorted[i]);
+
+        if (ps.get_match_count() != 0) {
             PT_family_list *fl = create_PT_family_list();
 
-            fl->name        = strdup(my_list[i]->name);
-            fl->matches     = my_list[i]->stat.match_count;
-            fl->rel_matches = my_list[i]->stat.rel_match_count;
+            fl->name        = strdup(pid.get_name());
+            fl->matches     = ps.get_match_count();
+            fl->rel_matches = ps.get_rel_match_count();
 
             aisc_link(&ffinder->pfl, fl);
@@ -263 +282 @@
     int   sequence_len = probe_compress_sequence(sequence, species->size);
 
-    clear_statistic();
-
     // if find_type > 0 -> search only probes starting with 'A' (quick but less accurate)
     char last_first_c = ffinder->find_type ? PT_A : PT_T;
@@ -270 +287 @@
     ProbeTraversal::restrictMatchesToRegion(ffinder->range_start, ffinder->range_end, probe_len);
 
+    FamilyStat famStat(psg.data_count);
+    
     // Note: code depends on order of ../AWTC/awtc_next_neighbours.hxx@FF_complement_dep
     for (int cmode = 1; cmode <= 8; cmode *= 2) {
@@ -290 +309 @@
                     for (char *probe = sequence; probe < last_probe; ++probe) {
                         if (probe_is_ok(probe, probe_len, first_c, second_c)) {
-                            ProbeTraversal(probe, probe_len, mismatch_nr).mark_matching(psg.pt);
+                            ProbeTraversal(probe, probe_len, mismatch_nr, famStat).mark_matching(psg.pt);
                         }
                     }
@@ -298 +317 @@
     }
 
-    make_match_statistic(ffinder->pr_len, sequence_len);
-    make_PT_family_list(ffinder);
+    famStat.calc_rel_matches(ffinder->pr_len, sequence_len);
+    make_PT_family_list(ffinder, famStat);
 
     ProbeTraversal::unrestrictMatchesToRegion();

trunk/PROBE/PT_findEx.cxx

@@ -21 +21 @@
         case PT_NT_NODE: {
             for (int i=PT_A; i<PT_B_MAX; ++i) {
-                POS_TREE *son = PT_read_son(psg.ptmain, node, PT_BASES(i));
+                POS_TREE *son = PT_read_son(node, PT_BASES(i));
                 if (son) {
                     probe[0] = PT_BASES(i); // write leftmost probe into result
@@ -37 +37 @@
         case PT_NT_LEAF: {
             // here the probe-tree is cut off, because only one species matches
-            int pos  = PT_read_rpos(psg.ptmain, node) + height;
-            int name = PT_read_name(psg.ptmain, node);
-            if (pos + restlen >= psg.data[name].size)
+            DataLoc loc(node);
+            int     pos  = loc.rpos + height;
+            int     name = loc.name;
+
+            if (pos + restlen >= psg.data[name].get_size())
                 break;          // at end-of-sequence -> no probe with wanted length here
 
             pt_assert(probe[restlen] == 0);
-            const char *seq_data = psg.data[name].data;
+            const char *seq_data = psg.data[name].get_data();
             for (int r = 0; r<restlen; ++r) {
                 int data = seq_data[pos+r];
@@ -70 +72 @@
     switch (PT_read_type(node)) {
         case PT_NT_NODE: {
-            POS_TREE *son   = PT_read_son(psg.ptmain, node, PT_BASES(probe[0]));
+            POS_TREE *son   = PT_read_son(node, PT_BASES(probe[0]));
             bool      found = (son != 0) && findNextProbe(son, probe+1, restlen-1, height+1);
 
@@ -77 +79 @@
             if (!found) {
                 for (int i=probe[0]+1; !found && i<PT_B_MAX; ++i) {
-                    son = PT_read_son(psg.ptmain, node, PT_BASES(i));
+                    son = PT_read_son(node, PT_BASES(i));
                     if (son) {
                         probe[0] = PT_BASES(i); // change probe

trunk/PROBE/PT_io.cxx

@@ -71 +71 @@
 }
 
-ARB_ERROR probe_read_data_base(const char *name) { // goes to header: __ATTR__USERESULT
+ARB_ERROR probe_read_data_base(const char *name, bool readOnly) { // goes to header: __ATTR__USERESULT
     ARB_ERROR error;
     GB_set_verbose();
@@ -77 +77 @@
     psg.gb_shell = new GB_shell;
 
-    GBDATA *gb_main     = GB_open(name, "r");
+    GBDATA *gb_main     = GB_open(name, readOnly ? "r" : "rw");
     if (!gb_main) error = GB_await_error();
     else {
@@ -195 +195 @@
 }
 
-char *probe_read_alignment(int j, int *psize) {
+char *probe_input_data::read_alignment(int *psize) const {
     char           *buffer     = 0;
-    GBDATA         *gb_species = psg.data[j].gbd;
+    GBDATA         *gb_species = get_gbdata();
     GB_transaction  ta(gb_species);
     GBDATA         *gb_ali     = GB_entry(gb_species, psg.alignment_name);
@@ -206 +206 @@
     }
     return buffer;
+}
+
+char *probe_read_alignment(int j, int *psize) { 
+    return psg.data[j].read_alignment(psize);
+}
+
+GB_ERROR probe_input_data::init(GBDATA *gb_species) {
+    GB_ERROR  error   = NULL;
+    GBDATA   *gb_ali  = GB_entry(gb_species, psg.alignment_name);
+    GBDATA   *gb_data = gb_ali ? GB_entry(gb_ali, "data") : NULL;
+
+    if (!gb_data) {
+        error = GBS_global_string("Species '%s' has no data in '%s'\n", GBT_read_name(gb_species), psg.alignment_name);
+    }
+    else {
+        int   hsize;
+        char *sdata = probe_read_string_append_point(gb_data, &hsize);
+
+        if (!sdata) {
+            error = GBS_global_string("Could not read data in '%s' for species '%s'\n(Reason: %s)\n",
+                                      psg.alignment_name, GBT_read_name(gb_species), GB_await_error());
+        }
+        else {
+            name = strdup(GBT_read_name(gb_species));
+
+            fullname                = GBT_read_string(gb_species, "full_name");
+            if (!fullname) fullname = strdup("");
+
+            gbd   = gb_species;
+
+            set_checksum(GB_checksum(sdata, hsize, 1, ".-"));
+            int csize = probe_compress_sequence(sdata, hsize);
+
+            set_data(GB_memdup(sdata, csize), csize);
+            free(sdata);
+        }
+    }
+
+    return error;
 }
 
@@ -230 +269 @@
     int icount = GB_number_of_subentries(psg.gb_species_data);
     
-    psg.data       = (probe_input_data *)calloc(sizeof(probe_input_data), icount);
+    psg.data       = new probe_input_data[icount];
     psg.data_count = 0;
 
@@ -246 +285 @@
             probe_input_data& pid = psg.data[count];
 
-            pid.name     = strdup(GBT_read_name(gb_species));
-            pid.fullname = GBT_read_string(gb_species, "full_name");
-
-            if (!pid.fullname) pid.fullname = strdup("");
-
-            pid.is_group = 1;
-            pid.gbd      = gb_species;
-
-            GBDATA *gb_ali  = GB_entry(gb_species, psg.alignment_name);
-            GBDATA *gb_data = gb_ali ? GB_entry(gb_ali, "data") : NULL;
-            if (!gb_data) {
-                fprintf(stderr, "Species '%s' has no data in '%s'\n", pid.name, psg.alignment_name);
+            GB_ERROR error = pid.init(gb_species);
+            if (error) {
+                fputs(error, stderr);
+                fputc('\n', stderr);
                 data_missing++;
             }
             else {
-                int   hsize;
-                char *data = probe_read_string_append_point(gb_data, &hsize);
-
-                if (!data) {
-                    GB_ERROR error = GB_await_error();
-                    fprintf(stderr, "Could not read data in '%s' for species '%s'\n(Reason: %s)\n",
-                            psg.alignment_name, pid.name, error);
-                    data_missing++;
-                }
-                else {
-                    pid.checksum = GB_checksum(data, hsize, 1, ".-");
-                    int   size = probe_compress_sequence(data, hsize);
-
-                    pid.data = GB_memdup(data, size);
-                    pid.size = size;
-
-                    free(data);
-                    count++;
-                }
-                    
+                count++;
             }
             progress.inc();
@@ -306 +318 @@
     psg.namehash = GBS_create_hash(psg.data_count, GB_MIND_CASE);
     for (i=0; i<psg.data_count; i++) {
-        GBS_write_hash(psg.namehash, psg.data[i].name, i+1);
+        GBS_write_hash(psg.namehash, psg.data[i].get_name(), i+1);
     }
     unsigned int    max_size;
     max_size = 0;
     for (i = 0; i < psg.data_count; i++) {  // get max sequence len
-        max_size = std::max(max_size, (unsigned)(psg.data[i].size));
-        psg.char_count += psg.data[i].size;
+        max_size = std::max(max_size, (unsigned)(psg.data[i].get_size()));
+        psg.char_count += psg.data[i].get_size();
     }
     psg.max_size = max_size;

trunk/PROBE/PT_main.cxx

@@ -16 +16 @@
 
 #include <arbdbt.h>
+#include <arb_defs.h>
 #include <servercntrl.h>
 #include <server.h>
@@ -21 +22 @@
 #include <struct_man.h>
 #include <ut_valgrinded.h>
+#include <ptclean.h>
 
 #include <unistd.h>
@@ -42 +44 @@
 
 ARB_ERROR pt_init_main_struct(PT_main *, const char *filename) { // __ATTR__USERESULT
-    ARB_ERROR error = probe_read_data_base(filename);
+    ARB_ERROR error = probe_read_data_base(filename, true);
     if (!error) {
         GB_begin_transaction(psg.gb_main);
@@ -67 +69 @@
     // shutdown server
     aisc_server_shutdown(psg.com_so);
-    PT_exit(EXIT_SUCCESS); // never returns
-    return 0;
+    PT_exit();
+    exit(EXIT_SUCCESS);
 }
 
@@ -98 +100 @@
     if (psg_initialized) {
         if (psg.gb_main) {
-            int count = GB_number_of_subentries(psg.gb_species_data);
-            for (int i = 0; i < count; ++i) {
-                free(psg.data[i].data);
-                free(psg.data[i].name);
-                free(psg.data[i].fullname);
-            }
-            free(psg.data);
+            delete [] psg.data;
 
             GB_close(psg.gb_main);
@@ -131 +127 @@
 }
 
-void PT_exit(int exitcode) { // goes to header: __ATTR__NORETURN
+void PT_exit() { 
     // unique exit point to ensure cleanup
     if (aisc_main) destroy_PT_main(aisc_main);
     if (psg_initialized) PT_exit_psg();
     PTM_finally_free_all_mem();
-    exit(exitcode);
 }
 
@@ -220 +215 @@
             const char *map_str     = GB_read_char_pntr(map_ptr_str);
 
-            parse_names_into_gene_struct(map_str, all_gene_structs);
+            error = parse_names_into_gene_struct(map_str, all_gene_structs).deliver();
 
             // build indices :
@@ -309 +304 @@
             if (update_reason) {
                 printf("- updating postree (Reason: %s)", update_reason);
-                char *build_cmd  = GBS_global_string_copy("%s -build -D%s", exename, arbdb_name);
-                make_valgrinded_call(build_cmd);
-                error            = GB_system(build_cmd);
-                free(build_cmd);
+
+                const char *build_step[] = {
+                    "build_clean",
+                    "build_map",
+                    "build",
+                };
+
+                for (size_t s = 0; !error && s<ARRAY_ELEMS(build_step); s++) {
+                    if (s == 1 && !GB_supports_mapfile()) continue; // skip useless step 
+                    
+                    char *build_cmd = GBS_global_string_copy("%s -%s -D%s", exename, build_step[s], arbdb_name);
+                    make_valgrinded_call(build_cmd);
+                    error           = GB_system(build_cmd);
+                    free(build_cmd);
+                }
+
                 if (error) error = GBS_global_string("Failed to update postree (Reason: %s)", error.deliver());
             }
@@ -364 +371 @@
         char *pt_name = GBS_global_string_copy("%s.pt", params->db_server);
 
-        if (strcmp(command, "-build") == 0) {  // build command
+        if (strcmp(command, "-build_clean") == 0) {  // cleanup source DB
+            error = probe_read_data_base(params->db_server, false);
+            if (!error) {
+                pt_assert(psg.gb_main);
+                error = prepare_ptserver_database(psg.gb_main, PTSERVER);
+                if (!error) {
+                    const char *mode = "bf"; // save PT-server database withOUT! Fastload file
+                    error            = GB_save_as(psg.gb_main, params->db_server, mode);
+                }
+            }
+        }
+        else if (strcmp(command, "-build_map") == 0) {  // create a clean mapfile for source DB
+            if (GB_supports_mapfile()) {
+                error = probe_read_data_base(params->db_server, false);
+                if (!error) {
+                    pt_assert(psg.gb_main);
+                    const char *mode = "bfm"; // save PT-server database with Fastload file
+                    error            = GB_save_as(psg.gb_main, params->db_server, mode);
+                }
+            }
+            else {
+                error = "Invalid invocation of -build_map (your ARB version does not support mapfiles)";
+            }
+        }
+        else if (strcmp(command, "-build") == 0) {  // build command
             error = pt_init_main_struct(aisc_main, params->db_server);
             if (error) error = GBS_global_string("Gave up (Reason: %s)", error.deliver());
@@ -477 +508 @@
 
     free_arb_params(params);
-    PT_exit(exitcode);
-}
+    PT_exit();
+    return exitcode;
+}

trunk/PROBE/PT_match.cxx

@@ -67 +67 @@
             pos = matchLoc.rpos+psg.height;
             height = psg.height;
-            while ((base=probe[height]) && (ref = psg.data[matchLoc.name].data[pos])) {
+            while ((base=probe[height]) && (ref = psg.data[matchLoc.name].get_data()[pos])) {
                 if (ref == PT_N || base == PT_N) {
                     // @@@ Warning: dupped code also counts PT_QU as mismatch!
@@ -124 +124 @@
     int            base;
     int            error;
-    int            name, pos, rpos;
     PT_probematch *ml;
 
@@ -135 +134 @@
     }
     if (PT_read_type(pt) == PT_NT_LEAF) {
-        name = PT_read_name(psg.ptmain, pt);
-        pos  = PT_read_apos(psg.ptmain, pt);
-        rpos = PT_read_rpos(psg.ptmain, pt);
+        DataLoc loc(pt);
 
         // @@@ dupped code from PT_store_match_in::operator()
         ml = create_PT_probematch();
 
-        ml->name         = name;
-        ml->b_pos        = pos;
+        ml->name         = loc.name;
+        ml->b_pos        = loc.apos;
         ml->g_pos        = -1;
-        ml->rpos         = rpos;
+        ml->rpos         = loc.rpos;
         ml->mismatches   = psg.mismatches;
         ml->wmismatches  = psg.wmismatches;
@@ -158 +155 @@
         if (PT_read_type(pt) == PT_NT_CHAIN) {
             psg.probe = 0;
-            if (PT_forwhole_chain(psg.ptmain, pt, PT_store_match_in(locs))) {
+            if (PT_forwhole_chain(pt, PT_store_match_in(locs))) {
                 error = 1;
                 return 1;
@@ -165 +162 @@
         else {
             for (base = PT_QU; base< PT_B_MAX; base++) {
-                error = read_names_and_pos(locs, PT_read_son(psg.ptmain, pt, (PT_BASES)base));
+                error = read_names_and_pos(locs, PT_read_son(pt, (PT_BASES)base));
                 if (error) return error;
             }
@@ -197 +194 @@
     if (PT_read_type(pt) == PT_NT_NODE && probe[height]) {
         for (i=PT_N; i<PT_B_MAX; i++) {
-            if ((pthelp = PT_read_son(psg.ptmain, pt, (PT_BASES)i))) {
+            if ((pthelp = PT_read_son(pt, (PT_BASES)i))) {
                 new_N_mis = N_mismatches;
                 base = probe[height];
@@ -232 +229 @@
             // @@@ code here is duplicate of code in PT_store_match_in::operator()
 
-            pos  = PT_read_rpos(psg.ptmain, pt) + height;
-            name = PT_read_name(psg.ptmain, pt);
+            DataLoc loc(pt);
+            pos  = loc.rpos + height;
+            name = loc.name;
 
             // @@@ recursive use of strlen with constant result (argh!)
-            if (pos + (int)(strlen(probe+height)) >= psg.data[name].size)       // end of sequence
+            if (pos + (int)(strlen(probe+height)) >= psg.data[name].get_size())       // end of sequence
                 return 0;
 
             while ((base = probe[height])) {
-                i = psg.data[name].data[pos];
+                i = psg.data[name].get_data()[pos];
                 if (i == PT_N || base == PT_N || i == PT_QU || base == PT_QU) {
                     psg.N_mismatches = psg.N_mismatches + 1;
@@ -260 +258 @@
             psg.probe = probe;
             psg.height = height;
-            PT_forwhole_chain(psg.ptmain, pt, PT_store_match_in(locs)); // @@@ why ignore result
+            PT_forwhole_chain(pt, PT_store_match_in(locs)); // @@@ why ignore result
             return 0;
         }
@@ -444 +442 @@
     pt_build_pos_to_weight((PT_MATCH_TYPE)locs->sort_by, probestring);
 
-    if (psg.deep >= 0) {
-        get_info_about_probe(locs, probestring, psg.pt, 0, 0.0, 0, 0);
-    }
-    else {
-        ptnd_new_match(locs,    probestring);
-    }
+    pt_assert(psg.deep >= 0); // deep < 0 was used till [8011] to trigger "new match" (feature unused)
+    get_info_about_probe(locs, probestring, psg.pt, 0, 0.0, 0, 0);
+
     if (locs->pm_reversed) {
         psg.reversed = 1;
-        rev_pro = reverse_probe(probestring, 0);
+        rev_pro      = reverse_probe(probestring, 0);
         complement_probe(rev_pro, 0);
         freeset(locs->pm_csequence, psg.main_probe = strdup(rev_pro));
-        if (psg.deep >= 0) {
-            get_info_about_probe(locs, rev_pro, psg.pt, 0, 0.0, 0, 0);
-        }
-        else {
-            ptnd_new_match(locs,        rev_pro);
-        }
+        
+        get_info_about_probe(locs, rev_pro, psg.pt, 0, 0.0, 0, 0);
         free(rev_pro);
     }
@@ -564 +555 @@
          pr_pos--, al_pos--)
     {
-        if (!psg.data[ml->name].data[al_pos]) break;
-        ref[pr_pos] = psg.data[ml->name].data[al_pos];
+        if (!psg.data[ml->name].get_data()[al_pos]) break;
+        ref[pr_pos] = psg.data[ml->name].get_data()[al_pos];
     }
     ref[9] = '-';
@@ -572 +563 @@
 
     for (int pr_pos = 0, al_pos = ml->rpos;
-         pr_pos < pr_len && al_pos < psg.data[ml->name].size;
+         pr_pos < pr_len && al_pos < psg.data[ml->name].get_size();
          pr_pos++, al_pos++)
     {
         int a = ml->sequence[pr_pos];
-        int b = psg.data[ml->name].data[al_pos];
+        int b = psg.data[ml->name].get_data()[al_pos];
         if (a == b) {
             ref[pr_pos+10] = '=';
@@ -593 +584 @@
 
     for (int pr_pos = 0, al_pos = ml->rpos+pr_len;
-         pr_pos < 9 && al_pos < psg.data[ml->name].size;
+         pr_pos < 9 && al_pos < psg.data[ml->name].get_size();
          pr_pos++, al_pos++)
     {
-        ref[pr_pos+11+pr_len] = psg.data[ml->name].data[al_pos];
+        ref[pr_pos+11+pr_len] = psg.data[ml->name].get_data()[al_pos];
     }
     ref[10+pr_len] = '-';
@@ -684 +675 @@
 
     for (; ml; ml = ml->next) {
-        probe_input_data&  pid    = psg.data[ml->name];
-        GBDATA            *gb_pos = GB_entry(pid.gbd, "abspos");
-
-        if (gb_pos) {
-            long gene_pos  = GB_read_int(gb_pos);
-            ml->g_pos      = ml->b_pos;
-            ml->b_pos     += gene_pos;
+        long gene_pos = psg.data[ml->name].get_abspos();
+        if (gene_pos >= 0) {
+            ml->g_pos  = ml->b_pos;
+            ml->b_pos += gene_pos;
         }
         else {
             fprintf(stderr, "Error in gene-pt-server: gene w/o position info\n");
-            pt_assert(gb_pos);
+            pt_assert(0);
         }
     }
@@ -796 +784 @@
     for (i = 0; i < psg.data_count; i++)
     {
-        GBS_strcat(memfile, psg.data[i].name);
+        GBS_strcat(memfile, psg.data[i].get_name());
         GBS_chrcat(memfile, (char)1);
     }

trunk/PROBE/PT_new_design.cxx

@@ -54 +54 @@
     }
 }
-struct ptnd_loop_com {
+
+static struct ptnd_loop_com {
     PT_pdc        *pdc;
     PT_local      *locs;
     PT_probeparts *parts;
     int            mishits;
-    int            new_match; // match or design the probe: 1 match   0 design
     double         sum_bonds; // sum of bond of longest non mismatch string
     double         dt;     // sum of mismatches
@@ -193 +193 @@
         // count all mishits for a probe
 
-        // @@@ dupped code is in ptnd_count_mishits and ptnd_count_mishits2
         char *probe = psg.probe;
         psg.abs_pos.announce(probeLoc.apos);
@@ -199 +198 @@
         const probe_input_data& pid = psg.data[probeLoc.name];
 
-        if (pid.is_group) return 0;              // don't count group or neverminds
-        if (probe) {
-            int rpos = probeLoc.rpos + psg.height;
-            while (*probe && pid.data[rpos]) {
-                if (pid.data[rpos] != *(probe)) return 0;
-                probe++;
-                rpos++;
-            }
-        }
-        ptnd.mishits++;
+        if (pid.outside_group()) {
+            if (probe) {
+                int rpos = probeLoc.rpos + psg.height;
+                while (*probe && pid.get_data()[rpos]) {
+                    if (pid.get_data()[rpos] != *(probe)) return 0;
+                    probe++;
+                    rpos++;
+                }
+            }
+            ptnd.mishits++;
+        }
         return 0;
     }
@@ -215 +215 @@
 static int ptnd_count_mishits2(POS_TREE *pt) {
     //! go down the tree to chains and leafs; count the species that are in the non member group
-    int base;
-    int name;
-    int mishits = 0;
-
     if (pt == NULL)
         return 0;
+    
     if (PT_read_type(pt) == PT_NT_LEAF) {
-        name     = PT_read_name(psg.ptmain, pt);
-        int apos = PT_read_apos(psg.ptmain, pt);
-
-        // @@@ dupped code from ptnd_chain_count_mishits::operator():
-        psg.abs_pos.announce(apos);
-        if (!psg.data[name].is_group)   return 1;
-        return 0;
-    }
-    else if (PT_read_type(pt) == PT_NT_CHAIN) {
+        DataLoc loc(pt);
+        psg.abs_pos.announce(loc.apos);
+        return psg.data[loc.name].outside_group();
+    }
+    
+    if (PT_read_type(pt) == PT_NT_CHAIN) {
         psg.probe = 0;
         ptnd.mishits = 0;
-        PT_forwhole_chain(psg.ptmain, pt, ptnd_chain_count_mishits());
+        PT_forwhole_chain(pt, ptnd_chain_count_mishits());
         return ptnd.mishits;
     }
-    else {
-        for (base = PT_QU; base< PT_B_MAX; base++) {
-            mishits += ptnd_count_mishits2(PT_read_son(psg.ptmain, pt, (PT_BASES)base));
-        }
-        return mishits;
-    }
+    
+    int mishits = 0;
+    for (int base = PT_QU; base< PT_B_MAX; base++) {
+        mishits += ptnd_count_mishits2(PT_read_son(pt, (PT_BASES)base));
+    }
+    return mishits;
 }
 
@@ -409 +403 @@
 static int ptnd_count_mishits(char *probe, POS_TREE *pt, int height) {
     //! search down the tree to find matching species for the given probe
-    int       name;
     int       i;
     POS_TREE *pthelp;
-    int       pos;
     int       mishits;
 
@@ -420 +412 @@
         for (i=PT_A; i<PT_B_MAX; i++) {
             if (i != *probe) continue;
-            if ((pthelp = PT_read_son(psg.ptmain, pt, (PT_BASES)i)))
+            if ((pthelp = PT_read_son(pt, (PT_BASES)i)))
                 mishits += ptnd_count_mishits(probe+1, pthelp, height+1);
         }
@@ -427 +419 @@
     if (*probe) {
         if (PT_read_type(pt) == PT_NT_LEAF) {
-            pos  = PT_read_rpos(psg.ptmain, pt) + height;
-            name = PT_read_name(psg.ptmain, pt);
-
-            // @@@ dupped code from ptnd_chain_count_mishits::operator()
-            if (pos + (int)(strlen(probe)) >= psg.data[name].size)              // after end
+            const DataLoc loc(pt);
+            int           pos = loc.rpos+height;
+
+            if (pos + (int)(strlen(probe)) >= psg.data[loc.name].get_size())              // after end
                 return 0;
 
             while (*probe) {
-                if (psg.data[name].data[pos++] != *(probe++))
+                if (psg.data[loc.name].get_data()[pos++] != *(probe++))
                     return 0;
             }
@@ -443 +434 @@
             psg.height = height;
             ptnd.mishits = 0;
-            PT_forwhole_chain(psg.ptmain, pt, ptnd_chain_count_mishits());
+            PT_forwhole_chain(pt, ptnd_chain_count_mishits());
             return ptnd.mishits;
         }
@@ -482 +473 @@
 }
 
-static void ptnd_check_bonds(PT_pdc *pdc, int match) {
+static void ptnd_check_bonds(PT_pdc *pdc) {
     /*! check the average bond size.
      *
@@ -501 +492 @@
         tprobe->sum_bonds = sbond;
     }
-    match = match;
 }
 
@@ -628 +618 @@
 }
 
-static void ptnd_check_part_inc_dt(PT_pdc *pdc, PT_probeparts *parts,
-                                   const DataLoc& matchLoc,
-                                   double dt, double sum_bonds)
-{
+static void ptnd_check_part_inc_dt(PT_pdc *pdc, PT_probeparts *parts, const DataLoc& matchLoc, double dt, double sum_bonds) {
     //! test the probe parts, search the longest non mismatch string
 
@@ -649 +636 @@
         while (start>=0) {
             if (pos<0) break;   // out of sight
-            h = ptnd_check_split(ptnd.pdc, probe, start, psg.data[matchLoc.name].data[pos]);
+            h = ptnd_check_split(ptnd.pdc, probe, start, psg.data[matchLoc.name].get_data()[pos]);
             if (h>0.0 && !split)        return; // there is a longer part matching this
             dt -= h;
@@ -664 +651 @@
     if (pos >= PERC_SIZE) return; // out of observation
     tprobe->perc[pos] ++;
-    if (ptnd.new_match) {                       // save the result in probematch
-        PT_probematch *match;
-        if (psg.data[matchLoc.name].match) {
-            if (psg.data[matchLoc.name].match->dt < ndt) return;
-            // there is a better hit for that sequence
-            match = psg.data[matchLoc.name].match;
-        }
-        else {
-            match = create_PT_probematch();
-            aisc_link(&ptnd.locs->ppm, match);
-            psg.data[matchLoc.name].match = match;
-        }
-        match->name = matchLoc.name;
-        match->b_pos = matchLoc.apos - parts->start;     // that's not correct !!!
-        match->rpos = matchLoc.rpos-parts->start;
-        match->N_mismatches = -1;       // there are no mismatches in this mode
-        match->mismatches = -1;
-        match->wmismatches = dt;        // only weighted mismatches (maybe)
-        match->dt = ndt;
-        match->sequence = psg.main_probe;
-        match->reversed = psg.reversed;
-    }
 }
 static int ptnd_check_inc_mode(PT_pdc *pdc, PT_probeparts *parts, double dt, double sum_bonds)
@@ -705 +670 @@
     
     int operator() (const DataLoc& partLoc) {
-        char   *probe  = psg.probe;
-        int     height = psg.height;
-        double  sbond  = ptnd.sum_bonds;
-        double  dt     = ptnd.dt;
-        double  h      = 1.0;
-        int     pos;
-        int     base;
-
-        if (!ptnd.new_match && psg.data[partLoc.name].is_group) return 0;           // don't count group or neverminds
-        if (probe) {
-            pos = partLoc.rpos+psg.height;
-            while (probe[height] && (base = psg.data[partLoc.name].data[pos])) {
-                if (!split && (h = ptnd_check_split(ptnd.pdc, probe, height, base) < 0.0)) {
-                    dt -= h;
-                    split = 1;
+        if (psg.data[partLoc.name].outside_group()) {
+            char   *probe  = psg.probe;
+            int     height = psg.height;
+            double  sbond  = ptnd.sum_bonds;
+            double  dt     = ptnd.dt;
+            double  h      = 1.0;
+            int     pos;
+            int     base;
+
+            if (probe) {
+                pos = partLoc.rpos+psg.height;
+                while (probe[height] && (base = psg.data[partLoc.name].get_data()[pos])) {
+                    if (!split && (h = ptnd_check_split(ptnd.pdc, probe, height, base) < 0.0)) {
+                        dt -= h;
+                        split = 1;
+                    }
+                    else {
+                        dt += h;
+                        sbond += ptnd_check_max_bond(ptnd.pdc, probe[height]) - h;
+                    }
+                    height++; pos++;
                 }
-                else {
-                    dt += h;
-                    sbond += ptnd_check_max_bond(ptnd.pdc, probe[height]) - h;
-                }
-                height++; pos++;
-            }
-        }
-        ptnd_check_part_inc_dt(ptnd.pdc, ptnd.parts, partLoc, dt, sbond);
+            }
+            ptnd_check_part_inc_dt(ptnd.pdc, ptnd.parts, partLoc, dt, sbond);
+        }
         return 0;
     }
@@ -739 +705 @@
 
     int base;
-    int name, apos, rpos;
-
     if (pt == NULL)
         return;
     if (PT_read_type(pt) == PT_NT_LEAF) {
         // @@@ dupped code is in ptnd_chain_check_part::operator()
-        name = PT_read_name(psg.ptmain, pt);
-        if (!ptnd.new_match && psg.data[name].is_group) return;
-        rpos = PT_read_rpos(psg.ptmain, pt);
-        apos = PT_read_apos(psg.ptmain, pt);
-        ptnd_check_part_inc_dt(ptnd.pdc, ptnd.parts, DataLoc(name, apos, rpos), dt, sum_bonds);
+        DataLoc loc(pt);
+        if (psg.data[loc.name].outside_group()) {
+            ptnd_check_part_inc_dt(ptnd.pdc, ptnd.parts, loc, dt, sum_bonds);
+        }
     }
     else if (PT_read_type(pt) == PT_NT_CHAIN) {
@@ -755 +718 @@
         ptnd.dt = dt;
         ptnd.sum_bonds = sum_bonds;
-        PT_forwhole_chain(psg.ptmain, pt, ptnd_chain_check_part(0));
+        PT_forwhole_chain(pt, ptnd_chain_check_part(0));
     }
     else {
         for (base = PT_QU; base< PT_B_MAX; base++) {
-            ptnd_check_part_all(PT_read_son(psg.ptmain, pt, (PT_BASES)base), dt, sum_bonds);
+            ptnd_check_part_all(PT_read_son(pt, (PT_BASES)base), dt, sum_bonds);
         }
     }
@@ -765 +728 @@
 static void ptnd_check_part(char *probe, POS_TREE *pt, int  height, double dt, double sum_bonds, int split) {
     //! search down the tree to find matching species for the given probe
-    int       name;
+    int       pos;
     int       i;
     POS_TREE *pthelp;
-    int       rpos, apos, pos;
     double    ndt, nsum_bonds, h;
     int       nsplit;
@@ -778 +740 @@
         if (split && ptnd_check_inc_mode(ptnd.pdc, ptnd.parts, dt, sum_bonds)) return;
         for (i=PT_A; i<PT_B_MAX; i++) {
-            if ((pthelp = PT_read_son(psg.ptmain, pt, (PT_BASES)i)))
+            if ((pthelp = PT_read_son(pt, (PT_BASES)i)))
             {
                 nsplit = split;
@@ -810 +772 @@
         if (PT_read_type(pt) == PT_NT_LEAF) {
             // @@@ dupped code is in ptnd_chain_check_part::operator()
-            name = PT_read_name(psg.ptmain, pt);
-            if (!ptnd.new_match && psg.data[name].is_group)     return;
-            rpos = PT_read_rpos(psg.ptmain, pt);
-            apos = PT_read_apos(psg.ptmain, pt);
-            pos = rpos + height;
-            if (pos + (int)(strlen(probe+height)) >= psg.data[name].size)               // after end
-                return;
-            while (probe[height] && (ref = psg.data[name].data[pos])) {
-                if (split) {
-                    h = ptnd_check_split(ptnd.pdc, probe, height, ref);
-                    if (h<0.0) dt -= h; else dt += h;
-                } else if ((h = ptnd_check_split(ptnd.pdc, probe, height,
-                                                 ref)) < 0.0) {
-                    dt -= h;
-                    split = 1;
+            const DataLoc loc(pt);
+            if (psg.data[loc.name].outside_group()) {
+                pos = loc.rpos + height;
+                if (pos + (int)(strlen(probe+height)) >= psg.data[loc.name].get_size())               // after end
+                    return;
+                while (probe[height] && (ref = psg.data[loc.name].get_data()[pos])) {
+                    if (split) {
+                        h = ptnd_check_split(ptnd.pdc, probe, height, ref);
+                        if (h<0.0) dt -= h; else dt += h;
+                    }
+                    else if ((h = ptnd_check_split(ptnd.pdc, probe, height, ref)) < 0.0) {
+                        dt -= h;
+                        split = 1;
+                    }
+                    else {
+                        dt += h;
+                        sum_bonds += ptnd_check_max_bond(ptnd.pdc, probe[height]) - h;
+                    }
+                    height++; pos++;
                 }
-                else {
-                    dt += h;
-                    sum_bonds += ptnd_check_max_bond(ptnd.pdc, probe[height]) - h;
-                }
-                height++; pos++;
-            }
-            ptnd_check_part_inc_dt(ptnd.pdc, ptnd.parts, DataLoc(name, apos, rpos), dt, sum_bonds);
+                ptnd_check_part_inc_dt(ptnd.pdc, ptnd.parts, loc, dt, sum_bonds);
+            }
             return;
         }
@@ -840 +801 @@
             ptnd.dt = dt;
             ptnd.sum_bonds = sum_bonds;
-            PT_forwhole_chain(psg.ptmain, pt, ptnd_chain_check_part(split));
+            PT_forwhole_chain(pt, ptnd_chain_check_part(split));
             return;
         }
@@ -895 +856 @@
 }
 
-inline void PT_incr_hash(GB_HASH *hash, char *sequence, int len) {
+inline void PT_incr_hash(GB_HASH *hash, const char *sequence, int len) {
     char c        = sequence[len];
-    sequence[len] = 0;
+    const_cast<char*>(sequence)[len] = 0;
 
     pt_assert(strlen(sequence) == (size_t)len);
@@ -903 +864 @@
     GBS_incr_hash(hash, sequence);
 
-    sequence[len] = c;
-}
-
-static void ptnd_add_sequence_to_hash(PT_pdc *pdc, GB_HASH *hash, char *sequence, int seq_len, int probe_len, char *prefix, int prefix_len) {
+    const_cast<char*>(sequence)[len] = c;
+}
+
+static void ptnd_add_sequence_to_hash(PT_pdc *pdc, GB_HASH *hash, const char *sequence, int seq_len, int probe_len, char *prefix, int prefix_len) {
     int pos;
     if (*prefix) { // partition search, else very large hash tables (>60 mbytes)
@@ -946 +907 @@
         int used_idx = 0;
         for (int name = 0; name < psg.data_count; name++) {
-            if (psg.data[name].is_group == 1) {
+            if (psg.data[name].inside_group()) {
                 group_idx[used_idx++]                  = name; // store marked group indices
-                unsigned long size                     = psg.data[name].size;
+                unsigned long size                     = psg.data[name].get_size();
                 datasize                              += size;
                 if (datasize<size) datasize            = ULONG_MAX; // avoid overflow!
@@ -1002 +963 @@
         for (int g = 0; g<group_count; ++g) {
             int      name             = group_idx[g];
-            long     possible_tprobes = psg.data[name].size-pdc->probelen+1;
+            long     possible_tprobes = psg.data[name].get_size()-pdc->probelen+1;
             GB_HASH *hash_one         = GBS_create_hash(possible_tprobes*hash_multiply, GB_MIND_CASE); // count tprobe occurrences for one group/sequence
-            ptnd_add_sequence_to_hash(pdc, hash_one, psg.data[name].data, psg.data[name].size, pdc->probelen, partstring, partsize);
+            ptnd_add_sequence_to_hash(pdc, hash_one, psg.data[name].get_data(), psg.data[name].get_size(), pdc->probelen, partstring, partsize);
             GBS_hash_do_loop(hash_one, ptnd_collect_hash, hash_outer); // merge hash_one into hash
 #if defined(DEBUG)
@@ -1049 +1010 @@
     //  IDP probe design
 
-    PT_local *locs   = (PT_local*)pdc->mh.parent->parent;
-    ptnd.new_match   = 0;
-    ptnd.locs        = locs;
-    ptnd.pdc         = pdc;
+    PT_local *locs = (PT_local*)pdc->mh.parent->parent;
+
+    ptnd.locs = locs;
+    ptnd.pdc  = pdc;
 
     const char *error;
@@ -1083 +1044 @@
     ptnd_first_check(pdc);
     ptnd_check_position(pdc);
-    ptnd_check_bonds(pdc, ptnd.new_match);
+    ptnd_check_bonds(pdc);
     ptnd_cp_tprobe_2_probepart(pdc);
     ptnd_duplicate_probepart(pdc);
@@ -1097 +1058 @@
 }
 
-void ptnd_new_match(PT_local * locs, char *probestring)
-{
-    PT_pdc     *pdc = locs->pdc;
-    PT_tprobes *tprobe;
-
-    ptnd.locs      = locs;
-    ptnd.pdc       = pdc;
-    ptnd.new_match = 1;
-
-    if (!pdc) return; // no config
-
-    tprobe           = create_PT_tprobes();
-    tprobe->sequence = strdup(probestring);
-
-    aisc_link(&pdc->ptprobes, tprobe);
-    ptnd_check_bonds(pdc, ptnd.new_match);
-    ptnd_cp_tprobe_2_probepart(pdc);
-    ptnd_duplicate_probepart(pdc);
-    ptnd_sort_parts(pdc);
-    ptnd_remove_duplicated_probepart(pdc);
-    ptnd_check_probepart(pdc);
-
-    while (pdc->parts)                  destroy_PT_probeparts(pdc->parts);
-    while ((tprobe = pdc->tprobes))     destroy_PT_tprobes(tprobe);
-}

trunk/PROBE/PT_prefixtree.cxx

@@ -204 +204 @@
 }
 
-POS_TREE *PT_add_to_chain(PTM2 *ptmain, POS_TREE *node, int name, int apos, int rpos)   // stage1
-{                                           // insert at the beginning of list
-    static char buffer[100];
+POS_TREE *PT_add_to_chain(POS_TREE *node, const DataLoc& loc) { // stage1
+    // insert at the beginning of list
+
+    char *data  = (&node->data) + psg.ptmain->mode;
+    data       += (node->flags&1) ? 4 : 2;
+
     unsigned long old_first;
-    char *data;
-    int mainapos;                           // TODO: mainapos isn't used
-    data = (&node->data) + ptmain->mode;
-    if (node->flags&1) {
-        PT_READ_INT(data, mainapos);
-        data += 4;
-    }
-    else {
-        PT_READ_SHORT(data, mainapos);
-        data += 2;
-    }
     PT_READ_PNTR(data, old_first);  // create a new list element
-    char *p;
-    p = buffer;
+
+    static char  buffer[100];
+    char        *p = buffer;
+
     PT_WRITE_PNTR(p, old_first);
     p += sizeof(PT_PNTR);
-    PT_WRITE_NAT(p, name);
-    PT_WRITE_NAT(p, rpos);
-    PT_WRITE_NAT(p, apos);
+
+    PT_WRITE_NAT(p, loc.name);
+    PT_WRITE_NAT(p, loc.rpos);
+    PT_WRITE_NAT(p, loc.apos);
+    
     int size = p - buffer;
-    p = (char *)PTM_get_mem(size);
+    p        = (char *)PTM_get_mem(size);
     memcpy(p, buffer, size);
     PT_WRITE_PNTR(data, p);
@@ -235 +231 @@
 }
 
-
-POS_TREE *PT_change_leaf_to_node(PTM2 * /* ptmain */, POS_TREE *node) // stage 1
-{
+POS_TREE *PT_change_leaf_to_node(POS_TREE *node) { // stage 1
+    if (PT_GET_TYPE(node) != PT_NT_LEAF) PT_CORE;
+    
     long i;
-    POS_TREE *father, *new_elem;
-    if (PT_GET_TYPE(node) != PT_NT_LEAF) PT_CORE;
     PT_READ_PNTR((&node->data), i);
-    father=(POS_TREE *)i;
-    new_elem = (POS_TREE *)PTM_get_mem(PT_EMPTY_NODE_SIZE);
+
+    POS_TREE *father   = (POS_TREE *)i;
+    POS_TREE *new_elem = (POS_TREE *)PTM_get_mem(PT_EMPTY_NODE_SIZE);
     if (father) PT_change_father(father, node, new_elem);
     PTM_free_mem((char *)node, PT_LEAF_SIZE(node));
     PT_SET_TYPE(new_elem, PT_NT_NODE, 0);
     PT_WRITE_PNTR((&(new_elem->data)), (long)father);
+
     return new_elem;
 }
 
-POS_TREE *PT_leaf_to_chain(PTM2 *ptmain, POS_TREE *node)        // stage 1
-{
+POS_TREE *PT_leaf_to_chain(POS_TREE *node) { // stage 1
+    if (PT_GET_TYPE(node) != PT_NT_LEAF) PT_CORE;
+
     long i;
-    int apos, rpos, name;
-    POS_TREE *father, *new_elem;
-    int chain_size;
-    char    *data;
-    if (PT_GET_TYPE(node) != PT_NT_LEAF) PT_CORE;
     PT_READ_PNTR((&node->data), i);
-    father=(POS_TREE *)i;
-    name = PT_read_name(ptmain, node);                          // backup name,
-    apos = PT_read_apos(ptmain, node);                          //        apos,
-    rpos = PT_read_rpos(ptmain, node);                          //        rpos
-    chain_size = PT_EMPTY_CHAIN_SIZE;
-    if (apos>PT_SHORT_SIZE) chain_size+=2;
-
-    new_elem = (POS_TREE *)PTM_get_mem(chain_size);
+
+    POS_TREE      *father = (POS_TREE *)i;
+    const DataLoc  loc(node);
+
+    int chain_size                          = PT_EMPTY_CHAIN_SIZE;
+    if (loc.apos>PT_SHORT_SIZE) chain_size += 2;
+
+    POS_TREE *new_elem = (POS_TREE *)PTM_get_mem(chain_size);
     PT_change_father(father, node, new_elem);
     PTM_free_mem((char *)node, PT_LEAF_SIZE(node));
     PT_SET_TYPE(new_elem, PT_NT_CHAIN, 0);
-    PT_WRITE_PNTR((&new_elem->data), (long)father);             // father
-    data = (&new_elem->data)+sizeof(PT_PNTR);
-    if (apos>PT_SHORT_SIZE) {                                   // mainapos
-        PT_WRITE_INT(data, apos);                               // .
-        data+=4; new_elem->flags|=1;                            // .
-    }
-    else {                                                      // .
-        PT_WRITE_SHORT(data, apos);                             // .
-        data+=2;                                                // .
-    }
-    PT_WRITE_PNTR(data, NULL);                                  // first element
-    PT_add_to_chain(ptmain, new_elem, name, apos, rpos);
+    PT_WRITE_PNTR((&new_elem->data), (long)father);
+    
+    char *data = (&new_elem->data)+sizeof(PT_PNTR);
+    if (loc.apos>PT_SHORT_SIZE) {                                   
+        PT_WRITE_INT(data, loc.apos);                               
+        data+=4;
+        new_elem->flags|=1;
+    }
+    else {                                                      
+        PT_WRITE_SHORT(data, loc.apos);
+        data+=2;
+    }
+    PT_WRITE_PNTR(data, NULL);
+    PT_add_to_chain(new_elem, loc);
+
     return new_elem;
 }
 
-POS_TREE       *
-PT_create_leaf(PTM2 *ptmain, POS_TREE ** pfather, PT_BASES base, int rpos, int apos, int name)  // stage 1
-{
-    POS_TREE       *father, *node, *new_elemfather;
-    int             base2;
-    int     leafsize;
-    char        *dest;
+POS_TREE *PT_create_leaf(POS_TREE ** pfather, PT_BASES base, const DataLoc& loc) { // stage 1
+    POS_TREE *father, *node, *new_elemfather;
+    int       base2;
+    int       leafsize;
+    char     *dest;
     leafsize = PT_EMPTY_LEAF_SIZE;
-    if (rpos>PT_SHORT_SIZE) leafsize+=2;
-    if (apos>PT_SHORT_SIZE) leafsize+=2;
-    if (name>PT_SHORT_SIZE) leafsize+=2;
-    node = (POS_TREE *) PTM_get_mem(leafsize);
+
+    if (loc.rpos>PT_SHORT_SIZE) leafsize += 2;
+    if (loc.apos>PT_SHORT_SIZE) leafsize += 2;
+    if (loc.name>PT_SHORT_SIZE) leafsize += 2;
+    node                              = (POS_TREE *) PTM_get_mem(leafsize);
     if (base >= PT_B_MAX)
-        *(int *) 0 = 0;
+        *(int *) 0                    = 0;
     if (pfather) {
         int             oldfathersize;
@@ -341 +335 @@
     PT_SET_TYPE(node, PT_NT_LEAF, 0);
     dest = (&node->data) + sizeof(PT_PNTR);
-    if (name>PT_SHORT_SIZE) {
-        PT_WRITE_INT(dest, name);
+    if (loc.name>PT_SHORT_SIZE) {
+        PT_WRITE_INT(dest, loc.name);
         node->flags |= 1;
         dest += 4;
     }
     else {
-        PT_WRITE_SHORT(dest, name);
+        PT_WRITE_SHORT(dest, loc.name);
         dest += 2;
     }
-    if (rpos>PT_SHORT_SIZE) {
-        PT_WRITE_INT(dest, rpos);
+    if (loc.rpos>PT_SHORT_SIZE) {
+        PT_WRITE_INT(dest, loc.rpos);
         node->flags |= 2;
         dest += 4;
     }
     else {
-        PT_WRITE_SHORT(dest, rpos);
+        PT_WRITE_SHORT(dest, loc.rpos);
         dest += 2;
     }
-    if (apos>PT_SHORT_SIZE) {
-        PT_WRITE_INT(dest, apos);
+    if (loc.apos>PT_SHORT_SIZE) {
+        PT_WRITE_INT(dest, loc.apos);
         node->flags |= 4;
         dest += 4;
     }
     else {
-        PT_WRITE_SHORT(dest, apos);
+        PT_WRITE_SHORT(dest, loc.apos);
         dest += 2;
     }
     if (base == PT_QU)
-        return PT_leaf_to_chain(ptmain, node);
+        return PT_leaf_to_chain(node);
     return node;
 }
-
 
 // ------------------------------------
 //      functions for stage 1: save
 
-void PTD_clear_fathers(PTM2 *ptmain, POS_TREE * node)       // stage 1
-{
-    POS_TREE       *sons;
-    int i;
-    PT_NODE_TYPE    type = PT_read_type(node);
-    if (type == PT_NT_SAVED) return;
-    PT_WRITE_PNTR((&node->data), NULL);
-    if (type == PT_NT_NODE) {
-        for (i = PT_QU; i < PT_B_MAX; i++) {
-            sons = PT_read_son(ptmain, node, (PT_BASES)i);
-            if (sons)
-                PTD_clear_fathers(ptmain, sons);
+void PTD_clear_fathers(POS_TREE * node) { // stage 1
+    PT_NODE_TYPE type = PT_read_type(node);
+    if (type != PT_NT_SAVED) {
+        PT_WRITE_PNTR((&node->data), NULL);
+        if (type == PT_NT_NODE) {
+            for (int i = PT_QU; i < PT_B_MAX; i++) {
+                POS_TREE *sons = PT_read_son(node, (PT_BASES)i);
+                if (sons) PTD_clear_fathers(sons);
+            }
         }
     }
@@ -445 +435 @@
 }
 
-long PTD_write_tip_to_disk(FILE * out, PTM2 * /* ptmain */, POS_TREE * node, long pos)
+long PTD_write_tip_to_disk(FILE * out, POS_TREE * node, long pos)
 {
     int size, cnt;
@@ -490 +480 @@
 }
 
-ARB_ERROR ptd_write_chain_entries(FILE * out, long *ppos, PTM2 * /* ptmain */, char ** entry_tab,  int n_entries, int mainapos) { // __ATTR__USERESULT
+ARB_ERROR ptd_write_chain_entries(FILE * out, long *ppos, char ** entry_tab,  int n_entries, int mainapos) { // __ATTR__USERESULT
     ARB_ERROR   error;
     int         lastname = 0;
@@ -530 +520 @@
 
 
-long PTD_write_chain_to_disk(FILE * out, PTM2 *ptmain, POS_TREE * node, long pos, ARB_ERROR& error) {
+long PTD_write_chain_to_disk(FILE * out, POS_TREE * node, long pos, ARB_ERROR& error) {
     char *data;
     long oldpos = pos;
@@ -536 +526 @@
     pos++;
     int mainapos;
-    data = (&node->data) + ptmain->mode;
+    data = (&node->data) + psg.ptmain->mode;
 
     if (node->flags&1) {
@@ -556 +546 @@
         char **entry_tab = (char **)GB_calloc(sizeof(char *), n_entries);
         ptd_set_chain_references((char *)first_entry, entry_tab);
-        error = ptd_write_chain_entries(out, &pos, ptmain, entry_tab, n_entries, mainapos);
+        error = ptd_write_chain_entries(out, &pos, entry_tab, n_entries, mainapos);
         free(entry_tab);
     }
@@ -593 +583 @@
 }
 
-long PTD_write_node_to_disk(FILE * out, PTM2 *ptmain, POS_TREE * node, long *r_poss, long pos) {
+long PTD_write_node_to_disk(FILE * out, POS_TREE * node, long *r_poss, long pos) {
     int i, size;   // Save node after all descendends are already saved
     POS_TREE *sons;
@@ -606 +596 @@
 
     for (i = PT_QU; i < PT_B_MAX; i++) {    // free all sons
-        sons = PT_read_son(ptmain, node, (PT_BASES)i);
+        sons = PT_read_son(node, (PT_BASES)i);
         if (sons) {
             int memsize;
@@ -759 +749 @@
 }
 
-long PTD_write_leafs_to_disk(FILE * out, PTM2 *ptmain, POS_TREE * node, long pos, long *pnodepos, int *pblock, ARB_ERROR& error) {
+long PTD_write_leafs_to_disk(FILE * out, POS_TREE * node, long pos, long *pnodepos, int *pblock, ARB_ERROR& error) {
     // returns new pos when son is written 0 otherwise
     // pnodepos is set to last object
@@ -778 +768 @@
     else if (type == PT_NT_LEAF) {
         *pnodepos = pos;
-        pos = PTD_write_tip_to_disk(out, ptmain, node, pos);
+        pos = PTD_write_tip_to_disk(out, node, pos);
     }
     else if (type == PT_NT_CHAIN) {
         *pnodepos = pos;
-        pos = PTD_write_chain_to_disk(out, ptmain, node, pos, error);
+        pos = PTD_write_chain_to_disk(out, node, pos, error);
     }
     else if (type == PT_NT_NODE) {
@@ -788 +778 @@
         o_pos = pos;
         for (i = PT_QU; i < PT_B_MAX && !error; i++) {    // save all sons
-            sons = PT_read_son(ptmain, node, (PT_BASES)i);
+            sons = PT_read_son(node, (PT_BASES)i);
             r_poss[i] = 0;
             if (sons) {
-                r_pos = PTD_write_leafs_to_disk(out, ptmain, sons, pos, &(r_poss[i]), &(block[0]), error);
+                r_pos = PTD_write_leafs_to_disk(out, sons, pos, &(r_poss[i]), &(block[0]), error);
                 if (r_pos>pos) {        // really saved ????
                     son_size[i] = r_pos-pos;
@@ -813 +803 @@
         else {          // now i can write my data
             *pnodepos = pos;
-            if (!error) pos = PTD_write_node_to_disk(out, ptmain, node, r_poss, pos);
+            if (!error) pos = PTD_write_node_to_disk(out, node, r_poss, pos);
         }
     }
@@ -824 +814 @@
 
 
-ARB_ERROR PTD_read_leafs_from_disk(const char *fname, PTM2 *ptmain, POS_TREE **pnode) { // __ATTR__USERESULT
+ARB_ERROR PTD_read_leafs_from_disk(const char *fname, POS_TREE **pnode) { // __ATTR__USERESULT
     GB_ERROR  error  = NULL;
     char     *buffer = GB_map_file(fname, 0);
@@ -892 +882 @@
             pt_assert(i >= 0);
 
-            *pnode             = (POS_TREE *)(i+buffer);
-            ptmain->mode       = 0;
-            ptmain->data_start = buffer;
+            *pnode = (POS_TREE *)(i+buffer);
+
+            psg.ptmain->mode       = 0;
+            psg.ptmain->data_start = buffer;
         }
     }

trunk/PROBE/needs_libs

@@ -4 +4 @@
 SERVERCNTRL/SERVERCNTRL.a
 SL/HELIX/HELIX.a
+SL/PTCLEAN/PTCLEAN.a
 

trunk/PROBE/probe.h

@@ -50 +50 @@
 #define FINDANSWER   52                             // private msg type: find result answer
 
+extern int gene_flag;           // if 'gene_flag' == 1 -> we are a gene pt server
 extern ULONG physical_memory;
 struct Hs_struct;
@@ -100 +101 @@
 //      Probe search
 
-struct probe_statistic {
-    int    match_count;                             // Counter for matches
-    double rel_match_count;                         // match_count / (seq_len - probe_len + 1)
-};
-
-struct probe_input_data {                           // every taxa's own data
-    char   *data;                                   // sequence
-    long    checksum;
-    int     size;
+class probe_input_data : virtual Noncopyable {      // every taxa's own data
+
+    char *data;       // sequence
+    long  checksum;   // checksum of sequence
+    int   size;
+
     char   *name;
     char   *fullname;
     GBDATA *gbd;
 
-    // probe design
-    int is_group;                                   // -1: nevermind, 0: no group, 1: group
-
-    // probe design (match)
-    PT_probematch *match;                           // best hit for PT_new_design
-
-    // find family
-    probe_statistic stat;
-
-    int next;
+    bool group;           // probe_design: whether species is in group
+
+    // obsolete methods below @@@ remove them
+    GBDATA *get_gbdata() const { return gbd; }
+    void set_data(char *assign, int size_) { pt_assert(!data); data = assign; size = size_; }
+    void set_checksum(long cs) { checksum = cs; }
+    
+public:
+
+    probe_input_data()
+        : data(0),
+          checksum(0), 
+          size(0), 
+          name(0), 
+          fullname(0), 
+          gbd(0), 
+          group(false) 
+    {}
+    ~probe_input_data() {
+        free(data);
+        free(name);
+        free(fullname);
+    }
+
+    GB_ERROR init(GBDATA *gbd_);
+
+    const char *get_data() const { return data; }
+    char *read_alignment(int *psize) const;
+
+    const char *get_name() const { return name; }
+    const char *get_fullname() const { return fullname; }
+    long get_checksum() const { return checksum; }
+    int get_size() const { return size; }
+
+    bool inside_group() const { return group; }
+    bool outside_group() const { return !group; }
+
+    void set_group_state(bool isGroupMember) { group = isGroupMember; }
+
+    long get_abspos() const {
+        pt_assert(gene_flag); // only legal in gene-ptserver
+        GBDATA *gb_pos = GB_entry(get_gbdata(), "abspos");
+        if (gb_pos) return GB_read_int(gb_pos);
+        return -1;
+    }
+
+private:
 };
 
@@ -198 +233 @@
     GB_HASH  *namehash;                             // name to int
 
+    int                      data_count;
     struct probe_input_data *data;                  // the internal database
 
@@ -203 +239 @@
     BI_ecoli_ref *bi_ecoli;
 
-    int  data_count;
     int  max_size;                                  // maximum sequence len
     long char_count;                                // number of all 'acgtuACGTU'
@@ -284 +319 @@
 };
 
-extern int gene_flag;           // if 'gene_flag' == 1 -> we are a gene pt server
-
 struct ltByArbName {
     bool operator()(const gene_struct *gs1, const gene_struct *gs2) const {
@@ -313 +346 @@
 #error probe.h included twice
 #endif
+
+

trunk/PROBE/probe_tree.h

@@ -411 +411 @@
 // calculate the index of the pointer in a node
 
-inline POS_TREE *PT_read_son(PTM2 *ptmain, POS_TREE *node, PT_BASES base)
+inline POS_TREE *PT_read_son(POS_TREE *node, PT_BASES base)
 {
-    long i;
-    UINT sec;
-    UINT offset;
+    long  i;
+    UINT  sec;
+    UINT  offset;
+    PTM2 *ptmain = psg.ptmain;
     if (ptmain->stage3) {       // stage 3  no father
         if (node->flags & IS_SINGLE_BRANCH_NODE) {
@@ -503 +504 @@
 }
 
-inline POS_TREE *PT_read_son_stage_1(PTM2 *ptmain, POS_TREE *node, PT_BASES base)
-{
-    long i;
+inline POS_TREE *PT_read_son_stage_1(POS_TREE *node, PT_BASES base) {
     if (!((1<<base) & node->flags)) return NULL;   // bit not set
     base = (PT_BASES)PT_count_bits[base][node->flags];
-    PT_READ_PNTR((&node->data)+sizeof(PT_PNTR)*base+ptmain->mode, i);
-    return (POS_TREE *)(i+ptmain->data_start); // ptmain->data_start == 0x00 in stage 1
+    long i;
+    PT_READ_PNTR((&node->data)+sizeof(PT_PNTR)*base+psg.ptmain->mode, i);
+    return (POS_TREE *)(i+psg.ptmain->data_start); // psg.ptmain->data_start == 0x00 in stage 1
 }
 
@@ -517 +517 @@
 }
 
-inline int PT_read_name(PTM2 *ptmain, POS_TREE *node)
-{
-    int i;
-    if (node->flags&1) {
-        PT_READ_INT((&node->data)+ptmain->mode, i);
-    }
-    else {
-        PT_READ_SHORT((&node->data)+ptmain->mode, i);
-    }
-    pt_assert(i >= 0);
-    return i;
-}
-
-inline int PT_read_rpos(PTM2 *ptmain, POS_TREE *node)
-{
-    int i;
-    char *data = (&node->data)+2+ptmain->mode;
-    if (node->flags&1) data+=2;
-    if (node->flags&2) {
-        PT_READ_INT(data, i);
-    }
-    else {
-        PT_READ_SHORT(data, i);
-    }
-    pt_assert(i >= 0);
-    return i;
-}
-
-inline int PT_read_apos(PTM2 *ptmain, POS_TREE *node)
-{
-    int i;
-    char *data = (&node->data)+ptmain->mode+4;  // father 4 name 2 rpos 2
-    if (node->flags&1) data+=2;
-    if (node->flags&2) data+=2;
-    if (node->flags&4) {
-        PT_READ_INT(data, i);
-    }
-    else {
-        PT_READ_SHORT(data, i);
-    }
-    pt_assert(i >= 0);
-    return i;
-}
-
 struct DataLoc {
-    int name;
+    int name; // index into psg.data[], aka as species id
     int apos;
-    int rpos;
+    int rpos; // position in data
 
     void init(const char ** data, int pos) {
         *data = PT_READ_CHAIN_ENTRY(*data, pos, &name, &apos, &rpos);
     }
-    void init(PTM2 *ptmain, POS_TREE *pt) {
-        pt_assert(PT_read_type(pt) == PT_NT_LEAF);
-
-        name = PT_read_name(ptmain, pt);
-        apos = PT_read_apos(ptmain, pt);
-        rpos = PT_read_rpos(ptmain, pt);
+    void init(POS_TREE *node) {
+        pt_assert(PT_read_type(node) == PT_NT_LEAF);
+        char *data = (&node->data)+psg.ptmain->mode;
+        if (node->flags&1) { PT_READ_INT(data, name); data += 4; } else { PT_READ_SHORT(data, name); data += 2; }
+        if (node->flags&2) { PT_READ_INT(data, rpos); data += 4; } else { PT_READ_SHORT(data, rpos); data += 2; }
+        if (node->flags&4) { PT_READ_INT(data, apos); data += 4; } else { PT_READ_SHORT(data, apos); data += 2; }
+
+        pt_assert(name >= 0);
+        pt_assert(apos >= 0);
+        pt_assert(rpos >= 0);
     }
 
     DataLoc(int name_, int apos_, int rpos_) : name(name_), apos(apos_), rpos(rpos_) {}
-    DataLoc(const char ** data, int pos) {
-        name = 0;
-        init(data, pos);
-    }
-    DataLoc(PTM2 *ptmain, POS_TREE *pt) {
-        init(ptmain, pt);
-    }
+    DataLoc(POS_TREE *pt) { init(pt); }
+    DataLoc(const char ** data, int pos) { name = 0; init(data, pos); }
+
+    const probe_input_data& get_pid() const { pt_assert(name >= 0 && name<psg.data_count); return psg.data[name]; }
+    const char *get_data() const { return get_pid().get_data(); }
+    PT_BASES operator[](int offset) const { return PT_BASES(get_data()[rpos+offset]); }
+
+    int restlength() const { return get_pid().get_size()-rpos; }
+    bool is_shorther_than(int offset) const { return offset >= restlength(); }
 
 #if defined(DEBUG)
     void dump(FILE *fp) const {
-        fprintf(fp, "          apos=%6i  rpos=%6i  name=%6i='%s'\n", apos, rpos, name, psg.data[name].name);
+        fprintf(fp, "          apos=%6i  rpos=%6i  name=%6i='%s'\n", apos, rpos, name, psg.data[name].get_name());
         fflush(fp);
     }
@@ -595 +557 @@
 
 template<typename T>
-int PT_forwhole_chain(PTM2 *ptmain, POS_TREE *node, T func) {
+int PT_forwhole_chain(POS_TREE *node, T func) {
     pt_assert(PT_read_type(node) == PT_NT_CHAIN);
 
-    const char *data = (&node->data) + ptmain->mode;
+    const char *data = (&node->data) + psg.ptmain->mode;
     int         pos;
 
@@ -621 +583 @@
 
 template<typename T>
-int PT_withall_tips(PTM2 *ptmain, POS_TREE *node, T func) {
+int PT_withall_tips(POS_TREE *node, T func) {
     // like PT_forwhole_chain, but also can handle leafs
     PT_NODE_TYPE type = PT_read_type(node);
     if (type == PT_NT_LEAF) {
-        return func(DataLoc(ptmain, node));
+        return func(DataLoc(node));
     }
 
     pt_assert(type == PT_NT_CHAIN);
-    return PT_forwhole_chain(ptmain, node, func);
+    return PT_forwhole_chain(node, func);
 }
 

trunk/PROBE/pt_prototypes.h

@@ -13 +13 @@
 
 /* PT_buildtree.cxx */
-POS_TREE *build_pos_tree(POS_TREE *pt, int anfangs_pos, int apos, int RNS_nr, unsigned int end);
-long PTD_save_partial_tree(FILE *out, PTM2 *ptmain, POS_TREE *node, char *partstring, int partsize, long pos, long *ppos, ARB_ERROR &error);
+
+ class DataLoc;
+
+long PTD_save_partial_tree(FILE *out, POS_TREE *node, char *partstring, int partsize, long pos, long *ppos, ARB_ERROR &error);
 ARB_ERROR enter_stage_1_build_tree(PT_main *, char *tname) __ATTR__USERESULT;
 ARB_ERROR enter_stage_3_load_tree(PT_main *, const char *tname) __ATTR__USERESULT;
@@ -40 +42 @@
 int compress_data(char *probestring);
 void PT_base_2_string(char *id_string, long len);
-ARB_ERROR probe_read_data_base(const char *name) __ATTR__USERESULT;
+ARB_ERROR probe_read_data_base(const char *name, bool readOnly) __ATTR__USERESULT;
 int probe_compress_sequence(char *seq, int seqsize);
 char *probe_read_alignment(int j, int *psize);
@@ -53 +55 @@
 void PT_init_psg(void);
 void PT_exit_psg(void);
-void PT_exit(int exitcode) __ATTR__NORETURN;
+void PT_exit(void);
 GB_ERROR PT_init_map(void) __ATTR__USERESULT;
 
@@ -76 +78 @@
 char *get_design_hinfo(PT_tprobes *tprobe);
 int PT_start_design(PT_pdc *pdc, int dummy_1x);
-void ptnd_new_match(PT_local *locs, char *probestring);
 
 /* PT_prefixtree.cxx */
@@ -88 +89 @@
 PTM2 *PT_init(void);
 void PT_change_father(POS_TREE *father, POS_TREE *source, POS_TREE *dest);
-POS_TREE *PT_add_to_chain(PTM2 *ptmain, POS_TREE *node, int name, int apos, int rpos);
-POS_TREE *PT_change_leaf_to_node(PTM2 *, POS_TREE *node);
-POS_TREE *PT_leaf_to_chain(PTM2 *ptmain, POS_TREE *node);
-POS_TREE *PT_create_leaf(PTM2 *ptmain, POS_TREE **pfather, PT_BASES base, int rpos, int apos, int name);
-void PTD_clear_fathers(PTM2 *ptmain, POS_TREE *node);
+POS_TREE *PT_add_to_chain(POS_TREE *node, const DataLoc &loc);
+POS_TREE *PT_change_leaf_to_node(POS_TREE *node);
+POS_TREE *PT_leaf_to_chain(POS_TREE *node);
+POS_TREE *PT_create_leaf(POS_TREE **pfather, PT_BASES base, const DataLoc &loc);
+void PTD_clear_fathers(POS_TREE *node);
 void PTD_put_longlong(FILE *out, ULONG i);
 void PTD_put_int(FILE *out, ULONG i);
 void PTD_put_short(FILE *out, ULONG i);
 void PTD_set_object_to_saved_status(POS_TREE *node, long pos, int size);
-long PTD_write_tip_to_disk(FILE *out, PTM2 *, POS_TREE *node, long pos);
+long PTD_write_tip_to_disk(FILE *out, POS_TREE *node, long pos);
 int ptd_count_chain_entries(char *entry);
 void ptd_set_chain_references(char *entry, char **entry_tab);
-ARB_ERROR ptd_write_chain_entries(FILE *out, long *ppos, PTM2 *, char **entry_tab, int n_entries, int mainapos) __ATTR__USERESULT;
-long PTD_write_chain_to_disk(FILE *out, PTM2 *ptmain, POS_TREE *node, long pos, ARB_ERROR &error);
+ARB_ERROR ptd_write_chain_entries(FILE *out, long *ppos, char **entry_tab, int n_entries, int mainapos) __ATTR__USERESULT;
+long PTD_write_chain_to_disk(FILE *out, POS_TREE *node, long pos, ARB_ERROR &error);
 void PTD_debug_nodes(void);
-long PTD_write_node_to_disk(FILE *out, PTM2 *ptmain, POS_TREE *node, long *r_poss, long pos);
-long PTD_write_leafs_to_disk(FILE *out, PTM2 *ptmain, POS_TREE *node, long pos, long *pnodepos, int *pblock, ARB_ERROR &error);
-ARB_ERROR PTD_read_leafs_from_disk(const char *fname, PTM2 *ptmain, POS_TREE **pnode) __ATTR__USERESULT;
+long PTD_write_node_to_disk(FILE *out, POS_TREE *node, long *r_poss, long pos);
+long PTD_write_leafs_to_disk(FILE *out, POS_TREE *node, long pos, long *pnodepos, int *pblock, ARB_ERROR &error);
+ARB_ERROR PTD_read_leafs_from_disk(const char *fname, POS_TREE **pnode) __ATTR__USERESULT;
 
 /* PT_debug.cxx */
@@ -113 +114 @@
 
 /* probe_tree.h */
-template <typename T >int PT_forwhole_chain(PTM2 *ptmain, POS_TREE *node, T func);
-template <typename T >int PT_withall_tips(PTM2 *ptmain, POS_TREE *node, T func);
+template <typename T >int PT_forwhole_chain(POS_TREE *node, T func);
+template <typename T >int PT_withall_tips(POS_TREE *node, T func);
 
 #else

trunk/SERVERCNTRL/servercntrl.cxx

@@ -153 +153 @@
 
             if (!error) {
-#if defined(DEBUG)
-                printf("Starting server (cmd='%s')\n", command);
-#endif // DEBUG
+                printf("[Starting server (cmd='%s')]\n", command);
                 if (!gbmain || GBCMC_system(gbmain, command)) system(command);
                 if (do_sleep) sleep(delay);

trunk/SL/Makefile

@@ -1 +1 @@
 
 ARCHS_ALL = \
+        PTCLEAN/PTCLEAN.dummy  \
         ALIVIEW/ALIVIEW.dummy  \
         AP_TREE/AP_TREE.dummy  \

trunk/SL/PTCLEAN/Makefile

@@ -33 +33 @@
 ptclean.o: ptclean.h
 ptclean.o: $(ARBHOME)/INCLUDE/ad_prot.h
+ptclean.o: $(ARBHOME)/INCLUDE/ad_t_prot.h
 ptclean.o: $(ARBHOME)/INCLUDE/arb_assert.h
 ptclean.o: $(ARBHOME)/INCLUDE/arb_core.h
@@ -40 +41 @@
 ptclean.o: $(ARBHOME)/INCLUDE/arbdb.h
 ptclean.o: $(ARBHOME)/INCLUDE/arbdb_base.h
+ptclean.o: $(ARBHOME)/INCLUDE/arbdbt.h
 ptclean.o: $(ARBHOME)/INCLUDE/arbtools.h
 ptclean.o: $(ARBHOME)/INCLUDE/attributes.h

trunk/SL/PTCLEAN/ptclean.cxx

@@ -11 +11 @@
 
 #include "ptclean.h"
-#include <arbdb.h>
+#include <arbdbt.h>
+
+#define pt_assert(cond) arb_assert(cond)
 
 // using namespace std;
 
-GB_ERROR clean_ptserver_database(GBDATA *gb_main, Servertype type) {
-    fprintf(stderr, "********* clean_ptserver_database does not delete anything yet\n");
-    // return "test-error";
-    return NULL;
+class EntryTempMarker : virtual Noncopyable {
+    // marks all entries of DB as 'temp', that are of no use for PTSERVER
+    // (Note: 'temp' entries will not be saved)
+
+    GBDATA         *gb_main;
+    GB_transaction  ta;
+    Servertype      type;
+    char           *ali_name;
+
+    enum Need {
+        NONE,
+        ALL,
+        SOME_OF_ROOT,
+        SOME_OF_PRESETS,
+        SOME_OF_SPECIES_DATA,
+        SOME_OF_EXTENDED_DATA,
+        SOME_OF_SPECIES,
+        SOME_OF_EXTENDED,
+        SOME_OF_ALI_CONTAINER, // below species or SAI
+    };
+
+    Need data_needed(GBDATA *gbd, const char *keyname, Need from) const {
+        switch (from) {
+            case SOME_OF_ROOT:
+                if (strcmp(keyname, "__SYSTEM__")    == 0) return ALL;
+                if (strcmp(keyname, "genom_db")      == 0) return ALL;
+                if (strcmp(keyname, "gene_map")      == 0) return ALL;
+                if (strcmp(keyname, "species_data")  == 0) return SOME_OF_SPECIES_DATA;
+                if (strcmp(keyname, "extended_data") == 0) return SOME_OF_EXTENDED_DATA;
+                if (strcmp(keyname, "presets")       == 0) return SOME_OF_PRESETS;
+                break;
+
+            case SOME_OF_SPECIES_DATA:
+                if (strcmp(keyname, "species") == 0) return SOME_OF_SPECIES;
+                break;
+
+            case SOME_OF_EXTENDED_DATA:
+                if (strcmp(keyname, "extended") == 0) {
+                    const char *sainame = GBT_read_name(gbd);
+                    if (strcmp(sainame, "ECOLI") == 0) return SOME_OF_EXTENDED; // only "need" ECOLI 
+                }
+                break;
+
+            case SOME_OF_SPECIES:
+            case SOME_OF_EXTENDED:
+                if (from == SOME_OF_SPECIES) {
+                    if (strcmp(keyname, "abspos") == 0) return ALL;
+                }
+                if (strcmp(keyname, "name")      == 0) return ALL;
+                if (strcmp(keyname, "acc")       == 0) return ALL;
+                if (strcmp(keyname, "full_name") == 0) return ALL;
+                if (strcmp(keyname, ali_name)    == 0) return SOME_OF_ALI_CONTAINER;
+                break;
+
+            case SOME_OF_PRESETS:
+                if (strcmp(keyname, "use") == 0) return ALL;
+                break;
+
+            case SOME_OF_ALI_CONTAINER:
+                if (strcmp(keyname, "data") == 0) return ALL;
+                break;
+
+            case NONE: pt_assert(0); break;
+            case ALL:  pt_assert(0); break;
+        }
+
+        return NONE;
+    }
+
+    GB_ERROR mark_child(GBDATA *gb_entry, const char *keyname, Need from) {
+        GB_ERROR error = 0;
+        Need     need  = data_needed(gb_entry, keyname, from);
+        switch (need) {
+            case NONE: error = GB_set_temporary(gb_entry); break;
+            case ALL:  pt_assert(!GB_is_temporary(gb_entry)); break;
+            default:   error = mark_subentries(gb_entry, need); break;
+        }
+        return error;
+    }
+    GB_ERROR mark_subentries(GBDATA *gb_father, Need from) {
+        GB_ERROR error = 0;
+        if (!GB_is_temporary(gb_father)) {
+            for (GBDATA *gb_child = GB_child(gb_father); gb_child && !error; gb_child = GB_nextChild(gb_child)) {
+                const char *key = GB_read_key_pntr(gb_child);
+                error           = mark_child(gb_child, key, from);
+            }
+        }
+        return error;
+    }
+
+public:
+    EntryTempMarker(Servertype type_, GBDATA *gb_main_)
+        : gb_main(gb_main_),
+          ta(gb_main),
+          type(type_),
+          ali_name(GBT_get_default_alignment(gb_main))
+    {}
+    ~EntryTempMarker() { free(ali_name); }
+
+    GB_ERROR mark_unwanted_entries() { return mark_subentries(gb_main, SOME_OF_ROOT); }
+};
+
+inline GB_ERROR clean_ptserver_database(GBDATA *gb_main, Servertype type) {
+    return EntryTempMarker(type, gb_main).mark_unwanted_entries();
 }
 
+GB_ERROR prepare_ptserver_database(GBDATA *gb_main, Servertype type) {
+    GB_ERROR error = GB_request_undo_type(gb_main, GB_UNDO_NONE);
+    if (!error) {
+        GB_push_my_security(gb_main);
+        error = clean_ptserver_database(gb_main, type);
+        if (!error) {
+            // @@@ calculate bp and checksums
+        }
+        GB_pop_my_security(gb_main);
+    }
+    return error;
+}
 // --------------------------------------------------------------------------------
 
@@ -29 +143 @@
 
 void TEST_ptclean() {
-    GB_shell  shell;
-    GBDATA   *gb_main = GB_open("TEST_pt_src.arb", "rw");
+    GB_shell    shell;
+    GBDATA     *gb_main = GB_open("TEST_pt_src.arb", "rw");
+    const char *saveas  = "TEST_pt_cleaned.arb";
 
     TEST_ASSERT(gb_main);
-    TEST_ASSERT_NO_ERROR(clean_ptserver_database(gb_main, PTSERVER));
-    TEST_ASSERT_NO_ERROR(GB_save_as(gb_main, "TEST_pt_cleaned.arb", "a"));
+    TEST_ASSERT_NO_ERROR(prepare_ptserver_database(gb_main, PTSERVER));
+    TEST_ASSERT_NO_ERROR(GB_save_as(gb_main, saveas, "a"));
     GB_close(gb_main);
 
-#define TEST_AUTO_UPDATE
+// #define TEST_AUTO_UPDATE
 #if defined(TEST_AUTO_UPDATE)
     TEST_COPY_FILE("TEST_pt_cleaned.arb", "TEST_pt_cleaned_expected.arb");
 #else
-    TEST_ASSERT_FILES_EQUAL("TEST_pt_cleaned.arb", "TEST_pt_cleaned_expected.arb");
+    TEST_ASSERT_TEXTFILES_EQUAL("TEST_pt_cleaned.arb", "TEST_pt_cleaned_expected.arb");
 #endif
+    TEST_ASSERT_ZERO_OR_SHOW_ERRNO(GB_unlink(saveas));
 }
 

trunk/SL/PTCLEAN/ptclean.h

@@ -22 +22 @@
 };
 
-GB_ERROR clean_ptserver_database(GBDATA *gb_main, Servertype type);
+GB_ERROR prepare_ptserver_database(GBDATA *gb_main, Servertype type);
 
 #else

trunk/SOURCE_TOOLS/dep.4dummy

@@ -24 +24 @@
 PHYLO/PHYLO.dummy: AWT/AWT.dummy SL/MATRIX/MATRIX.dummy
 PRIMER_DESIGN/PRIMER_DESIGN.dummy: AWT/AWT.dummy
-PROBE/PROBE.dummy: PROBE_COM/PROBE_COM.dummy SERVERCNTRL/SERVERCNTRL.dummy SL/HELIX/HELIX.dummy
+PROBE/PROBE.dummy: PROBE_COM/PROBE_COM.dummy SERVERCNTRL/SERVERCNTRL.dummy SL/HELIX/HELIX.dummy SL/PTCLEAN/PTCLEAN.dummy
 PROBE_DESIGN/PROBE_DESIGN.dummy: SERVERCNTRL/SERVERCNTRL.dummy SL/TREEDISP/TREEDISP.dummy
 RNA3D/RNA3D.dummy: AWT/AWT.dummy GL/glAW/glAW.dummy GL/glpng/glpng.dummy SL/HELIX/HELIX.dummy
@@ -48 +48 @@
 SL/NEIGHBOURJOIN/NEIGHBOURJOIN.dummy: ARBDB/ARBDB.dummy
 SL/PRONUC/PRONUC.dummy: ARBDB/ARBDB.dummy
+SL/PTCLEAN/PTCLEAN.dummy: ARBDB/ARBDB.dummy
 SL/REFENTRIES/REFENTRIES.dummy: WINDOW/WINDOW.dummy
 SL/REGEXPR/REGEXPR.dummy: ARBDB/ARBDB.dummy

trunk/SOURCE_TOOLS/dep.alltargets

@@ -48 +48 @@
 SL/NEIGHBOURJOIN/NEIGHBOURJOIN.a
 SL/PRONUC/PRONUC.a
+SL/PTCLEAN/PTCLEAN.a
 SL/REFENTRIES/REFENTRIES.a
 SL/REGEXPR/REGEXPR.a

trunk/SOURCE_TOOLS/dep.libtargets

@@ -48 +48 @@
 SL/NEIGHBOURJOIN/NEIGHBOURJOIN.a
 SL/PRONUC/PRONUC.a
+SL/PTCLEAN/PTCLEAN.a
 SL/REFENTRIES/REFENTRIES.a
 SL/REGEXPR/REGEXPR.a

trunk/SOURCE_TOOLS/generate_all_links.sh

@@ -278 +278 @@
 symlink_file ../SL/PRONUC/AP_pro_a_nucs.hxx INCLUDE/AP_pro_a_nucs.hxx &&
 symlink_file ../SL/PRONUC/iupac.h INCLUDE/iupac.h &&
+symlink_file ../SL/PTCLEAN/ptclean.h INCLUDE/ptclean.h &&
 symlink_file ../SL/REFENTRIES/refentries.h INCLUDE/refentries.h &&
 symlink_file ../SL/REGEXPR/RegExpr.hxx INCLUDE/RegExpr.hxx &&

trunk/TOOLS/arb_probe.cxx

@@ -319 +319 @@
 
 #ifdef UNIT_TESTS
-    const int minServerID   = TEST_SERVER_ID;
+    const int minServerID   = TEST_GENESERVER_ID;
 #else // !UNIT_TESTS
     const int minServerID   = 0;
@@ -326 +326 @@
     P.SERVERID = getInt("serverid", 0, minServerID, 100, "Server Id, look into $ARBHOME/lib/arb_tcp.dat");
 #ifdef UNIT_TESTS
-    if (P.SERVERID<0) { arb_assert(P.SERVERID == TEST_SERVER_ID); }
+    if (P.SERVERID<0) { arb_assert(P.SERVERID == TEST_SERVER_ID || P.SERVERID == TEST_GENESERVER_ID); }
 #endif
 
@@ -455 +455 @@
 #endif
 
-static void test_setup() {
-    static bool setup = false;
-    if (!setup) {
-        TEST_SETUP_GLOBAL_ENVIRONMENT("ptserver"); // first call will recreate the test pt-server
-        setup = true;
-    }
+static int test_setup(bool use_gene_ptserver) {
+    static bool setup[2] = { false, false };
+    if (!setup[use_gene_ptserver]) {
+        TEST_SETUP_GLOBAL_ENVIRONMENT(use_gene_ptserver ? "ptserver_gene" : "ptserver"); // first call will recreate the test pt-server
+        setup[use_gene_ptserver] = true;
+    }
+    return use_gene_ptserver ? TEST_GENESERVER_ID : TEST_SERVER_ID;
 }
 
 void TEST_SLOW_variable_defaults_in_server() {
-    test_setup();
+    test_setup(false);
 
     const char *server_tag = GBS_ptserver_tag(TEST_SERVER_ID);
@@ -524 +525 @@
 //      test probe design / match
 
-#define TEST_PART1(fake_argc,fake_argv)                                 \
-    test_setup();                                                       \
-    TEST_ASSERT_EQUAL(true, parseCommandLine(fake_argc, fake_argv));    \
-    P.SERVERID = TEST_SERVER_ID;                                        \
-    ARB_ERROR  error;                                                   \
-    char      *answer = execute(error);                                 \
-    TEST_ASSERT_NO_ERROR(error.deliver());                              \
+#define TEST_PART1(fake_argc,fake_argv)                                                 \
+    int       serverid = test_setup(use_gene_ptserver);                                 \
+    TEST_ASSERT_EQUAL(true, parseCommandLine(fake_argc, fake_argv));                    \
+    TEST_ASSERT((serverid == TEST_SERVER_ID)||(serverid == TEST_GENESERVER_ID));        \
+    P.SERVERID         = serverid;                                                      \
+    ARB_ERROR error;                                                                    \
+    char      *answer   = execute(error);                                               \
+    TEST_ASSERT_NO_ERROR(error.deliver())
 
 
@@ -553 +555 @@
     } while(0)
 
+typedef const char *CCP;
 void TEST_SLOW_match_probe() {
-    typedef const char *CCP;
-    {
-        const char *arguments[] = {
-            "fake", // "program"-name
+    bool use_gene_ptserver = false;
+    {
+        const char *arguments[] = {
+            "prgnamefake",
             "matchsequence=UAUCGGAGAGUUUGA",
         };
-        CCP expected = "    name---- fullname mis N_mis wmis pos rev          'UAUCGGAGAGUUUGA'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     0  0.0   3 0   .......UU-===============-UCAAGUCGA\1";
+        CCP expected = "    name---- fullname mis N_mis wmis pos ecoli rev          'UAUCGGAGAGUUUGA'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     0  0.0   3     2 0   .......UU-===============-UCAAGUCGA\1";
 
         TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expected);
@@ -571 +574 @@
     {
         const char *arguments[] = {
-            "fake", // "program"-name
+            "prgnamefake",
             "matchsequence=CANCUCCUUUC", // contains 1 N
             NULL // matchmismatches
         };
 
-        CCP expectd0 = "    name---- fullname mis N_mis wmis pos rev          'CANCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176 0   CGGCUGGAU-==C========-U\1"; // only N-mismatch accepted
-
-        CCP expectd1 = "    name---- fullname mis N_mis wmis pos rev          'CANCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176 0   CGGCUGGAU-==C========-U\1" 
-            "PbcAcet2\1" "  PbcAcet2            0     2  0.0 176 0   CGGCUGGAU-==C=======N-N\1" 
-            "ClfPerfr\1" "  ClfPerfr            1     1  0.0 176 0   AGAUUAAUA-=CC========-U\1";
-
-        CCP expectd2 = "    name---- fullname mis N_mis wmis pos rev          'CANCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176 0   CGGCUGGAU-==C========-U\1"
-            "PbcAcet2\1" "  PbcAcet2            0     2  0.0 176 0   CGGCUGGAU-==C=======N-N\1"
-            "DlcTolu2\1" "  DlcTolu2            0     3  0.0 176 0   CGGCUGGAU-==C======NN-N\1"
-            "ClfPerfr\1" "  ClfPerfr            1     1  0.0 176 0   AGAUUAAUA-=CC========-U\1";
+        CCP expectd0 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176   162 0   CGGCUGGAU-==C========-U\1" ""; // only N-mismatch accepted
+
+        CCP expectd1 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176   162 0   CGGCUGGAU-==C========-U\1"
+            "PbcAcet2\1" "  PbcAcet2            0     2  0.0 176   162 0   CGGCUGGAU-==C=======N-N\1"
+            "ClfPerfr\1" "  ClfPerfr            1     1  0.0 176   162 0   AGAUUAAUA-=CC========-U\1";
+
+        CCP expectd2 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176   162 0   CGGCUGGAU-==C========-U\1"
+            "PbcAcet2\1" "  PbcAcet2            0     2  0.0 176   162 0   CGGCUGGAU-==C=======N-N\1"
+            "DlcTolu2\1" "  DlcTolu2            0     3  0.0 176   162 0   CGGCUGGAU-==C======NN-N\1"
+            "ClfPerfr\1" "  ClfPerfr            1     1  0.0 176   162 0   AGAUUAAUA-=CC========-U\1";
+
+        arguments[2] = "matchmismatches=0";  TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd0);
+        arguments[2] = "matchmismatches=1";  TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd1);
+        arguments[2] = "matchmismatches=2";  TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd2);
+    }
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=UCACCUCCUUUC", // contains no N
+            NULL // matchmismatches
+        };
+
+        CCP expectd0 = "    name---- fullname mis N_mis wmis pos ecoli rev          'UCACCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175   161 0   GCGGCUGGA-============-U\1"
+            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175   161 0   GCGGCUGGA-===========N-N\1";
+
+        CCP expectd1 = "    name---- fullname mis N_mis wmis pos ecoli rev          'UCACCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175   161 0   GCGGCUGGA-============-U\1"
+            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175   161 0   GCGGCUGGA-===========N-N\1"
+            "DlcTolu2\1" "  DlcTolu2            0     2  0.0 175   161 0   GCGGCUGGA-==========NN-N\1" "";
+
+        CCP expectd2 = "    name---- fullname mis N_mis wmis pos ecoli rev          'UCACCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175   161 0   GCGGCUGGA-============-U\1"
+            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175   161 0   GCGGCUGGA-===========N-N\1"
+            "DlcTolu2\1" "  DlcTolu2            0     2  0.0 175   161 0   GCGGCUGGA-==========NN-N\1"
+            "ClfPerfr\1" "  ClfPerfr            2     0  0.0 175   161 0   AAGAUUAAU-A=C=========-U\1" "";
 
         arguments[2] = "matchmismatches=0"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd0);
@@ -594 +623 @@
         arguments[2] = "matchmismatches=2"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd2);
     }
-    {
-        const char *arguments[] = {
-            "fake", // "program"-name
-            "matchsequence=UCACCUCCUUUC", // contains no N
-            NULL // matchmismatches
-        };
-
-        CCP expectd0 = "    name---- fullname mis N_mis wmis pos rev          'UCACCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175 0   GCGGCUGGA-============-U\1"
-            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175 0   GCGGCUGGA-===========N-N\1" "";
-
-        CCP expectd1 = "    name---- fullname mis N_mis wmis pos rev          'UCACCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175 0   GCGGCUGGA-============-U\1"
-            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175 0   GCGGCUGGA-===========N-N\1"
-            "DlcTolu2\1" "  DlcTolu2            0     2  0.0 175 0   GCGGCUGGA-==========NN-N\1" "";
-
-        CCP expectd2 = "    name---- fullname mis N_mis wmis pos rev          'UCACCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175 0   GCGGCUGGA-============-U\1"
-            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175 0   GCGGCUGGA-===========N-N\1"
-            "DlcTolu2\1" "  DlcTolu2            0     2  0.0 175 0   GCGGCUGGA-==========NN-N\1"
-            "ClfPerfr\1" "  ClfPerfr            2     0  0.0 175 0   AAGAUUAAU-A=C=========-U\1" "";
+
+    // ----------------------------------------------
+    //      do not accept any N-matches as match
+
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=CANCUCCUUUC", // contains 1 N
+            NULL, // matchmismatches
+            "matchacceptN=0",
+        };
+
+        CCP expectd0 = ""; // nothing matches
+
+        CCP expectd1 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176   162 0   CGGCUGGAU-==C========-U\1" "";
+ 
+        CCP expectd2 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176   162 0   CGGCUGGAU-==C========-U\1"
+            "PbcAcet2\1" "  PbcAcet2            0     2  0.0 176   162 0   CGGCUGGAU-==C=======N-N\1"
+            "ClfPerfr\1" "  ClfPerfr            1     1  0.0 176   162 0   AGAUUAAUA-=CC========-U\1" "";
 
         arguments[2] = "matchmismatches=0"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd0);
@@ -620 +649 @@
         arguments[2] = "matchmismatches=2"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd2);
     }
-
-    // ----------------------------------------------
-    //      do not accept any N-matches as match
-
-    {
-        const char *arguments[] = {
-            "fake", // "program"-name
-            "matchsequence=CANCUCCUUUC", // contains 1 N
-            NULL, // matchmismatches
-            "matchacceptN=0",
-        };
-
-        CCP expectd0 = ""; // nothing matches
-
-        CCP expectd1 = "    name---- fullname mis N_mis wmis pos rev          'CANCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176 0   CGGCUGGAU-==C========-U\1" "";
-
-        CCP expectd2 = "    name---- fullname mis N_mis wmis pos rev          'CANCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     1  0.0 176 0   CGGCUGGAU-==C========-U\1"
-            "PbcAcet2\1" "  PbcAcet2            0     2  0.0 176 0   CGGCUGGAU-==C=======N-N\1"
-            "ClfPerfr\1" "  ClfPerfr            1     1  0.0 176 0   AGAUUAAUA-=CC========-U\1" "";
-
-        arguments[2] = "matchmismatches=0"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd0);
-        arguments[2] = "matchmismatches=1"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd1);
-        arguments[2] = "matchmismatches=2"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd2);
-    }
-    {
-        const char *arguments[] = {
-            "fake", // "program"-name
+    {
+        const char *arguments[] = {
+            "prgnamefake",
             "matchsequence=UCACCUCCUUUC", // contains no N
             NULL, // matchmismatches
@@ -654 +657 @@
         };
 
-        CCP expectd0 = "    name---- fullname mis N_mis wmis pos rev          'UCACCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175 0   GCGGCUGGA-============-U\1" "";
-
-        CCP expectd1 = "    name---- fullname mis N_mis wmis pos rev          'UCACCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175 0   GCGGCUGGA-============-U\1"
-            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175 0   GCGGCUGGA-===========N-N\1" "";
-
-        CCP expectd2 = "    name---- fullname mis N_mis wmis pos rev          'UCACCUCCUUUC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175 0   GCGGCUGGA-============-U\1"
-            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175 0   GCGGCUGGA-===========N-N\1"
-            "DlcTolu2\1" "  DlcTolu2            0     2  0.0 175 0   GCGGCUGGA-==========NN-N\1"
-            "ClfPerfr\1" "  ClfPerfr            2     0  0.0 175 0   AAGAUUAAU-A=C=========-U\1" "";
+        CCP expectd0 = "    name---- fullname mis N_mis wmis pos ecoli rev          'UCACCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175   161 0   GCGGCUGGA-============-U\1" "";
+
+        CCP expectd1 = "    name---- fullname mis N_mis wmis pos ecoli rev          'UCACCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175   161 0   GCGGCUGGA-============-U\1"
+            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175   161 0   GCGGCUGGA-===========N-N\1" "";
+
+        CCP expectd2 = "    name---- fullname mis N_mis wmis pos ecoli rev          'UCACCUCCUUUC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     0  0.0 175   161 0   GCGGCUGGA-============-U\1"
+            "PbcAcet2\1" "  PbcAcet2            0     1  0.0 175   161 0   GCGGCUGGA-===========N-N\1"
+            "DlcTolu2\1" "  DlcTolu2            0     2  0.0 175   161 0   GCGGCUGGA-==========NN-N\1"
+            "ClfPerfr\1" "  ClfPerfr            2     0  0.0 175   161 0   AAGAUUAAU-A=C=========-U\1" "";
         
         arguments[2] = "matchmismatches=0"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd0);
@@ -677 +680 @@
     {
         const char *arguments[] = {
-            "fake", // "program"-name
+            "prgnamefake",
             "matchsequence=CANCUCCUUNC", // contains 2 N
             NULL, // matchmismatches
@@ -684 +687 @@
         };
 
-        CCP expectd0 = "    name---- fullname mis N_mis wmis pos rev          'CANCUCCUUNC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     2  0.0 176 0   CGGCUGGAU-==C======U=-U\1" "";
+        CCP expectd0 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCUCCUUNC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     2  0.0 176   162 0   CGGCUGGAU-==C======U=-U\1" "";
+
+        CCP expectd1 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCUCCUUNC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     2  0.0 176   162 0   CGGCUGGAU-==C======U=-U\1"
+            "DlcTolu2\1" "  DlcTolu2            0     3  0.0 176   162 0   CGGCUGGAU-==C=======N-N\1"
+            "PbcAcet2\1" "  PbcAcet2            0     3  0.0 176   162 0   CGGCUGGAU-==C======UN-N\1"
+            "ClfPerfr\1" "  ClfPerfr            1     2  0.0 176   162 0   AGAUUAAUA-=CC======U=-U\1" "";
         
-        CCP expectd1 = "    name---- fullname mis N_mis wmis pos rev          'CANCUCCUUNC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     2  0.0 176 0   CGGCUGGAU-==C======U=-U\1"
-            "DlcTolu2\1" "  DlcTolu2            0     3  0.0 176 0   CGGCUGGAU-==C=======N-N\1"
-            "PbcAcet2\1" "  PbcAcet2            0     3  0.0 176 0   CGGCUGGAU-==C======UN-N\1"
-            "ClfPerfr\1" "  ClfPerfr            1     2  0.0 176 0   AGAUUAAUA-=CC======U=-U\1" "";
-        
-        CCP expectd2 = "    name---- fullname mis N_mis wmis pos rev          'CANCUCCUUNC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     2  0.0 176 0   CGGCUGGAU-==C======U=-U\1"
-            "DlcTolu2\1" "  DlcTolu2            0     3  0.0 176 0   CGGCUGGAU-==C=======N-N\1"
-            "PbcAcet2\1" "  PbcAcet2            0     3  0.0 176 0   CGGCUGGAU-==C======UN-N\1"
-            "ClfPerfr\1" "  ClfPerfr            1     2  0.0 176 0   AGAUUAAUA-=CC======U=-U\1" "";
+        CCP expectd2 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCUCCUUNC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     2  0.0 176   162 0   CGGCUGGAU-==C======U=-U\1"
+            "DlcTolu2\1" "  DlcTolu2            0     3  0.0 176   162 0   CGGCUGGAU-==C=======N-N\1"
+            "PbcAcet2\1" "  PbcAcet2            0     3  0.0 176   162 0   CGGCUGGAU-==C======UN-N\1"
+            "ClfPerfr\1" "  ClfPerfr            1     2  0.0 176   162 0   AGAUUAAUA-=CC======U=-U\1" "";
         
         arguments[2] = "matchmismatches=0"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd0);
@@ -709 +712 @@
     {
         const char *arguments[] = {
-            "fake", // "program"-name
+            "prgnamefake",
             "matchsequence=CANCNCNNUNC", // contains 5N
             NULL, // matchmismatches
@@ -717 +720 @@
         };
 
-        CCP expectd0 = "    name---- fullname mis N_mis wmis pos rev          'CANCNCNNUNC'\1"
-            "BcSSSS00\1" "  BcSSSS00            0     5  0.0 176 0   CGGCUGGAU-==C=U=CU=U=-U\1" "";
-            
-        CCP expectd1 = "    name---- fullname mis N_mis wmis pos rev          'CANCNCNNUNC'\1" 
-            "BcSSSS00\1" "  BcSSSS00            0     5  0.0 176 0   CGGCUGGAU-==C=U=CU=U=-U\1"
-            "DlcTolu2\1" "  DlcTolu2            0     6  0.0 176 0   CGGCUGGAU-==C=U=CU==N-N\1"
-            "PbcAcet2\1" "  PbcAcet2            0     6  0.0 176 0   CGGCUGGAU-==C=U=CU=UN-N\1"
-            "LgtLytic\1" "  LgtLytic            1     5  0.0  31 0   GUCGAACGG-==G=A=AG=CU-AGCUUGCUA\1"
-            "ClfPerfr\1" "  ClfPerfr            1     5  0.0 111 0   CGGCUGGAU-==U=AUAA=G=-AGCGAUUGG\1"; // one hit is truncated here
+        CCP expectd0 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCNCNNUNC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     5  0.0 176   162 0   CGGCUGGAU-==C=U=CU=U=-U\1" "";
+
+        CCP expectd1 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCNCNNUNC'\1"
+            "BcSSSS00\1" "  BcSSSS00            0     5  0.0 176   162 0   CGGCUGGAU-==C=U=CU=U=-U\1"
+            "DlcTolu2\1" "  DlcTolu2            0     6  0.0 176   162 0   CGGCUGGAU-==C=U=CU==N-N\1"
+            "PbcAcet2\1" "  PbcAcet2            0     6  0.0 176   162 0   CGGCUGGAU-==C=U=CU=UN-N\1"
+            "LgtLytic\1" "  LgtLytic            1     5  0.0  31    26 0   GUCGAACGG-==G=A=AG=CU-AGCUUGCUA\1"
+            "ClfPerfr\1" "  ClfPerfr            1     5  0.0 111    99 0   CGGCUGGAU-==U=AUAA=G=-AGCGAUUGG\1"; // one hit is truncated here
         
-        CCP expectd2 = "    name---- fullname mis N_mis wmis pos rev          'CANCNCNNUNC'\1"
-            "VbrFurni\1" "  VbrFurni            2     5  0.0  40 0   CGGCAGCGA-==A=AUUGAA=-CUUCGGGGG\1"
-            "HllHalod\1" "  HllHalod            2     5  0.0  45 0   AAACGAUGG-A=G=UUGC=U=-CAGGCGUCG\1"
-            "VblVulni\1" "  VblVulni            2     5  0.0  49 0   AGCACAGAG-A=A=UUGU=U=-UCGGGUGGC\1"
-            "LgtLytic\1" "  LgtLytic            2     5  0.0 101 0   GGGGAAACU-==AGCUAA=A=-CGCAUAAUC\1"
-            "ClfPerfr\1" "  ClfPerfr            2     5  0.0 172 0   AGGAAGAUU-A=UAC=CC=C=-UUUCU\1" ""; // many hits are truncated here
+        CCP expectd2 = "    name---- fullname mis N_mis wmis pos ecoli rev          'CANCNCNNUNC'\1"
+            "VbrFurni\1" "  VbrFurni            2     5  0.0  40    35 0   CGGCAGCGA-==A=AUUGAA=-CUUCGGGGG\1"
+            "HllHalod\1" "  HllHalod            2     5  0.0  45    40 0   AAACGAUGG-A=G=UUGC=U=-CAGGCGUCG\1"
+            "VblVulni\1" "  VblVulni            2     5  0.0  49    44 0   AGCACAGAG-A=A=UUGU=U=-UCGGGUGGC\1"
+            "LgtLytic\1" "  LgtLytic            2     5  0.0 101    89 0   GGGGAAACU-==AGCUAA=A=-CGCAUAAUC\1"
+            "ClfPerfr\1" "  ClfPerfr            2     5  0.0 172   158 0   AGGAAGAUU-A=UAC=CC=C=-UUUCU\1"; // many hits are truncated here
 
         arguments[2] = "matchmismatches=0"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd0);
         arguments[2] = "matchmismatches=1"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd1);
         arguments[2] = "matchmismatches=2"; TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd2);
+    }
+}
+
+void TEST_SLOW_match_geneprobe() {
+    bool use_gene_ptserver = true;
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=NNUCNN",
+            "matchacceptN=4", 
+            "matchlimitN=5", 
+        };
+        CCP expectd = "    organism genename------- mis N_mis wmis pos gpos rev          'NNUCNN'\1"
+            "genome2\1" "  genome2  gene3             0     4  0.0   2    1 0   .........-UU==GG-UUGAUC\1"
+            "genome2\1" "  genome2  joined1           0     4  0.0   2    1 0   .........-UU==GG-UUGAUCCUG\1"
+            "genome2\1" "  genome2  gene2             0     4  0.0  10    4 0   ......GUU-GA==CU-GCCA\1"
+            "genome2\1" "  genome2  intergene_19_65   0     4  0.0  31   12 0   GGUUACUGC-AU==GG-UGUUCGCCU\1"
+            "genome1\1" "  genome1  intergene_17_65   0     4  0.0  31   14 0   GGUUACUGC-UA==GG-UGUUCGCCU\1"
+            "genome2\1" "  genome2  intergene_19_65   0     4  0.0  38   19 0   GCAUUCGGU-GU==GC-CUAAGCACU\1"
+            "genome1\1" "  genome1  intergene_17_65   0     4  0.0  38   21 0   GCUAUCGGU-GU==GC-CUAAGCCAU\1"
+            "genome1\1" "  genome1  intergene_17_65   0     4  0.0  56   39 0   AGCCAUGCG-AG==AU-AUGUA\1" "";
+        
+        TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd);
+    }
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=NGGUUN",
+            "matchacceptN=2", 
+            "matchlimitN=3", 
+        };
+        CCP expectd = "    organism genename------- mis N_mis wmis pos gpos rev          'NGGUUN'\1"
+            "genome1\1" "  genome1  joined1           0     2  0.0   5    2 0   ........C-U====G-AUCCUGC\1"
+            "genome2\1" "  genome2  intergene_19_65   0     2  0.0  21    2 0   ........G-A====A-CUGCAUUCG\1"
+            "genome1\1" "  genome1  intergene_17_65   0     2  0.0  21    4 0   ......CAG-A====A-CUGCUAUCG\1"
+            "genome2\1" "  genome2  gene3             0     2  0.0   5    4 0   ......UUU-C====G-AUC\1"
+            "genome2\1" "  genome2  joined1           0     2  0.0   5    4 0   ......UUU-C====G-AUCCUGCCA\1" "";
+
+        TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd);
+    }
+
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=UGAUCCU", // exists in data
+        };
+        CCP expectd = "    organism genename mis N_mis wmis pos gpos rev          'UGAUCCU'\1"
+            "genome1\1" "  genome1  gene2      0     0  0.0   9    1 0   .........-=======-GC\1"
+            "genome2\1" "  genome2  gene2      0     0  0.0   9    3 0   .......GU-=======-GCCA\1" "";
+
+        TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd); // @@@ defect: probe exists as well in 'joined1' (of both genomes)
+    }
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=GAUCCU",
+        };
+        CCP expectd = "    organism genename mis N_mis wmis pos gpos rev          'GAUCCU'\1"
+            "genome2\1" "  genome2  gene2      0     0  0.0  10    4 0   ......GUU-======-GCCA\1" "";
+
+        TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd); // @@@ defect: probe is part of above probe, but reports less hits
+    }
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=UUUCGG", // exists only in genome2 
+        };
+        CCP expectd = "    organism genename mis N_mis wmis pos gpos rev          'UUUCGG'\1"
+            "genome2\1" "  genome2  gene3      0     0  0.0   2    1 0   .........-======-UUGAUC\1"
+            "genome2\1" "  genome2  joined1    0     0  0.0   2    1 0   .........-======-UUGAUCCUG\1" "";
+
+        TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd); // @@@ defect: also exists in genome2/gene1
+    }
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=AUCCUG", 
+        };
+        CCP expectd = "    organism genename mis N_mis wmis pos gpos rev          'AUCCUG'\1"
+            "genome2\1" "  genome2  gene2      0     0  0.0  11    5 0   .....GUUG-======-CCA\1" "";
+
+        TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd); // @@@ defect: exists in 'gene2' and 'joined1' of both genomes
+    }
+    {
+        const char *arguments[] = {
+            "prgnamefake",
+            "matchsequence=UUGAUCCUGC",
+        };
+        CCP expectd = "    organism genename mis N_mis wmis pos gpos rev          'UUGAUCCUGC'\1"
+            "genome2\1" "  genome2  gene2      0     0  0.0   8    2 0   ........G-==========-CA\1"
+            "genome1\1" "  genome1  joined1    0     0  0.0   8    5 0   .....CUGG-==========-\1" "";
+
+        TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expectd); // @@@ defect: also exists in 'genome2/joined1'
     }
 }
@@ -773 +869 @@
 
 void TEST_SLOW_design_probe() {
+    bool use_gene_ptserver = false;
     const char *arguments[] = {
-        "fake", // "program"-name
+        "prgnamefake",
         "designnames=ClnCorin#CltBotul#CPPParap#ClfPerfr",
         "designmintargets=100",
@@ -787 +884 @@
         "Min Group Hits       100%\n"
         "Target             le     apos ecol grps  G+C 4GC+2AT Probe sequence     | Decrease T by n*.3C -> probe matches n non group species\n"
-        "CGAAAGGAAGAUUAAUAC 18 A=    94   94    4 33.3 48.0    GUAUUAAUCUUCCUUUCG |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
-        "GAAAGGAAGAUUAAUACC 18 A+     1   95    4 33.3 48.0    GGUAUUAAUCUUCCUUUC |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
-        "UCAAGUCGAGCGAUGAAG 18 B=    18   18    4 50.0 54.0    CUUCAUCGCUCGACUUGA |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
-        "AUCAAGUCGAGCGAUGAA 18 B-     1   17    4 44.4 52.0    UUCAUCGCUCGACUUGAU |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  2,  3,\n";
+        "CGAAAGGAAGAUUAAUAC 18 A=    94   82    4 33.3 48.0    GUAUUAAUCUUCCUUUCG |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
+        "GAAAGGAAGAUUAAUACC 18 A+     1   83    4 33.3 48.0    GGUAUUAAUCUUCCUUUC |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
+        "UCAAGUCGAGCGAUGAAG 18 B=    18   17    4 50.0 54.0    CUUCAUCGCUCGACUUGA |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
+        "AUCAAGUCGAGCGAUGAA 18 B-     1   16    4 44.4 52.0    UUCAUCGCUCGACUUGAU |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  2,  3,\n";
 
     TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expected);
@@ -804 +901 @@
 
     const char *arguments_loc[] = {
-        "fake", // "program"-name
+        "prgnamefake",
         // "designnames=Stsssola#Stsssola", // @@@ crashes the ptserver
         "designnames=CPPParap#PsAAAA00",
@@ -823 +920 @@
 
 void TEST_SLOW_match_designed_probe() {
+    bool use_gene_ptserver = false;
     const char *arguments[] = {
-        "fake", // "program"-name 
+        "prgnamefake", 
         "matchsequence=UCAAGUCGAGCGAUGAAG", 
     };
-    const char *expected =
-    "    name---- fullname mis N_mis wmis pos rev          'UCAAGUCGAGCGAUGAAG'\1"
-    "ClnCorin\1" "  ClnCorin            0     0  0.0  18 0   .GAGUUUGA-==================-UUCCUUCGG\1"
-    "CltBotul\1" "  CltBotul            0     0  0.0  18 0   ........A-==================-CUUCUUCGG\1"
-    "CPPParap\1" "  CPPParap            0     0  0.0  18 0   AGAGUUUGA-==================-UUCCUUCGG\1"
-    "ClfPerfr\1" "  ClfPerfr            0     0  0.0  18 0   AGAGUUUGA-==================-UUUCCUUCG\1";
+    CCP expected = "    name---- fullname mis N_mis wmis pos ecoli rev          'UCAAGUCGAGCGAUGAAG'\1"
+        "ClnCorin\1" "  ClnCorin            0     0  0.0  18    17 0   .GAGUUUGA-==================-UUCCUUCGG\1"
+        "CltBotul\1" "  CltBotul            0     0  0.0  18    17 0   ........A-==================-CUUCUUCGG\1"
+        "CPPParap\1" "  CPPParap            0     0  0.0  18    17 0   AGAGUUUGA-==================-UUCCUUCGG\1"
+        "ClfPerfr\1" "  ClfPerfr            0     0  0.0  18    17 0   AGAGUUUGA-==================-UUUCCUUCG\1";
 
     TEST_ARB_PROBE(ARRAY_ELEMS(arguments), arguments, expected);

trunk/TOOLS/arb_test.cxx

@@ -66 +66 @@
     TEST_ASSERT_ZERO_OR_SHOW_ERRNO(GB_unlink("ascii2bin.ARF"));
     TEST_ASSERT_ZERO_OR_SHOW_ERRNO(GB_unlink("ascii2bin2.ARF"));
-}
-
-void TEST_SLOW_arb_gene_probe() {
-    const char *genome   = "tools/gene_probe.arb";
-    const char *out      = "tools/gene_probe_out.arb";
-    const char *expected = "tools/gene_probe_expected.arb";
-
-    TEST_RUN_TOOL(GBS_global_string("arb_gene_probe %s %s", genome, out));
-    TEST_ASSERT_FILES_EQUAL(out, expected);
-    TEST_ASSERT_ZERO_OR_SHOW_ERRNO(GB_unlink(out));
-    TEST_ASSERT_ZERO_OR_SHOW_ERRNO(GB_unlink("tools/gene_probe_out.ARM"));
 }
 
@@ -181 +170 @@
 
 void TEST_arb_replace() {
-    const char *infile = "tools/gene_probe.arb";
+    const char *infile = "tools/arb_replace.in";
     const char *file1  = "tools/arb_replace_1.out";
     const char *file2  = "tools/arb_replace_2.out";
@@ -299 +288 @@
                        " matchsequence=UAUCGGAGAGUUUGA",
 
-                       "    name---- fullname mis N_mis wmis pos rev          'UAUCGGAGAGUUUGA'"
-                       "BcSSSS00"
-                       "  BcSSSS00            0     0  0.0   3 0   .......UU-===============-UCAAGUCGA"
-                       );
+                       /* ---- */ "    name---- fullname mis N_mis wmis pos ecoli rev          'UAUCGGAGAGUUUGA'\1"
+                       "BcSSSS00\1" "  BcSSSS00            0     0  0.0   3     2 0   .......UU-===============-UCAAGUCGA\1"
+        );
 
     TEST_STDOUT_EQUALS("arb_probe"
@@ -317 +305 @@
                        "Min Group Hits       100%\n"
                        "Target             le     apos ecol grps  G+C 4GC+2AT Probe sequence     | Decrease T by n*.3C -> probe matches n non group species\n"
-                       "CGAAAGGAAGAUUAAUAC 18 A=    94   94    4 33.3 48.0    GUAUUAAUCUUCCUUUCG |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
-                       "GAAAGGAAGAUUAAUACC 18 A+     1   95    4 33.3 48.0    GGUAUUAAUCUUCCUUUC |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
-                       "UCAAGUCGAGCGAUGAAG 18 B=    18   18    4 50.0 54.0    CUUCAUCGCUCGACUUGA |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
-                       "AUCAAGUCGAGCGAUGAA 18 B-     1   17    4 44.4 52.0    UUCAUCGCUCGACUUGAU |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  2,  3,\n"
+                       "CGAAAGGAAGAUUAAUAC 18 A=    94   82    4 33.3 48.0    GUAUUAAUCUUCCUUUCG |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
+                       "GAAAGGAAGAUUAAUACC 18 A+     1   83    4 33.3 48.0    GGUAUUAAUCUUCCUUUC |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
+                       "UCAAGUCGAGCGAUGAAG 18 B=    18   17    4 50.0 54.0    CUUCAUCGCUCGACUUGA |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n"
+                       "AUCAAGUCGAGCGAUGAA 18 B-     1   16    4 44.4 52.0    UUCAUCGCUCGACUUGAU |  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  2,  3,\n"
                        );
 }

trunk/UNIT_TESTER/TestEnvironment.cxx

@@ -270 +270 @@
 //      ptserver
 
-static void test_ptserver_activate(bool start) {
-    const char *server_tag = GBS_ptserver_tag(TEST_SERVER_ID);
+static void test_ptserver_activate(bool start, int serverid) {
+    const char *server_tag = GBS_ptserver_tag(serverid);
     if (start) {
         TEST_ASSERT_NO_ERROR(arb_look_and_start_server(AISC_MAGIC_NUMBER, server_tag, 0));
@@ -290 +290 @@
     switch (mode) {
         case SETUP: {
-            test_ptserver_activate(false);                        // first kill pt-server (otherwise we may test an outdated pt-server)
-            TEST_ASSERT_NO_ERROR(GB_system("touch TEST_pt.arb")); // force rebuild
-            test_ptserver_activate(true);
+            test_ptserver_activate(false, TEST_SERVER_ID);                     // first kill pt-server (otherwise we may test an outdated pt-server)
+            TEST_ASSERT_NO_ERROR(GB_system("cp TEST_pt_src.arb TEST_pt.arb")); // force rebuild
+            test_ptserver_activate(true, TEST_SERVER_ID);
             TEST_ASSERT_FILES_EQUAL("TEST_pt.arb.pt.expected", "TEST_pt.arb.pt");
             TEST_ASSERT(GB_time_of_file("TEST_pt.arb.pt") >= GB_time_of_file("TEST_pt.arb"));
@@ -298 +298 @@
         }
         case CLEAN: {
-            test_ptserver_activate(false);
+            test_ptserver_activate(false, TEST_SERVER_ID);
             TEST_ASSERT_ZERO_OR_SHOW_ERRNO(unlink("TEST_pt.arb.pt"));
             break;
@@ -307 +307 @@
     }
 
+    return NULL;
+}
+
+static Error ptserver_gene(Mode mode) {
+    // test-gene-ptserver is restarted and rebuild.
+    // This is done only once in the complete test suite.
+    // 
+    // every unit-test using the test-gene-ptserver should simply call
+    // TEST_SETUP_GLOBAL_ENVIRONMENT("ptserver_gene");
+
+// #define TEST_AUTO_UPDATE
+
+    switch (mode) {
+        case SETUP: {
+            test_ptserver_activate(false, TEST_GENESERVER_ID);                     // first kill pt-server (otherwise we may test an outdated pt-server)
+            TEST_ASSERT_NO_ERROR(GB_system("arb_gene_probe TEST_gpt_src.arb TEST_gpt.arb")); // prepare gene-ptserver-db (forcing rebuild)
+
+#if defined(TEST_AUTO_UPDATE)
+            TEST_COPY_FILE("TEST_gpt.arb", "TEST_gpt.arb.expected");
+#else // !defined(TEST_AUTO_UPDATE)
+            TEST_ASSERT_FILES_EQUAL("TEST_gpt.arb.expected", "TEST_gpt.arb");
+#endif
+
+            test_ptserver_activate(true, TEST_GENESERVER_ID);
+
+#if defined(TEST_AUTO_UPDATE)
+            TEST_COPY_FILE("TEST_gpt.arb.pt", "TEST_gpt.arb.pt.expected");
+#else // !defined(TEST_AUTO_UPDATE)
+            TEST_ASSERT_FILES_EQUAL("TEST_gpt.arb.pt.expected", "TEST_gpt.arb.pt");
+#endif
+
+            TEST_ASSERT(GB_time_of_file("TEST_gpt.arb.pt") >= GB_time_of_file("TEST_gpt.arb"));
+            break;
+        }
+        case CLEAN: {
+            test_ptserver_activate(false, TEST_GENESERVER_ID);
+            TEST_ASSERT_ZERO_OR_SHOW_ERRNO(unlink("TEST_gpt.arb.pt"));
+            break;
+        }
+        case UNKNOWN:
+            env_assert(0);
+            break;
+    }
+
+#undef TEST_AUTO_UPDATE
+    
     return NULL;
 }
@@ -414 +460 @@
 static FunInfo modules[] = {
     FUNINFO(ptserver),
+    FUNINFO(ptserver_gene),
 };
 

trunk/UNIT_TESTER/run/TEST_pt_cleaned_expected.arb

@@ -2 +2 @@
 genom_db                %i 0
 presets                 %% (%
-        alignment       :6000   %% (%
-                alignment_name  :7600   "ali_mini"
-                alignment_len   :7000   %i 187
-                aligned         :7000   %i 1
-                alignment_write_security        :7600   %i 0
-                alignment_type  :7000   "rna"
-                auto_format             %i 0
-                alignment_rem           "<NONE>"
-                %) /*alignment*/
-
-        key_data                %% (%
-                key                     %% (%
-                        key_name                "name"
-                        key_type                %i 12
-                        key_hidden              %i 0
-                        %) /*key*/
-
-                key                     %% (%
-                        key_name                "acc"
-                        key_type                %i 12
-                        key_hidden              %i 0
-                        %) /*key*/
-
-                key                     %% (%
-                        key_name                "ali_mini"
-                        key_type                %i 15
-                        key_hidden              %i 0
-                        %) /*key*/
-
-                key                     %% (%
-                        key_name                "ali_mini/data"
-                        key_type                %i 12
-                        key_hidden              %i 0
-                        %) /*key*/
-
-                %) /*key_data*/
-
         use                     "ali_mini"
         %) /*presets*/
@@ -246 +209 @@
         extended                %% (%
                 name            :7000   "ECOLI"
-                errors                  %i 0
                 acc                     "J01695"
                 full_name               "Escherichia coli"
@@ -257 +219 @@
         %) /*extended_data*/
 
-tree_data       :7000   %% (%
-        tree_ph_24306           %% (%
-                tree                    "N0.03618,0.03618;N0.04082,0.06452;N0.0404,0.28364;N0.0473,0.2638;N0.06826,0.13072;N0.09494,0.11285;LHllHalod\ALLgtLytic\ALPslFlave\AN0.04416,0.07602;N0.02484,0.01242;LVbhChole\ALVblVulni\ALVbrFurni\AN0.13971,0.16265;N0.02,0.35135;N0.07947,0.09524;LClnCorin\ALCPPParap\ALCltBotul\ALClfPerfr\AN0.28846,0.2;N0.06844,0.10559;N0.06211,0.58369;N0.09357,0.06548;LAclPleur\ALPtVVVulg\ALPsAAAA00\ALDcdNodos\ALFrhhPhil\AN0.19802,0.06369;N0.04192,0.02516;LBcSSSS00\ALBl0LLL00\AN0.04516,0.04487;N0.03974,0.04516;N0.09717,0.10759;N0.10726,0.77778;LDlcTolu2\ALDsssDesu\ALStsssola\ALPbcAcet2\ALPbrPropi\A"
-                nnodes                  %i 21
-                remark                  "PRG=neighbor CORR=F84 FILTER=none PKG=phylip\n\nSun Aug 22 21:38:37 2010: Loaded from outtree\n\nTree loaded from 'outtree' on Sun Aug 22 21:38:37 2010\nSun Aug 22 22:01:06 2010: tree_ph_24306 saved to /home/ralf/data/db/ph_24306.tree\nSun Aug 22 22:02:33 2010: Loaded from /home/ralf/data/db/ph_24306.tree\n"
-                security                %i 0
-                ruler                   %% (%
-                        size                    %f 0.1
-                        LIST                    %% (%
-                                ruler_y                 %f 0
-                                ruler_x                 %f 0
-                                text_x                  %f 0
-                                text_y                  %f 0
-                                %) /*LIST*/
-
-                        ruler_width             %i 0
-                        %) /*ruler*/
-
-                %) /*tree_ph_24306*/
-
-        %) /*tree_data*/
-
-focus                   %% (%
-        tree_name               "tree_ph_24306"
-        %) /*focus*/
-
-description             "db for unit-test pt-server"
-checks                  %% (%
-        check                   "fix gene_data"
-        check                   "fix_dict_compress"
-        check                   "del_mark_move_REF"
-        check                   "duplicated_item_colors"
-        %) /*checks*/
-
-tmp                     %% (%
-        message                 %% (%
-                pending                 %% (%
-                        %) /*pending*/
-
-                %) /*message*/
-
-        %) /*tmp*/
-

trunk/UNIT_TESTER/test_unit.h

@@ -593 +593 @@
 };
 
+#define TEST_COPY_FILE(src, dst) TEST_ASSERT(system(GBS_global_string("cp '%s' '%s'", src, dst)) == 0)
+
 #define TEST_ASSERT_TEXTFILE_DIFFLINES(f1,f2,diff)         TEST_ASSERT(arb_test::test_textfile_difflines(f1,f2, diff))
 #define TEST_ASSERT_TEXTFILE_DIFFLINES__BROKEN(f1,f2,diff) TEST_ASSERT__BROKEN(arb_test::test_textfile_difflines(f1,f2, diff))
@@ -625 +627 @@
 // --------------------------------------------------------------------------------
 
-#define TEST_SETUP_GLOBAL_ENVIRONMENT(modulename) TEST_ASSERT_NO_ERROR(GB_system("../test_environment setup " modulename))
+#define TEST_SETUP_GLOBAL_ENVIRONMENT(modulename) TEST_ASSERT_NO_ERROR(GB_system(GBS_global_string("../test_environment setup %s",  (modulename))))
 // cleanup is done (by Makefile.suite) after all unit tests have been run
 

trunk/lib/arb_tcp_org.dat

@@ -32 +32 @@
 
 ARB_TEST_PT_SERVER          localhost:3200          arb_pt_server   -D$(ARBHOME)/UNIT_TESTER/run/TEST_pt.arb
-
+ARB_TEST_PT_SERVER_GENE     localhost:3201          arb_pt_server   -D$(ARBHOME)/UNIT_TESTER/run/TEST_gpt.arb
 
 #***********    Private Servers (for each user) ******************

trunk/util/arb_srclst.pl

@@ -168 +168 @@
                              qr/\/UNIT_TESTER\/run\/.*\.tree$/o,
                              qr/\/UNIT_TESTER\/run\/impexp\/.*\.exported$/o,
-                             qr/\/UNIT_TESTER\/run\/TEST_.*\.pt$/o, # has to move to skipped_when_matchesFull (when merging test env)
                              qr/\/UNIT_TESTER\/valgrind\/arb_valgrind_logged$/o,
                              qr/^\.\/etc\//o,
@@ -211 +210 @@
                                 qr/^\.\/SOURCE_TOOLS\/valgrind2grep\.lst$/o,
                                 qr/^\.\/TEMPLATES\/arb_build\.h$/o,
+                                qr/^\.\/UNIT_TESTER\/run\/TEST_g?pt\.arb$/o,
+                                qr/^\.\/UNIT_TESTER\/run\/.*\.ARM$/o,
+                                qr/^\.\/UNIT_TESTER\/run\/.*\.ARF$/o,
                                 qr/date\.xsl$/o,
                                );