in the recent years , electron paramagnetic resonance imaging ( epri ) has been used to measure tissue oxygen noninvasively , directly , and quantitatively to evaluate hypoxia in tumors [ 17 ] .
the estimation of the spin density and the oxygen - dependent epr line width ( lw ) of triarylmethyl- ( tam- ) based radicals has been made possible by noninvasive po2 imaging technique based on the application of time - domain ( td ) epr single point imaging ( spi ) modality [ 4 , 6 ] .
we recently reported that the 3d tumor oxygen images in mice by td - epri were well consistent with the blood perfusion images by magnetic resonance imaging ( mri ) .
spi is based on the pure phase encoding of a constant time - point in the free induction decay ( fid ) , following a pulse .
successive fid time - points will produce images with voxel intensities reduced by the transverse relaxation time t2 * which , in turn , linearly depends on the local oxygen partial pressure po2 .
however , phase encoding of all three spatial dimensions with one spectral dimension creates huge amount of k - space data .
zoom - in  effect to the images since the field of view ( fov ) depends on the delay from the pulse as well as the phase - encoding gradient steps . in order to keep the resolution and signal - to - noise ratio ( snr ) nearly uniform throughout the range of time delay , we perform three individual three - dimensional ( 3d ) experiments with three different gradients .
this requirement in 3d oximetric imaging results in further three times larger amount of k - space data in the acquisition computer .
the k - space data sets accumulated for the three gradients thus become large , forcing the digital filtration and reconstruction tasks ( figure 1 ) to become enormous computational efforts , often too demanding for single processor architectures . hence , with the availability of advanced computer architectures , there is a need to explore and exploit parallelism in the processing of the spi oximetric data . in this work
, we present the implementation of a novel parallel processing approach to speed up the filtration and image reconstruction tasks in 3d epr oximetric imaging .
parallel computing is becoming a dominant paradigm in high - performance computing . in recent years ,
cluster - based parallel processing algorithms has been implemented recently in the field of hyper spectral imagery to analyze the airborne visible / infrared imaging spectrometer ( aviris ) data [ 10 , 11 ] .
implementation of fourier - based reconstruction for computed tomography ( ct ) using parallel computing is found elsewhere .
bayesian inversion for 3d dental x - ray imaging has recently been parallelized using a beowulf cluster to perform 3d reconstruction [ 13 , 14 ] .
many parallelization techniques have been employed to implement image reconstruction in positron emission tomography ( pet ) [ 1517 ] , single photon emission ct [ 18 , 19 ] , and other imaging modalities [ 20 , 21 ] .
open multiprocessing ( openmp ) and message passing interface ( mpi ) approaches have been currently used to write parallel programs .
mpi is the standard parallel application programming interface ( api ) , which has been designed for distributed memory architectures whereas openmp has emerged as a popular api and widely accepted industrial standard interface for explicit multithreaded shared memory architectures .
parallel statistical image reconstruction for cone - beam x - ray ct on shared memory processor ( smp ) has been implemented using openmp as well as mpi .
the ordered - subsets expectation - maximization ( osem ) algorithm for 3d pet image reconstruction has been recently parallelized with mpi and hybrid mpi - openmp . however , in molecular modeling application , openmp performed better than mpi environments .
the implementation of openmp is more suitable than mpi because of its minimal programming overhead .
openmp is known to be the first successful directive- ( pragma- ) based api for parallel programming intended for general - purpose computing .
openmp offers a way to write programs in c / c++ and fortran and run efficient applications with a shared memory programming model on platforms including unix and microsoft windows . by just inserting the pragma without making any other changes to the original sequential version of a program , an excellent parallel performance can be achieved by the users of openmp . for image processing and computer vision ,
shared memory parallelization has proved to be a suitable way to reach better runtime performance .
the penalty of using interprocessor communication is very low on smp compared to distributed memory architectures . for a relatively large data size
, it is advantageous to use smp architecture with openmp rather than distributed architecture with mpi .
recently , a c++ code for content - based image retrieval using openmp has been developed to exploit shared memory parallelization .
it has also been shown that shared memory parallelization is more suitable than distributed memory parallelization for image processing tasks and leads to better throughput on a parallel computer .
these features have motivated us to perform the parallelization of digital lowpass filtration and background subtraction tasks using the features of openmp and c++ , on an smp parallel architecture .
the aim of this work was to investigate the potential of parallel algorithms in the high - speed processing of 3d oximetric data for near real - time computation of spin density distribution and oxygen level in normal and tumor tissues in small animals .
the proposed parallel system can be viewed as a three - stage procedure . to begin with ,
the fids are lowpass filtered and background - subtracted using a parallel c++ program based on openmp .
this stage is automatically executed as soon as the 3d data is placed on the server 's memory .
custom parallel matlab code was used in the second stage to perform the 3d fast fourier transform- ( fft- ) based reconstruction of the filtered data .
the 3d mesh view and 3d spin intensity images were displayed consecutively on the graphical user interface ( gui ) .
third , 3d oxygen images were computed and displayed using gui - based parallel matlab code running on the server . the distributed computing toolbox ( dct ) enabled this stage as a parallel application , with minimal changes in the serial code .
all experimental phantom and in vivo small animal data were acquired with radio - frequency fourier transform ( rf ft ) epr imaging system .
the schematic of the rf ft epr imager and other details appear in earlier reports [ 6 , 7 ] .
a brief description about the collection of raw projection data is presented here . in phantom experiments ,
four cylindrical tubes of 4.8 mm diameter filled with the contrast agent oxo63   were used .
the four tubes containing different concentrations of the contrast agent were imaged using a 25 mm diameter    25 mm length parallel - coil resonator .
the solutions were saturated with gas mixtures 0% , 1% , 2.5% , and 5% oxygen for at least 30 minutes and sealed .
several data sets were acquired by changing different gradient settings , number of k - space samples , and number of samples summed per fid .
for instance , two data sets were collected with gradient settings ( 1.2 , 1.0 , 0.8 ) and ( 2.2 , 1.8 , 1.5 ) g / cm and ( 15  15  15 ) and ( 25  25  25 ) k - space samples , respectively . the length of fids summed for signal averaging was set to 640 at a sampling speed of 200 ms / s .
the 3d multigradient oximetric imaging of mouse tumor has been reported earlier [ 6 , 7 ] . in a typical experiment , a female c3h hen
mtv mouse with squamous cell carcinoma ( scc ) tumor with body weight of 32.2 g was anesthetized using isoflurane .
the normal and tumor - bearing legs of the mouse were placed inside the parallel coil resonator with a vertical partitioning between the two legs .
a cartoon in figure 2(b ) shows the position of the mouse inside the resonator .
experiments were carried out in compliance with the guide for the care and use of laboratory animal resources ( national research council , 1996 ) and approved by the national cancer institute animal care and use committee .
the k - space samples of 23  23  23 were collected with three different gradient maxima settings ( 1.4 , 1.14 , 0.96 g / cm ) keeping the number of fids averaged per gradient setting as 640 .
several data sets were collected with different numbers of k - space samples , different gradient settings , and different numbers of fid sums .
if the data collection is carried out using receivers that are phase shifted during acquisition , the overall size of the data will be one fourth of what we have mentioned . in the present configuration of our equipment ,
the transmitter is phase shifted in quadrature , and for each of the four transmit phase , the real and imaginary parts are collected and stored separately .
they are combined during the subsequent data processing stage ( by exchanging real and imaginary parts and using add / subtract ) , and this is the reason that for a 23  23  23   k - space dimension , the data size is given by ( 23  23  23 )  640 ( fid data length )  4 ( quadrature data sets )  2 ( real & imaginary pair )  4 ( four bytes required for an integer storage )  3 ( number of interleaved experiments ) leading to a total of 747.5 mb .
a personal computer ( pc ) with intel celeron 3.06 ghz with 1.99 gb ram was used as stand - alone computing platform to perform the three stages as indicated in figure 1 using serial matlab codes .
the parallel platform and the software technology used to develop the parallel system are briefly provided in this section .
the parallel system has four dual - core amd opteron smp 880 cpus with nonuniform memory access ( numa ) 16 gb ram and 2.2 tb of attached hdd , running fedora core 6 and intel c++ compiler professional edition for linux ( v9.1.037 ) .
numa provides cache coherency ( ccnuma ) , where the memory access time depends on the memory location relative to the accessing processor .
the term smp originally stood for symmetric multiprocessor which means that the cost of a memory access is the same no matter which cpu ( or thread ) performs the operation .
the parallel server is located at the radiation biology branch , national cancer institute , nih in bethesda , md , usa . the parallel system has been organized to make the tasks easily accessible from pcs through nihnet .
nihnet provides a high - speed network infrastructure , transferring data at 10 gigabits per second and interconnects the lans of individual windows pcs and the parallel server .
figure 3 illustrates the architecture of the parallel system that includes data acquisition , parallel server , three stages , client workstations , and the network connectivity .
the connectivity between microsoft windows clients and the parallel server is established via samba 3.0.2 .
samba is a server message block ( smb ) networking protocol used by microsoft windows network file system .
samba can be a part of active directory domain and runs all distributions of linux .
samba is mounted on each of the windows clients by mapping network drive of  my computer  with the appropriate host name of the server .
secure shell ( ssh ) , a network protocol is used for port forwarding or tunneling from a windows client machine .
putty is a free ssh client with remote file copying support and connects to the remote linux server running samba .
xming , a free unlimited x window server for microsoft windows ( xp/2003/vista ) is fully featured , light and fast , simple to install .
it is totally secured when used with ssh and optionally includes an enhanced putty link ssh client and a portable putty replacement package .
the x11 clients are allowed to use local windows x11 server by enabling ssh x11 forwarding option in putty .
perl ( v.5.8.8 ) has been used to create an invisible daemon process to provide immediate response to the server on arrival of data sets from the client machine .
the daemon is started by the root process of the linux operating system and run in the background indefinitely .
torque ( v 2.1.8 ) , an open source high - performance computing ( hpc ) resource manager , provides control over batch processing of the incoming data sets in the multiuser environment .
it is based on portable batch system ( openpbs ) , a queuing system developed for nasa , operating on networked unix environment . in the present work ,
a pbs job is designed to perform the digital filtration task and transfer the filtered data to a shared directory of the server . in the remainder of this section we will summarize the various stages in the parallel processing system .
the data files that are transferred from the windows client computers need to be identified uniquely by the server .
in addition to the file names and size of each of the 3d oximetric gradient data , there is a need to transmit data acquisition and filtration parameters to the parallel server .
hence , immediately after the 3d oximetric data is acquired and collected in a windows pc , an index file is created automatically containing information such as name and size of each of the data files , number of steps in each of the three directional magnetic gradients , number of points per fid , and other parameters required for the digital filtration stage .
the image data is collected at a sampling frequency corresponding to a bandwidth of 200 mhz , whereas the actual phase - encoded raw data covers just fewer than 20 mhz , being in the range    10 mhz . in order to avoid unnecessary noise above this frequency range
we use a digital lowpass filtering of the raw data along with subtraction of background signals which is a time consuming process .
table 1 shows the flow of the steps involved in the digital filtration task ( stage 1 of figure 4 ) .
the parallel c++ code begins execution sequentially as a single thread until a parallel openmp pragma is encountered .
the number of threads ( num_thread ) is set in the parallel environment using  getenv  command and environment variable omp_num_threads .
the information file ( data.mat ) and index file in the shared directory are used to access the data file names and filtration parameters that are required during the execution of the parallel c++ code .
this pragma is inserted ( step 3 of table 1 ) to instruct the compiler to parallelize the code using multiple threads . when the initial thread encounters a parallel region , a team of threads
the buffer variables that are declared as  shared  clause are shared among all threads in the team within the parallel region .
the variables that need not to be shared among threads are declared as  private  clause .
a work - sharing directive is inserted in each of the steps 4 , 5 , 7 , 8 , 9 , and 11 of table 1 to divide the execution among the threads ; for instance ,  for  directive is inserted in the computation of background noise . in step 7 , 
single  directive is inserted to allow a single thread in the team to serialize a section of code , for example , to write dummy data into the binary output file . in steps 8 and 9 , 
nowait  clause is specified to indicate that threads do not synchronize at the end of the parallel loop .
a  barrier  directive is inserted to reach synchronization among all threads at the end of each work - sharing construct . in step 6 , the threads rejoin to complete the reading of the three gradient files into the allocated buffers before step 7 is started . in step 10 ,
pragma is inserted to wait for all the threads to finish writing the filtered data into the respective output files .
the reconstruction of 3d spin density images from the filtered data constitutes stage 2 of the parallel system ( figure 4 ) .
the source code has been developed in matlab 7.4 as a user - friendly gui and available on the server 's source code directory .
any authorized user of the parallel system can invoke parallel matlab and execute the gui - based image reconstruction code .
in step 3 , the zero - factor means zero - filling of the k - space data , which is the size of the data matrix that will result upon ft .
once the 3d mesh view and 3d spin density images are displayed , parallel thresholding process of the oxygen data ( stage 3 of figure 4 ) is performed with different values of spin threshold .
the oximetry thresholding application can be split into interdependent tasks and is accelerated via parallel execution of the matlab code ( steps 1117 of table 2 ) .
the number of parallel matlab workers ( or labs ) is assumed to be 4 , and the workers are set to the job . though the number of workers is initially set to four , the maximum number of workers can be modified using  maximumnumberofworkers
the oximetric thresholding code is made available to the workers with the job 's  filedependencies  property ( step 13 ) .
finally , the job is run using  submit  function ( step 14 ) .
the user waits for the job to finish before the results are collected using  waitforstate  function .
the results of these three output arguments are collected in separate matrices using  getalloutputarguments  function .
one among the three results is the lw image from which oxygen image is computed . in the parallel job ( task function ) , the worker whose  labindex 
value is 1 is treated as master worker while other workers are treated as slaves .
the master worker loads the spin - thresholded matrix ( step 11 ) in the system and computes the number of jobs based on the total number of planes in each of the twelve 3d spin images . depending upon the total number of slices and number of workers
, the task is divided into many subtasks and sent to the individual workers ( slaves ) using
the  labreceive  function is used by the master worker to receive the matrices from the individual slaves .
the resultant matrices are stored in the matrices by the master worker as and when the slaves send answers to master .
in this section , we will describe the implementation and results of parallelization approach of the procedure explained in section 2 .
the main goal of this work was to show the feasibility of employing high - performance parallel computing in the data - intensive filtration and reconstruction of 3d oximetric data .
the performance of the parallel system was tested by feeding the actual 3d oximetric projection data sets that have been collected using phantom and in vivo experiments using spi modality [ 6 , 7 ] .
the results were then compared with the ones obtained from the pc version implemented in matlab .
the acquired 3d gradient data files are transferred from the windows client machine to the windows share directory of the server via the nihnet using smb file sharing .
the invisible daemon reads the index file , checks if all the data files mentioned in the index file exist in the shared directory , and if so transfers the data files to a temporary subdirectory of the server .
a portable batch system ( pbs ) script is created to submit the parallel jobs to the queue .
once the data files are transferred to the temporary subdirectory of the server , the parallel c++ code starts executing on the server to perform back - ground subtraction and filtration jobs .
the resultant filtered data files are placed in another shared folder of the server for later processing .
once this stage is performed , the size of the filtered data is reduced by a factor of 2.2 from that of acquired data .
the reduction has occurred because of the binary data format of the filtered data and the reduction of the number of points per fid from 640 to 581 .
the filtration part of the parallel system was tested using data sets collected from three different 3d imaging experiments by varying the number of gradient steps as given in table 4 . the execution time taken by the filtration task using 8 parallel workers of the server and the pc
it should be noted that the pc was running the filtration stage using a matlab code whereas the parallel system uses a parallel c++ code .
the sequential execution time of the code was 840 seconds when a data set with gradient steps 23  23  23 was used ; whereas the execution time of the parallel code was only 18 seconds .
the parallelization speed - up factor ( sf ) , which is the factor by which the execution time is reduced , is then given by sf = s/p , where s and p are the execution times of the filtration code by pc and parallel systems , respectively .
it is observed that the sf is 46.66 for the filtration task when data acquired with 23  23  23 gradient steps is used .
however , the parallel program has been designed so that the environment will migrate naturally to  free  cpu cores of the parallel processor .
the filtered data needed for the reconstruction of 3d spin density and oxygen images is readily available in a separate shared directory of the server and accessible at any time by the authorized users of the server through the network .
the parallel matlab installed in the server is called from the client pc after loading the putty session using ssh connection .
the parallel matlab gui program can then be accessed by the users from their windows client computer to select the data set from the shared directory of the server and to proceed to the second and third stages of the parallel system .
the time - point data files are created using the filtered data files by choosing proper values of starting time point ( nanosecond ) , the interval ( nanosecond ) between steps , the total time - delay steps , the dead time of the imager and the zero - factor . depending upon these values that are chosen , the time points for each of the gradients are picked up .
the time - point files thus generated for each of the gradients are stored in the same shared folder of the server . in a typical experiment , the values of the start time point , the interval between steps , the total time - delay steps , the dead time and the zero - factor are given as 250 nanoseconds , 35 nanoseconds , 12 , 265 nanoseconds , and 120 , respectively .
the start time of 250 nanoseconds is the delay from the start of the acquisition of data .
the dead - time ( the time gap between the end of the pulse and the beginning of the acquisition ) of 265 nanoseconds is added to all time steps . with the increment interval of 35 nanoseconds ,
the time - point files are generated with twelve time - delay steps ( including dead time ) in the range of 515900 nanoseconds , four each for the three gradients .
these time - point files are used by the 3d fft - based program to reconstruct twelve 3d images of spin density and derive an oxygen map as well .
out of the twelve time - course images used for relaxation calculation , the 6th image occurs in the middle showing the mean intensity and resolution , and hence it is chosen for display .
the 3d spin density mesh view of the 6th image reconstructed from a phantom data is displayed in the gui ( figure 6 ) .
twelve images are generated as a function of time delay from the excitation pulse from interleaved measurements at three different gradients . as the time delay increases , the signal - to - noise ratio decreases . in order to have maximum number of pixels included in the evaluation of decay slopes ,
very low thresholds will unnecessarily include areas where there are no signals and thus lead to waste of time .
higher thresholds will make many images from the longer delay times not to be included .
we have found by trial and error that if we consider the middle image ( 6th image out of a total of 12 ) and use 10% of maximum intensity in this image for threshold , we get optimal sampling of pixel intensities from all the images .
this is the general  rule - of - thumb  that we have used .
it indicates the minimum level of spin intensity signal that can be used for the computation of the oxygen image . after providing a proper threshold value in the gui ,
the coronal , sagittal , and axial slices of 6th 3d spin density image and the corresponding slices of the oxygen image are simultaneously displayed on the gui .
the parallel oximetry thresholding stage can be repeated by changing the values of the spin threshold , different sets of 3d oxygen images are viewed on the gui , and oxygen content is computed . 

