void SetMachineParameters( void )
{
double dval;
DB_MSG(("-->SetMachineParameters\n"));
if( ParxRelsParHasValue("ACQ_word_size") == No )
{
ACQ_word_size = _32_BIT;
}
dval = PVM_GradDelayTime + PVM_2dPhaseGradientTime - 0.01;
dval = MAX_OF(PVM_DigEndDelOpt,dval);
DEOSC = (PVM_AcquisitionTime + dval)*1000.0;
ACQ_scan_shift = -1;
ParxRelsParRelations("ACQ_scan_shift",Yes);
DE = DE < 6.0 ? 6.0: DE;
PAPS = QP;
ACQ_BF_enable = Yes;
DB_MSG(("<--SetMachineParameters\n"));
}
void SetRecoParam( void )
{
int dim,i,complexDataCorr;
DB_MSG(("-->SetRecoParam\n"));
/* set baselevel reconstruction parameter */
/* default initialization of reco based on acqp pars allready set */
ATB_InitDefaultReco();
/* configure information available during setup mode */
GS_info_dig_filling = Yes;
ParxRelsParRelations("GS_info_dig_filling",Yes);
GS_info_normalized_area = Of_raw_data;
ParxRelsParRelations("GS_info_normalized_area",Yes);
/* set reco rotate according to phase offsets */
dim = (int) PARX_get_dim("ACQ_size",1);
for (i=0; i<dim; i++)
{
if (i==0)
complexDataCorr = 2;
else
complexDataCorr = 1;
RECO_size[i] = (int)(ACQ_size[i] / complexDataCorr) ;
}
DB_MSG(("<--SetRecoParam\n"));
}
void initMeth()
/*:=MPE=:=======================================================*/
{
DB_MSG(( "Entering singlepulse:initMeth()" ));
int dimRange[2] = { 1,2 };
int lowMat[3] = { 32, 32, 8 };
int upMat[3] = { 32, 32, 8 };
/* which version of toolboxes should be active */
PTB_VersionRequirement( Yes,20070101,"");
/*
* initialize NOE and Decoupling parameter group
*/
STB_NoeOnOffRange();
STB_DecOnOffRange();
/*
* init decoupling module
*/
STB_InitDecModule();
/*
* init noe module
*/
STB_InitNoeModule();
/*
* init the local adjustments available
*/
/*
* initialize the nuclei dependent on NOE or Decoupling
*/
LocalDecNoeHandling();
/* Initialize PVM_NAverages PVM_NRepetitions see code in parsRelations.c */
Local_NAveragesRange();
NrepRange();
/* Initialisation of rf pulse parameters */
/* 1: flip angle in the scan edidor */
if(ParxRelsParHasValue("PVM_ExcPulseAngle") == No)
PVM_ExcPulseAngle = 30.0;
ParxRelsShowInEditor("PVM_ExcPulseAngle");
if(ParxRelsParHasValue("FrequencyLock_OnOff") == No)
FrequencyLock_OnOff = Off;
/* 2: pulses declared in parDefinitions.h
in this case - ExcPulse. We initalise it to default name,
1ms, and the flip angle given in PVM_ExcPulseAngle*/
if(ParxRelsParHasValue("ExcPulse") == No)
{
STB_InitRFPulse(&ExcPulse,
"gauss.exc",
1,
PVM_ExcPulseAngle);
}
ExcPulseRange();
/* 3: the corresponding pulse enums */
STB_InitExcPulseEnum("ExcPulseEnum");
/*KW-sliceSPEC (begin) 100714*/
if(ParxRelsParHasValue("PVM_EchoTime") == No)
PVM_EchoTime = 1.0;
if(ParxRelsParHasValue("SliceSpoilerDuration") == No)
SliceSpoilerDuration = 2;
if(ParxRelsParHasValue("SliceSpoilerStrength") == No)
SliceSpoilerStrength = 20;
/* Initialisation of nucleus */
STB_InitNuclei(1);
/* Initialisation of geometry parameters */
/* A: in-plane */
STB_InitStandardInplaneGeoPars(2,dimRange,lowMat,upMat,No);
/* B: slice geometry */
STB_InitSliceGeoPars(0,0,0);
STB_InitExSliceAtoms();
/*KW-sliceSPEC (end) 100714*/
/* initialisation of spectroscopy */
ParxRelsHideInEditor("PVM_SpecOffsetHz,PVM_SpecOffsetppm");
STB_InitSpectroscopy( 1, 1, 1 , PVM_Nucleus1 , 200.0, 1000000 );
/* Initialize multi receiver parameters */
STB_InitEncoding();
/* Initialisation of modules */
STB_InitWsModule (1);
STB_InitSatSlicesModule();
STB_InitFatSupModule();
NdummyRange();
/*kw-mod 101014 begin*/
STB_InitTriggerModule();
STB_InitTriggerOutModule();
/*kw-mod 101014 end*/
/*Gba - shim (start)*/
if(ParxRelsParHasValue("Slice1ShimStrength_x") == No)
Slice1ShimStrength_x = 1.0;
if(ParxRelsParHasValue("Slice1ShimStrength_y") == No)
Slice1ShimStrength_y = 1.0;
if(ParxRelsParHasValue("Slice1ShimStrength_z") == No)
Slice1ShimStrength_z = 1.0;
if(ParxRelsParHasValue("Slice2ShimStrength_x") == No)
Slice2ShimStrength_x = 1.0;
if(ParxRelsParHasValue("Slice2ShimStrength_y") == No)
Slice2ShimStrength_y = 1.0;
if(ParxRelsParHasValue("Slice2ShimStrength_z") == No)
Slice2ShimStrength_z = 1.0;
/*Gba - shim (end)*/
/* initialisation of DeadTime */
DeadTimeRange();
/* setting for Pipeline filter in case of multi channel acquisition */
PVM_RefScanPCYN = No;
/* Once all parameters have initial values, the backbone is called
to assure they are consistent */
backbone();
DB_MSG(( "Exiting singlepulse:initMeth()" ));
}
void SetPpgParameters( void )
{
DB_MSG(("-->SetPpgParameters\n"));
if( ParxRelsParHasValue("ACQ_trigger_enable") == No )
{
ACQ_trigger_enable = No;
}
if( ParxRelsParHasValue("ACQ_trigger_reference") == No )
{
ACQ_trigger_reference[0] = '\0';
}
if( ParxRelsParHasValue("ACQ_trigger_delay") == No )
{
ACQ_trigger_delay = 0;
}
ParxRelsParRelations("ACQ_trigger_reference",Yes);
ACQ_vd_list_size=1;
PARX_change_dims("ACQ_vd_list",1);
ACQ_vd_list[0] = 1e-6;
ParxRelsParRelations("ACQ_vd_list",Yes);
ACQ_vp_list_size=1;
PARX_change_dims("ACQ_vp_list",1);
ACQ_vp_list[0] = 1e-6;
ParxRelsParRelations("ACQ_vp_list",Yes);
ATB_SetPulprog("T1rho_MSME.ppg");
if(PVM_SelIrOnOff)
{
D[0] = PVM_InterGradientWaitTime / 1000.0;
D[10] = SliceSegEndDelay/1000.0;
}
else
{
D[0] = ((PVM_RepetitionTime - PVM_MinRepetitionTime)/NSLICES
+ PVM_InterGradientWaitTime) / 1000.0;
D[10] = 0.00001;
}
D[1] = ((PVM_EchoTime - minTE1)/2.0 + PVM_InterGradientWaitTime) / 1000.0;
D[2] = ((PVM_EchoTime - minTE2)/2.0 + 0.04) / 1000.0; /* 0.04 is duration of ADC_END_4ch */
D[3] = PVM_GradDelayTime / 1000.0;
D[3] = MAX_OF(D[3], 1e-5); /* min d3 in case PVM_GradDelayTime==0 */
D[4] = PVM_RampTime / 1000.0;
D[5] = (SliceSpoilerDuration - 2*PVM_RampTime)/1000.0;
D[6] = (PVM_2dPhaseGradientTime - 2*PVM_RampTime)/1000.0;
D[11] = (PVM_ReadDephaseTime - 2.0*PVM_RampTime) / 1000.0;
D[8] = CFG_AmplifierEnable()/1000.0;
/* set shaped pulses */
sprintf(TPQQ[0].name,ExcPulse.Filename);
sprintf(TPQQ[1].name,RefPulse.Filename);
if(PVM_DeriveGains == Yes) {
TPQQ[0].power = ExcPulse.Attenuation;
TPQQ[1].power = RefPulse.Attenuation;
}
TPQQ[0].offset = 0.0;
TPQQ[1].offset = 0.0;
ParxRelsParRelations("TPQQ",Yes);
/* set duration of pulse, in this method P[0] is used */
P[0] = ExcPulse.Length * 1000;
P[1] = RefPulse.Length * 1000;
ParxRelsParRelations("P",Yes);
DB_MSG(("<--SetPpgParameters\n"));
}
void SetInfoParameters( void )
{
int slices, i, spatDim;
DB_MSG(("-->SetInfoParameters\n"));
spatDim = PTB_GetSpatDim();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetInfoParameters: In function call!");
return;
}
ATB_SetAcqMethod();
ATB_SetAcqFov( Spatial, spatDim, PVM_Fov, PVM_AntiAlias );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetInfoParameters: In function call!");
return;
}
ACQ_flip_angle = PVM_ExcPulseAngle;
PARX_change_dims("ACQ_echo_time",PVM_NEchoImages);
for(i=0; i<PVM_NEchoImages; i++)
ACQ_echo_time[i] = EffectiveTE[i];
PARX_change_dims("ACQ_inter_echo_time",1);
ACQ_inter_echo_time[0] = PVM_EchoTime;
PARX_change_dims("ACQ_repetition_time",1);
ACQ_repetition_time[0] = PVM_RepetitionTime;
PARX_change_dims("ACQ_recov_time",1);
ACQ_recov_time[0] = PVM_RepetitionTime - PVM_ExSlicePulseLength;
PARX_change_dims("ACQ_inversion_time",1);
ACQ_inversion_time[0] = PVM_InversionTime;
strcpy(ACQ_fit_function_name,FitFunctionName);
if( ParxRelsVisibleForEdit("ProcessingMacro") == 1)
{
GO_use_macro = ProcessingMacro;
ParxRelsParRelations("GO_use_macro", Yes);
if(ProcessingMacro == Yes)
strcpy(GO_macro,ProcessingMacroName);
}
else
{
GO_use_macro = No;
ParxRelsParRelations("GO_use_macro", Yes);
}
ATB_SetAcqSliceAngle( PtrType3x3 PVM_SPackArrGradOrient[0],
PVM_NSPacks );
ACQ_slice_orient = Arbitrary_Oblique;
ACQ_slice_thick = PVM_SliceThick;
slices = GTB_NumberOfSlices( PVM_NSPacks, PVM_SPackArrNSlices );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetInfoParameters: In function call!");
return;
}
PARX_change_dims("ACQ_slice_offset",slices);
PARX_change_dims("ACQ_read_offset",slices);
PARX_change_dims("ACQ_phase1_offset",slices);
PARX_change_dims("ACQ_phase2_offset",slices);
for(i=0;i<slices;i++)
{
ACQ_slice_offset[i] = PVM_SliceOffset[i];
ACQ_read_offset[i] = PVM_ReadOffset[i];
ACQ_phase1_offset[i] = PVM_Phase1Offset[i];
ACQ_phase2_offset[i] = PVM_Phase2Offset[i];
}
ACQ_read_ext = (int)PVM_AntiAlias[0];
PARX_change_dims("ACQ_slice_sepn", slices==1 ? 1 : slices-1);
if( slices == 1 )
{
ACQ_slice_sepn[0] = 0.0;
}
else
{
for( i=1; i<slices;i++ )
{
ACQ_slice_sepn[i-1]=PVM_SliceOffset[i]-PVM_SliceOffset[i-1];
}
}
ATB_SetAcqSliceSepn( PVM_SPackArrSliceDistance,
PVM_NSPacks );
ATB_SetAcqPatientPosition();
ATB_SetAcqExpType( Imaging );
ACQ_n_t1_points = 1;
if( ParxRelsParHasValue("ACQ_transmitter_coil") == No )
{
ACQ_transmitter_coil[0] = '\0';
}
if( ParxRelsParHasValue("ACQ_receiver_coil") == No )
{
ACQ_receiver_coil[0] = '\0';
}
if( ParxRelsParHasValue("ACQ_contrast_agent") == No )
{
ACQ_contrast_agent[0] = '\0';
}
if( ParxRelsParHasValue("ACQ_contrast") == No )
{
ACQ_contrast.volume = 0.0;
ACQ_contrast.dose = 0.0;
ACQ_contrast.route[0] = '\0';
ACQ_contrast.start_time[0] = '\0';
ACQ_contrast.stop_time[0] = '\0';
}
ParxRelsParRelations("ACQ_contrast_agent",Yes);
ACQ_position_X = 0.0;
ACQ_position_Y = 0.0;
ACQ_position_Z = 0.0;
PARX_change_dims("ACQ_temporal_delay",1);
ACQ_temporal_delay[0] = 0.0;
ACQ_RF_power = 0;
ACQ_flipback = No;
ACQ_n_echo_images = PVM_NEchoImages;
ACQ_n_movie_frames = 1;
DB_MSG(("<--SetInfoParameters\n"));
}
void SetGradientParameters( void )
{
int spatDim, dim;
DB_MSG(("-->SetGradientParameters\n"));
ATB_SetAcqPhaseFactor( 1 );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetGradientParameters: In function call!");
return;
}
spatDim = PTB_GetSpatDim();
dim = PARX_get_dim("ACQ_phase_encoding_mode", 1 );
PARX_change_dims("ACQ_phase_encoding_mode", spatDim );
PARX_change_dims("ACQ_phase_enc_start", spatDim );
switch(spatDim)
{
case 3:
ACQ_phase_encoding_mode[2] = User_Defined_Encoding;
ACQ_phase_enc_start[2] = -1; /* set, but no used */
ACQ_spatial_size_2 = PVM_EncMatrix[2];
ParxRelsCopyPar("ACQ_spatial_phase_2","PVM_EncValues2");
/* no break */
case 2:
ACQ_phase_encoding_mode[1] = User_Defined_Encoding;;
ACQ_phase_enc_start[1] = -1.0; /* set, but no used */
ACQ_spatial_size_1 = PVM_EncMatrix[1];
ParxRelsCopyPar("ACQ_spatial_phase_1","PVM_EncValues1");
/* no break */
default:
ACQ_phase_encoding_mode[0] = Read;
ACQ_phase_enc_start[0] = -1;
}
ATB_SetAcqGradMatrix( PVM_NSPacks, PVM_SPackArrNSlices,
PtrType3x3 PVM_SPackArrGradOrient[0],
PVM_ObjOrderList );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetGradientParameters: In function call!");
return;
}
ACQ_scaling_read = 1.0;
ACQ_scaling_phase = 1.0;
ACQ_scaling_slice = 1.0;
ACQ_rare_factor = 1;
ACQ_grad_str_X = 0.0;
ACQ_grad_str_Y = 0.0;
ACQ_grad_str_Z = 0.0;
strcpy(GRDPROG, "");
ATB_SetAcqTrims( 10,
PVM_ExSliceGradient, /* t0 */
-PVM_ExSliceRephaseGradient, /* t1 */
PVM_ExSliceGradient, /* t2 */
SliceSpoilerStrength, /* t3 */
PVM_ReadDephaseGradient, /* t4 */
PVM_ReadGradient, /* t5 */
PVM_2dPhaseGradient, /* t6 */
-PVM_3dPhaseGradient, /* t7 */
-PVM_2dPhaseGradient, /* t8 */
PVM_3dPhaseGradient /* t9 */
);
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetGradientParameters: In function call!");
return;
}
DB_MSG(("<--SetGradientParameters\n"));
}
void SetFrequencyParameters( void )
{
int nslices;
DB_MSG(("-->SetFrequencyParameters\n"));
ATB_SetNuc1(PVM_Nucleus1);
sprintf(NUC2,"off");
sprintf(NUC3,"off");
sprintf(NUC4,"off");
sprintf(NUC5,"off");
sprintf(NUC6,"off");
sprintf(NUC7,"off");
sprintf(NUC8,"off");
ATB_SetNucleus(PVM_Nucleus1);
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetFrequencyParameters: In function call!");
return;
}
/* setting of SW_h, DIGMOD, DSPFIRM and AQ_mod */
ATB_SetDigPars();
ACQ_O1_mode = BF_plus_Offset_list;
ParxRelsParRelations("ACQ_O1_mode",Yes);
ACQ_O2_mode = BF_plus_Offset_list;
ParxRelsParRelations("ACQ_O2_mode",Yes);
ACQ_O3_mode = BF_plus_Offset_list;
ParxRelsParRelations("ACQ_O3_mode",Yes);
O1 = 0.0;
O2 = 0.0;
O3 = 0.0;
O4 = 0.0;
O5 = 0.0;
O6 = 0.0;
O7 = 0.0;
O8 = 0.0;
nslices = GTB_NumberOfSlices( PVM_NSPacks, PVM_SPackArrNSlices );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetFrequencyParameters: In function call!");
return;
}
ATB_SetAcqO1List( nslices,
PVM_ObjOrderList,
PVM_SliceOffsetHz );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetFrequencyParameters: In function call!");
return;
}
ATB_SetAcqO1BList( nslices,
PVM_ObjOrderList,
PVM_ReadOffsetHz);
ATB_SetRouting();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetFrequencyParameters: In function call!");
return;
}
DB_MSG(("<--SetFrequencyParameters\n"));
}
void SetBaseLevelParam( void )
{
DB_MSG(("-->SetBaseLevelParam\n"));
SetBasicParameters();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBaseLevelParam: Error in function call!");
return;
}
SetFrequencyParameters();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBaseLevelParam: In function call!");
return;
}
SetPpgParameters();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBaseLevelParam: In function call!");
return;
}
SetGradientParameters();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBaseLevelParam: In function call!");
return;
}
SetInfoParameters();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBaseLevelParam: In function call!");
return;
}
SetMachineParameters();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBaseLevelParam: In function call!");
return;
}
/* ------------------------------------------------------------------------
Sets parameters needed for multi-receiver acq. Overrides some previously
set parameters such as NUCn Must be called at the end of
SetBaseLevel.
----------------------------------------------------------------------- */
if(Yes==ATB_SetMultiRec())
{
ATB_SetPulprog("T1rho_MSME.4ch");
}
/* setting baselevel parameters used by modules */
ATB_SetFatSupBaselevel();
ATB_SetMagTransBaseLevel();
ATB_SetSatSlicesBaseLevel();
ATB_SetFlowSaturationBaseLevel();
ATB_SetTriggerBaseLevel();
ATB_SetEvolutionBaseLevel();
{
int nSlices;
nSlices = GTB_NumberOfSlices( PVM_NSPacks, PVM_SPackArrNSlices );
ATB_SetSelIrBaseLevel(nSlices);
}
DB_MSG(("<--SetBaseLevelParam\n"));
}
void SetBasicParameters( void )
{
int spatDim, specDim;
int nSlices;
int echo;
DB_MSG(("-->SetBasicParameters\n"));
/* ACQ_dim */
spatDim = PTB_GetSpatDim();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
specDim = PTB_GetSpecDim();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
ACQ_dim = spatDim + specDim;
ParxRelsParRelations("ACQ_dim",Yes);
/* ACQ_dim_desc */
ATB_SetAcqDimDesc( specDim, spatDim, NULL );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
/* ACQ_size */
/* With the Encoding group, this call
ATB_SetAcqSize( Spatial, spatDim, PVM_Matrix, PVM_AntiAlias, No );
is replaced by: */
ATB_SetAcqSize( Spatial, spatDim, PVM_EncMatrix, NULL, No );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
/* NSLICES */
nSlices = GTB_NumberOfSlices( PVM_NSPacks, PVM_SPackArrNSlices );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
ATB_SetNSlices( nSlices );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
/* NR */
ATB_SetNR( PVM_NRepetitions );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
/* NI */
ATB_SetNI( nSlices * PVM_NEchoImages );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
/* AVERAGING */
switch(PVM_MotionSupOnOff)
{
default:
case Off:
ATB_SetNA( PVM_NAverages );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
ATB_SetNAE( 1 );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
break;
case On:
ATB_SetNAE( PVM_NAverages );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
ATB_SetNA( 1 );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
break;
}
/* ACQ_ns */
ACQ_ns_list_size = PVM_NEchoImages;
ParxRelsParRelations("ACQ_ns_list_size",Yes);
for(echo=0; echo<PVM_NEchoImages; echo++)
{
ACQ_ns_list[echo] = nEchoesPerEchoImage[echo];
}
NS = ACQ_ns = ACQ_ns_list[0];
/* NECHOES */
NECHOES = NEchoes;
/* ACQ_obj_order */
PARX_change_dims("ACQ_obj_order",NI);
ATB_SetAcqObjOrder( nSlices, PVM_ObjOrderList, PVM_NEchoImages, 1 );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
/* DS */
DS = NDummyScans;
ACQ_DS_enabled = Yes;
ATB_DisableAcqUserFilter();
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
ATB_SetAcqScanSize( One_scan );
if( PVM_ErrorDetected == Yes )
{
UT_ReportError("SetBasicParameters: In function call!");
return;
}
DB_MSG(("<--SetBasicParameters\n"));
}
void SetRecoParam( void )
{
int dim,i,size,ftSize[3];
DB_MSG(("-->SetRecoParam\n"));
/* set baselevel reconstruction parameter */
/* default initialization of reco based on acqp pars allready set */
ATB_InitDefaultReco();
for(i=0; i<PTB_GetSpatDim(); i++)
ftSize[i] = (int)(PVM_Matrix[i]*PVM_AntiAlias[i]);
if(PVM_EncUseMultiRec == Yes || PVM_EncPftAccel1 > 1.0)
{
int k=0;
/* select method specific reconstruction method */
RECO_mode = USER_MODE;
ParxRelsParRelations("RECO_mode",Yes);
ATB_InitUserModeReco(ACQ_dim, PVM_EncMatrix, ftSize,
PVM_EncSteps1, PVM_EncSteps2,
PVM_EncNReceivers, PVM_EncPpiAccel1, PVM_EncPpiRefLines1,
NI, ACQ_obj_order, ACQ_phase_factor, PVM_EchoPosition);
/* set scaling values for phased array coils */
for(k=0; k<PVM_EncNReceivers;k++)
RecoScaleChan[k] = PVM_EncChanScaling[k];
}
dim = PTB_GetSpatDim();
/* set reco sizes and ft_mode (dim 2&3) */
/* (dim 1 is kept as it was set by ATB_InitDefaultReco) */
for(i=0; i<dim; i++)
{
size = (int)(PVM_Matrix[i]*PVM_AntiAlias[i]);
RECO_ft_mode[i] = (size == PowerOfTwo(size)) ? COMPLEX_FFT:COMPLEX_FT;
RECO_ft_size[i] = size;
RECO_size[i] = PVM_Matrix[i];
}
ParxRelsParRelations("RECO_ft_mode",Yes);
ParxRelsParRelations("RECO_ft_size",Yes);
ParxRelsParRelations("RECO_size",Yes);
/* set reco rotate according to phase offsets */
ATB_SetRecoRotate(PVM_EffPhase1Offset,
PVM_Fov[1]*PVM_AntiAlias[1],
NSLICES,
PVM_NEchoImages,
1) ; /* phase1 direction*/
if(dim==3)
{
ATB_SetRecoRotate(PVM_EffPhase2Offset,
PVM_Fov[2]*PVM_AntiAlias[2],
NSLICES,
PVM_NEchoImages,
2) ; /* phase2 direction*/
}
/* set reco offset */
ATB_SetRecoOffset(RECO_ft_size,
PVM_AntiAlias,
NI,
dim);
for(i=0;i<dim;i++)
RECO_fov[i]= PVM_FovCm[i];
ParxRelsParRelations("RECO_fov",Yes);
ATB_SetRecoTransposition(PtrType3x3 ACQ_grad_matrix[0],
PVM_NSPacks,
NSLICES,
ACQ_ns_list_size,
ACQ_obj_order) ;
DB_MSG(("<--SetRecoParam\n"));
}
