Merge remote-tracking branch 'origin/main'

Author: deslaughter

docs/content/docs/results/blade-tip.png

@@ -81,4 +81,28 @@ To visualize a mode shape, click the `Visualize` button on the `Mode` card or th
 
 The white lines are the blades and tower. The colored lines are the paths that the nodes travel through during the animation. The color, from blue to yellow, is based on the length of the path, with longer paths being a brighter color. The display of the node paths can be toggled by clicking the `Hide Node Paths` button.
 
-The `Clear` button is used to clear modes that have been visualized. Below the `Clear` and `Hide Node Paths` buttons is a list of buttons indicating which line and operating point is being visualized. Each time the `Visualize` button is clicked, a new line-operating-point button appears. The user can select which mode to visualize by clicking these buttons. 
+The `Clear` button is used to clear modes that have been visualized. Below the `Clear` and `Hide Node Paths` buttons is a list of buttons indicating which line and operating point is being visualized. Each time the `Visualize` button is clicked, a new line-operating-point button appears. The user can select which mode to visualize by clicking these buttons. 
+
+
+When a mode shape is visualized, an additional 2D chart will appear below showing the `blade tip deflection analysis`. This chart demonstrates the deflection of blade tips across frames for both flap and edge directions.
+
+![](blade-tip.png)
+
+The blade tip deflection chart provides the following information:
+
+- **X-axis**: Animation frame number (1 through total number of frames)
+- **Y-axis**: Tip deflection magnitude in the local coordinate system
+- **Flap deflection**: Solid lines showing out-of-plane blade bending
+- **Edge deflection**: Dashed lines showing in-plane blade bending
+- **Multiple blades**: Each blade component is displayed with different colors for easy comparison
+
+Note that the blade tip deflection analysis requires specific OpenFAST configuration settings to generate the necessary VTK files with orientation data:
+
+**Required settings in the main `.fst` file:**
+```
+Linearize    True      Linearization analysis {True/False}
+WrVTK        2         VTK visualization data output: (0: none; 1: init; 2: animation)
+VTK_fields   True      Write mesh fields to VTK data files? {True/False}
+```
+
+With these settings, verify that generated `.vtp` files contain orientation field data.

docs/content/docs/results/index.md

