<?xml version="1.0" encoding="UTF-8"?>
<!-- generator="bbPress/1.0.2" -->
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom">
	<channel>
		<title>k-Wave User Forum &#187; Topic: Simulating US Beam by shifting the transducer</title>
		<link>http://www.k-wave.org/forum/topic/simulating-us-beam-by-shifting-the-transducer</link>
		<description>Support for the k-Wave MATLAB toolbox</description>
		<language>en-US</language>
		<pubDate>Wed, 13 May 2026 02:32:02 +0000</pubDate>
		<generator>http://bbpress.org/?v=1.0.2</generator>
		<textInput>
			<title><![CDATA[Search]]></title>
			<description><![CDATA[Search all topics from these forums.]]></description>
			<name>q</name>
			<link>http://www.k-wave.org/forum/search.php</link>
		</textInput>
		<atom:link href="http://www.k-wave.org/forum/rss/topic/simulating-us-beam-by-shifting-the-transducer" rel="self" type="application/rss+xml" />

		<item>
			<title>maktjik on "Simulating US Beam by shifting the transducer"</title>
			<link>http://www.k-wave.org/forum/topic/simulating-us-beam-by-shifting-the-transducer#post-1747</link>
			<pubDate>Tue, 26 Mar 2013 14:42:06 +0000</pubDate>
			<dc:creator>maktjik</dc:creator>
			<guid isPermaLink="false">1747@http://www.k-wave.org/forum/</guid>
			<description>&#60;p&#62;Here I post again the code with better arrangement:&#60;/p&#62;
&#60;p&#62;Initial transducer position:&#60;br /&#62;
&#60;pre&#62;&#60;code&#62;transducer.position = round([1, (((Ny-128)/2) + (128-transducer_width)), Nz/2 - transducer.element_length/2]);

Complete script:

% =========================================================================
% ULTRASOUND SIMULATION (TRANSDUCER SHIFTING)
% Linear array transducer (32 element)
% Transmit: Soundbeam
% Medium  : Layer phantom (4 layers) in water
% =========================================================================

clear all;

%simulation setting
data_cast = &#38;#39;single&#38;#39;;

% run the simulation
run_simulation = true;

% =========================================================================
% DEFINE THE K-WAVE GRID
% =========================================================================

% set the size of the perfectly matched layer (PML)
PML_X_SIZE = 20;            % [grid points]
PML_Y_SIZE = 10;            % [grid points]
PML_Z_SIZE = 10;            % [grid points]

% set total number of grid points not including the PML
Nx = 256 - 2*PML_X_SIZE;   % [grid points]
Ny = 256 - 2*PML_Y_SIZE;   % [grid points]
Nz = 128 - 2*PML_Z_SIZE;   % [grid points]

% set desired grid size in the x-direction not including the PML
x = 40e-3;                  % [m]
y = 50e-3;                  % [m]
z = 60e-3;                  % [m]

% calculate the spacing between the grid points
dx = x/Nx;                  % [m]
dy = y/Ny;                  % [m]
dz = z/Nz;                  % [m]

% create the k-space grid
kgrid = makeGrid(Nx, dx, Ny, dy, Nz, dz);

% =========================================================================
% DEFINE THE MEDIUM PARAMETERS
% =========================================================================

c0 = 1497;                    % c in water [m/s]
rho0 = 1000;                  % density of water [kg/m^3]

% create the time array
t_end = 40e-6;                  % [s]
kgrid.t_array = makeTime(kgrid, c0, [], t_end);

% =========================================================================
% DEFINE THE INPUT SIGNAL
% =========================================================================

% define properties of the input signal
source_strength = 1e6;  % [Pa]
tone_burst_freq = 5e6;     % [Hz]
tone_burst_cycles = 10;

% create the input signal using toneBurst
input_signal = toneBurst(1/kgrid.dt, tone_burst_freq, tone_burst_cycles);

% scale the source magnitude by the source_strength divided by the
% impedance (the source is assigned to the particle velocity)
input_signal = (source_strength./(c0*rho0)).*input_signal;

% =========================================================================
% DEFINE THE ULTRASOUND TRANSDUCER
% =========================================================================