figure 7 shows the reconstruction results of the parallel processing system when the system is supplied with the data sets of a four - tube phantom .
the spin intensity images and oxygen images are shown in figures 7(a )   and 7(b ) , respectively .
the levels of oxygen are indicated near the respective tubes ( figure 7(b ) ) .
the data sets acquired with ( 15  15  15 ) gradient steps and ( 1.2 , 1.0 , 0.8 ) g / cm maximum gradients were used to reconstruct 3d spin density and oxygen images of phantoms .
the reconstruction results have been obtained by the parallel approach using a set of in vivo 3d oximetric data collected at 3 minutes after the injection of the oxo63 through the tail vein of the tumor mouse .
there are ( 100  100  100 ) voxels in each of the twelve 3d spin density images .
each voxel represents the spin density in the tumor - bearing leg and the contralateral normal leg of a c3h mouse in a specific location .
the oxygen images are computed by applying a spin threshold of 0.01 and shown in figure 8(b ) .
the slices ( a1 , a2 , and a3 ) show the 7th , 8th , and 9th coronal planes of the 6th 3d spin density image .
the slices ( b1 , b2 , and b3 ) show the 7th , 8th , and 9th coronal planes of the 6th 3d oxygen image .
the tumor type studied here ( squamous cell carcinoma , scc ) is characterized by a large number of growing and  leaky  blood vessels , and therefore the spin probe accumulates faster in the tumor region , and the leaked out portion tends to remain longer in the tumor region .
the time taken by the pc and the parallel system for the reconstruction of twelve 3d spin density images from the selected time - point data files is computed and tabulated in table 5 . for a data set with ( 23  23  23 ) gradient steps , the parallel system has achieved a speed - up factor of 4.57 compared to the pc performance .
this means that a 3d spin density image with ( 100  100  100 ) voxels can be reconstructed in less than 1.2 seconds .
it can be seen that the computation time scales well with the number of workers .
we also measured the runtime of the parallel oxygen thresholding stage by varying spin threshold values .
the execution times of the pc executing serial matlab code and parallel system executing parallel matlab code are listed in table 6 .
 value in table 6 is fixed by observing noise level in the 3d mesh plot . a bar chart showing the execution time of the reconstruction and oximetry stages of the pc as well as
