Setup some API functions, move soil info out of anchor design dict

-- addPlatform
-- addMooring
-- addAnchor
-- addSubstation
-- addTurbine
-- added some mooring API functions too
	-- addSection
	-- addConnector
	-- connectSubcomponents
-- initialization/loading now uses API functions
-- soil info now stored in anchor.soilProps instead of in design dictionary

Author: lsirkis

famodel/anchors/anchor.py

@@ -30,8 +30,6 @@ def __init__(self, dd=None, ms=None, r=[0,0,0], aNum=None, id=None,
                      L2   torpedo anchor shaft length
                      zlug padeye z elevation (+ down into the soil)
                      beta angle of plate anchor after keying (optional)
-                soil_type:    <<< not design information
-                angle: # seabed angle   <<< not design information
                 cost:
                     matCost: # material cost
                     instCost: # installation cost
@@ -136,15 +134,15 @@ def makeMoorPyAnchor(self, ms):
         return(ms)
 
 
-    def getAnchorCapacity(self,ground_conds=None,installAdj=1,profile=None,loads=None,plot=True):
+    def getAnchorCapacity(self,ground_cons=None,installAdj=1,profile=None,loads=None,plot=True):
         '''
         Calls anchor capacity functions developed by Felipe Moreno for the correct anchor type 
 
         Parameters
         ----------
         ground_conds : dict, optional
-            Ground conditions ex: UCS,Em,phi,gamma,effective stress,etc. The default is None.
-            If no dict provided, the ground conds will be pulled from the dd['soil_properties']
+            Ground conditions dictionary with the key as the soil type name, values as soil info such as UCS,Em,phi,gamma,effective stress,etc. The default is None.
+            If no dict provided, the ground conds will be pulled from the anchor soilProps property
         installAdj : float, optional
             Adjustment to the capacity based on installation (dummy variable for now, but future installation functions
                                                               will dictate this value)
@@ -167,8 +165,12 @@ def getAnchorCapacity(self,ground_conds=None,installAdj=1,profile=None,loads=Non
         anchType = self.dd['type'] 
         geom = self.dd['design']# geometric anchor information
 
-        if not ground_conds: 
-            ground_conds = self.dd['soil_properties']
+        if not ground_cons:
+            soil = next(iter(self.soilProps.keys()), None) # soil type
+            ground_conds = self.soilProps[soil]
+        else:
+            soil = next(iter(ground_cons.keys()))
+            ground_conds = ground_cons[soil]
 
         for key,prop in ground_conds.items():
             if isinstance(prop,list) or isinstance(prop,np.ndarray):
@@ -177,7 +179,7 @@ def getAnchorCapacity(self,ground_conds=None,installAdj=1,profile=None,loads=Non
                     break 
                 else:
                     ground_conds[key] = prop[0]
-        soil = self.dd['soil_type'] # soil type
+        
 
         if loads:
             # find out if mudline loads or anchor loads
@@ -548,8 +550,8 @@ def makeEqual_TaTm(mudloads):
                         else:
                             md = att['obj'].dd['sections'][0]['type']['d_nom']
                             mw = att['obj'].dd['sections'][0]['type']['w']
-                soil = self.dd['soil_type']
-                ground_conds = self.dd['soil_properties']
+                soil = next(iter(self.soilProps.keys()), None)
+                ground_conds = self.soilProps[soil]
                 # update soil conds as needed to be homogeneous
                 for key,prop in ground_conds.items():
                     if isinstance(prop,list) or isinstance(prop,np.ndarray):

famodel/helpers.py

@@ -942,7 +942,7 @@ def getConnectors(c_config, mName, proj):
             # create connector object with c_config entries
             proj.mooringList[mName].dd['connectors'].append(Connector(**c_config[i]))
 
-def getAnchors(lineAnch, arrayAnchor, proj, mc=None,aNum=0):
+def getAnchors(lineAnch, arrayAnchor, proj):
     '''Create anchor design dictionary based on a given anchor type
 
     Parameters
@@ -953,10 +953,6 @@ def getAnchors(lineAnch, arrayAnchor, proj, mc=None,aNum=0):
         list of anchors listed in array_mooring anchor_data table of ontology yaml.
     proj : project class instance
         project object to develop anchors for
-    mc : mooring class instance, optional
-        mooring class that the anchor is a part of (used only if not a shared anchor). The default is None.
-    aNum : int, optional
-        anchor ID in the anchor data table (used only if it is a shared anchor). The default is 0.
 
     Returns
     -------
@@ -966,11 +962,6 @@ def getAnchors(lineAnch, arrayAnchor, proj, mc=None,aNum=0):
     '''
     ad = {'design':{}, 'cost':{}} 
     ad['design'] = deepcopy(proj.anchorTypes[lineAnch])
-    if proj.soil_x is not None: # get soil conditions at anchor location if soil info available
-        if mc:
-            ad['soil_type'], ad['soil_properties'] = proj.getSoilAtLocation(mc.rA[0], mc.rA[1])
-        else:
-            ad['soil_type'], ad['soil_properties'] = proj.getSoilAtLocation(arrayAnchor[aNum-1]['x'],arrayAnchor[aNum-1]['y'])
     ad['type'] = proj.anchorTypes[lineAnch]['type']
     ad['name'] = lineAnch
 

famodel/mooring/mooring.py

@@ -89,32 +89,22 @@ def __init__(self, dd=None, subsystem=None, anchor=None,
             # and dict of scaling props (would be used by linedesign) ?
             self.n_sec = len(self.dd['sections'])
 
+            self.i_con = []
+            self.i_sec = []
             # Turn what's in dd and turn it into Sections and Connectors
             for i, con in enumerate(self.dd['connectors']):
                 if con and 'type' in con:
                     Cid = con['type']+str(i)
                 else:
-                    Cid = 'Conn'+str(i)
-                self.dd['connectors'][i] = Connector(Cid,**self.dd['connectors'][i])
+                    Cid = None
+                self.addConnector(con, i, id=Cid, insert=False)
 
             for i, sec in enumerate(self.dd['sections']):
-                self.dd['sections'][i] = Section('Section'+str(i),**self.dd['sections'][i])
-                #self.dd['connectors'][i  ].attach(self.dd['sections'][i], end=0)
-                #self.dd['connectors'][i+1].attach(self.dd['sections'][i], end=1)
+                self.addSection(sec['L'],sec['type'],i, insert=False)
 
-            # >>> add some error checks for the correct lengths <<<
-            
-            # Connect them and store them in self(Edge).subcomponents!
-            subcons = []  # temporary list of node-edge-node... to pass to the function
-            for i in range(self.n_sec):
-                subcons.append(self.dd['connectors'][i])
-                subcons.append(self.dd['sections'][i])
-            subcons.append(self.dd['connectors'][-1])
-            self.addSubcomponents(subcons)  # Edge method to connect and store em
-            
-            # Indices of connectors and sections in self.subcomponents list
-            self.i_con = list(range(0, 2*self.n_sec+1, 2))
-            self.i_sec = list(range(1, 2*self.n_sec+1, 2))
+            # connect subcomponents and update i_sec and i_conn lists
+            self.connectSubcomponents()
+
 
 
         # relative positions (variables could be renamed)
@@ -274,7 +264,7 @@ def reposition(self, r_center=None, heading=None, project=None,
 
         for i,att in enumerate(self.attached_to):
             iend = self.rA if i == 0 else self.rB
-            if hasattr(att,'aNum'):
+            if type(att).__name__ in 'Anchor':
                 # this is an anchor, move anchor location
                 att.r = iend
                 if att.mpAnchor:
@@ -926,3 +916,100 @@ def getEnvelope(self,ang_spacing=45,SFs=True):
 
         return(x,y)
 
+
+    def addSection(self, section_length, section_type, index, id=None, insert=True):
+        '''
+        Add a section to the design
+        
+        Parameters
+        ----------
+        section_length : float
+            Length of new section in [m]
+        section_type : dict
+            Dictionary of section properties
+        index : int
+            New index of section in the mooring design dictionary sections list
+        id : str/int, optional
+            Id of section
+        '''
+        if not id:
+            if insert:
+                for i,sec in enumerate(self.dd['sections']):
+                    # update ids of sections
+                    if i>=index and isinstance(sec, Section):
+                        sec.id = 'Section'+str(i+1)
+            id='Section'+str(index)
+        newsection_dd = {'type':section_type,'L':section_length}
+        newsection = Section(id,**newsection_dd)
+        if insert:
+            self.dd['sections'].insert(index, newsection)
+        else:
+            self.dd['sections'][index] = newsection
+        
+        
+        return(newsection)
+    
+    def addConnector(self, conn_dd, index, id=None, insert=True):
+        '''
+        Add a connector to the design
+
+        Parameters
+        ----------
+        conn_dd : dict
+            Connector design dictionary
+        index : int
+            New index of connector in the mooring design dictionary connectors list
+        id : str or int, optional
+            ID of new connector
+        insert : bool, optional
+            Controls whether to insert a connector in the list or replace an entry with a connector
+
+        Returns
+        -------
+        Connector object
+            New connector object added to design dictionary
+
+        '''
+        if not id:
+            if insert:
+                for i,conn in enumerate(self.dd['connectors']):
+                    # update ids of connectors
+                    if i>=index and isinstance(conn, Connector):
+                        conn.id = 'Conn'+str(i+1)
+            id = 'Conn'+str(index)
+        newconn = Connector(id, **conn_dd)
+        if insert:
+            self.dd['connectors'].insert(index, newconn)
+        else:
+            self.dd['connectors'][index] = newconn
+        
+        return(newconn)
+    
+    def connectSubcomponents(self):
+        
+        # first disconnect any current subcomponents
+        for ii in self.i_sec:
+            self.subcomponents[ii].detachFrom('A')
+            self.subcomponents[ii].detachFrom('B')
+            
+        # detach end connectors from platforms/anchors just in case
+        if len(self.subcomponents)>0:
+            endattsA = [att['obj'] for att in self.subcomponents[0].attachments.values()]
+            endattsB = [att['obj'] for att in self.subcomponents[-1].attachments.values()]
+            for att in endattsA:
+                self.subcomponents[0].detach(att)
+            for att in endattsB:
+                self.subcomponents[-1].detach(att)
+            
+        # Now connect the new set of subcomponents and store them in self(Edge).subcomponents!
+        subcons = []  # temporary list of node-edge-node... to pass to the function
+        for i in range(self.n_sec):
+            subcons.append(self.dd['connectors'][i])
+            subcons.append(self.dd['sections'][i])
+        subcons.append(self.dd['connectors'][-1])
+        self.addSubcomponents(subcons)  # Edge method to connect and store em
+        
+        # Indices of connectors and sections in self.subcomponents list
+        self.i_con = list(range(0, 2*self.n_sec+1, 2))
+        self.i_sec = list(range(1, 2*self.n_sec+1, 2))
+