@@ -241,4 +241,4 @@ onMounted(() => {
     <canvas id="modeVizCanvas" class="h-100 w-100"></canvas>
 </template>
 
-<style scoped></style>
+<style scoped></style>

frontend/src/components/ModeViz.vue

@@ -241,6 +241,133 @@ const charts = computed(() => {
     return objs
 })
 
+// Add Blade Tip Deflection Chart with Local Line Data
+const bladeTipChart = computed(() => {
+    const currentModeData = project.modeViz[project.currentVizID]
+
+    // Get Component names
+    const componentNames = new Set<string>()
+    for (const frame of currentModeData.Frames) {
+        for (const componentName in frame.Components) {
+            componentNames.add(componentName)
+        }
+    }
+    console.log("Component Names:", Array.from(componentNames))
+
+    const datasets: any[] = []
+    const colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b']       // Expecting 3 blades with 2 series each (Flap and Edge)
+    let colorIndex = 0
+
+    // Loop over each component (blade) - similar to PlotTipDeflection
+    for (const componentName of componentNames) {
+        console.log("Adding series for", componentName)
+        
+        // For the blade tip, we only need the last point of each frame
+        const tipFlapData: {x: number, y: number}[] = []
+        const tipEdgeData: {x: number, y: number}[] = []
+        
+        for (let frameIndex = 0; frameIndex < currentModeData.Frames.length; frameIndex++) {
+            const frame = currentModeData.Frames[frameIndex]
+            
+            if (frame.Components[componentName]) {
+                const component = frame.Components[componentName]
+                
+                // Check if LocalLine exists and has data
+                if (component.LocalLine && component.LocalLine.length > 0) {
+                    // Get the last point (tip)
+                    const tipPoint = component.LocalLine[component.LocalLine.length - 1]
+                    
+                    tipFlapData.push({
+                        x: frameIndex + 1, // Frame numbers start from 1
+                        y: tipPoint.XYZ[0]  // X coordinate (Flap direction)
+                    })
+                    
+                    tipEdgeData.push({
+                        x: frameIndex + 1, // Frame numbers start from 1
+                        y: tipPoint.XYZ[1]  // Y coordinate (Edge direction)
+                    })
+                }
+            }
+        }
+        
+        console.log("Tip Flap data:", tipFlapData)
+        console.log("Tip Edge data:", tipEdgeData)
+        
+        // Create Flap series
+        if (tipFlapData.length > 0) {
+            datasets.push({
+                label: `Flap_${componentName}`,
+                data: tipFlapData,
+                borderColor: colors[colorIndex % colors.length],
+                backgroundColor: colors[colorIndex % colors.length],
+                showLine: true,
+                pointRadius: 2,
+                pointHoverRadius: 4,
+                borderWidth: 2,
+            })
+        }
+        
+        // Create Edge series
+        if (tipEdgeData.length > 0) {
+            datasets.push({
+                label: `Edge_${componentName}`,
+                data: tipEdgeData,
+                borderColor: colors[(colorIndex + 1) % colors.length],
+                backgroundColor: colors[(colorIndex + 1) % colors.length],
+                showLine: true,
+                pointRadius: 2,
+                pointHoverRadius: 4,
+                borderWidth: 2,
+                borderDash: [5, 5], // Dashed line to distinguish from Flap
+            })
+        }
+        
+        colorIndex += 2 // Increment by 2 since we use 2 colors per component
+    }
+
+    const options: ChartOptions<'scatter'> = {
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: {
+            legend: { 
+                display: true,
+                position: 'right',
+                labels: {
+                    font: { size: 10 }
+                }
+            },
+            title: {
+                display: true,
+                text: 'Blade Tip Deflection',
+                font: { size: 16, weight: 'bold' }
+            }
+        },
+        scales: {
+            x: {
+                title: { display: true, text: 'Frames', font: { size: 14 } },
+                ticks: { font: { size: 12 } },
+                grid: {
+                    color: '#e0e0e0',
+                }
+            },
+            y: {
+                title: { display: true, text: 'Tip Deflection', font: { size: 14 } },
+                ticks: { font: { size: 12 } },
+                grid: {
+                    color: '#e0e0e0',
+                }
+            },
+        },
+        interaction: {
+            mode: 'nearest',
+            intersect: false
+        },
+        animation: { duration: 0 }
+    }
+
+    return { data: { datasets }, options }
+})
+
 
 </script>
 
@@ -529,10 +656,15 @@ const charts = computed(() => {
             <div class="card-body">
                 <div class="row">
                     <div class="col-10">
+                        <!-- 3D Mode Visualization -->
                         <div style="width:100%; height: 80vh">
                             <ModeViz :ModeData="project.modeViz[project.currentVizID]" :showNodePaths="showNodePaths">
                             </ModeViz>
                         </div>
+                        <!-- 2D Blade Tip Deflection Chart -->
+                        <div style="width:100%; height: 30vh" class="mt-3">
+                            <Scatter ref="bladeTipChart" :options="bladeTipChart.options" :data="bladeTipChart.data" />
+                        </div>
                     </div>
                     <div class="col-2">
                         <div class="d-grid gap-2 mb-3">

frontend/src/components/Results.vue

@@ -1546,6 +1546,7 @@ export namespace viz {
 	}
 	export class Component {
 	    Line: Point[];
+	    LocalLine: Point[];
 
 	    static createFrom(source: any = {}) {
 	        return new Component(source);
@@ -1554,6 +1555,7 @@ export namespace viz {
 	    constructor(source: any = {}) {
 	        if ('string' === typeof source) source = JSON.parse(source);
 	        this.Line = this.convertValues(source["Line"], Point);
+	        this.LocalLine = this.convertValues(source["LocalLine"], Point);
 	    }
 
 		convertValues(a: any, classs: any, asMap: boolean = false): any {

frontend/wailsjs/go/models.ts

@@ -27,7 +27,8 @@ type Point struct {
 }
 
 type Component struct {
-	Line []Point `json:"Line"`
+	Line      []Point `json:"Line"`
+	LocalLine []Point `json:"LocalLine"`
 }
 
 type Frame struct {
@@ -203,6 +204,7 @@ func (opts *Options) GenerateModeData(execPath string, op *lin.LinOP, modeIDs []
 
 	// Parse mode data from files
 	md, err := ParseModeData(vtpFilePaths)
+
 	if err != nil {
 		return nil, err
 	}
@@ -219,14 +221,15 @@ func ParseModeData(vtpFilePaths []string) (*ModeData, error) {
 
 	// Loop through files
 	for _, vtpFile := range vtpFilePaths {
+		fmt.Println("\nProcessing file:", vtpFile)
 
 		// Skip BD blade rotating states files
 		if strings.Contains(filepath.Base(vtpFile), "BD_BldMotionRot") {
 			continue
 		}
 
 		// Load vtk file
-		vtk, err := LoadVTK(vtpFile)
+		vtk, local_vtk, err := LoadVTK(vtpFile)
 		if err != nil {
 			return nil, err
 		}
@@ -296,6 +299,14 @@ func ParseModeData(vtpFilePaths []string) (*ModeData, error) {
 		for j, c := range conn {
 			copy(component.Line[j].XYZ[:], vtk.PolyData.Piece.Points.DataArray.MatrixF32[c])
 		}
+
+		// Copy local line data into component
+		if local_vtk != nil {
+			component.LocalLine = make([]Point, len(conn))
+			for j, c := range conn {
+				copy(component.LocalLine[j].XYZ[:], local_vtk.PolyData.Piece.Points.DataArray.MatrixF32[c])
+			}
+		}
 	}
 
 	return &mv, nil

viz/viz.go

@@ -2,7 +2,11 @@ package viz_test
 
 import (
 	"acdc/viz"
+	"fmt"
+	"os"
 	"testing"
+
+	"github.com/wcharczuk/go-chart/v2" // This can be deleted later after rendering the graph in the frontend. Need v2 to show axes labels.
 )
 
 func TestBuildModeViz(t *testing.T) {
@@ -14,8 +18,86 @@ func TestBuildModeViz(t *testing.T) {
 		"testdata/03_NREL_5MW-ED.Mode1.LinTime1.ED_TowerLn2Mesh_motion.004.vtp",
 		"testdata/03_NREL_5MW-ED.Mode1.LinTime1.ED_TowerLn2Mesh_motion.005.vtp",
 	})
+
 	if err != nil {
 		t.Fatal(err)
 	}
 	t.Logf("%+v", data)
+
+	PlotTipDeflection(data)
+}
+
+func PlotTipDeflection(data *viz.ModeData) {
+
+	fmt.Println(data.Frames)
+
+	// Get Component names - BD_BldMotion1, BD_BldMotion2, BD_BldMotion3.
+	componentNames := make(map[string]struct{})
+	for _, frame := range data.Frames {
+		for k := range frame.Components {
+			componentNames[k] = struct{}{}
+		}
+	}
+	fmt.Println("Component Names:", componentNames)
+	seriesList := make([]chart.Series, 0, len(componentNames)*2)
+
+	// Loop over each blade
+	for componentName := range componentNames {
+		fmt.Println("Adding series of ", componentName)
+		// For the Blade Tip, we only need the last point of each frame
+		tipFlap := make([]float64, len(data.Frames))
+		tipEdge := make([]float64, len(data.Frames))
+		frames := make([]float64, len(data.Frames))
+		for i, frame := range data.Frames {
+			frames[i] = float64(i + 1) // Frame numbers start from 1
+			if component, ok := frame.Components[componentName]; ok {
+				if len(component.LocalLine) > 0 {
+					tipFlap[i] = float64(component.LocalLine[len(component.LocalLine)-1].XYZ[0]) // X coordinate of the last point
+					tipEdge[i] = float64(component.LocalLine[len(component.LocalLine)-1].XYZ[1]) // Y coordinate of the last point
+				}
+			}
+		}
+
+		fmt.Println("Frames:", frames)
+		fmt.Println("Tip Flap:", tipFlap)
+		fmt.Println("Tip Edge:", tipEdge)
+
+		// Create a new series
+		flapSeries := chart.ContinuousSeries{
+			Name:    "Flap_" + componentName,
+			XValues: frames,
+			YValues: tipFlap,
+		}
+
+		edgeSeries := chart.ContinuousSeries{
+			Name:    "Edge_" + componentName,
+			XValues: frames,
+			YValues: tipEdge,
+		}
+
+		seriesList = append(seriesList, flapSeries, edgeSeries)
+	}
+
+	// Create a new chart
+	graph := chart.Chart{
+		Title:  "",
+		Series: seriesList,
+		XAxis: chart.XAxis{
+			Name: "Frames",
+		},
+		YAxis: chart.YAxis{
+			Name: "Tip Deflection",
+		},
+	}
+
+	// Add the legend to the chart
+	graph.Elements = []chart.Renderable{
+		chart.Legend(&graph),
+	}
+
+	// Save the plot as a file
+	f, _ := os.Create("output.png")
+	defer f.Close()
+	graph.Render(chart.PNG, f)
+
 }