GRADIENT COIL OF MRI

The ultimate goal of MRI is Image generation .The combination of static magnetic field and Radio frequency coils allows detection of MR signal but MR signal alone cannot be used to create an image .The fundamental measurement of MRI is merely the amount of current through a coil which in itself has no spatial information .Gradient coils provide the final touch up required for imaging .The main purpose of gradient coil is to cause MR signal spatially dependent in a controlled fashion. Gradient coils are generally turned off when Image acquisition is not required

To make the recovery of spatial information as simple as possible, gradient coils are used to generate a magnetic field that increases in strength along one spatial direction .The spatial direction used are relative to the main magnetic field, with Z axis parallel to main magnetic field and X and Y going perpendicularly to the main field .As previously gradient coils are evaluated on two criteria:: linearity and the field strength. The simplest example for gradient coil is MAXWELL pair. X and Y gradients are also called as Transverse Gradient both are created in the same fashion as Z, this transverse gradient changes the intensity of main field, and generally Golay pair is used is used .Strength of gradient coil is a function of both current density and the physical size of the coil

RADIO FREQUENCY COILS OF MRI

I had previously posted about static magnetic field this part the RADIO FREQUENCY COILS will continue the description of MRI ,hope you all will like it ,there could be typing error please correct it on the comment bar The static field does not produce any MR signal it is actually produced by use of two types of coils (transmitting coils )they are the transmitter and the receiver coils ,they generate and receive electromagnetic fields at the resonant frequency of the atomic nuclei within the static magnetic field ,this process gives the name resonance to magnetic resonance imaging. Because most atomic nuclei of interest for MRI studies have their resonant frequency in the radiofrequency portion of electromagnetic spectrum (at typical field strength of MRI),these coils are called radio frequency coils ,these coils can be evaluated on the same criteria as static field :uniformity and sensitivity .The radio frequency coils sends electromagnetic waves that resonate at a particular frequency ,as determined by the strength of magnetic field into the body ,disturbing the equilibrium state the process is known as excitation .When atomic nuclei are excited they absorb the energy of the radiofrequency pulse, But when the radiofrequency pulse ends the atomic nuclei go to equilibrium releasing energy absorbed during excitation ,this releasing energy are detected by the receiver coils the process is called as reception .The detected electromagnetic pulse defines raw MR signal

To explain it in a much simpler let me explain the way as I understood let me put it like this ,when I throw a ball in air I apply some potential energy to it by that I can give some energy to the ball ,now after the energy is lost the ball will come to equilibrium ,the energy present in the ball is given to the environment ,what happens in the atom is RF coils give potential energy and as the process of equilibrium is obtained the atom losses its energy to the surroundings ,here the difference with the ball and atom is we keep a receiver coil to extract all the energy i.e. the receiver coils the energy received depends on the distance from the sample being measured so the RF coils are generally placed immediately around the head in FMRI in both surface and volume coil arrangement. Now let me introduce you all to two other concepts of surface coil and volume coil. As I am from electrical background I would elaborate on this concept a bit more, as simple as possible The concept of surface coil begins with single loop (indicator-capacitor circuit) an additional resistance is also provided. As you all know that capacitor has a property of charging and discharging now when connected with an inductor due to rapid charge and discharge between capacitor and indicator it provides an oscillating current that can be tuned with the frequency of our interest, what happens here for the capacitor to charge we need a slow rising current which is accomplished by using an inductor what happens here to the total circuit is it will yield us a frequency which is f=1/2*(pi)*sqrt(L*C) by varying capacitance and inductance we can control the frequency ,it is similar to a radio receiver which uses similar circuit to receive station ,since receiver resonates at a particular frequency stations which are far off will not excite or give response ,the value of R should be small as possible so that only station is picked .In MRI the hydrogen atom will have a frequency which can be taken by the receiver coil ,the frequency adjustment is done by inductance and capacitance and Resistance should be small so that energy of only required area is captured .Because of close proximity towards brain surface coil it produces a high image sensitivity so it is generally used in FMRI to target one specific region of brain ,since the imaging depends on the distance from the surface coil ,whenever whole volume imaging is required it is inappropriate to use this

