In this article’s exercise, we will create a Campbell chart in .NET, using the Lightning Chart .NET library. As always, you can download the complete project attached to this article but remember to have a recent version of .NET and Visual Studio.

To create the project from scratch, we will use the Lightning Chart interactive examples tool, so I recommend that you install it so that you can generate this project from scratch if you wish. You will also be able to access the catalog of charts that LC .NET offers.

This application has its free trial version, so you will have no problems using it. That said, let’s get started!

Campbell Diagram

A Campbell diagram (named after Wilfred Campbell) is a type of graph used in modeling turbulence and rotational dynamics. This diagram shows how the rate at which turbulence kinetic energy is dissipated and the scale of turbulence within a flow are related.

It is especially useful for studying boundary layers or turbulent shear flows, helping to understand the turbulent characteristics of such a flow. This graph also represents the response spectrum of a system as a function of its oscillation regime. These diagrams are commonly used to understand the dynamic behavior of rotating machines.

• It is used to analyze the dynamic stability of mechanical systems, especially rotating ones (such as turbines, motors, generators, etc.), where the frequencies of the excitation forces can vary with the rotation speed. 

• Engineers use the Campbell diagram to identify potential resonance problems that may occur at certain speeds and adjust the design to avoid coincidence between the system’s natural frequencies and the excitation frequencies.

A traditional Campbell diagram uses a rotor motion equation to express the external force due to the rotation frequency as a periodic function. This function is represented on a graph, allowing the vibration characteristics of the system to be analyzed.

A transient Campbell diagram, on the other hand, is based on a test or simulation of a complex rotor system, for which a mode equation cannot be formulated.

To create a Campbell diagram, one must follow the increase in RPM over time and record the system response at each RPM state.  This data is then divided and fed into a Fast Fourier Transform (FFT) algorithm to display the frequency response in a 3D graph.

If a constant increase in RPM can be implemented in the rotor system, the frequency response characteristics of the system can be obtained and a graphical representation like a mathematical Campbell diagram can be generated.

Parameters:

• Excitation frequency (on the x-axis): This represents the variation in the frequency of the external forces that affect the system. 

• Natural frequency (on the y-axis): Corresponds to the frequencies at which the vibration modes of the system tend to oscillate. 

Resonance curves: Indicated by the intersections of the excitation frequencies and the natural frequencies, indicating critical zones where resonances can occur.

Feel free to download the ZIP file to follow this Campbell Diagram project.

1. OS: 32-bit or 64-bit Windows Vista or later, Windows Server 2008 R2 or later.
2. DirectX: 9.0c (Shader model 3 and higher) or 11.0 compatible graphics adapter.
3. Visual Studio: 2022 for development, not required for deployment.
4. Platform .NET Framework: installed version 8.0 or newer.

Now go to the next URL and download LightningChart .NET. You’ll then be redirected to a sign-in form where you’ll have to complete a simple sign-up process to get access to your LightningChart account.

After signing in to your account, you can download the SDK “free trial” version that allows you to use important features for this tutorial. When you download the SDK, you’ll have a .exe file like this:

The installation will be a typical Windows process, so please continue with it until it is finished. After the installation, you will see the following programs:

License Manager

In this application, you will see the purchase options. All the projects that you will create with this trial SDK will be available for future developments with all features enabled.

This code creates a chart, optimizes performance, sets margins, and clears any previous data series to prepare the chart for new data.

Creating a Chart:

The code starts by creating a new chart object called _chart using the LightningChart class. It also gives the chart the name, “Campbell diagram chart”. This is essentially initializing a blank chart to work with.

Begin Chart Update:

The BeginUpdate() method is called to disable rendering (displaying the chart) temporarily. This is done to prevent the chart from refreshing every time a property is changed, which makes the updates more efficient. It allows multiple changes to be made to the chart before it’s rendered again.

Memory and Performance Optimization:

The properties DropOldSeriesData and DropOldEventMarkers are set to false. This means that the chart won’t discard old series data or event markers, which helps preserve memory and improve performance.

Setting Margins:

The Margins property of the chart’s XY view is adjusted to set the bottom margin to 100. This changes the space at the bottom of the chart.

Clear Point Line Series:

Finally, the PointLineSeries.Clear() method is called to remove all existing point line series (visual data representations like lines connecting points) from the chart. This clears out any previous data, preparing the chart for new data.

The following code configures various elements of a chart, specifically the legend box and axes (X and Y):

• Make the Legend Box Visible: This makes the first legend box visible on the chart.
  • ViewXY.LegendBoxes[0].Visible = true;

• Position the Legend Box: The legend box is positioned at the top center of the chart.
  • ViewXY.LegendBoxes[0].Position = LegendBoxPositionXY.TopCenter;

• Offset the Legend Box: This sets an offset of 0 on the X-axis (no shift) and 20 on the Y-axis (moves it down 20 units).
  • ViewXY.LegendBoxes[0].Offset.SetValues(0, 20);

• Layout of Legend Items: This sets the legend items to be laid out in a horizontal row.
  • ViewXY.LegendBoxes[0].Layout = LegendBoxLayout.HorizontalRowSpan;

• Hide Checkboxes in the Legend: This disables checkboxes next to the legend items, so users cannot toggle series visibility via checkboxes.
  • ViewXY.LegendBoxes[0].ShowCheckboxes = false;

X-Axis Configuration:

• Set X-Axis Range: This defines the visible range of the X-axis, from 1000 to 6500.
  • ViewXY.XAxes[0].SetRange(1000, 6500); 

• Disable X-Axis Scrolling: This disables scrolling on the X-axis (meaning users can’t drag to zoom or move the axis).
  • ViewXY.XAxes[0].ScrollMode = XAxisScrollMode.None; 

• Set X-Axis Label Format: This formats the X-axis labels to show whole numbers (no decimal places).
  • ViewXY.XAxes[0].LabelsNumberFormat = "0"; 

• Disable Automatic Division Spacing: This prevents automatic spacing for axis divisions, meaning you can manually control the divisions.
  • ViewXY.XAxes[0].AutoDivSpacing = false; 

• Set Major Divisions on X-Axis: The X-axis will have major divisions every 500 units.
  • ViewXY.XAxes[0].MajorDiv = 500; 

• Set X-Axis Value Type: This specifies that the X-axis will use numeric values.
  • ViewXY.XAxes[0].ValueType = AxisValueType.Number; 

• Set X-Axis Title: The title of the X-axis is set to “Engine speed (rpm)”.
  • ViewXY.XAxes[0].Title.Text = "Engine speed (rpm)"; 

• Make X-Axis Title Visible and Change Color:
  • ViewXY.XAxes[0].Title.Visible = true; 

• The title of the X-axis is made visible:
  • ViewXY.XAxes[0].Title.Color = Colors.White; 

• The color of the X-axis title is set to white.

Y-Axis Configuration:

• Set Y-Axis Title: The title of the Y-axis is set to “Frequency (Hz)”.
  • ViewXY.YAxes[0].Title.Text = "Frequency (Hz)";

• Disable Automatic Division Spacing: Like the X-axis, this disables automatic division spacing for the Y-axis.
  • ViewXY.YAxes[0].AutoDivSpacing = false;

• Set Major Divisions on Y-Axis: The Y-axis will have major divisions for every 100 units.
  • ViewXY.YAxes[0].MajorDiv = 100;

• Enable Y-Axis Snapping to Divisions: This means when users drag or zoom the Y-axis, it will snap to the nearest division mark.
  • ViewXY.YAxes[0].DragSnapToDiv = true;

• Set Y-Axis Range: The visible range for the Y-axis is set between 0 and 1000.
  • ViewXY.YAxes[0].SetRange(0, 1000);

• Change Y-Axis Title Color: The Y-axis title color is set to white.
  • ViewXY.YAxes[0].Title.Color = Colors.White;

• Hide Y-Axis Units: This hides the units (e.g., Hz) next to the Y-axis values.
  • ViewXY.YAxes[0].Units.Visible = false;

Adding markers:

This code adds event markers (which are not bound to axes) to the chart to create a “legend” of sorts. These markers are used to highlight specific points on the chart, in this case, representing different dB levels (60 dB, 40 dB, and 20 dB). Each marker has a label, a shape, and a position on the chart.

• Font Setup: A font is created using WpfFont, with the font “Segoe UI”, size 16, bold (true), and not italic (false).

• Text Shadow: A shadow effect for the text is created with no shadow style (TextShadowStyle.Off), meaning no shadow will be applied to the text.

• Label (EventMarkerTitle): A label is created for each marker (e.g., “60 dB(A)”). This label includes alignment (right and center), the font, the text color (white), a small offset, and the previously defined shadow.

• Point Shape Style: The shape and appearance of the marker are defined here:
  • Color: A red color (with alpha transparency).
  • Size: Width and height of 60 (for the 60 dB marker).
  • Other Style Options: Various graphical options like border color, gradient style, and direction are set.

• Event Marker: A ChartEventMarker is created to combine the label and shape. It specifies the position of the marker on the chart and other properties, like whether it should be clickable or not (false).

• Add to Chart: The marker is added to the chart’s collection of event markers. (_chart.ViewXY.ChartEventMarkers). 

This code will populate a chart with a series of calculated data points across multiple measurement sets. The points are related to vibration or frequency analysis, represented in a Campbell diagram format, and the chart is updated after all the points are added.

Chart Update Preparation:

The code begins by disabling the rendering of the chart to improve performance during updates with _chart.BeginUpdate().

Data Structure Setup:

• An array of dataPoints is created to hold all the data points (of type CampbellDataPoint) that will be added to the chart. The array is a large size to accommodate multiple sets of measurements.
• A variable pointIndex is used to track the position in the dataPoints array as new points are added.

Font Setup:

A specific font is defined for labeling or displaying text on the chart, using the WpfFont class.

Adding Data Points for Each Measurement Set:

• The code defines a series of measurement sets for different curves (1E, 2E, 3E, etc.). For each curve, a series of CampbellDataPoint objects is created with:
  • A frequency value (e.g., 2600, 2700),
  • A corresponding Y-value calculated by the function CalcDataPointY(),
  • A specific amplitude or value associated with that frequency.
  • These data points are added sequentially to the dataPoints array, with pointIndex updated each time a new data point is added.

Adding Data Points to Chart:

After each set of points for a curve is added to the dataPoints array, the AddPoint() function is called in a loop to add those points to the chart with the specified font.

Repeat for Other Curves:

The process is repeated for different curves (1E, 2E, 3E, etc.), each with its own set of frequency and amplitude data points.

Final Update:

Once all points have been added, the chart rendering is enabled again with _chart.EndUpdate() to display the updated chart.

Functions Used:

• CampbellDataPoint(): Creates a data point with frequency, Y-value, and amplitude.

• CalcDataPointY(): A function used to calculate the Y-value for a given frequency and order number.

• AddPoint(): Adds a data point to the chart with a specified font and style.

Thank you for getting this far! This is the first time I must analyze and work with Campbell diagrams. Honestly, what I can analyze is quite interesting. I think it will be a good idea to continue working with this chart in the future, don’t you think?

At the beginning of my working life, I was lucky enough to be able to work as a maintenance mechanic. I worked with rotors, electric motors and screw compressors. Taking that into account, the Campbell chart gains much more importance, because preventive diagnoses can be made on the state of rotating equipment.

A corrective service is usually very expensive, and even more so if faults are not diagnosed in time. A Campbell diagram offers us a historical analysis of the dynamics of equipment.

LC .NET again offers us tools to create complex charts, with an intuitive implementation. This chart is at an intermediate level, so, if you have worked with LC .NET, it will not be very difficult for you to understand it.

Remember that a Campbell chart in LC .NET can be created with the help of PointLineSeries, PointShapeStyle, and EventMarkerTitle components. PointLineSeries will help us generate the lines, while the markers can be created with EventMarkerTitle and shaped as we need with PointShapeStyle.

I hope you liked this article. Remember that we have an extensive catalog of .NET, JS, and Python articles. Bye!