% physical properties of the transducer
transducer.number_elements = 32;  	% total number of transducer elements
transducer.element_width = 1;       % width of each element [grid points]
transducer.element_length = 8;  	% length of each element [grid points]
transducer.element_spacing = 0;  	% spacing (kerf  width) between the elements [grid points]
transducer.radius = inf;            % radius of curvature of the transducer [m]

% calculate the width of the transducer in grid points
transducer_width = transducer.number_elements*transducer.element_width ...
    + (transducer.number_elements - 1)*transducer.element_spacing;

% use this to position the transducer in the edge of (&#38;#39;pseudo&#38;#39; transducer 128 elements if it is located in the middle of computational grid)
transducer.position = round([1, (((Ny-128)/2) + (128-transducer_width)), Nz/2 - transducer.element_length/2]);

% properties used to derive the beamforming delays
transducer.sound_speed = 1530;                % sound speed [m/s]
transducer.focus_distance = 10.5e-3;          % focus distance [m]
transducer.elevation_focus_distance = 19e-3;  % focus distance in the elevation plane [m]
transducer.steering_angle = 0;                % steering angle [degrees]

% apodization
transducer.transmit_apodization = &#38;#39;Hanning&#38;#39;;
transducer.receive_apodization = &#38;#39;Rectangular&#38;#39;;

% define the transducer elements that are currently active
number_active_elements = 32;
transducer.active_elements = ones(transducer.number_elements, 1);

% append input signal used to drive the transducer
transducer.input_signal = input_signal;

% create the transducer using the defined settings
transducer = makeTransducer(kgrid, transducer);

% print out transducer properties
transducer.properties;
% break
% =========================================================================
% DEFINE THE MEDIUM PROPERTIES
% =========================================================================

% define a random distribution of scatterers for the medium
background_map_mean = 1;
background_map_std = 0.008;
% background_map = background_map_mean + background_map_std*randn([Nx, Ny, Nz]);

% define the thicknesses of layer phantom
d_layer_1 = 5.4e-3;          % [m]
d_layer_2 = 4.9e-3;          % [m]
d_layer_3 = 4.4e-3;          % [m]
d_layer_4 = 6.3e-3;          % [m]

% define the properties of the propagation medium
% water
medium.sound_speed = c0*ones(Nx, Ny, Nz);      % [m/s]
medium.density = rho0*ones(Nx, Ny, Nz);        % [kg/m^3]

% layer_1
background_map_layer_1 = background_map_mean + background_map_std*randn([round(Nx*(d_layer_1/x)), Ny, Nz]);
medium.sound_speed(1:round(Nx*(d_layer_1/x)), :, :) = 1520.*background_map_layer_1;        % [m/s]
medium.density(1:round(Nx*(d_layer_1/x)), :, :) = 1281.*background_map_layer_1;            % [kg/m^3]

% layer_2
background_map_layer_2 = background_map_mean + background_map_std*randn([round(Nx*((d_layer_1+d_layer_2)/x))-(round(Nx*(d_layer_1/x))), Ny, Nz]);
medium.sound_speed(round(Nx*(d_layer_1/x))+1:round(Nx*((d_layer_1+d_layer_2)/x)), :, :) = 1218.*background_map_layer_2;    % [m/s]
medium.density(round(Nx*(d_layer_1/x))+1:round(Nx*((d_layer_1+d_layer_2)/x)), :, :) = 1510.*background_map_layer_2;    % [kg/m^3]

% layer_3
background_map_layer_3 = background_map_mean + background_map_std*randn([round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x))-(round(Nx*((d_layer_1+d_layer_2)/x))), Ny, Nz]);
medium.sound_speed(round(Nx*((d_layer_1+d_layer_2)/x))+1:round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x)), :, :) = 1325.*background_map_layer_3;       % [m/s]
medium.density(round(Nx*((d_layer_1+d_layer_2)/x))+1:round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x)), :, :) = 1643.*background_map_layer_3;       % [kg/m^3]

% layer_4
background_map_layer_4 = background_map_mean + background_map_std*randn([round(Nx*((d_layer_1+d_layer_2+d_layer_3+d_layer_4)/x))-(round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x))), Ny, Nz]);
medium.sound_speed(round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x))+1:round(Nx*((d_layer_1+d_layer_2+d_layer_3+d_layer_4)/x)), :, :) = 1429.*background_map_layer_4; % [m/s]
medium.density(round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x))+1:round(Nx*((d_layer_1+d_layer_2+d_layer_3+d_layer_4)/x)), :, :) = 1684.*background_map_layer_4; % [kg/m^3]

