Updating ReadMes

Author: lsirkis

famodel/README.md

@@ -110,18 +110,26 @@ The Node class contains the following properties:
 				  'type': 'node'}
  - part_of     : Edge object this node is a subcomponent of (if applicable)
  - r           : xy position of Node [m]
- - theta       : heading of Node [rad]
+ - theta       : heading of Node [rad], rotation is counter-clockwise +
  - R           : rotation matrix
+ - inst        : installation status dictionary, set up as shown below:
+                 {'mobilized': bool,
+                  'installed': bool}
 
 
 The Node class methods are:
  - isAttached      : check if an object is attached to the node
+ - join            : joins another node to this node, in a mutual way. i.e. connector to fairlead
+ - isJoined        : checks if a node is joined to anything else
+ - separate        : opposite of join (separates 2 nodes connected mutually)
  - attach          : attach an object to this node
  - detach          : detach a specified object from this node 
  - getTopLevelEdge : returns higher-level edge this node is a part of, if applicable
  - setPosition     : sets position of node, and heading if applicable 
+ - calculate_r_rel : calculates the relative position between node and object based on combined relative distances of the subordinate subcomponent nodes connecting them
 
 ### Edge Class
+Edge classes may connect to multiple Nodes on each end in the case of parallel sections such as a bridle for a mooring line. 
 The Edge class contains the following properties:
   - id            : unique ID of the edge object
   - attached_to   : object(s) either end of the edge is attached to. 
@@ -131,15 +139,24 @@ The Edge class contains the following properties:
   - rB            : end B location [x,y]
   - part_of       : Edge object this edge is a subcomponent of (if applicable)
   - subcomponents : chain of edges and nodes that make up this edge
+  - subcons_A     : subcomponent for end A (can be multiple)
+  - subcons_B     : subcomponent for end B (can be multiple)
+  - inst          : installation status dictionary. set up as follows:
+                    {'mobilized': bool,
+                     'installed': bool,
+                     'hookedUpA': bool,
+                     'hookedUpB': bool}
   - whole         : boolean, false if sub edges/nodes aren't all connected
 
 The Edge class methods are:
   - isAttachedTo     : checks if specified node is attached to this edge
   - attachTo         : attaches a specified node to end A or end B of this edge
   - detachFrom       : detach a specified end of this edge from what it is attached to
-  - addSubcomponents : adds a sequence of alternating nodes and edges as subcomponents of this edge, connecting the 
+  - addSubcomponents : adds a sequence of alternating nodes and edges as subcomponents 
+  of this edge, connecting the 
                        subcomponent objects in the process.
-  - getTopLevelEdge  : returns higher-level edge this edge is a part of, if applicable
+  - findEnd          : checks if object is a subcomponent of self and which end it's at
+  - getSubcomponent  : returns the subcomponent of the edge corresponding to the provided index. An index with multiple entries can be used for reference to parallel subcomponents
   - setEndPosition   : sets the position of an edge end 
   - delete           : detach the edge from anything it is attached to 
 

famodel/cables/README.md

