added very basic argument parsing

tick marks are next

Author: benjaminbeer256

.gitignore

@@ -1 +1,6 @@
+js/*
+*
 **/.DS_Store
+
+!.gitignore
+!python

python/__pycache__/composite.cpython-39.pyc

@@ -3,75 +3,90 @@
 import xml.dom.minidom as dom
 import argparse
 import math
+import parseComposite
 
 class Composite:    
-    def __init__(self, xmin=None, xmax=None, sense=[], anti=[]):
+    def __init__(self, xmin=None, xmax=None, sense=[], anti=[], id=""):
         self.xmin = xmin
         self.xmax = xmax
         self.sense = sense
         self.anti = anti
+        self.id = id
 
     def __str__(self):
-        return "Sense: " + str(self.sense) + "\nAnti: " + str(self.anti) + "\nXMin: " + str(self.xmin) + "\nXMax: " + str(self.xmax)
+        return "Sense: " + str(self.sense) + "\nAnti: " + str(self.anti) + "\nXMin: " + str(self.xmin) + "\nXMax: " + str(self.xmax) + "\nID:" + str(self.id)
 
-def parseComposite(file):
-    fileArr = open(file, "r").read().split("\n")
-    xmin = None
-    xmax = None
-    sense = []
-    anti = []
-    xmin_curr = 0
-    xmax_curr = 0
-    offset = 0
-    for line in fileArr:
-        print("line")
-        # Skip empty
-        if len(line.strip()) == 0 :
-            continue
-        # Separate fields
-        fields = line.split("\t")
-        if fields[0] == "" or fields[0] == "NAME":
-            print("name")
-            xmin_curr = int(float(fields[1]))
-            xmax_curr = int(float(fields[-1]))
-            # If the x domain starts at 0 shift it to the left
-            if xmin_curr == 0:
-                xmin_curr -= math.floor(xmax_curr / 2)
-                xmax_curr -= math.floor(xmax_curr / 2)
-            # If the x domain is not defined yet, define it
-            if xmin == None or xmax == None:
-                xmin = xmin_curr
-                xmax = xmax_curr
-            # Redefine min and max if necessary
-            xmax = max(xmax_curr, xmax)
-            xmin = min(xmin_curr, xmin)
-            sense = [0] * (xmax - xmin + 1)
-            anti = [0] * (xmax - xmin + 1)
+class CompositeGroup:
+    def __init__(self):
+        self.xmin = 0
+        self.xmax = 0
+        self.sense = []
+        self.anti = []
+        self.individual_composites = {}
+        self.files_loaded = len(self.individual_composites)
+    
+    def loadComposite(self,composite: Composite):
+        # If no files, initialize sense and anti arrays; otherwise, pad sense and anti arrays to new xdomain
+        self.xmin = min(composite.xmin, self.xmin)
+        self.xmax = max(composite.xmax, self.xmax)
+        if len(self.individual_composites) == 0:
+            self.sense = [0] * (composite.xmax - composite.xmin + 1)
+            self.anti = [0] * (composite.xmax - composite.xmin + 1)
+        else:
+            xmin = min([int(self.individual_composites[c].xmin) for c in self.individual_composites])
+            xmax = max([int(self.individual_composites[c].xmax) for c in self.individual_composites])
+            prefix = [0] * (xmin - self.xmin)
+            suffix = [0] * (self.xmax - xmax)
+            self.sense = prefix + self.sense + suffix
+            self.anti = prefix + self.anti + suffix
+
+        # Update sense and anti arrays
+        j = composite.xmin - self.xmin
+        while j <= composite.xmax - composite.xmin:
+            idx = composite.xmin - self.xmin + j
+            self.sense[idx] += composite.sense[j]
+            self.anti[idx] += composite.anti[j]
+            j += 1
+
+        self.individual_composites[composite.id] = composite
+
+    def loadCompositeDict(self,compositeDict: dict):
+        for composite in compositeDict:
+            # If no files, initialize sense and anti arrays; otherwise, pad sense and anti arrays to new xdomain
+            self.xmin = min(composite.xmin, self.xmin)
+            self.xmax = max(composite.xmax, self.xmax)
+            if len(self.individual_composites) == 0:
+                self.sense = [0] * (composite.xmax - composite.xmin + 1)
+                self.anti = [0] * (composite.xmax - composite.xmin + 1)
+            else:
+                xmin = min([c.xmin for c in self.individual_composites])
+                xmax = max([c.xmax for c in self.individual_composites])
+                prefix = [0] * (xmin - self.xmin)
+                suffix = [0] * (self.xmax - xmax)
+                self.sense = prefix + self.sense + suffix
+                self.anti = prefix + self.anti + suffix
 
-        # Add the values to sense and anti arrays
-        if "sense" in fields[0].lower():
-            print("sense")
-            i = 1
-            while i < len(fields):
-                sense[offset + i - 1] += float(fields[i])
-                i += 1
-        elif "anti" in fields[0].lower():
-            i = 1
-            while i < len(fields):
-                anti[offset + i - 1] += float(fields[i])
-                i += 1
-        # If the first field is not empty or "NAME" and does not contain "sense" or "anti" parse as combined or midpoint data
-        elif not (fields[0] == "" or fields[0] == "NAME"):
-            i = 1
-            while i < len(fields):
-                sense[offset + i - 1] += float(fields[i]) / 2
-                anti[offset + i - 1] += float(fields[i]) / 2
-    return Composite(xmin, xmax, sense, anti)
+            # Update sense and anti arrays
+            j = composite.xmin - self.xmin
+            while j <= composite.xmax - composite.xmin:
+                idx = composite.xmin - self.xmin + j
+                self.sense[idx] += composite.sense[j]
+                self.anti[idx] += composite.anti[j]
+                j += 1
 
+            self.individual_composites[composite.id] = composite
+
+    def __str__(self):
+        return str(self.individual_composites)
 
 def main():
-    c = parseComposite("sample.out")
-    print(c)
+    c = parseComposite.parseComposite("sample_composites/sample_1.out")
+    compositeGroup = CompositeGroup()
+    compositeGroup.loadComposite(c)
+    c2 = parseComposite.parseComposite("sample_composites/sample2.out.txt")
+    compositeGroup.loadComposite(c2)
+    print(compositeGroup)
+
 
 if __name__ == "__main__":
     main()