Adding new capability to rotate array:

1) arrayReorientation: reorients the array such that the wind direction is always aligned with the global x-axis to facilitate extraction to FAST.Farm.
2) getRAFT function updated in Project to reinsert IDs after extracting info so that when called again, an error doesn't occur because of absence of ID key.
3) Platform setPosition function updated to only reposition/reorient anchored lines.

Author: Yuksel-Rudy

famodel/platform/platform.py

@@ -107,8 +107,9 @@ def setPosition(self, r, heading=None, degrees=False,project=None):
 
                 # Heading of the mooring line
                 heading_i = self.mooring_headings[count] + self.phi
-                # Reposition the whole Mooring
-                self.attachments[att]['obj'].reposition(r_center=self.r, heading=heading_i,project=project)
+                # Reposition the whole Mooring if it is an anchored line
+                if not self.attachments[att]['obj'].shared:
+                    self.attachments[att]['obj'].reposition(r_center=self.r, heading=heading_i,project=project)
 
                 count += 1
 

famodel/project.py

@@ -2765,7 +2765,9 @@ def getRAFT(self,RAFTDict,pristine=1):
 
             if 'ID' in RAFTDict['array']['keys']:
                 IDindex = np.where(np.array(RAFTDict['array']['keys'])=='ID')[0][0]
+                IDdata  = [row[IDindex] for row in RAFTDict['array']['data']]
                 RAFTDict['array']['keys'].pop(IDindex) # remove key for ID because this doesn't exist in RAFT array table
+                reinsert = True
             if 'topsideID' in RAFTDict['array']['keys']:
                 ts_loc = RAFTDict['array']['keys'].index('topsideID')
                 RAFTDict['array']['keys'][ts_loc] = 'turbineID'
@@ -2789,7 +2791,8 @@ def getRAFT(self,RAFTDict,pristine=1):
                     if turb[tsIDindex] > ti:
                         turb[tsIDindex] -= 1
 
-                
+            
+
             # create empty mooring dictionary
             RAFTDict['mooring'] = {}
             #RAFTDict['mooring']['currentMod']
@@ -2817,6 +2820,12 @@ def getRAFT(self,RAFTDict,pristine=1):
             # connect RAFT fowt to the correct moorpy body
             for i in range(0,len(self.platformList)): # do not include substations (these are made last)
                 self.array.fowtList[i].body = self.ms.bodyList[i]
+
+            # Reinsert 'ID' key and data back into RAFTDict
+            if reinsert:
+                RAFTDict['array']['keys'].insert(IDindex, 'ID')  # Reinsert 'ID' key at its original position
+                for i, row in enumerate(RAFTDict['array']['data']):
+                    row.insert(IDindex, IDdata[i])  # Reinsert 'ID' data into each row            
         else:
             raise Exception('Platform(s) must be specified in YAML file')
 
@@ -4251,8 +4260,116 @@ def resetArrayCenter(self, FOWTOnly=True):
 
             if 'platforms' in self.RAFTDict or 'platform' in self.RAFTDict:
                     self.getRAFT(self.RAFTDict,pristine=1)