a speed - up factor of 4.25 has been realized by the parallel system compared to the pc system , for a data set with 23  23  23 gradient steps .
this means that an oxygen image with ( 100  100  100 ) voxels can be computed using the spin density threshold of .01 , in 2 seconds .
it is noted that the computation time scales well for the threshold value of 0.01 with four workers in the parallel matlab environment . the time required for the computation of oxygen images for a spin intensity threshold less than .01
is high ( table 6 ) because the computation includes much more additional noisy data . in order to interactively
analyze the experimental results with the same set of oximetric projection data , the gui of the parallel system can now be utilized to change the input parameters in a flexible and simple environment .
the oxygen images and spin density images are visualized from the raw filtered data in the parallel matlab environment at almost real time .
the interested readers can contact the corresponding author for a copy of the c++ and matlab codes .
in this article , we have presented a parallel implementation of lowpass filtration and reconstruction of 3d oximetric data , to overcome the limitations faced by the extensive size of projection data .
we were able to efficiently apply parallelization using c++ code with openmp paradigm for the filtration task and execute it on a parallel computer system .
this task has been performed automatically as soon as the data sets are transferred to the server from the client computers . with 8 parallel workers , we could achieve significant speed up factor during the filtration of 3d oximetric data against sequential execution time .
a parallel matlab version enables the reconstruction of 3d spin density images and 3d oxygen images of small animals to study oximetry using epr technique in the spi modality .
the parallel system consumes 14.29 seconds for the reconstruction of twelve 3d spin density images whereas the pc consumes 65.30 seconds , when a data set with ( 23  23  23 ) gradient steps has been used as input to both the systems .
the parallel system computes twelve 3d oxygen images in 23.69 seconds using a spin threshold value of .01 , whereas the pc system consumes 100.64 seconds .
the attempt of parallelization of the reconstruction process on a high - performance smp computing environment yielded useful speed - up results , thus allowing the users to map the oxygen levels in the tumor readily .
the results from phantom and in vivo experiments and achievable speed - up factors demonstrate the potential of exploiting parallel computing in 3d oximetric imaging .
more specifically , the client - server - based implementation of the parallel system makes the 3d oximetric research environment more flexible and easily accessible .
our recent results indicate that the readily available computational power offered by last generation parallel computer architectures , combined with the design of effective parallel algorithms , may enhance 3d oximetric imaging studies to visualize the po2 levels almost in real time .
this approach may also be extended to computational efforts that need to deal with very high data density .
 three - dimensional oximetric electron paramagnetic resonance imaging using the single point imaging modality generates unpaired spin density and oxygen images that can readily distinguish between normal and tumor tissues in small animals . 
 it is also possible with fast imaging to track the changes in tissue oxygenation in response to the oxygen content in the breathing air . 
 however , this involves dealing with gigabytes of data for each 3d oximetric imaging experiment involving digital band pass filtering and background noise subtraction , followed by 3d fourier reconstruction . 
 this process is rather slow in a conventional uniprocessor system . 
 this paper presents a parallelization framework using openmp runtime support and parallel matlab to execute such computationally intensive programs . 
 the intel compiler is used to develop a parallel c++ code based on openmp . 
 the code is executed on four dual - core amd opteron shared memory processors , to reduce the computational burden of the filtration task significantly . 
 the results show that the parallel code for filtration has achieved a speed up factor of 46.66 as against the equivalent serial matlab code . 
 in addition , a parallel matlab code has been developed to perform 3d fourier reconstruction . 
 speedup factors of 4.57 and 4.25 have been achieved during the reconstruction process and oximetry computation , for a data set with 23  23  23 gradient steps . 
 the execution time has been computed for both the serial and parallel implementations using different dimensions of the data and presented for comparison . 
 the reported system has been designed to be easily accessible even from low - cost personal computers through local internet ( nihnet ) . 
 the experimental results demonstrate that the parallel computing provides a source of high computational power to obtain biophysical parameters from 3d epr oximetric imaging , almost in real - time . 
1. Introduction
2. Material and Methods
3. Results and Discussion
4. Summary