Add interpolation between cable designs to adjust for depth;

  - add multiple cable designs for range of depths and FAModel will now determine suitable cable design options and interpolate for new depths
more efficient load/sf storage for connectors&sections

Author: lsirkis

famodel/cables/cable.py

@@ -10,6 +10,7 @@
 from famodel.cables.static_cable import StaticCable
 from famodel.cables.components import Joint, Jtube
 from famodel.famodel_base import Edge
+from famodel.helpers import cableDesignInterpolation
 
 
 class Cable(Edge):
@@ -109,8 +110,7 @@ def __init__(self, id, d=None):
         self.r = []
 
         # get cable length
-        self.getL()
-            
+        self.getL()           
 
         # failure probability
         self.failure_probability = {}
@@ -185,14 +185,25 @@ def reposition(self,headings=None,project=None,rad_fair=[]):
             if lensub > 1:
                 for i,sub in enumerate(self.subcomponents):                 
                     if i == 0:
+                        oldz = project.getDepthAtLocation(sub.rB[0],
+                                                          sub.rB[1])
                         # get depth at location of rB
                         xy = [sub.rA[0]+np.cos(headingA)*sub.span,
                               sub.rA[1]+np.sin(headingA)*sub.span]
                         z = project.getDepthAtLocation(xy[0],xy[1])
+                        # adjust design if applicable
+                        if sub.alternate_designs is not None and oldz!=z:
+                            sub.dd = cableDesignInterpolation(
+                                sub.dd, 
+                                sub.alternate_designs,
+                                z)
+                            self.reposition() # recursively call reposition
                         # set the end B of the first subsection
                         sub.rB = [xy[0],xy[1],-z]
                         sub.z_anch = -z
                         sub.depth = z
+                        
+
                         # set joint
                         self.subcomponents[i+1]['r'] = sub.rB
                         # set rA of next cable section
@@ -201,6 +212,13 @@ def reposition(self,headings=None,project=None,rad_fair=[]):
                         xy = [sub.rB[0]+np.cos(headingB)*sub.span,
                               sub.rB[1]+np.sin(headingB)*sub.span]
                         z = project.getDepthAtLocation(xy[0],xy[1])
+                        # adjust design if applicable
+                        if sub.alternate_designs is not None and oldz!=z:
+                            sub.dd = cableDesignInterpolation(
+                                sub.dd, 
+                                sub.alternate_designs,
+                                z)
+                            self.reposition() # re-call reposition
                         # set the end A of the last subsection
                         sub.rA = [xy[0],xy[1],-z]
                         # update z_anch and depth of the subsection
@@ -272,6 +290,67 @@ def makeLine(self,buff_rad=20,include_dc=True):
 
         return(line)
 
+    def dynamicCables(self):
+        """ Return list of dynamic cables in this cable object """
+        return [a for a in self.subcomponents if isinstance(a, DynamicCable)]
+    
+    def updateTensions(self, DAF=1):
+        """
+        Update the tensions stored in dynamic cable load dictionaries
+
+        Returns
+        -------
+        None.
+
+        """
+        for dc in self.dynamicCables():
+            if not 'Tmax' in dc.loads:
+                dc.loads['Tmax'] = 0
+            if dc.ss:
+                for line in dc.ss.lineList:
+                    Tmax = max([abs(line.TA), abs(line.TB)])
+                    if Tmax*DAF > dc.loads['Tmax']:
+                        dc.loads['Tmax'] = deepcopy(Tmax)*DAF
+        return(dc.loads['Tmax'])
+    
+    # def updateCurvature(self):
+    #     for dc in self.dyamicCables():
+    #         if not dc.curvature:
+    #             dc.curvature = np.inf
+    #         if dc.ss:
+    #             curv = dc.ss.calcCurvature()
+    #             if curv > dc.curvature:
+    #                 dc.curvature = curv
+    #             mCSF = dc.ss.getMinCurvSF()
+    
+    def updateSafetyFactors(self, key='tension', load='Tmax', prop='MBL',
+                            info={}):
+        """
+        Update the safety factor dictionaries stored in dynamic cable objects
+
+        Parameters
+        ----------
+        key : str/int, optional
+            key in safety factor dictionary of dynamic cables. 
+            The default is 'tension'.
+        load : str, optional
+            Key in load dictionary of dynamic cables. The default is 'Tmax'.
+        prop : str, optional
+            Key in dynamic cable properties dictionary to compare to load. 
+            The default is 'MBL'.
+        info : dict, optional
+            Information dictionary to add in the safety_factors dict for context
+
+        Returns
+        -------
+        None.
+
+        """
+        for dc in self.dynamicCables():
+            dc.safety_factors[key] = dc.dd['type'][prop]/dc.loads[load]
+            dc.safety_factors['info'] = info
+        
+    
     def updateSpan(self,newSpan):
         '''
         Change the lengths of subcomponents based on the new total span

famodel/cables/dynamic_cable.py

@@ -110,6 +110,9 @@ def __init__(self, id, dd=None, subsystem=None, rA=[0,0,0], rB=[0,0,0],
         self.rho = rho
         self.g = g
 
+        # alternate designs to interpolate between when depth changes
+        self.alternate_designs = None
+        
         # Dictionaries for addition information
         self.loads = {}
         self.safety_factors = {} # calculated safety factor