% =========================================================================
% RUN THE SIMULATION
% =========================================================================

% set the input settings
% plot medium map
input_args = {...
    &#38;#39;PlotLayout&#38;#39;, true, &#38;#39;PMLInside&#38;#39;, false, &#38;#39;PlotSim&#38;#39;, false, &#38;#39;PMLSize&#38;#39;, [PML_X_SIZE, PML_Y_SIZE, PML_Z_SIZE], ...
    &#38;#39;DataCast&#38;#39;, data_cast};

% run the simulation if set to true, otherwise, load previous results from disk
if run_simulation

    desired_num_channels = 128;
    total_time_index = 1078;
    total_scan_lines = 97;

    sensor_data_output = zeros(desired_num_channels, total_time_index, total_scan_lines);

    for scan_line = 0 : total_scan_lines-1
        fprintf(&#38;#39;Calculating scan line %d of %d\n&#38;#39;, scan_line+1, total_scan_lines);

        transducer_position = transducer.position(:,:,:);

        sensor_data = kspaceFirstOrder3D(kgrid, medium, transducer, transducer, input_args{:});

        % Zero padding to fill 3D matrix output
        padding_before = zeros(scan_line, total_time_index);
        padding_after = zeros(desired_num_channels - number_active_elements - scan_line, total_time_index);

        % Populate 3D matrix output with the output of each iteration
        sensor_data_output(:, :, scan_line + 1) = [padding_before; sensor_data; padding_after];
        transducer_position = transducer_position + transducer.element_width;
    end

   % save the scan lines to disk
    save sensor_data_output sensor_data_output;
else
   % load the scan lines from disk
   load sensor_data_output;
end&#60;/code&#62;&#60;/pre&#62;</description>
		</item>
		<item>
			<title>maktjik on "Simulating US Beam by shifting the transducer"</title>
			<link>http://www.k-wave.org/forum/topic/simulating-us-beam-by-shifting-the-transducer#post-1740</link>
			<pubDate>Tue, 26 Mar 2013 10:47:43 +0000</pubDate>
			<dc:creator>maktjik</dc:creator>
			<guid isPermaLink="false">1740@http://www.k-wave.org/forum/</guid>
			<description>&#60;p&#62;Hi all,&#60;/p&#62;
&#60;p&#62;I would like to simulate US beam by shifting the transducer. I have 32 elements transducer (with 32 active elements) and I shift it 1 element_width in each iteration. My looping iterates from 0:(97-1), so with this iteration I intended to simulate 'pseudo' transducer with 128 elements. Is it valid?&#60;/p&#62;
&#60;p&#62;I generate the final output in 3D matrix with dimensions 128x1078x97 = (desired_num_channels, total_time_index, number_scan_lines). So I need to do zero padding in every iteration.&#60;/p&#62;
&#60;p&#62;Initial position of my transducer is in the edge of my 'pseudo' 128 elements transducer, if that 'pseudo' transducer placed in the middle of computational grid. &#60;/p&#62;
&#60;p&#62;transducer.position = round([1, (((Ny-128)/2) + (128-transducer_width)), Nz/2 - transducer.element_length/2]);&#60;/p&#62;
&#60;p&#62;My medium is 4 layers phantom (with different soundspeed and density in each layer) above water.&#60;/p&#62;
&#60;p&#62;This is the copy of the script:&#60;/p&#62;
&#60;p&#62;% =========================================================================&#60;br /&#62;
% ULTRASOUND SIMULATION (TRANSDUCER SHIFTING)&#60;br /&#62;
% Linear array transducer (32 element)&#60;br /&#62;
% Transmit: Soundbeam&#60;br /&#62;
% Medium  : Layer phantom (4 layers) in water&#60;br /&#62;
% =========================================================================&#60;/p&#62;
&#60;p&#62;clear all;&#60;/p&#62;
&#60;p&#62;%simulation setting&#60;br /&#62;
data_cast = 'single';&#60;/p&#62;
&#60;p&#62;% run the simulation&#60;br /&#62;
run_simulation = true;&#60;/p&#62;
&#60;p&#62;% =========================================================================&#60;br /&#62;
% DEFINE THE K-WAVE GRID&#60;br /&#62;
% =========================================================================&#60;/p&#62;
&#60;p&#62;% set the size of the perfectly matched layer (PML)&#60;br /&#62;
PML_X_SIZE = 20;            % [grid points]&#60;br /&#62;
PML_Y_SIZE = 10;            % [grid points]&#60;br /&#62;
PML_Z_SIZE = 10;            % [grid points]&#60;/p&#62;
&#60;p&#62;% set total number of grid points not including the PML&#60;br /&#62;
Nx = 256 - 2*PML_X_SIZE;   % [grid points]&#60;br /&#62;
Ny = 256 - 2*PML_Y_SIZE;   % [grid points]&#60;br /&#62;
Nz = 128 - 2*PML_Z_SIZE;   % [grid points]&#60;/p&#62;
&#60;p&#62;% set desired grid size in the x-direction not including the PML&#60;br /&#62;
x = 40e-3;                  % [m]&#60;br /&#62;
y = 50e-3;                  % [m]&#60;br /&#62;
z = 60e-3;                  % [m]&#60;/p&#62;
&#60;p&#62;% calculate the spacing between the grid points&#60;br /&#62;
dx = x/Nx;                  % [m]&#60;br /&#62;
dy = y/Ny;                  % [m]&#60;br /&#62;
dz = z/Nz;                  % [m]&#60;/p&#62;
&#60;p&#62;% create the k-space grid&#60;br /&#62;
kgrid = makeGrid(Nx, dx, Ny, dy, Nz, dz);&#60;/p&#62;
&#60;p&#62;% =========================================================================&#60;br /&#62;
% DEFINE THE MEDIUM PARAMETERS&#60;br /&#62;
% =========================================================================&#60;/p&#62;
&#60;p&#62;c0 = 1497;                    % c in water [m/s]&#60;br /&#62;
rho0 = 1000;                  % density of water [kg/m^3]&#60;/p&#62;
&#60;p&#62;% create the time array&#60;br /&#62;
t_end = 40e-6;                  % [s]&#60;br /&#62;
kgrid.t_array = makeTime(kgrid, c0, [], t_end);&#60;/p&#62;
&#60;p&#62;% =========================================================================&#60;br /&#62;
% DEFINE THE INPUT SIGNAL&#60;br /&#62;
% =========================================================================&#60;/p&#62;
&#60;p&#62;% define properties of the input signal&#60;br /&#62;
source_strength = 1e6;  % [Pa]&#60;br /&#62;
tone_burst_freq = 5e6;     % [Hz]&#60;br /&#62;
tone_burst_cycles = 10;&#60;/p&#62;
&#60;p&#62;% create the input signal using toneBurst&#60;br /&#62;
input_signal = toneBurst(1/kgrid.dt, tone_burst_freq, tone_burst_cycles);&#60;/p&#62;
&#60;p&#62;% scale the source magnitude by the source_strength divided by the&#60;br /&#62;
% impedance (the source is assigned to the particle velocity)&#60;br /&#62;
input_signal = (source_strength./(c0*rho0)).*input_signal;&#60;/p&#62;
&#60;p&#62;% =========================================================================&#60;br /&#62;
% DEFINE THE ULTRASOUND TRANSDUCER&#60;br /&#62;
% =========================================================================&#60;/p&#62;
&#60;p&#62;% physical properties of the transducer&#60;br /&#62;
transducer.number_elements = 32;  	% total number of transducer elements&#60;br /&#62;
transducer.element_width = 1;       % width of each element [grid points]&#60;br /&#62;
transducer.element_length = 8;  	% length of each element [grid points]&#60;br /&#62;
transducer.element_spacing = 0;  	% spacing (kerf  width) between the elements [grid points]&#60;br /&#62;
transducer.radius = inf;            % radius of curvature of the transducer [m]&#60;/p&#62;
&#60;p&#62;% calculate the width of the transducer in grid points&#60;br /&#62;
transducer_width = transducer.number_elements*transducer.element_width ...&#60;br /&#62;
    + (transducer.number_elements - 1)*transducer.element_spacing;&#60;/p&#62;
&#60;p&#62;% use this to position the transducer in the edge of ('pseudo' transducer 128 elements if it is located in the middle of computational grid)&#60;br /&#62;
transducer.position = round([1, (((Ny-128)/2) + (128-transducer_width)), Nz/2 - transducer.element_length/2]);&#60;/p&#62;
&#60;p&#62;% properties used to derive the beamforming delays&#60;br /&#62;
transducer.sound_speed = 1530;                % sound speed [m/s]&#60;br /&#62;
transducer.focus_distance = 10.5e-3;          % focus distance [m]&#60;br /&#62;
transducer.elevation_focus_distance = 19e-3;  % focus distance in the elevation plane [m]&#60;br /&#62;
transducer.steering_angle = 0;                % steering angle [degrees]&#60;/p&#62;
&#60;p&#62;% apodization&#60;br /&#62;
transducer.transmit_apodization = 'Hanning';&#60;br /&#62;
transducer.receive_apodization = 'Rectangular';&#60;/p&#62;
&#60;p&#62;% define the transducer elements that are currently active&#60;br /&#62;
number_active_elements = 32;&#60;br /&#62;
transducer.active_elements = ones(transducer.number_elements, 1);&#60;/p&#62;
&#60;p&#62;% append input signal used to drive the transducer&#60;br /&#62;
transducer.input_signal = input_signal;&#60;/p&#62;
&#60;p&#62;% create the transducer using the defined settings&#60;br /&#62;
transducer = makeTransducer(kgrid, transducer);&#60;/p&#62;
&#60;p&#62;% print out transducer properties&#60;br /&#62;
transducer.properties;&#60;br /&#62;
% break&#60;br /&#62;
% =========================================================================&#60;br /&#62;
% DEFINE THE MEDIUM PROPERTIES&#60;br /&#62;
% =========================================================================&#60;/p&#62;
&#60;p&#62;% define a random distribution of scatterers for the medium&#60;br /&#62;
background_map_mean = 1;&#60;br /&#62;
background_map_std = 0.008;&#60;br /&#62;
% background_map = background_map_mean + background_map_std*randn([Nx, Ny, Nz]);&#60;/p&#62;
&#60;p&#62;% define the thicknesses of layer phantom&#60;br /&#62;
d_layer_1 = 5.4e-3;          % [m]&#60;br /&#62;
d_layer_2 = 4.9e-3;          % [m]&#60;br /&#62;
d_layer_3 = 4.4e-3;          % [m]&#60;br /&#62;
d_layer_4 = 6.3e-3;          % [m]&#60;/p&#62;
&#60;p&#62;% define the properties of the propagation medium&#60;br /&#62;
% water&#60;br /&#62;
medium.sound_speed = c0*ones(Nx, Ny, Nz);      % [m/s]&#60;br /&#62;
medium.density = rho0*ones(Nx, Ny, Nz);        % [kg/m^3]&#60;/p&#62;
&#60;p&#62;% layer_1&#60;br /&#62;
background_map_layer_1 = background_map_mean + background_map_std*randn([round(Nx*(d_layer_1/x)), Ny, Nz]);&#60;br /&#62;
medium.sound_speed(1:round(Nx*(d_layer_1/x)), :, :) = 1520.*background_map_layer_1;        % [m/s]&#60;br /&#62;
medium.density(1:round(Nx*(d_layer_1/x)), :, :) = 1281.*background_map_layer_1;            % [kg/m^3]&#60;/p&#62;
&#60;p&#62;% layer_2&#60;br /&#62;
background_map_layer_2 = background_map_mean + background_map_std*randn([round(Nx*((d_layer_1+d_layer_2)/x))-(round(Nx*(d_layer_1/x))), Ny, Nz]);&#60;br /&#62;
medium.sound_speed(round(Nx*(d_layer_1/x))+1:round(Nx*((d_layer_1+d_layer_2)/x)), :, :) = 1218.*background_map_layer_2;    % [m/s]&#60;br /&#62;
medium.density(round(Nx*(d_layer_1/x))+1:round(Nx*((d_layer_1+d_layer_2)/x)), :, :) = 1510.*background_map_layer_2;    % [kg/m^3]&#60;/p&#62;
&#60;p&#62;% layer_3&#60;br /&#62;
background_map_layer_3 = background_map_mean + background_map_std*randn([round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x))-(round(Nx*((d_layer_1+d_layer_2)/x))), Ny, Nz]);&#60;br /&#62;
medium.sound_speed(round(Nx*((d_layer_1+d_layer_2)/x))+1:round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x)), :, :) = 1325.*background_map_layer_3;       % [m/s]&#60;br /&#62;
medium.density(round(Nx*((d_layer_1+d_layer_2)/x))+1:round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x)), :, :) = 1643.*background_map_layer_3;       % [kg/m^3]&#60;/p&#62;
&#60;p&#62;% layer_4&#60;br /&#62;
background_map_layer_4 = background_map_mean + background_map_std*randn([round(Nx*((d_layer_1+d_layer_2+d_layer_3+d_layer_4)/x))-(round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x))), Ny, Nz]);&#60;br /&#62;
medium.sound_speed(round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x))+1:round(Nx*((d_layer_1+d_layer_2+d_layer_3+d_layer_4)/x)), :, :) = 1429.*background_map_layer_4; % [m/s]&#60;br /&#62;
medium.density(round(Nx*((d_layer_1+d_layer_2+d_layer_3)/x))+1:round(Nx*((d_layer_1+d_layer_2+d_layer_3+d_layer_4)/x)), :, :) = 1684.*background_map_layer_4; % [kg/m^3]&#60;/p&#62;
&#60;p&#62;% =========================================================================&#60;br /&#62;
% RUN THE SIMULATION&#60;br /&#62;
% =========================================================================&#60;/p&#62;
&#60;p&#62;% set the input settings&#60;br /&#62;
% plot medium map&#60;br /&#62;
input_args = {...&#60;br /&#62;
    'PlotLayout', true, 'PMLInside', false, 'PlotSim', false, 'PMLSize', [PML_X_SIZE, PML_Y_SIZE, PML_Z_SIZE], ...&#60;br /&#62;
    'DataCast', data_cast};&#60;/p&#62;