+        self.getMoorPyArray()
+        
+    def arrayReorientation(self, windHeading=None, degrees=False):
+        '''
+        Reorients the array based on a given wind heading. The array will be reoriented such that wind faces East (the zero in FFarm). 
+        Useful to allign the array with the wind direction.
+
+        Parameters
+        ----------
+        windHeading, float (optional)
+            The heading of the wind [deg or rad] depending on
+            degrees parameter. The heading is based on compass convention (North=0deg and +ve CW).
+        degrees : bool (optional)
+            Determines whether to use degree or radian for heading.
+        '''
+
+        from scipy.interpolate import griddata
+
+        # Check if windHeading is given
+        if windHeading is None:
+            raise ValueError("windHeading is not given. Please provide a valid wind heading.")
+        
+        if degrees:
+            windHeading = np.radians(windHeading)
+        
+        # reference wind heading (aligned with x-axis)
+        windHeadingRef = np.radians(270)
+        # Calculate the phi angle with which we will rotate the array
+        phi = ((np.pi/2 - windHeading) + np.pi) % (2*np.pi)
+        
+        # Compute rotation matrix for faster computation
+        R = np.array([[np.cos(phi), np.sin(phi)],
+                  [-np.sin(phi), np.cos(phi)]])
+        
+        # Rotate the boundary
+        self.boundary = np.dot(R, self.boundary.T).T
+        
+        # Rotate the bathymetry
+        X, Y = np.meshgrid(self.grid_x, self.grid_y)
+        coords_flat = np.stack([X.flatten(), Y.flatten()], axis=-1)
+        rotated_coords_flat = np.dot(R, coords_flat.T).T
+        rotated_X_flat, rotated_Y_flat = rotated_coords_flat[:, 0], rotated_coords_flat[:, 1]
+        X_rot = rotated_X_flat.reshape(X.shape)
+        Y_rot = rotated_Y_flat.reshape(Y.shape)
+
+        min_X = np.min(X_rot)
+        max_X = np.max(X_rot)
+        min_Y = np.min(Y_rot)
+        max_Y = np.max(Y_rot)
+
+        self.grid_x = np.arange(min_X, max_X, np.min(np.diff(self.grid_x)))
+        self.grid_y = np.arange(min_Y, max_Y, np.min(np.diff(self.grid_y)))
+        X_rot, Y_rot = np.meshgrid(self.grid_x, self.grid_y)
+        
+        # Interpolate self.grid_depth onto the rotated grid
+        depth_flat = self.grid_depth.flatten()  # Flatten the depth values
+        rotated_depth = griddata(
+            points=rotated_coords_flat,  # Original grid points
+            values=depth_flat,   # Original depth values
+            xi=(X_rot, Y_rot),   # New rotated grid points
+            method='linear'      # Interpolation method (can also use 'nearest' or 'cubic')
+        )        
+
+        if np.isnan(rotated_depth).any():
+            nan_mask = np.isnan(rotated_depth)
+            nearest_depth = griddata(
+                points=rotated_coords_flat,
+                values=depth_flat,
+                xi=(X_rot, Y_rot),
+                method='nearest'
+            )
+            rotated_depth[nan_mask] = nearest_depth[nan_mask]
+
+        self.grid_depth = rotated_depth
+        
+        # Rotate the platforms
+        for pf in self.platformList.values():
+            pf.r[:2] = np.dot(R, pf.r[:2].T).T
+            pf.phi = pf.phi + windHeadingRef - windHeading
+        
+
+        # Rotate moorings
+        for moor in self.mooringList.values():
+            # if not moor.shared:
+            mooringHeading = np.radians(moor.heading) + windHeadingRef - windHeading
+            moor.reposition(heading=mooringHeading, project=self)
+            # else:
+            #     mooringHeading = np.radians(obj.heading)
+            #     moor.reposition(heading=mooringHeading)
+            
+            
+
+            #     if isinstance(obj, Cable):
+            #         cableHeading = [obj.subcomponents[0].headingA + phi, obj.subcomponents[-1].headingB + phi]
+            #         obj.reposiiton(headings=cableHeading, project=self)
 
+        # Change RAFTDict if available.
+        if self.RAFTDict:
+            x_idx = self.RAFTDict['array']['keys'].index('x_location')
+            y_idx = self.RAFTDict['array']['keys'].index('y_location')            
+            p_idx = self.RAFTDict['array']['keys'].index('heading_adjust')            
+            for i, pf in enumerate(self.platformList.values()):
+                self.RAFTDict['array']['data'][i][x_idx] = pf.r[0]
+                self.RAFTDict['array']['data'][i][y_idx] = pf.r[1]
+                self.RAFTDict['array']['data'][i][p_idx] = np.degrees(pf.phi)
 
+            if 'platforms' in self.RAFTDict or 'platform' in self.RAFTDict:
+                    self.getRAFT(self.RAFTDict,pristine=1)        
+        
+        self.getMoorPyArray()
 
     def updateFailureProbability(self):
         '''