diff --git a/arbdmodel/polymer.py b/arbdmodel/polymer.py
deleted file mode 100644
index 40c684a3b34a5e37d4d16c22ba8c3716fc962f96..0000000000000000000000000000000000000000
--- a/arbdmodel/polymer.py
+++ /dev/null
@@ -1,159 +0,0 @@
-class PolymerParticle(PointParticle):
- def __init__(self, type_, position, name="A", **kwargs):
- self.name = name
- self.contour_position = None
- PointParticle.__init__(self, type_, position, name=name, **kwargs)
- self.intrahelical_neighbors = []
- self.other_neighbors = []
- self.locations = []
-
- def get_intrahelical_above(self):
- """ Returns bead directly above self """
- # assert( len(self.intrahelical_neighbors) <= 2 )
- for b in self.intrahelical_neighbors:
- if b.get_contour_position(self.parent, self.contour_position) > self.contour_position:
- return b
-
- def get_intrahelical_below(self):
- """ Returns bead directly below self """
- # assert( len(self.intrahelical_neighbors) <= 2 )
- for b in self.intrahelical_neighbors:
- if b.get_contour_position(self.parent, self.contour_position) < self.contour_position:
- return b
-
- def _neighbor_should_be_added(self,b):
- if type(self.parent) != type(b.parent):
- return True
-
- c1 = self.contour_position
- c2 = b.get_contour_position(self.parent,c1)
- if c2 < c1:
- b0 = self.get_intrahelical_below()
- else:
- b0 = self.get_intrahelical_above()
-
- if b0 is not None:
- c0 = b0.get_contour_position(self.parent,c1)
- if np.abs(c2-c1) < np.abs(c0-c1):
- ## remove b0
- self.intrahelical_neighbors.remove(b0)
- b0.intrahelical_neighbors.remove(self)
- return True
- else:
- return False
- return True
-
- def make_intrahelical_neighbor(self,b):
- add1 = self._neighbor_should_be_added(b)
- add2 = b._neighbor_should_be_added(self)
- if add1 and add2:
- # assert(len(b.intrahelical_neighbors) <= 1)
- # assert(len(self.intrahelical_neighbors) <= 1)
- self.intrahelical_neighbors.append(b)
- b.intrahelical_neighbors.append(self)
-
- def conceptual_get_position(self, context):
- """
- context: object
-
-Q: does this function do too much?
-Danger of mixing return values
-
-Q: does context describe the system or present an argument?
- """
-
- ## Validate Inputs
- ...
-
- ## Algorithm
- """
-context specifies:
- - kind of output: real space, nt within segment, fraction of segment
- - absolute or relative
- - constraints: e.g. if passing through
- """
- """
-given context, provide the position
- input
-"""
-
- def get_nt_position(self, seg, near_address=None):
- """ Returns the "address" of the nucleotide relative to seg in
- nucleotides, taking the shortest (intrahelical) contour length route to seg
- """
- if seg == self.parent:
- pos = self.contour_position
- else:
- pos = self.get_contour_position(seg,near_address)
- return seg.contour_to_nt_pos(pos)
-
- def get_contour_position(self,seg, address = None):
- """ TODO: fix paradigm where a bead maps to exactly one location in a polymer
- - One way: modify get_contour_position to take an optional argument that indicates where in the polymer you are looking from
- """
-
- if seg == self.parent:
- return self.contour_position
- else:
- cutoff = 30*3
- target_seg = seg
-
- ## depth-first search
- ## TODO cache distances to nearby locations?
- def descend_search_tree(seg, contour_in_seg, distance=0, visited_segs=None):
- nonlocal cutoff
- if visited_segs is None: visited_segs = []
-
- if seg == target_seg:
- # pdb.set_trace()
- ## Found a segment in our target
- sign = 1 if contour_in_seg == 1 else -1
- if sign == -1: assert( contour_in_seg == 0 )
- if distance < cutoff: # TODO: check if this does anything
- cutoff = distance
- return [[distance, contour_in_seg+sign*seg.nt_pos_to_contour(distance)]], [(seg, contour_in_seg, distance)]
- if distance > cutoff:
- return None,None
-
- ret_list = []
- hist_list = []
- ## Find intrahelical locations in seg that we might pass through
- conn_locs = seg.get_connections_and_locations("intrahelical")
- if isinstance(target_seg, SingleStrandedSegment):
- tmp = seg.get_connections_and_locations("sscrossover")
- conn_locs = conn_locs + list(filter(lambda x: x[2].container == target_seg, tmp))
- for c,A,B in conn_locs:
- if B.container in visited_segs: continue
- dx = seg.contour_to_nt_pos( A.address, round_nt=False ) - seg.contour_to_nt_pos( contour_in_seg, round_nt=False)
- dx = np.abs(dx)
- results,history = descend_search_tree( B.container, B.address,
- distance+dx, visited_segs + [seg] )
- if results is not None:
- ret_list.extend( results )
- hist_list.extend( history )
- return ret_list,hist_list
-
- results,history = descend_search_tree(self.parent, self.contour_position)
- if results is None or len(results) == 0:
- raise Exception("Could not find location in segment") # TODO better error
- if address is not None:
- return sorted(results,key=lambda x:(x[0],(x[1]-address)**2))[0][1]
- else:
- return sorted(results,key=lambda x:x[0])[0][1]
- # nt_pos = self.get_nt_position(seg)
- # return seg.nt_pos_to_contour(nt_pos)
-
- def update_position(self, contour_position):
- self.contour_position = contour_position
- self.position = self.parent.contour_to_position(contour_position)
- if 'orientation_bead' in self.__dict__:
- o = self.orientation_bead
- o.contour_position = contour_position
- orientation = self.parent.contour_to_orientation(contour_position)
- if orientation is None:
- print("WARNING: local_twist is True, but orientation is None; using identity")
- orientation = np.eye(3)
- o.position = self.position + orientation.dot( np.array((Segment.orientation_bond.r0,0,0)) )
-
- def __repr__(self):
- return "<SegmentParticle {} on {}[{:.2f}]>".format( self.name, self.parent, self.contour_position)