Now let us move to a second type of coil that is the volume coil which provides uniform spatial coverage throughout a large volume, the basic concept is that of surface coil (LC circuit) but here this LC circuit is replicated around a cylindrical surface to achieve uniform distribution of energy within the enclosed volume coil and sometimes referred as birdcage coil. As volume coil is father from the brain so sensitivity in the region of brain is less

A compromise approach has been made to get the best features of both the coil types, use volume coil for exiting and surface coil for receiving the MR signal .if multiple receiver coils is used arranged in a overlapping pattern known as phased array. Sensitivity of radiofrequency coil is proportional to strength of magnetic field generated within the coil by unit current. To obtain quantitative measurement of coil sensitivity, Quality factor is defined as ratio of maximum energy stored and total energy dissipated per period

Quality factor (Q)=sqrt(INDUCTANCE)/RESISTANCE*sqrt(CAPACITANCE)

Minimizing resistance will boost coil sensitivity

mineSweeper game run using matlab

function mineSweeper(varargin);

%
%The game is probably familiar to everyone, but the game has a slight
%twist. You may play the game such that there may be up to 7 mines per
%square instead of just one.
%
%Left click:
% - If the square is not a mine then a number will appear counting the
% number of mines in the uncovered surrounding squares.
%
% - If the square is a mine, the game is over.
%
% - If the square was already uncovered, and all the flags have been set,
% then it will uncover the surrounding squares - however, if any of
% those are actually a mine, the game is over.
%
% - If the square was flagged, one flag will be removed.
%
%Right click:
% - Set and cycle through the flags, each right click will add another
% flag.
%
% - To clear all the flags from the square, continue to right click and
% cycle back to the reset position. (Or, left click down to 0 flags.)
%
% - If the square was uncovered, nothing will happen.

%
%% Initial set up

%Change MATLAB's rand state
rand('twister',sum(100*clock));

%Number of board columns
gameBoard.gameCols = 30;
%Number of board rows
gameBoard.gameRows = 16;
gameBoard.numberBoxes = gameBoard.gameRows * gameBoard.gameCols;
%Maximum number of mines per square, default value of 1 if not set
gameBoard.maxMines = 1;
if nargin == 1;
gameBoard.maxMines = varargin{1};
if ischar(gameBoard.maxMines);%Surprise me
gameBoard.maxMines = ceil(7 * rand);
end;
end;

%Initial mine distribution matrix, each column represents a maxMines
%value and each row represents the number of mines to be placed on the
%board
mineDistribution = [...
100,60,50,40,40,35,30;...
0, 40,30,30,24,25,24;...
0, 0, 20,20,18,16,18;...
0, 0, 0, 10,12,11,12;...
0, 0, 0, 0, 6, 8, 8;...
0, 0, 0, 0, 0, 5, 5;...
0, 0, 0, 0, 0, 0, 3];

%Initial distribution vector for the case we will play
mineDistribution = mineDistribution(:,gameBoard.maxMines);

%Will be used later to determine the number of flags left to mark
flagsLeft = 0 * mineDistribution;

%gameBoard will hold the user clicks and the state of the board:
%The first page:
%0 means covered, 1 means uncovered, -X means X flags set
%The second page:
%The handles to the text representing the flags set
%The third page:
%The handles to the boxes drawn
%The fourth page:
%The mine values
temp = zeros(gameBoard.gameRows,gameBoard.gameCols);
gameBoard.mineValues = temp;
gameBoard.boxHandles = temp;
gameBoard.flagHandle = temp;
gameBoard.userClicks = temp;

%% Create game board display

%Create figure
gameHandle = figure;
figColor = [0.80 0.80 0.80];
set(gameHandle,'Units','Normalized',...
'Position',[0.15 0.20 0.70 0.50],...
'Color',figColor,...
'Name','Mine Sweeper',...
'NumberTitle','Off',...
'Resize','Off');