&#60;p&#62;% run the simulation if set to true, otherwise, load previous results from disk&#60;br /&#62;
if run_simulation&#60;/p&#62;
&#60;p&#62;    desired_num_channels = 128;&#60;br /&#62;
    total_time_index = 1078;&#60;br /&#62;
    total_scan_lines = 97;&#60;/p&#62;
&#60;p&#62;    sensor_data_output = zeros(desired_num_channels, total_time_index, total_scan_lines);&#60;/p&#62;
&#60;p&#62;    for scan_line = 0 : total_scan_lines-1&#60;br /&#62;
        fprintf('Calculating scan line %d of %d\n', scan_line+1, total_scan_lines);&#60;/p&#62;
&#60;p&#62;        transducer_position = transducer.position(:,:,:);&#60;/p&#62;
&#60;p&#62;        sensor_data = kspaceFirstOrder3D(kgrid, medium, transducer, transducer, input_args{:});&#60;/p&#62;
&#60;p&#62;        % Zero padding to fill 3D matrix output&#60;br /&#62;
        padding_before = zeros(scan_line, total_time_index);&#60;br /&#62;
        padding_after = zeros(desired_num_channels - number_active_elements - scan_line, total_time_index);&#60;/p&#62;
&#60;p&#62;        % Populate 3D matrix output with the output of each iteration&#60;br /&#62;
        sensor_data_output(:, :, scan_line + 1) = [padding_before; sensor_data; padding_after];&#60;br /&#62;
        transducer_position = transducer_position + transducer.element_width;&#60;br /&#62;
    end&#60;/p&#62;
&#60;p&#62;   % save the scan lines to disk&#60;br /&#62;
    save sensor_data_output sensor_data_output;&#60;br /&#62;
else&#60;br /&#62;
   % load the scan lines from disk&#60;br /&#62;
   load sensor_data_output;&#60;br /&#62;
end&#60;br /&#62;
% =========================================================================&#60;/p&#62;
&#60;p&#62;Thanks,&#60;/p&#62;
&#60;p&#62;Makcik
&#60;/p&#62;</description>
		</item>

	</channel>
</rss>
