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 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 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 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 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"));
}