%Add game menu
set(gameHandle,'MenuBar','None');
menuHandle = uimenu('Label','Start New Game');
uimenu(menuHandle,'Label','At most 1 mine,',...
'Callback','closereq;mineSweeper(1);','Accelerator','1');
uimenu(menuHandle,'Label','At most 2 mines,',...
'Callback','closereq;mineSweeper(2);','Accelerator','2');
uimenu(menuHandle,'Label','At most 3 mines,',...
'Callback','closereq;mineSweeper(3);','Accelerator','3');
uimenu(menuHandle,'Label','At most 4 mines,',...
'Callback','closereq;mineSweeper(4);','Accelerator','4');
uimenu(menuHandle,'Label','At most 5 mines,',...
'Callback','closereq;mineSweeper(5);','Accelerator','5');
uimenu(menuHandle,'Label','At most 6 mines,',...
'Callback','closereq;mineSweeper(6);','Accelerator','6');
uimenu(menuHandle,'Label','At most 7 mines,',...
'Callback','closereq;mineSweeper(7);','Accelerator','7');
uimenu(menuHandle,'Label','Surprise me,',...
'Callback','closereq;mineSweeper(''s'');','Accelerator','S');
uimenu(menuHandle,'Label','End game,',...
'Callback','closereq;','Accelerator','Q');

%Add box to count number of flags remaining
flagHandle = uicontrol(gameHandle,'Style','text');
set(flagHandle,'Units','Normalized',...
'Position',[0.02 0.55 0.14 0.40],...
'BackgroundColor',figColor);

%Add message dialog box
talkHandle = uicontrol(gameHandle,'Style','text');
set(talkHandle,'Units','Normalized',...
'Position',[0.02 0.35 0.14 0.10],...
'BackgroundColor',figColor,...
'String','Good luck!','FontSize',16);

%Add game board axes
axisHandle = axes;
set(axisHandle,'Units','Normalized',...
'Position',[0.18 0.05 0.80 0.90],...
'XLim',[0 gameBoard.gameCols],'YLim',[0 gameBoard.gameRows],...
'YDir','Reverse',...
'XTick',[],'YTick',[],'Box','On');

%% Create game board values

%The indices into the board which contain a mine will be randomly
%selected using randperm
gameBoardIndex = randperm(gameBoard.numberBoxes);
mineCumulative = cumsum(mineDistribution);

%Set the first set as containing one mine
gameBoard.mineValues(gameBoardIndex(1:mineCumulative)) = -1;

%Loop through remaining random spots for next mine increment
for dMine = 2:gameBoard.maxMines;
gameBoard.mineValues(gameBoardIndex...
(mineCumulative(dMine - 1) + 1:mineCumulative(dMine))) = -dMine;
end;