@@ -59,6 +59,11 @@ These subcomponents alternate between Edges (either a DynamicCable or StaticCabl
 Any connector costs in the cable cost dictionary are added twice (once for each end)
 - getL() : Get the total length of the cable (includes any routing for static cables)
 - updateSpan() : Change the lengths of subcomponents based on the new total span. For dynamic-static-dynamic configurations, just increase static span. For suspended cable, increase lengths of non-buoyant sections
+- makeLine(): make a 2D shapely linestring of the cable
+- dynamicCables(): returns a list of dynamic cables in this cable object
+- updateTensions(): updates the tensions stored in dynamic cable load dictionaries
+- updateSafetyFactors(): updates the safety factor dictionaries stored in dynamic cable objects
+- updateSpan: change the lengths of subcompoennts based on the new total span. For dynamic-static-dynamic configurations, just increase static span. For suspended cable, increase lengths of non-buoyant sections
 
 
 
@@ -79,10 +84,7 @@ The DynamicCable class includes information on the bare cable properties as well
         - L_mid: location along the cable of the midpoint of the buoyancy section
         - module_props: buoyancy module properties
 - ss
-: pristine MoorPy subsystem associated with this dynamic cable
-- ss_mod
-: modified MoorPy subsystem associated with this dynamic cable. 
-Often this is used for adding marine growth
+: MoorPy subsystem associated with this dynamic cable. Reflects the current state of the subsystem, which could include marine growth if addMarineGrowth/project.getMarineGrowth is called
 - rA
 : xyz location for end A of the dynamic cable
 - rB
@@ -188,10 +190,43 @@ Where
 The StaticCable class contains properties and methods for a static section of a power cable. The StaticCable class inherits from Edge.
 
 ### Static Cable Properties
+- dd : design description dictionary for static cable
+- voltage : cable voltage
+- n_sec : number of sections. Default is 1
+- cableType : cable type properties
+- L : static cable length
+- rA : coordinates of static cable end A
+- rB : coordinates of static cable end B
+- rho : density of water [kg/m^3]
+- g : acceleration due to gravity [m/s^2]
+- x : list of x coordinates of routing points
+- y : list of y coordiantes of routing points
+- burial : depth of cable buried
+- loads : dictionary of loads on static cable
+- reliability : dictionary of reliability information 
+- cost : dictionary of cost information
+- failure_probability : probability of failure
 
 ### Static Cable Methods
+- getLength(): Compute the length of the cable based on the end point locations (rA, rB) and any routing information (self.x, self.y. self.rad)
+- makeCableType(): Processes dictionary info to make cableType dictionary
+- updateRouting(): updates routing parameters based on passed in coordinates or existing coordinates. Also re-calculates length of static cable and total length of overall cable object
+- getCost(): returns total cost of static cable based on length and cost per meter. Calls getLength at start to ensure updated length is used.
+
 
 [Back to Top](#the-cable-class)
 ## Joint Class
+The Joint class provides a data structure for cable joint information.
+Joints occur at the transition between static and dynamic cables.
+
+Joints inherit from dictionary and Node.
+### Joint Properties
+- mpConn : moorpy point object associated with this joint
+- r : 3D location of Joint
+### Joint Methods
+- makeMoorPyConnector(): creates a MoorPy point object for this joint. Essentially acts as an anchor point for dynamic cables in most cases.
+
+## Jtube Class
+The Jtube class provides a data structure for J-tubes, which in this case are defined as any structure connecting a dynamic cable to a platform (does not necessarily need to be J-shaped). Inherits from Node and dictionary.
 
 [Back to Top](#the-cable-class)

famodel/cables/static_cable.py

@@ -114,7 +114,7 @@ def makeCableType(self,cabDict):
         cableType=cabDict
         return(cableType)
 
-    
+    """
     def initializeRoute(self):
         # Initially assume that the static portion of the cable goes straight
         # between the two ends of the dynamic cables.
@@ -137,7 +137,7 @@ def initializeRoute(self):
         self.r = np.array([0, 0])
         
         # (fancier routing could be applied later by layout design methods)
-
+    """
 
     def resolveRoute(self):
         '''Takes established cable route points, considers seabed

famodel/mooring/README.md

@@ -43,6 +43,8 @@ The Mooring object contains subcomponent objects that represent each component o
 ## Mooring Properties
 - dd
 : design description dictionary
+- lineProps
+: line property sizing function coefficients
 - n_sec
 : number of sections
 - i_con
@@ -82,6 +84,9 @@ The Mooring object contains subcomponent objects that represent each component o
 
 ## Mooring methods
 
+### reset
+Resets the subsystem and the applied_states dictionary
+
 ### update
 Update the Mooring object based on the current state of the design dictionary, or, a new design dictionary.
 
@@ -91,6 +96,10 @@ Sets length of the section, including in the subsystem if there is one
 ### setSectionType
 Sets lineType of section, including in the subsystem if there is one
 
+### adjustSectionType
+Adjusts the section line Type relative by specifying a new diameter
+and/or material, and looking up the resulting lineType from lineProps.
+
 ### reposition
 Adjusts mooring position based on changed platform location or heading, It can cll a custom "adjuster" function if one is provided. Otherwise it will just update the end positions.
 
@@ -103,30 +112,61 @@ Finds the cost based on the MoorPy subsystem cost estimates
 ### updateTensions
 Gets tensions from subsystem and updates the max tensions dictionaries of each Section object if it is larger than a previous tension
 
+### updateSafetyFactors
+Update safety factors for desired factor type, load type, and property
+
 ### createSubsystem
 
 Create a MoorPy subsystem for a line configuration from the design dictionary. Regular or suspended lines 
 may be used.
 
-### addMarineGrowth
-Re-creates sections part of design dictionary to account for marine growth on the subsystem, then calls createSubsystem() to recreate the line. For a detailed explanation of the function and modeling methods behind it, see [Marine Growth Modeling](#marine-growth-modeling)
+### positionSubcomponents
+Puts any subcomponent connectors/nodes along the mooring in  
+approximate positions relative to the endpoints based on the 
+section lengths.
 
+### addMarineGrowth
+Updates subsystem to account for marine growth on the subsystem. For a detailed explanation of the function and modeling methods behind it, see [Marine Growth Modeling](#marine-growth-modeling)
 
+### setCreep
+Elongates the lines that have the `creep_rate` feature in their MoorProps description (e.g. polyester).
 
+### adjustPropertySets
+Switches the line type propertes to another set as defined in the MoorProps yaml.
 
+### mirror
+Mirrors a half design to create a full line (symmetry assumption). 
+Works with self.sections() and self.connectors() instead of self.dd.
 
+### updateState
+Updates the state of the mooring system based on the provided state dictionary.
 
 ### setCorrosion
 Calculates MBL of chain line with corrosion included for those lines that have a corrosion_rate feature in their MoorProps dictionary.
 
-### setCreep
-Elongates the length of a line that has a creep_rate feature in its MoorProps dictionary.
-
 ### getEnvelope
 Computes the motion envelope of the Mooring based on the watch 
 circle(s) of what it's attached to. If those aren't already 
 calculated, this method will call the relevant getWatchCircle method
 
+### addSection
+Convenience function to add a section to the design
+
+### addConnector
+Convenience function to add a connector to the design
+
+### convertSubcomponents
+Creates Section and Connector objects from the subcomponents dict
+
+### sections 
+Returns a list of sections in the mooring in order from end A to end B
+
+### connectors
+Returns a list of connectors in the mooring in order from end A to end B
+
+### fairleads
+Returns a list of fairleads connected to the mooring at a specified end (A or B)
+
 [Back to Top](#moorings-sections-and-connectors)
 ## The Connector Class
 
@@ -228,11 +268,13 @@ Where A is the area of the line defined as $A=length*diameter$, $\rho$ is the de
 
 Since the drag force calculation depends on the diameter, DNVGL OS-E301_2018 specifies that the pristine nominal diameter should be used to determine the drag force in the area calculation, and only the drag coefficient should be changed to reflect the increase in drag from marine growth. However, MoorDyn utilizes the volume equivalent marine growth diameter for its calculations. To ensure that the resulting drag force will be equivalent, the drag coefficient entered into MoorDyn needs to use the pristine line nominal diameter in the numerator of the last ratio, rather than the marine growth nominal diameter. 
 
-### Marine Growth Dictionary
-The Marine growth dictionary is made of the following sections:
-- th : a list of lists. Each entry is a list with the following contents:
-	[t, z_lower, z_upper] where t is the thickness of marine growth, z_lower is the lower limit of the depth this marine growth thickness is found at, and z_upper is the upper limit of the depth this marine growth thickness is found at. 
-- rho : either a float or a list. If it is a float, this is the density of marine growth for all depths. If it is a list, the index corresponds index in the th list.
-- buoys : a list of marine growth thicknesses for buoyant sections of dynamic power cables. Marine growth on power cables is modeled differently than for mooring lines. See the Marine Growth on Dynamic Cables section in the [Cables ReadMe](../cables/README.md) for more information.
+### Marine Growth Input
+The Marine growth input is a list of dictionaries with the following keys:
+- thickness : marine growth thickness [m] added to nominal radius 
+- lowerRange : lower z value of the range [m] for the corresponding thickness
+- upperRange : upper z value of the range [m] for the corresponding thickness
+- density : marine growth density, if this key is not use the default is 1325 kg/m^3
+
+Marine growth on power cables is modeled differently than for mooring lines. See the Marine Growth on Dynamic Cables section in the [Cables ReadMe](../cables/README.md) for more information.
 
 [Back to Top](#moorings-sections-and-connectors)

famodel/platform/README.md

@@ -5,21 +5,23 @@ The platform class contains properties and methods relating to a moored floating
 Currently, RAFT information on the specific geometry and hydrostatic properties of the platform are not stored in the platform object. When a project is initialized, a RAFT model is created if directed to, and this information is stored in the RAFT model found in project.array.
 
 ## Platform Properties
- - **dd** : design dictionary of the platform, including 
+ - **dd** : design dictionary of the platform
  - **r** : [x,y] coordinates of the platform
- - **phi** : heading offset of the platform
+ - **phi** : heading offset of the platform [rad], clockwise positive
  - **rFair** : fairlead radius [m]
  - **zFair** : fairlead depth [m]
- - **body** : moorpy body object associated with this platform
+ - **body** : moorpy body object associated with this platform. Filled in automatically when project.getMoorPyArray is called
  - **mooring_headings** : headings of associated mooring lines
  - **n_mooring** : number of mooring lines
- - **endB** : dictionary with key as mooring object names and values of booleans for if the end B of that mooring object is attached to the platform
+ - **entity** : describes type of platform. Common options are 'FOWT' (floating wind turbine), 'Substation', 'WEC' (wave energy converter), but user may prescribe any string for the entity
  - **rc** : [row,column] informating location in a uniform grid array
  - **envelopes** : dictionary of 2D motion envelopes, buffers, etc. Each entry is a dict with x,y or shape
-- **loads** : dictionary of loads on platform
+ - **x_ampl** : [m] expected wave-frequency motion amplitude about mean
+- **mean_loads** : dictionary of mean external load magnitudes on platform, default keys are 'current', 'wind', 'thrust', and 'waves'
 - **reliability** : dictionary of platform reliability information
 - **cost** : dictionary of platform costs
 - **failure_probability** : dictionary of platform failure probabilities
+- **raftResults** : dictionary containing raft simulation results for this platform
 
 
 ## Platform Methods
@@ -30,3 +32,5 @@ Currently, RAFT information on the specific geometry and hydrostatic properties
 - **getCables()** : Creates list of cable objects connected to this platform
 - **getAnchors()** : Creates list of anchor objects associated with this platform
 - **getBufferZones()** : Calculates buffer zones around mooring lines and anchors, and saves buffer zones in envelopes dictionary.
+- **updateMooringPoints()** : updates end points of attached moorings based on midpoint of connected fairlead points
+- **calcThrustTotal()** : calculates the total thrust force on a platform by combining thrust forces of all associated turbines

famodel/turbine/README.md

@@ -0,0 +1,15 @@
+# The Turbine Class
+The turbine class contains properties and structures related to a turbine, for example a wind or water turbine. This class inherits from the Node class.
+
+## Turbine Class Properties
+- dd : design description dictionary
+- D  : rotor diameter of turbine
+- loads : dictionary of loads on the turbine
+- reliability : dictionary of turbine reliability factors
+- cost : dictionary of turbine costs
+- failure_probability : dictionary of turbine failure probabilities
+- thrust : maximum thrust force on the turbine
+
+## Turbine Class Methods
+- makeRotor(): creates a RAFT rotor object for the turbine
+- calcThrustForces(): computes and stores the thrust force of the turbine based on rated speed