/*---------------------------------------------------------------------
| hardware_get - Set the appropriate event op for proper external
| syncing
| Author: Greg Brissey 11/14/88
+---------------------------------------------------------------------*/
hardware_get(Object dev_obj, ...)
{
char msge[128];
va_list vargs;
int error = 0;
Msg_Set_Param param;
Msg_Set_Result result;
va_start(vargs, dev_obj);
if (dev_obj->dispatch == NULL)
{
abort_message("hardware_get: Uninitialized Device...\n");
}
/* Options allways follow the format 'Option,(value),Option,(value),etc' */
while ((param.setwhat = va_arg(vargs, int)) != 0)
{
switch (param.setwhat)
{
case GET_RTVALUE:
param.value = (c68int) va_arg(vargs, int);
DPRINT3(DPRTLEVEL,"hardware_get: Cmd: '%s' to %d, for device: '%s'\n",
ObjCmd(param.setwhat),param.value,dev_obj->objname);
error = Send(dev_obj, MSG_GET_EVENT_VAL_pr, ¶m, &result);
break;
default:
sprintf(msge,"%s : Unknown Command '%s'.\n",
dev_obj->objname,ObjCmd(param.setwhat));
abort_message(msge);
break;
}
}
va_end(vargs);
return (error);
}
void grad_limit_checks(double xgrad,double ygrad,double zgrad,char *routinename)
{
double precision_limit;
char msge[256];
if (bgflag)
cout << "grad_limit_checks: xgrad=" << xgrad << " ygrad=" << ygrad << " zgrad=" << zgrad << endl;
precision_limit = 0.5/MAX_GRAD_AMP;
xgrad = fabs(xgrad);
ygrad = fabs(ygrad);
zgrad = fabs(zgrad);
if (xgrad > (gxlimit+(gxlimit*precision_limit)))
{
sprintf(msge,"%s: X gradient: %7.3f exceeds safety limit: %7.3f.\n",
routinename,xgrad,gxlimit);
abort_message(msge);
}
if (ygrad > (gylimit+(gylimit*precision_limit)))
{
sprintf(msge,"%s: Y gradient: %7.3f exceeds safety limit: %7.3f.\n",
routinename,ygrad,gylimit);
abort_message(msge);
}
if (zgrad > (gzlimit+(gzlimit*precision_limit)))
{
sprintf(msge,"%s: Z gradient: %7.3f exceeds safety limit: %7.3f.\n",
routinename,zgrad,gzlimit);
abort_message(msge);
}
}
void pulsesequence()
{
char pwpat[MAXSTR],p1pat[MAXSTR];
/* equilibrium period */
getstr("pwpat",pwpat);
if (pwpat[0] == '\0')
{
abort_message("no pwpat? ABORT");
}
getstr("p1pat",p1pat);
if (p1pat[0] == '\0')
{
abort_message("no p1pat? ABORT");
}
status(A);
obspower(zero);
decpower(tpwr);
hsdelay(d1);
rcvroff();
status(B);
if (is_y(rfwg[1])) decshaped_pulse(p1pat,p1,zero,rof1,rof2);
else apshaped_decpulse(p1pat,p1,zero,t1,t2,rof1,rof2);
hsdelay(d2);
status(C);
if (is_y(rfwg[1])) decshaped_pulse(pwpat,pw,oph,rof1,rof2);
else apshaped_decpulse(pwpat,pw,oph,t1,t2,rof1,rof2);
}
pulsesequence()
{
double pd, seqtime;
double minte,ted1,ted2;
double restol, resto_local;
int vph180 = v2; /* Phase of 180 pulse */
init_mri(); /****needed ****/
restol=getval("restol"); //local frequency offset
roff=getval("roff"); //receiver offset
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2); /* hard pulse */
calc_rf(&p1_rf,"tpwr1","tpwr1f");
init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2); /* hard pulse */
calc_rf(&p2_rf,"tpwr2","tpwr2f");
seqtime = at+(p1/2.0)+rof1+d2;
pd = tr - seqtime; /* predelay based on tr */
if (pd <= 0.0) {
abort_message("%s: Requested tr too short. Min tr = %f ms",seqfil,seqtime*1e3);
}
minte = p1/2.0 + p2 + 2*rof2 + rof1;
if(d2 > 0) {
if(d2 < minte+4e-6)
abort_message("%s: TE too short. Min te = %f ms",seqfil,minte*1e3);
}
ted1 = d2/2 - p1/2 - p2/2 + rof2 + rof1;
ted2 = d2/2 - p2/2 + rof2;
resto_local=resto-restol;
status(A);
xgate(ticks);
delay(pd);
/* --- observe period --- */
obsoffset(resto_local);
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
shapedpulse(p1pat,p1,oph,rof1,rof2);
/* if d2=0 no 180 pulse applied */
if (d2 > 0) {
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
settable(t2,2,ph180); /* initialize phase tables and variables */
getelem(t2,ct,v6); /* 180 deg pulse phase alternates +/- 90 off the rcvr */
add(oph,v6,vph180); /* oph=zero */
delay(ted1);
shapedpulse(p2pat,p2,vph180,rof1,rof2);
delay(ted2);
}
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
void set_angle_list(int angleListId, char *logAxis, char mode, int rtvar)
{
if (gradtype[0] != gradtype[1])
abort_message("error in gradient or pfg configuration parameter gradtype. abort!\n");
if (gradtype[0] != gradtype[2])
abort_message("error in gradient or pfg configuration parameter gradtype. abort!\n");
GradientBase *gC = P2TheConsole->getConfiguredGradient();
gC->set_angle_list(angleListId, logAxis, mode, rtvar);
}
void set_rotation_matrix(double ang1, double ang2, double ang3)
{
if (gradtype[0] != gradtype[1])
abort_message("error in gradient or pfg configuration parameter gradtype. abort!\n");
if (gradtype[0] != gradtype[2])
abort_message("error in gradient or pfg configuration parameter gradtype. abort!\n");
GradientBase *gC = P2TheConsole->getConfiguredGradient();
gC->set_rotation_matrix(ang1,ang2,ang3);
}
__cxa_eh_globals * __cxa_get_globals () {
// Try to get the globals for this thread
__cxa_eh_globals* retVal = __cxa_get_globals_fast ();
// If this is the first time we've been asked for these globals, create them
if ( NULL == retVal ) {
retVal = static_cast<__cxa_eh_globals*>
(std::calloc (1, sizeof (__cxa_eh_globals)));
if ( NULL == retVal )
abort_message("cannot allocate __cxa_eh_globals");
if ( 0 != pthread_setspecific ( key_, retVal ) )
abort_message("pthread_setspecific failure in __cxa_get_globals()");
}
return retVal;
}
int getorientation(char *c1,char *c2,char *c3,char *orientname)
{
char orientstring[MAXSTR];
int i;
getstr(orientname,orientstring);
if (orientstring[0] == '\0')
{
abort_message("can't find variable in tree\n");
}
else if (bgflag)
fprintf(stderr,"orientname = %s\n",orientname);
for (i=0;i<3;i++)
{
switch(orientstring[i])
{
case 'X': case 'x':
case 'Y': case 'y':
case 'Z': case 'z':
case 'R': case 'r':
case 'N': case 'n':
break;
default: return(-1);
}
}
*c1 = orientstring[0];
*c2 = orientstring[1];
*c3 = orientstring[2];
return(0);
}
void
__unexpected(unexpected_handler func)
{
func();
// unexpected handler should not return
abort_message("unexpected_handler unexpectedly returned");
}
void pulsesequence()
{
double tro;
char gread,gphase,gslice;
char grdname[MAXSTR];
gread = 'z';
if (getorientation(&gread,&gphase,&gslice,"orient") < 0)
abort_message("illegal value in orient parameter");
gro = getval("gro");
tro = getval("tro");
getstr("gname",grdname);
/* equilibrium period */
status(A);
hsdelay(d1);
/* --- tau delay --- */
status(B);
pulse(p1, zero);
hsdelay(d2);
/* --- observe period --- */
status(C);
pulse(pw,oph);
delay(0.0001);
shapedgradient(grdname,tro,gro,gread,1,1);
hsdelay(d2);
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
pulsesequence()
{
double pd, seqtime;
initparms_sis(); /* initialize standard imaging parameters */
seqtime = at+pw+rof1+rof2;
pd = tr - seqtime; /* predelay based on tr */
if (pd <= 0.0) {
abort_message("%s: Requested tr too short. Min tr = %f ms",seqfil,seqtime*1e3);
}
status(A);
delay(pd);
xgate(ticks);
/* --- observe period --- */
obspower(tpwr);
shapedpulse(pwpat,pw,oph,rof1,rof2);
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
// Note that this implementation will reliably return NULL if not
// preceded by a call to __cxa_get_globals(). This is an extension
// to the Itanium ABI and is taken advantage of in several places in
// libc++abi.
__cxa_eh_globals * __cxa_get_globals_fast () {
// First time through, create the key.
if (0 != pthread_once(&flag_, construct_))
abort_message("pthread_once failure in __cxa_get_globals_fast()");
// static int init = construct_();
return static_cast<__cxa_eh_globals*>(::pthread_getspecific(key_));
}
pulsesequence()
{
double seqtime,tr_delay,sign1,sign2;
sign1 = getval("sign1"); // first gradient multiplier, -1 to 1
sign2 = getval("sign2"); // second gradient multiplier, -1 to 1
/* Initialize paramaters **********************************/
init_mri();
/* Gradient calculations **********************************/
init_generic(&spoil_grad,"gtest",gspoil,tspoil);
calc_generic(&spoil_grad,WRITE,"","");
seqtime = 2*(tspoil + d2) + at;
tr_delay = tr - seqtime;
if (tr_delay < 0.0)
abort_message("gradtest: TR too short, minimum TR = %6.1f msec",1000*seqtime);
/* PULSE SEQUENCE *************************************/
rotate(); // Initialize default orientation
sp1on(); delay(4e-6); sp1off(); // TTL scope trigger
obl_shapedgradient(spoil_grad.name,spoil_grad.duration,sign1*gspoil,0,0,WAIT);
delay(d2);
obl_shapedgradient(spoil_grad.name,spoil_grad.duration,sign2*gspoil,0,0,WAIT);
delay(d2);
delay(tr_delay);
}
static void
get_one_sdac_setting_from_file(FILE *fd, char *label, float values[4])
{
char buf[512];
int i;
float x;
// printf("label='%s'\n",label);
rewind(fd);
while (fgets(buf, sizeof(buf), fd)){
if (strncasecmp(buf, label, strlen(label)) == 0){
/* This line has the data */
if ( (strcmp(label,"slewlimit") == 0) ||
(strcmp(label,"eccscale") == 0) )
{
sscanf(buf,"%*s %f %f %f %f", &values[0], &values[1],
&values[2], &values[3]);
if (values[3] < 1e-6)
{ abort_message("B0 limit or scale value is zero. Run 'decctool' as VnmrJ Admin to correct\n");
}
if (bugmask & ECCBUGBIT){
printf("%s %f %f %f %f\n", label, values[0], values[1],
values[2], values[3]);
}
}
else
{
sscanf(buf,"%*s %f %f %f", &values[0], &values[1],
&values[2]);
if (bugmask & ECCBUGBIT){
printf("%s %f %f %f\n", label, values[0], values[1],
values[2]);
}
}
break;
}
}
if (strcmp(label,"dutylimit") == 0) values[3] = 1.0;
if (strcmp(label,"shimscale") == 0) {
for (i=0; i<3; i++) {
x=values[i];
if ( (fabs(x-0.01)>1e-5) && (fabs(x-0.02)>1e-5) &&
(fabs(x-0.05)>1e-5) && (fabs(x-0.10)>1e-5) ) {
abort_message("shimscale value is invalid. Run 'decctool' as VnmrJ Admin to correct\n");
}
}
}
}
int create_angle_list(char *nm, double* angle_set, int num_sets)
{
if (gradtype[0] != gradtype[1])
abort_message("error in gradient or pfg configuration parameter gradtype. abort!\n");
if (gradtype[0] != gradtype[2])
abort_message("error in gradient or pfg configuration parameter gradtype. abort!\n");
int listId = -1;
GradientBase *gC = P2TheConsole->getConfiguredGradient();
listId = gC->create_angle_list(nm, angle_set, num_sets);
if (listId > 0)
return listId;
else
text_error("error in creating rotation list on %s . abort!\n", gC->getName());
return(listId);
}
void pulsesequence()
{
double pd, seqtime;
double n,r,bigtau;
double restol, resto_local;
init_mri();
restol=getval("restol"); //local frequency offset
roff=getval("roff"); //receiver offset
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2); /* hard pulse */
calc_rf(&p1_rf,"tpwr1","tpwr1f");
init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2); /* hard pulse */
calc_rf(&p2_rf,"tpwr2","tpwr2f");
/* calculate 'big tau' values */
bigtau = getval("bigtau");
n = bigtau/(2.0*d2);
n = (double)((int)((n/2.0) + 0.5)) * 2.0;
initval(n,v3);
seqtime = at+p1+rof1+rof2;
seqtime += 2*d2+p2+rof1+rof2; /* cpmg pulse and delay */
pd = tr - seqtime; /* predelay based on tr */
if (pd <= 0.0) {
abort_message("%s: Requested tr too short. Min tr = %f ms",seqfil,seqtime*1e3);
}
resto_local=resto-restol;
status(A);
delay(pd);
xgate(ticks);
/* calculate exact delay and phases */
r = d2-p2/2.0-rof2; /* correct delay for pulse width */
mod2(oph,v2); /* 0,1,0,1 */
incr(v2); /* 1,2,1,2 = y,y,-y,-y */
obsoffset(resto_local);
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
rgpulse(p1,oph,rof1,rof2); /* 90deg */
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
starthardloop(v3);
delay(r);
rgpulse(p2,v2,rof1,rof2); /* 180deg pulse */
delay(r);
endhardloop();
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
void rot_angle_list(int listId, char mode, int vindex)
{
if (gradtype[0] != gradtype[1])
abort_message("error in gradient or pfg configuration parameter gradtype. abort!\n");
if (gradtype[0] != gradtype[2])
abort_message("error in gradient or pfg configuration parameter gradtype. abort!\n");
if ( (listId < 1) || (listId >= 0x7FFFFF) )
abort_message("invalid coordinate rotation list id specified. abort!\n");
if (! validrtvar(vindex))
abort_message("invalid real time variable specified in rot_angle_list command. abort!\n");
int buffer[2];
GradientBase *gC = P2TheConsole->getConfiguredGradient();
buffer[0] = listId;
buffer[1] = vindex;
gC->outputACode(SETVGRDROTATION,2,buffer);
}
int getArrayparval(const char *parname, double *parval[])
{
int nn, j, k;
double am=0.0;
if (P_getsize(CURRENT,parname,&nn) <= 0)
{
abort_message("parameter %s does not exist\n", parname);
}
(*parval = (double *) calloc(nn, sizeof(double)));
for (j=0; j<nn; j++)
{
if ((k = P_getreal(CURRENT, parname, &am, j+1)) < 0)
{
abort_message("parameter %s does not exist\n", parname);
}
(*parval)[j] = am;
}
return nn;
}
void zero_all_gradients()
{
GradientBase *gC = P2TheConsole->getConfiguredGradient();
if ( (gC != NULL) && gC->isNoWaitMode())
abort_message("gradient event requested too soon after previous one in NOWAIT mode. abort!\n");
if ( (gradtype[0] | 0x20) != 'n') rgradient('x',0.0);
if ( (gradtype[1] | 0x20) != 'n') rgradient('y',0.0);
if ( (gradtype[2] | 0x20) != 'n') rgradient('z',0.0);
if (!strcmp(gradtype,"rrr") || strcmp(gradtype,"RRR")) rgradient('b',0.0);
delay(0.0000040); // NECESSARY TO PREVENT GRADIENT OVERRUN
}
/********************************************************************
* Function Name:write_tab_file
* Example: write_tab_file("myTabFile",2,1,t1size,t1array,2,t2size,t2array);
* Purpose: writes an arbitrary number number of tables to a tab file.
* this function uses a variable length arguement list.
*
* Input
* Formal: tableFilename - a string containin the name of the tab file
* numTable - int - number of tables to be written
* for each of the tables there are 3 arguements
* tableNumber - int - refers to the table number
* tableSize - int - the table size
* tableArray - int pointer - array of values
* Private: none
* Public: none
* Output
* Return: none
* Formal: none
* Private: none
* Public: none
* Notes: none
*********************************************************************/
void write_tab_file( char *tableFileName, int numTables, ... )
{
va_list ap;
FILE *fp;
char tablePath[MAX_STR];
int i,j;
int _size;
int _list;
int *_ptr;
sprintf( tablePath,"%s/tablib/%s",userdir,tableFileName );
if(( fp = fopen( tablePath, "w" )) == NULL )
{
abort_message("write_tab_file: error opening file%s\n",tableFileName);
}
va_start(ap, numTables);
for(i=0;i<numTables;i++)
{
_list = va_arg(ap, int);
_size = va_arg(ap, int);
_ptr = va_arg(ap, int*);
if((_list < 1 )||(_list > 60 ))
{
abort_message("write_tab_file: invalid table number = %d", _list);
}
fprintf(fp,"t%d= ",_list);
for(j=0;j<_size;j++) fprintf(fp,"%d ",_ptr[j]);
fprintf(fp,"\n");
fclose(fp);
}
va_end(ap);
}
/*-----------------------------------------------------------------
| getmaxval()/1
| Gets the maximum value of an arrayed or list real parameter.
+------------------------------------------------------------------*/
int getmaxval(const char *parname )
{
int size,r,i,tmpval,maxval;
double dval;
vInfo varinfo;
if ( (r = P_getVarInfo(CURRENT, parname, &varinfo)) ) {
abort_message("getmaxval: could not find the parameter \"%s\"\n",parname);
}
if ((int)varinfo.basicType != 1) {
abort_message("getmaxval: \"%s\" is not an array of reals.\n",parname);
}
size = (int)varinfo.size;
maxval = 0;
for (i=0; i<size; i++) {
if ( P_getreal(CURRENT,parname,&dval,i+1) ) {
abort_message("getmaxval: problem getting array element %d.\n",i+1);
}
tmpval = (int)(dval+0.5);
if (tmpval > maxval) maxval = tmpval;
}
return(maxval);
}
void pulsesequence(){
//Define Variables and Get Parameter Values
double pwTune = getval("pwTune");
pwTune = pwTune*6.0;
at = pwTune*2.0;
char atval[MAXSTR];
sprintf(atval,"at = %f\n", at);
putCmd(atval);
int chTune = (int) getval("chTune");
if ((chTune < 1) || (chTune > 4)) {
abort_message("chTune(%d) must be between 1 and 4\n", chTune);
}
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Set Phase Tables
settable(phTune,4,table1);
settable(phRec,4,table2);
setreceiver(t2);
//Begin Sequence
obspwrf(getval("aTune"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2e-6); sp1off(); delay(2.0e-6);
//Begin Phase Detected Pulse
set4Tune(chTune,getval("gain"));
delay(1.0e-4);
ShapedXmtNAcquire("phtran",pwTune,phTune,6.0e-6,chTune);
obsunblank(); decunblank(); _unblank34();
}
void get_asl_parameters() {
char asltype_str[MAXSTR];
asltag = (int) getval("asltag");
irthk = getval("irthk");
irgap = getval("irgap");
qgcrush = getval("qgcrush");
qtcrush = getval("qtcrush");
nsat = (int) getval("nsat");
ti1 = getval("ti1");
getstr("asltype",asltype_str);
getstr("quipss",quipss);
if ((!strcmp(asltype_str,"fair")) || (!strcmp(asltype_str,"FAIR")))
asltype = FAIR;
else if ((!strcmp(asltype_str,"star")) || (!strcmp(asltype_str,"STAR")))
asltype = STAR;
else if ((!strcmp(asltype_str,"picore")) || (!strcmp(asltype_str,"PICORE")))
asltype = PICORE;
else
abort_message("Unknown tag type %s",asltype_str);
}
pulsesequence()
{
dpwr = getval("dpwr");
if (dpwr > 46) /* Do not fry the probe */
{ abort_message("Decoupling power too large (max is 46) - acquisition aborted.");
}
/* equilibrium period */
status(A);
decpwrf(4095.0);
hsdelay(d1);
/* --- tau delay --- */
status(B);
pulse(p1, zero);
hsdelay(d2);
/* --- observe period --- */
status(C);
pulse(pw,oph);
}
/********************************************************************
* Function Name: copyToOutputGradient
* Example: copyToOutputGradient( &outputGradient, &gradientPoints,
* numPoints, startTime, polarity )
* Purpose: initializes an output gradient for a compound gradient axis
* Input
* Formal: outputGradient - pointer to a output gradient
* gradientpoints - pointer to gradient points
* numPoints
* startTime
* polarity
* Private: none
* Public: none
* Output
* Return: none
* Formal: none
* Private: none
* Public: none
* Notes: none
*********************************************************************/
void copyToOutputGradient( GENERIC_GRADIENT_T *outputGradient,
double *gradientPoints, long numPoints,
double startTime, SGL_CHANGE_POLARITY_T invert )
{
long _startIndex;
long _i;
double _scale;
_scale = invert == INVERT ? -1.0 : 1.0;
_startIndex = (long)ROUND(startTime/outputGradient->resolution);
if( _startIndex + numPoints > outputGradient->numPoints )
{
abort_message("copy_to_gradient: copy will overrun!");
}
for( _i=0; _i<numPoints; _i++ )
{
outputGradient->dataPoints[_i+_startIndex] += gradientPoints[_i]*_scale;
outputGradient->amp = MAX( fabs(outputGradient->dataPoints[_i+_startIndex]),
fabs(outputGradient->amp) );
}
}
pulsesequence()
{
double slpwrR = getval("slpwrR"),
slpwR = getval("slpwR"),
mixR = getval("mixR"),
selpwrA = getval("selpwrA"),
selpwA = getval("selpwA"),
gzlvlA = getval("gzlvlA"),
gtA = getval("gtA"),
selpwrB = getval("selpwrB"),
selpwB = getval("selpwB"),
gzlvlB = getval("gzlvlB"),
gtB = getval("gtB"),
gstab = getval("gstab"),
selfrq = getval("selfrq"),
gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
gzlvl2 = getval("gzlvl2"),
gt2 = getval("gt2"),
zqfpw1 = getval("zqfpw1"),
zqfpwr1 = getval("zqfpwr1"),
gzlvlzq1 = getval("gzlvlzq1"),
phincr1 = getval("phincr1");
char selshapeA[MAXSTR],selshapeB[MAXSTR], slpatR[MAXSTR],
zqfpat1[MAXSTR], alt_grd[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtA = syncGradTime("gtA","gzlvlA",1.0);
gzlvlA = syncGradLvl("gtA","gzlvlA",1.0);
gtB = syncGradTime("gtB","gzlvlB",1.0);
gzlvlB = syncGradLvl("gtB","gzlvlB",1.0);
getstr("slpatR",slpatR);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("zqfpat1",zqfpat1);
getstr("alt_grd",alt_grd);
if (strcmp(slpatR,"cw") &&
strcmp(slpatR,"troesy") &&
strcmp(slpatR,"dante"))
abort_message("SpinLock pattern %s not supported!.\n", slpatR);
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */
assign(ct,v17);
ifzero(ssctr);
assign(v17,v13);
elsenz(ssctr);
/* purge option does not adjust v13 during steady state */
sub(ssval, ssctr, v13);
endif(ssctr);
/* Beginning phase cycling */
dbl(v13,v1); /* v1 = 0 2 */
hlv(v13,v13);
dbl(v13,v20); /* v20 = 00 22 */
hlv(v13,v13);
dbl(v13,v6); /* v6 = 0000 2222 */
hlv(v13,v13);
dbl(v13,v7); /* v7 = 00000000 22222222 */
assign(v1,oph);
if (getflag("Gzqfilt"))
add(v7,oph,oph);
/* CYCLOPS */
assign(v13,v14); /* v14 = 8x0 8x1 8x2 8x3 */
if (getflag("Gzqfilt"))
hlv(v13,v14); /* v14 = 16x0 16x1 16x2 16x3 */
add(v1,v14,v1);
add(v20,v14,v20);
add(v6,v14,v6);
add(v7,v14,v7);
add(oph,v14,oph);
/* add(oph,v18,oph);
add(oph,v19,oph); */
assign(zero,v9);
mod2(ct,v2); /* 01 01 */
hlv(ct,v11); hlv(v11,v11); mod2(v11,v11); dbl(v11,v11); /* 0000 2222 */
add(v11,v2,v11); mod4(v11,v11); /* 0101 2323 first echo in Excitation Sculpting */
hlv(ct,v4); mod2(v4,v4); /* 0011 */
hlv(ct,v12); hlv(v12,v12); hlv(v12,v12); dbl(v12,v12); add(v12,v4,v12);
mod4(v12,v12); /* 0011 0011 2233 2233 second echo in Excitation Sculpting */
dbl(v2,v2); /* 0202 */
dbl(v4,v4); /* 0022 */
add(v2,v4,v4); /* 0220 correct oph for Excitation Sculpting */
add(oph,v4,oph); mod4(oph,oph);
if (!strcmp(slpatR,"troesy"))
assign(v20,v21);
else
add(v20,one,v21);
if (alt_grd[0] == 'y') mod2(ct,v8); /* alternate gradient sign on even scans */
/* The following is for flipback pulse */
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v5);
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
delay(d1);
if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */
status(B);
rgpulse(pw, v1, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
ifzero(v8); zgradpulse(gzlvlA,gtA);
elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v14,rof1,rof1);
obspower(tpwr);
ifzero(v8); zgradpulse(gzlvlA,gtA);
elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
ifzero(v8); zgradpulse(gzlvlB,gtB);
elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v6,rof1,rof1);
obspower(slpwrR);
ifzero(v8); zgradpulse(gzlvlB,gtB);
elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
if (mixR > 0.0)
{
if (dps_flag)
rgpulse(mixR,v21,0.0,0.0);
else
SpinLock(slpatR,mixR,slpwR,v21);
}
if (getflag("Gzqfilt"))
{
obspower(tpwr);
rgpulse(pw,v7,rof1,rof1);
ifzero(v8); zgradpulse(gzlvl1,gt1);
elsenz(v8); zgradpulse(-gzlvl1,gt1); endif(v8);
delay(gstab);
obspower(zqfpwr1);
ifzero(v8); rgradient('z',gzlvlzq1);
elsenz(v8); rgradient('z',-gzlvlzq1); endif(v8);
delay(100.0e-6);
shaped_pulse(zqfpat1,zqfpw1,zero,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
delay(gstab);
ifzero(v8); zgradpulse(-gzlvl2,gt2);
elsenz(v8); zgradpulse(gzlvl2,gt2); endif(v8);
obspower(tpwr);
delay(gstab);
if (getflag("flipback"))
FlipBack(v14,v5);
rgpulse(pw,v14,rof1,2.0e-6);
}
ExcitationSculpting(v11,v12,v8);
delay(rof2);
status(C);
}
double calc_zfill_gradient2(FLOWCOMP_T *grad0, FLOWCOMP_T *grad1,
GENERIC_GRADIENT_T *grad2)
{
double time = 0.0; /* longest duration of gradient */
double duration0, duration1, duration2; /* gradient durations */
ZERO_FILL_GRADIENT_T zf_grad0,zf_grad1, zf_grad2; /* define zero-fill grad structure in case of flow comp */
if ((ix > 1) && !sglarray) return(grad0->duration);
/* find longest gradient duration */
duration0 = grad0->duration;//- grad[0]->tramp; /* duration of a square gradient with same integral & amplitude */
duration1 = grad1->duration;// - grad[1]->tramp;
duration2 = grad2->duration;// - grad[2]->tramp;
time = MAX(MAX(duration0,duration1),duration2); /* should already be granulated */
text_message("time is %f", time);
/* zerofill new duration for each gradient */
initZeroFillGradient(&zf_grad0); /* initialize zerofill structure for pe grad */
// strcpy(zf_grad0.name,"zfgrad0"); /*fill in the unique name, otherwise the name will be repeated for each zerofill pattern*/
strcpy(zf_grad0.name,"zfgrad0");
zf_grad0.numPoints= grad0->numPoints ;/* assign number of waveform points */
zf_grad0.dataPoints = grad0->dataPoints; /* assign waveform to be zero-filled */
zf_grad0.newDuration= time; /* duration of the fc grad for readout */
zf_grad0.location = FRONT; /* add zero at front of waveform */
zeroFillGradient(&zf_grad0);
if (zf_grad0.error) abort_message("Gradient library error --> Check text window \n");
//Now put it back
grad0->duration=time ;
grad0->numPoints=zf_grad0.numPoints ;/* assign number of waveform points */
grad0->dataPoints= zf_grad0.dataPoints ; /* assign waveform to be zero-filled */
writeToDisk(grad0->dataPoints, grad0->numPoints, 0, grad0->resolution,
TRUE /*rolout*/, grad0->name);
initZeroFillGradient(&zf_grad1); /* initialize zerofill structure for pe grad */
strcpy(zf_grad1.name,"zfgrad1"); /*fill in the unique name, otherwise the name will be repeated for each zerofill pattern*/
zf_grad1.numPoints= grad1->numPoints ;/* assign number of waveform points */
zf_grad1.dataPoints = grad1->dataPoints; /* assign waveform to be zero-filled */
zf_grad1.newDuration= time; /* duration of the fc grad for readout */
zf_grad1.location = FRONT; /* add zero at front of waveform */
zeroFillGradient(&zf_grad1);
if (zf_grad1.error) abort_message("Gradient library error --> Check text window \n");
//Now put it back
grad1->duration=time ;
grad1->numPoints=zf_grad1.numPoints ;/* assign number of waveform points */
grad1->dataPoints= zf_grad1.dataPoints ; /* assign waveform to be zero-filled */
writeToDisk(grad1->dataPoints, grad1->numPoints, 0, grad1->resolution,
grad1->rollOut, grad1->name);
initZeroFillGradient(&zf_grad2); /* initialize zerofill structure for pe grad */
strcpy(zf_grad2.name,"zfgrad2"); /*fill in the unique name, otherwise the name will be repeated for each zerofill pattern*/
zf_grad2.numPoints= grad2->numPoints ;/* assign number of waveform points */
zf_grad2.dataPoints = grad2->dataPoints; /* assign waveform to be zero-filled */
zf_grad2.newDuration= time; /* duration of the fc grad for readout */
zf_grad2.location = FRONT; /* add zero at front of waveform */
zeroFillGradient(&zf_grad2);
if (zf_grad2.error) abort_message("Gradient library error --> Check text window \n");
//Now put it back
grad2->duration=time ;
grad2->numPoints=zf_grad2.numPoints ;/* assign number of waveform points */
grad2->dataPoints= zf_grad2.dataPoints ; /* assign waveform to be zero-filled */
writeToDisk(grad2->dataPoints, grad2->numPoints, 0, grad2->resolution,
grad2->rollOut, grad2->name);
return(time);
}
void calc_grad_duty(double time)
{
double gradenergy[3],gradduty[3];
double mult=1.0;
double currentlimit,RMScurrentlimit;
double sglduty,dutylimit;
int checksilent,r,nrcvrs,arraydim,error=0;
char rcvrs[MAXSTR];
currentlimit = getval("currentlimit");
RMScurrentlimit = getval("RMScurrentlimit");
getRealSetDefault(GLOBAL, "sglduty", &sglduty,0.0);
dutylimit = RMScurrentlimit/currentlimit;
checksilent = option_check("checksilent");
/* Adjust array dimenstion for multiple receivers */
nrcvrs = 0;
getstr("rcvrs",rcvrs);
arraydim = getvalnwarn("arraydim");
for (r = 0; r < strlen(rcvrs); r++) {
if (rcvrs[r] == 'y') nrcvrs++;
}
arraydim /= nrcvrs;
if (seqcon[2] == 'c')
mult *= nv;
if (seqcon[3] == 'c')
mult *= nv2;
if (!checkflag)
mult *= arraydim;
getgradpowerintegral(gradenergy);
gradduty[0] = sqrt(gradenergy[0]/(mult*time));
gradduty[1] = sqrt(gradenergy[1]/(mult*time));
gradduty[2] = sqrt(gradenergy[2]/(mult*time));
if (sglduty && ((checkflag && !checksilent) || (!checksilent && ix == arraydim))) {
text_message("Grad energy X: %.3g Grad energy Y: %.3g Grad energy Z: %.3g",gradenergy[0],gradenergy[1],gradenergy[2]);
text_message("Grad duty X: %.3g%% Grad duty Y: %.3g%% Grad duty Z: %.3g%%",100*gradduty[0],100*gradduty[1],100*gradduty[2]);
}
if ((gradduty[0] > dutylimit) && ((checkflag && !checksilent) || (!checksilent && ix == arraydim))) {
text_message("%s: X gradient duty cycle %5.1f%% exceeds allowed limit of %5.1f%%",seqfil,100*gradduty[0],100*dutylimit);
error = 1;
}
if ((gradduty[1] > dutylimit) && ((checkflag && !checksilent) || (!checksilent && ix == arraydim))) {
text_message("%s: Y gradient duty cycle %5.1f%% exceeds allowed limit of %5.1f%%",seqfil,100*gradduty[1],100*dutylimit);
error = 1;
}
if ((gradduty[2] > dutylimit) && ((checkflag && !checksilent) || (!checksilent && ix == arraydim))) {
text_message("%s: Z gradient duty cycle %5.1f%% exceeds allowed limit of %5.1f%%",seqfil,100*gradduty[2],100*dutylimit);
error = 1;
}
if (error) {
if (sglduty)
warn_message("%s: Duty cycle exceeds allowed limit",seqfil);
else
abort_message("%s: Duty cycle exceeds allowed limit",seqfil);
}
}
pulsesequence()
{
int selectCTP = getval("selectCTP");
double kappa = getval("kappa"),
gzlvl1 = getval("gzlvl1"),
gzlvl3 = getval("gzlvl3"),
gzlvl_max = getval("gzlvl_max"),
gt1 = getval("gt1"),
gt3 = getval("gt3"),
del = getval("del"),
gstab = getval("gstab"),
gss = getval("gss"),
tweak = getval("tweak"),
gzlvl_read=getval("gzlvl_read"),
num=getval("num"),
hsgt = getval("hsgt"),
gzlvlhs = getval("gzlvlhs"),
avm,gzlvl4,gt4,Dtau,Ddelta,dosytimecubed,dosyfrq;
char alt_grd[MAXSTR],avflag[MAXSTR],delflag[MAXSTR],STEflag[MAXSTR],sspul[MAXSTR];
gt4 = 2.0*gt1;
getstr("alt_grd",alt_grd);
getstr("delflag",delflag);
getstr("avflag",avflag);
getstr("STEflag",STEflag);
getstr("sspul",sspul);
avm=0.0;
if(avflag[0]=='y')
{
avm=1.0;
}
/* Decrement gzlvl4 as gzlvl1 is incremented, to ensure constant
energy dissipation in the gradient coil
Current through the gradient coil is proportional to gzlvl */
gzlvl4=sqrt(2.0*gt1*(1+3.0*kappa*kappa)/gt4)*sqrt(gzlvl_max*gzlvl_max/((1+kappa)*(1+kappa))-gzlvl1*gzlvl1);
/* In pulse sequence, del>4.0*pw+3*rof1+2.0*gt1+5.0*gstab+gt3 */
if ((del-(4*pw+3.0*rof1+2.0*gt1+5.0*gstab+gt3)) < 0.0)
{ del=(4*pw+3.0*rof1+2.0*gt1+5.0*gstab+gt3);
printf("Warning: del too short; reset to minimum value\n");}
if ((d1 - (gt3+gstab) -2.0*(gt4/2.0+gstab)) < 0.0)
{ d1 = (gt3+gstab) -2.0*(gt4/2.0+gstab);
printf("Warning: d1 too short; reset to minimum value\n");}
if ((abs(gzlvl1)*(1+kappa)) > gzlvl_max)
{ abort_message("Max. grad. amplitude exceeded: reduce either gzlvl1 or kappa\n");
}
if (ni > 1.0)
{ abort_message("This is a 2D, not a 3D dosy sequence: please set ni to 0 or 1\n");
}
Ddelta=gt1;
Dtau=2.0*pw+gstab+gt1/2.0+rof1;
dosyfrq = getval("sfrq");
dosytimecubed=del+(gt1*((kappa*kappa-2)/6.0))+Dtau*((kappa*kappa-1.0)/2.0);
dosytimecubed=(gt1*gt1)*dosytimecubed;
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* This section determines the phase calculation for any number of transients */
initval(num,v14);
add(v14,ct,v13);
/* phase cycling calculation */
if(delflag[0]=='y')
{
mod4(v13,v3); /* 1st 180, 0 1 2 3 */
hlv(v13,v9);
hlv(v9,v9);
mod4(v9,v4); /* 2nd 90, (0)4 (1)4 (2)4 (3)4 */
hlv(v9,v9);
hlv(v9,v9);
mod4(v9,v1); /* 2nd 180, (0)16 (1)16 (2)16 (3)16 */
hlv(v9,v9);
hlv(v9,v9);
mod4(v9,v2); /* 1st 90, (0)64 (1)64 (2)64 (3)64 */
hlv(v9,v9);
hlv(v9,v9);
mod4(v9,v5); /* 3rd 90, (0)256 (1)256 (2)256 (3)256 */
if(STEflag[0]=='y')
{
dbl(v2,v6); assign(v6,oph); sub(oph,v1,oph);
sub(oph,v3,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /* receiver phase for STE */
}
else
{
assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph);
add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /* receiver phase for STAE */
}
}
mod2(ct,v7); /* change sign of gradients on alternate transients */
status(A);
if(delflag[0]=='y')
{
if (sspul[0]=='y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
delay(d1 - (gt3+gstab) -2.0*(gt4/2.0+gstab)-gss); /* Move d1 to here */
zgradpulse(-1.0*gzlvl4,gt4/2.0); /* 1st dummy heating pulse */
delay(gstab);
zgradpulse(gzlvl4,gt4/2.0); /* 2nd dummy heating pulse */
delay(gstab);
delay(gss); /* Short delay to acheive steady state */
if (alt_grd[0] == 'y')
{
ifzero(v7);
zgradpulse(-1.0*gzlvl3,gt3);
elsenz(v7);
zgradpulse(gzlvl3,gt3);
endif(v7);
}
else zgradpulse(-1.0*gzlvl3,gt3); /* Spoiler gradient balancing pulse */
delay(gstab);
}
else delay(d1);
status(B); /* first part of sequence */
if(delflag[0]=='y')
{
if(gt1>0 && abs(gzlvl1)>0)
{
if(selectCTP==2)
{
rgpulse(0.0, v1, rof1, rof2); /* first 90, v1 */
}
else
rgpulse(pw, v1, rof1, rof2); /* first 90, v1 */
zgradpulse(gzlvl1*(1.0+kappa),gt1/2.0); /*1st main gradient pulse*/
delay(gstab);
if(selectCTP==2)
{
rgpulse(0.0, v2, rof1, rof2); /* first 180, v2 */
}
else
rgpulse(pw*2.0, v2, rof1, rof2); /* first 180, v2 */
zgradpulse(-1.0*gzlvl1*(1.0-kappa),gt1/2.0); /*2nd main grad. pulse*/
delay(gstab);
if((selectCTP==1)||(selectCTP==2))
{
rgpulse(0.0, v3, rof1, rof2); /* second 90, v3 */
}
else
rgpulse(pw, v3, rof1, rof2); /* second 90, v3 */
zgradpulse(-gzlvl1*2.0*kappa,gt1/2.0); /*Lock refocussing pulse*/
delay(gstab);
if (alt_grd[0] == 'y')
{
ifzero(v7);
zgradpulse(gzlvl3,gt3); /* Spoiler gradient */
elsenz(v7);
zgradpulse(-1.0*gzlvl3,gt3);
endif(v7);
}
else zgradpulse(gzlvl3,gt3); /* Spoiler gradient */
delay(gstab);
delay(del-4.0*pw-3.0*rof1-2.0*gt1-5.0*gstab-gt3); /* diffusion delay */
if(STEflag[0]=='y')
{
zgradpulse(2.0*kappa*gzlvl1,gt1/2.0); /*Lock refocussing pulse*/
delay(gstab);
}
else
{
zgradpulse(-2.0*kappa*gzlvl1,gt1/2.0); /*Lock refocussing pulse*/
delay(gstab);
}
if(selectCTP==1)
{
rgpulse(0.0, v4, rof1, rof2); /* third 90, v4 */
}
else
rgpulse(pw, v4, rof1, rof2); /* third 90, v4 */
if(STEflag[0]=='y')
{
zgradpulse(-gzlvl1*(1.0+kappa),gt1/2.0); /*3rd main gradient pulse*/
delay(gstab);
}
else
{
zgradpulse(gzlvl1*(1.0+kappa),gt1/2.0); /*3rd main gradient pulse*/
delay(gstab);
}
rgpulse(pw*2.0, v5, rof1, rof2); /* second 180, v5 */
rcvron();
if(STEflag[0]=='y')
{
zgradpulse(1.0*(1.0-kappa)*gzlvl1+tweak-avm*at*gzlvl_read/gt1,gt1/2.0); /*4th main grad. pulse*/
delay(gstab);
}
else
{
zgradpulse(-1.0*(1.0-kappa)*gzlvl1-tweak-avm*at*gzlvl_read/gt1,gt1/2.0); /*4th main grad. pulse*/
delay(gstab);
}
rgradient('z',gzlvl_read);
}
}
else rgpulse(pw,oph,rof1,rof2);
status(C);
}
pulsesequence()
{
double slpwrT = getval("slpwrT"),
slpwT = getval("slpwT"),
mixT = getval("mixT"),
trim = getval("trim"),
tauz1 = getval("tauz1"),
tauz2 = getval("tauz2"),
tauz3 = getval("tauz3"),
tauz4 = getval("tauz4"),
selpwrA = getval("selpwrA"),
selpwA = getval("selpwA"),
gzlvlA = getval("gzlvlA"),
gtA = getval("gtA"),
selpwrB = getval("selpwrB"),
selpwB = getval("selpwB"),
gzlvlB = getval("gzlvlB"),
gtB = getval("gtB"),
gstab = getval("gstab"),
selfrq = getval("selfrq");
char selshapeA[MAXSTR], selshapeB[MAXSTR], slpatT[MAXSTR],
alt_grd[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtA = syncGradTime("gtA","gzlvlA",1.0);
gzlvlA = syncGradLvl("gtA","gzlvlA",1.0);
gtB = syncGradTime("gtB","gzlvlB",1.0);
gzlvlB = syncGradLvl("gtB","gzlvlB",1.0);
getstr("slpatT",slpatT);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("alt_grd",alt_grd);
/* alternate gradient sign on every 2nd transient */
if (strcmp(slpatT,"mlev17c") &&
strcmp(slpatT,"dipsi2") &&
strcmp(slpatT,"dipsi3") &&
strcmp(slpatT,"mlev17") &&
strcmp(slpatT,"mlev16"))
abort_message("SpinLock pattern %s not supported!.\n", slpatT);
assign(ct,v17);
assign(v17,v6);
if (getflag("zqfilt"))
{ hlv(v6,v6); hlv(v6,v6); }
settable(t1,4,ph1); getelem(t1,v6,v1);
settable(t3,8,ph3); getelem(t3,v6,v11);
settable(t4,8,ph4);
settable(t5,4,ph5); getelem(t5,v6,v5);
settable(t2,4,ph2); getelem(t2,v6,v2);
settable(t7,8,ph7); getelem(t7,v6,v7);
settable(t8,4,ph8); getelem(t8,v6,v8);
settable(t11,16,phs8); getelem(t11,v6,v3); /* 1st echo in ES */
settable(t12,16,phs9); getelem(t12,v6,v4); /* 2nd exho in ES */
if (getflag("zqfilt"))
getelem(t4,v6,oph);
else
assign(v1,oph);
add(oph,v5,oph); mod4(oph,oph);
sub(v2,one,v21);
add(v21,two,v23);
mod4(ct,v10);
if (alt_grd[0] == 'y') mod2(ct,v12); /* alternate gradient sign on every 2nd transient */
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
delay(d1);
if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */
status(B);
rgpulse(pw, v1, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
ifzero(v12); zgradpulse(gzlvlA,gtA);
elsenz(v12); zgradpulse(-gzlvlA,gtA); endif(v12);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v1,rof1,rof1);
obspower(tpwr);
ifzero(v12); zgradpulse(gzlvlA,gtA);
elsenz(v12); zgradpulse(-gzlvlA,gtA); endif(v12);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
ifzero(v12); zgradpulse(gzlvlB,gtB);
elsenz(v12); zgradpulse(-gzlvlB,gtB); endif(v12);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v2,rof1,rof1);
obspower(slpwrT);
ifzero(v12); zgradpulse(gzlvlB,gtB);
elsenz(v12); zgradpulse(-gzlvlB,gtB); endif(v12);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
if (mixT > 0.0)
{
rgpulse(trim,v11,0.0,0.0);
if (dps_flag)
rgpulse(mixT,v21,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v21);
}
if (getflag("zqfilt"))
{
obspower(tpwr);
rgpulse(pw,v7,1.0e-6,rof1);
ifzero(v10); delay(tauz1); endif(v10);
decr(v10);
ifzero(v10); delay(tauz2); endif(v10);
decr(v10);
ifzero(v10); delay(tauz3); endif(v10);
decr(v10);
ifzero(v10); delay(tauz4); endif(v10);
rgpulse(pw,v8,rof1,2.0e-6);
}
ExcitationSculpting(v3,v4,v12);
delay(rof2);
status(C);
}