%For each non-mine position, need to count the number of mines around,
%start by computing all the rows and columns
[dIndexRow,dIndexCol] = ind2sub...
([gameBoard.gameRows gameBoard.gameCols],...
1:gameBoard.numberBoxes);
dIndexRow = repmat(dIndexRow',[1 3]);
dIndexCol = repmat(dIndexCol',[1 3]);
%The rows and columns that surround are +/- 1 from the middle
surroundingPoints = repmat([-1 0 1],[size(dIndexRow,1),1]);
dIndexRow = dIndexRow + surroundingPoints;
dIndexCol = dIndexCol + surroundingPoints;

for dIndex = 1:gameBoard.numberBoxes;
if gameBoard.mineValues(dIndex) < 0;
%Nothing to count, index is flagged
continue;
end;
%Find the surrounding squares
surroundingIndices = surroundingSquares(...
dIndexRow(dIndex,:),gameBoard.gameRows,...
dIndexCol(dIndex,:),gameBoard.gameCols);

%Find these gameBoard values
temp = gameBoard.mineValues(surroundingIndices);
%Only count the flags (negative values)
k = temp < 0;
%Sum the number of flags surrounding this index
gameBoard.mineValues(dIndex) = abs(sum(sum(temp .* k)));
end;

%Display the game board in the background of the figure
gameBoard.xOffset = -0.75;%Offset from edge of row/col
gameBoard.yOffset = -0.50;%Offset from edge of row/col
[x,y] = meshgrid(...
1 + gameBoard.xOffset:1:gameBoard.gameCols + gameBoard.xOffset,...
1 + gameBoard.yOffset:1:gameBoard.gameRows + gameBoard.yOffset);

%Display text
textHandles = text(x(:),y(:),int2str(gameBoard.mineValues(:)),...
'FontSize',8);
set(textHandles,'Color',[0.00 0.00 1.00]);
%The 0 values should not display, and mines are to be colored red
k = gameBoard.mineValues(:);
set(textHandles(k == 0),'Visible','Off');
set(textHandles(k < 0),'Color',[1.00 0.00 0.00]);

%Now, cover the number of mines (otherwise the game would be pointless)
gameBoard.uncoveredColor = [0.40 0.40 0.40];%dark gray covering square
gameBoard.markedColor = [1.00 1.00 0.50];%yellow indicating flagged
%For each grid point, create a patch of a box covering the area
for dRow = 0:gameBoard.gameRows - 1;
for dCol = 0:gameBoard.gameCols - 1;
gameBoard.boxHandles(dRow + 1,dCol + 1) = patch(...
[dCol, dCol, dCol + 1, dCol + 1, dCol],...
[dRow, dRow + 1, dRow + 1, dRow, dRow],...
gameBoard.uncoveredColor);
set(gameBoard.boxHandles(dRow + 1,dCol + 1),...
'EdgeColor',[0.00 0.00 0.00]);
end;
end;

%Setup the text containing the flag information
flagsLeftString = char(zeros(gameBoard.maxMines,6));
for dMine = 1:gameBoard.maxMines;
switch dMine;
case 1;
flagsLeftString(dMine,:) = ' I - ';
case 2;
flagsLeftString(dMine,:) = 'II - ';
case 3;
flagsLeftString(dMine,:) = 'III - ';
case 4;
flagsLeftString(dMine,:) = 'IV - ';
case 5;
flagsLeftString(dMine,:) = ' V - ';
case 6;
flagsLeftString(dMine,:) = 'VI - ';
case 7;
flagsLeftString(dMine,:) = 'VII - ';
end;
end;

%% Play game
gameContinues = true;
gameWon = false;

while gameContinues;

%Update mine count
for dMine = 1:gameBoard.maxMines;
flagsLeft(dMine,1) = mineDistribution(dMine) -...
sum(sum(gameBoard.userClicks == -dMine));
end;
set(flagHandle,...
'String',[flagsLeftString,...
int2str(flagsLeft(1:gameBoard.maxMines))],'FontSize',12);

%Determine if game has been won
k = gameBoard.mineValues < 0;
if all(all(gameBoard.mineValues(k) == gameBoard.userClicks(k))) &&...
all(all(gameBoard.userClicks(~k) == 1));
%All flags set and match the mine value, and all boxes uncovered
gameContinues = false;
gameWon = true;
continue;
end;

%Get user click
try;
m = waitforbuttonpress;
if m == 1;
continue;
end;
catch;
%User closed game
return;
end;

%Return mouse position
thisPoint = get(axisHandle,'CurrentPoint');
thisRow = floor(thisPoint(1,2)) + 1;
thisCol = floor(thisPoint(1,1)) + 1;
%Return mouse button used
thisButton = get(gameHandle,'SelectionType');

if thisRow <= 0 || thisRow > gameBoard.gameRows ||...
thisCol <= 0 || thisCol > gameBoard.gameCols;
%Clicked outside the board, try again
continue;
end;

switch thisButton;
case 'normal';%Left button

%Square has a flag on it, left click void
if gameBoard.userClicks(thisRow,thisCol) < 0;
gameBoard.userClicks(thisRow,thisCol) =...
gameBoard.userClicks(thisRow,thisCol) + 1;
%Place/update flag on board
gameBoard = setFlag(gameBoard,thisRow,thisCol);
continue;
end;

%Square was not clear, but is a mine
if gameBoard.mineValues(thisRow,thisCol) < 0 &&...
gameBoard.userClicks(thisRow,thisCol) == 0;
%Oops, stepped on a mine
set(gameBoard.boxHandles(thisRow,thisCol),...
'FaceColor','None');
gameContinues = false;
continue;
end;

%Square was not clear, not a mine
if gameBoard.mineValues(thisRow,thisCol) >= 0 &&...
gameBoard.userClicks(thisRow,thisCol) == 0;
set(gameBoard.boxHandles(thisRow,thisCol),...
'FaceColor','None');
gameBoard.userClicks(thisRow,thisCol) = 1;
newlyUncovered = sub2ind...
([gameBoard.gameRows gameBoard.gameCols],...
thisRow,thisCol);
end;

%Square clear, number of flags set, clear surrounding area
surroundingIndices = surroundingSquares(...
thisRow,gameBoard.gameRows,...
thisCol,gameBoard.gameCols);

temp = gameBoard.userClicks(surroundingIndices);
k = temp < 0;
flagsSet = abs(sum(sum(temp .* k)));

if flagsSet == gameBoard.mineValues(thisRow,thisCol) &&...
flagsSet > 0 &&...
gameBoard.userClicks(thisRow,thisCol) == 1;
%Find all surrounding points that aren't flagged
k = gameBoard.userClicks(surroundingIndices) < 0;
set(gameBoard.boxHandles(surroundingIndices(~k)),...
'FaceColor','None');
gameBoard.userClicks(surroundingIndices(~k)) = 1;
newlyUncovered = surroundingIndices(~k);
if any(gameBoard.mineValues(surroundingIndices(~k)) < 0);
%Oops, set a flag incorrectly and uncovered a mine
gameContinues = false;
continue;
end;
end;

%Call a recursive function to uncover all the connected 0
%values, this will happen if the square was a 0 or if the
%flags were set and a 0 was uncovered
[newlyUncovered,gameBoard] = uncoverZeros...
(newlyUncovered,gameBoard,[]);

case 'alt';%Right button

%Box already cleared, right click void
if gameBoard.userClicks(thisRow,thisCol) == 1;
continue;
end;

%Mark flag, subtract 1 to mean another flag added
gameBoard.userClicks(thisRow,thisCol) =...
gameBoard.userClicks(thisRow,thisCol) - 1;

%Place/update flag on board
gameBoard = setFlag(gameBoard,thisRow,thisCol);
end;
end;

%Game over, display end game message
if gameWon;
newColor = [0.30 0.30 1.00];
set(talkHandle,'String','Well Done!');
else;
newColor = [1.00 0.50 0.00];
set(talkHandle,'String',' O O P S! ');
%Display flags set incorrectly
k = gameBoard.userClicks < 0 &...
gameBoard.mineValues ~= gameBoard.userClicks;
set(gameBoard.boxHandles(k),'FaceColor',[1.00 0.00 0.00]);
%Display mines not flagged
k = gameBoard.mineValues < 0 & gameBoard.userClicks >= 0;
set(gameBoard.boxHandles(k),'FaceColor','None');
end;
set(gameHandle,'Color',newColor);
set(flagHandle,'BackgroundColor',newColor);
set(talkHandle,'BackgroundColor',newColor);

end

%% Set Flags

%Function to place/update the correct flag on the board
function gameBoard = setFlag(gameBoard,thisRow,thisCol);

%Use mod arithmetic only
temp = mod(-gameBoard.userClicks(thisRow,thisCol),...
gameBoard.maxMines + 1);
gameBoard.userClicks(thisRow,thisCol) = -temp;
%If text has previously been set...
if gameBoard.flagHandle(thisRow,thisCol) ~= 0;
%...Clear flag string
set(gameBoard.flagHandle(thisRow,thisCol),'String','');
end;
%Set square color to indicate it is marked
thisColor = gameBoard.markedColor;
switch temp;%Number of flags set
case 0;%Reset square to uncovered state
flagString = '';
thisColor = gameBoard.uncoveredColor;
case 1;
flagString = ' I ';
case 2;
flagString = ' I I ';
case 3;
flagString = 'I I I';
case 4;
flagString = 'I V ';
case 5;
flagString = ' V ';
case 6;
flagString = 'V I ';
case 7;
flagString = 'VI I';
end;
%Display flags, set square color
gameBoard.flagHandle(thisRow,thisCol) =...
text(thisCol + gameBoard.xOffset,thisRow + gameBoard.yOffset,...
flagString,'FontName','Arial','FontSize',6);
set(gameBoard.boxHandles(thisRow,thisCol),...
'FaceColor',thisColor);

end

%% Surrounding Squares Indices

%Return the indices surrounding the current square(s)
function surroundingIndices = surroundingSquares(rowIndices,gameRows,...
colIndices,gameCols);

if length(rowIndices) == 1;
rowIndices = rowIndices + [-1 0 1];
end;
if length(colIndices) == 1;
colIndices = colIndices + [-1 0 1];
end;

%For one index at a time, determine the rows and columns that
%surround the index, removing those off the game board.
m = ~(rowIndices <= 0 | rowIndices > gameRows);
n = ~(colIndices <= 0 | colIndices > gameCols);
%Compute the "all-possible" pairings of rows and columns
[surroundingRows,surroundingCols] = meshgrid...
(rowIndices(m),colIndices(n));
%Easier to use indices
surroundingIndices = sub2ind...
([gameRows gameCols],surroundingRows,surroundingCols);

end

%% Uncover 0 Squares

%Recursive function to uncover squares with a 0 value
function [newlyUncovered,gameBoard] =...
uncoverZeros(newlyUncovered,gameBoard,alreadyCleared);

%Game size
[gameRows,gameCols] = size(gameBoard.mineValues);

%Keep only the new squares that are a 0
newlyUncovered = newlyUncovered...
(gameBoard.mineValues(newlyUncovered) == 0);

while ~isempty(newlyUncovered);
%Take the first index
[rowIndex,colIndex] = ind2sub...
([gameRows gameCols],newlyUncovered(1));
%Return all points the surround this square
temp = surroundingSquares(rowIndex,gameRows,colIndex,gameCols);

%Add to a list of squares already dealt with to avoid an infinite
%recursion
alreadyCleared = unique([alreadyCleared;newlyUncovered(1)]);

%Remove squares marked as already clear
temp = setdiff(temp(:),alreadyCleared);
%Remove point currently being cleared
newlyUncovered(1) = [];
%Add the surrounding squares to this list
newlyUncovered = unique([newlyUncovered;temp(:)]);

%If the user set a 0 as a flag don't uncover
temp = temp(gameBoard.userClicks(temp) >= 0);

%Mark these squares as cleared
gameBoard.userClicks(temp) = 1;
set(gameBoard.boxHandles(temp),'FaceColor','None');

%Recursive call, will continue until the trail of 0s has been
%uncovered
[newlyUncovered,gameBoard] = uncoverZeros...
(newlyUncovered,gameBoard,alreadyCleared);
end;

end

Heart has built-in repair mechanism

Researchers have for the first time succeeded in transforming a new type of stem-like cell in the adult heart, into heart muscle in mice.

The study, led by UCL scientists proves the heart has dormant repair cells in its outer layer that may be re-activated. The research suggests that in the future hearts damaged by a heart attack could be encouraged to repair themselves.

The damage caused by a heart attack is currently permanent. It can lead to heart failure, which is debilitating, has a poor prognosis, and affects over 750,000 people in the UK.

British Heart Foundation-funded scientists working at UCL targeted stem-like cells called progenitor cells in the epicardium, the outer layer of the heart. In the embryo, these epicardium-derived progenitor cells (EPDCs) are able to transform into a number of specialist cells including heart muscle. Scientists thought this ability was lost in adults but researchers have managed to reactivate this potential.

They restored the EPDCs’ embryonic potential by treating the healthy hearts of adult mice with a peptide molecule called thymosin β4 (Tβ4). This appeared to ’prime’ the heart for repair. When damage to the heart occurred, a booster dose of Tβ4 was given, and this sparked the EPDCs to transform into new heart muscle and integrate with existing healthy muscle. Crucially, muscle is not formed if the EPDCs have not been pre-treated with Tβ4.

Explaining how this work might eventually translate into clinical practice, Professor Paul Riley (UCL Institute of Child Health), who led the research, said: “I could envisage a patient known to be at risk of a heart attack – either because of family history or warning signs spotted by their GP – taking an oral tablet, along the lines of a statin, which would prime their heart so that if they had a heart attack, the damage could be repaired.”

However, treatments based on this method are several years away. Tβ4 enabled only a limited number of heart muscle cells to be generated. With BHF funding, the researchers now plan to carry out further research into the molecule. They hope to make it more effective or come up with alternative ways to activate the embryonic potential of EPDCs and eventually translate what they have found in mice into humans. This will also be helped by gaining better knowledge of the mechanism by which Tβ4 works.

Professor Riley added: “This is an important piece of work and something we’ve been working toward for some time. Our earlier research proved blood vessels could be regenerated in adult hearts but there were major doubts about whether the same might be true for heart muscle. This work has demonstrated a possible method for repairing hearts damaged by a heart attack and could have a major impact on future therapies to treat heart failure.”

Professor Jeremy Pearson, Associate Medical Director at the BHF, said:

“To repair a damaged heart is one of the holy grails of heart research. This groundbreaking study shows that adult hearts contain cells that, given the right stimulus, can mobilise and turn into new heart cells that might repair a damaged heart. The team have identified the crucial molecular signals needed to make this happen.

“These results strengthen the evidence that in the future there may be a drug, or cocktail of drugs, that could be given to people whose hearts have been damaged by a heart attack, to prevent the onset of heart failure. This is why the BHF has launched its Mending Broken Hearts appeal to raise money for research to turn this vision into reality for heart patients as quickly as possible.”

A fiducial marker based technique for alignment of simultaneously acquired PET and MRI images

Combined MRI and PET systems are currently being developed by a number of research groups and also commercially. Most systems have been designed to permit the simultaneous acquisition of MRI and PET data. The approach taken by many groups, is to build an MRI compatible PET insert, that works inside a standard MRI scanner. Unlike other multi-modality imaging systems such as PET/CT, the physical location of the PET scanner within the MRI scanner may vary each time the PET scanner is removed and replaced in the MRI scanner. In order to produce fully aligned PET and MRI images over the same region of the subject, the PET scanner location within the MRI field of view (FOV) is required, as well as the transformation between the PET and the MRI images. We have developed such a technique for our single slice pre-clinical MR-compatible PET system that uses long optical fibres to distance the PET PMTs from the high field at the centre of the MRI scanner. The method uses MRI visible markers attached to the PET scanner at a known position with respect to the PET FOV. In our configuration the markers must be positioned close to MRI compatible PET gamma shields which are used to improve the signal to noise ratio of the PET images by reducing the number of events recorded from activity outside the FOV. These shields are made from BGO and PbO, which have similar magnetic properties to LSO. The main magnetic field of the MRI scanner becomes distorted near to the shields, although they impose little distortion over the useful FOV of the PET system. We have assessed the accuracy with which the MRI visible markers can be used to select the location of the PET imaging slice and to align the PET and MRI images in-plane, using simultaneously acquired data of various phantoms. In order to carry out the in-plane registration, two separate MRI images had to be acquired in which the direction of the MRI frequency-encoding gradient was flipped between the two acquisitions to estimate the in-pl- - ane shift in marker location caused by field inhomogeneities imposed by the PET shielding materials. The slice location accuracy and the in-plane registration appear to be accurate to approximately 0.5 mm. We have successfully applied the method to produce simultaneously acquired, registered ¹⁸F^-PET and MRI images of the mouse neck. A similar method is likely to be required for many future pre-clinical simultaneous PET and MRI studies as it will be essential for situations in which there is little similarity between the PET and MRI images.

STATIC MAGNETIC FEILD OF MRI

There are three important or main components in an MRI scanner static magnetic field, radio frequency coils and gradient coils which majorly contribute towards creating of images, yet there are other components also...
Static magnetic field
it is an absolute necessity for MRI, providing the magnetic in magnetic resonance imaging.MRI scanner use strong magnetic field to align certain nuclei within the human body (commonly Hydrogen) to allow mapping of tissue properties. The magnetic field strength is in fact proportional to current strength ,so that by adjusting the current strength in a wire one could precisely control field intensity .these findings led to the development of electromagnets ,which generate their fields by passing current through tight coils of wire .Nearly all scanners today create static magnetic field through electromagnetism. There are in general two criteria for a suitable magnetic field in MRI ,the first is uniformity (homogeneity) and second is strength. Uniformity is necessary in what we want to create Images of the body that do not depend on which MRI scanner we are using or how the body is positioned in the field .If magnetic field were Inhomogeneous,the signal measured from a given part of the body would depend upon where it is located in the magnetic field

A simple design for generating a homogeneous magnetic field is the HELMHOLTZ PAIR

This is a pair of circular loops that carry identical current and are separated by a distance equal to the radius of the loops, an even more uniform field can be generated by a Solenoid, and the internal field near its center is highly homogeneous

Field Strength in contrast to uniformity requires force rather than finesse, to generate this field, we require enormous electric power and thus enormous expense.MRI scanners use Super conducting electromagnets whose wires are cooled by cryogens (liquid helium) to reduce their temperature to near absolute zero. Coil windings are typically made of metal alloys such as niobium-titanium, which when immersed in liquid helium reach temperatures of less than 12K (-261 deg).At this extremely low temperature ,the resistance in the wire disappears thereby enabling a strong and lasting electric current to be generated with no power requirements and minimal cost