int AspUtil::getParSize(string parName) { const char *cname = parName.c_str(); vInfo info; if (!(P_getVarInfo(CURRENT,cname,&info)) ) return info.size; else if (!(P_getVarInfo(GLOBAL,cname,&info)) ) return info.size; else return 0; }
static int setspecmaxmin() /********************/ { vInfo info; double cutoff; specmax = mnumypnts - 3; specmin = mnumypnts - 3; if (P_getVarInfo(CURRENT,"cutoff",&info)) return(COMPLETE); if (info.active == ACT_OFF) return(COMPLETE); P_getreal(CURRENT,"cutoff",&cutoff,1); if (cutoff < 2.0) cutoff = 2.0; if (info.size == 2) { specmax = (int) (dispcalib * cutoff); P_getreal(CURRENT,"cutoff",&cutoff,2); if (cutoff < 0.0) cutoff = 0.0; specmin = (int) (dispcalib * cutoff); } else if (info.size == 1) { specmax = (int) (dispcalib * cutoff); specmin = (int) (dispcalib * cutoff); } if (specmax > mnumypnts - 3) specmax = mnumypnts - 3; if (specmin < 0) specmin = 0; return(COMPLETE); }
static int check_int(int *number) /********************/ { vInfo info; char intmod[9]; int res; *number = ((P_getVarInfo(CURRENT,"liamp",&info)) ? 0 : info.size); if ( (res=P_getstring(CURRENT,"intmod",intmod,1,8)) ) { P_err(res,"intmod",":"); ABORT; } return(!(strcmp(intmod,INT_FULL))); }
/*------------------------------------------------------------------------------ | | parmult(tree,name) | | This function returns the multiplier of a real parameter +----------------------------------------------------------------------------*/ double parmult(int tree, const char *name) { int ret; vInfo varinfo; /* variable information structure */ if ( (ret = P_getVarInfo(tree, name, &varinfo)) ) { text_error("parmult(): cannot find variable %s", name); if (bgflag) P_err(ret, name, ": "); return (-1.0); } return( (varinfo.subtype == ST_PULSE) ? 1e-6 : 1.0); }
/*------------------------------------------------------------------------------ | | whattype(tree,name) | | This function returns the address of a real value of a variable based on +----------------------------------------------------------------------------*/ int whattype(int tree, const char *name) { int ret; vInfo varinfo; /* variable information structure */ char mess[MAXSTR]; if ( (ret = P_getVarInfo(tree, name, &varinfo)) ) { sprintf(mess, "Cannot find the variable: %s", name); text_error(mess); if (bgflag) P_err(ret, name, ": "); return (-1); } return (varinfo.basicType); }
int jcurwin_jexp(int expnum, int oldexpnum ) { int index, get1, get2, retval=1; double dval; vInfo info; /* int VnmrJViewId */ char path[MAXSTR]; struct stat stat_blk; (void) oldexpnum; if (mode_of_vnmr==AUTOMATION) /* || (mode_of_vnmr==BACKGROUND) */ return(retval); if (expnum > 0) { sprintf(path, "%s/lock_%d.primary", userdir, expnum); if (stat( path, &stat_blk ) != 0) return(retval); get1 = P_getVarInfo(GLOBAL, "jcurwin", &info); get2 = P_getreal(GLOBAL, "jviewports", &dval, 1); /* read number of viewports from jviewports[1] */ if (get1==0 && get2==0) { get2 = (int) (dval + 0.5); if ((get2 > 0) && (get2 <= info.size)) { for (index=0; index<get2; index++) { P_getreal(GLOBAL, "jcurwin", &dval, index+1); if (expnum == (int)dval) { char mstr[MAXPATH]; /* sprintf(mstr, "viewport %d", index+1); writelineToVnmrJ("vnmrjcmd",mstr); sprintf(mstr, "vplayout use %d", index+1); writelineToVnmrJ("vnmrjcmd",mstr); */ P_getstring(GLOBAL, "jviewportlabel", mstr, index+1, MAXPATH); Winfoprintf("Cannot join workspace exp%d - in use by %s viewport.\n",expnum,mstr); retval = 0; break; } } } } } return(retval); }
void jcurwin_setexp(char *estring, int oldexpnum ) { int expnum; expnum = atoi(estring); if ((expnum < 0) || (expnum > MAXEXPS)) { Werrprintf("jexp: value of jcurwin=%s out-of-range",estring); return; } if (P_setreal(GLOBAL,"jcurwin",(double)(expnum),VnmrJViewId) != 0) { Werrprintf("WARNING: jexp could not set parameter jcurwin"); } else { /* see jAutoSendIfGlobal( "jcurwin" ); */ char mstr[MAXSTR]; double dval; int i; vInfo info; sprintf(mstr,"jcurwin[%d]=%d",VnmrJViewId,expnum); writelineToVnmrJ("pglo",mstr); /* check all other jcurwin values */ if (oldexpnum > -1) { if (P_getVarInfo(GLOBAL, "jcurwin", &info)==0) { if (info.size > VnmrJViewId) { for (i=VnmrJViewId; i<info.size; i++) { P_getreal(GLOBAL, "jcurwin", &dval, i+1); /* if match, set to oldexpnum - see unlockAllExp() in locksys.c */ if ((int)(dval+0.1) == expnum) { P_setreal(GLOBAL, "jcurwin", (double)(oldexpnum), i+1); sprintf(mstr,"jcurwin[%d]=%d", i+1, oldexpnum); writelineToVnmrJ("pglo",mstr); } } } } } } }
/*------------------------------------------------------------------------------ | | maxminlimit(tree,name) | | This function returns the max & min limit of the real variable based | Author: Greg Brissey 8-18-95 +----------------------------------------------------------------------------*/ int par_maxminstep(int tree, const char *name, double *maxv, double *minv, double *stepv) { int ret,pindex; vInfo varinfo; /* variable information structure */ char mess[MAXSTR]; if ( (ret = P_getVarInfo(tree, name, &varinfo)) ) { sprintf(mess, "Cannot find the variable: %s", name); text_error(mess); if (bgflag) P_err(ret, name, ": "); return (-1); } if (varinfo.basicType != ST_REAL) { sprintf(mess, "The variable '%s' is not a type 'REAL'", name); text_error(mess); } if (varinfo.prot & P_MMS) { pindex = (int) (varinfo.minVal+0.1); if (P_getreal( SYSTEMGLOBAL, "parmin", minv, pindex )) *minv = -1.0e+30; pindex = (int) (varinfo.maxVal+0.1); if (P_getreal( SYSTEMGLOBAL, "parmax", maxv, pindex )) *maxv = 1.0e+30; pindex = (int) (varinfo.step+0.1); if (P_getreal( SYSTEMGLOBAL, "parstep", stepv, pindex )) *stepv = 0.0; } else { *maxv = varinfo.maxVal; *minv = varinfo.minVal; *stepv = varinfo.step; } return (0); }
/* --------------------------------------------------------------- | var_active(varname,tree); | | Purpose: | This module determines if the variable passed is active or not. | This is determined by looking at the variable information | structure "_vInfo". | if a real variable the info.active is check. | if a string then it's value is checked for 'unused' value. | Returns 1 if active, 0 if not, and -1 if error. | | Author Greg Brissey 5/13/86 +------------------------------------------------------------------*/ int var_active(char *varname, int tree) { char strval[20]; int ret; vInfo varinfo; /* variable information structure */ if (bgflag) fprintf(stderr,"active(): Variable: %s, Tree: %d \n",varname,tree); if ( (ret = P_getVarInfo(tree,varname,&varinfo)) ) { if (bgflag) fprintf(stderr,"Cannot find the variable: %s",varname); return(-1); } if (bgflag) fprintf(stderr,"active(): vInfo.basicType = %d \n",varinfo.basicType); if (varinfo.basicType != T_STRING) { if (bgflag) fprintf(stderr,"active(): vInfo.active = %d \n",varinfo.active); if (varinfo.active == ACT_ON) return(1); else return(0); } else /* --- variable is string check is value for 'undef' --- */ { P_getstring(tree,varname,strval,1,10); /*getparm(varname,"string",tree,&strval[0],10);*/ if (bgflag) fprintf(stderr,"active(): Value of String variable: '%s'\n",strval); if ((strncmp(strval,"unused",6) == 0) || (strncmp(strval,"Unused",6) == 0) ) return(0); else return(1); } }
/*----------------------------------------------------------------- | 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); }
int wrspec_find_epscale(float *epscale, int proctype, int elem1_num, int elem2_num ) { float *epsdelay, deps1, deps2; double eps_tmp; vInfo info; int i; (void) proctype; /* if (proctype == 6) { *epscale = 0.0; else do below; } */ /* calc scale from eps */ /* note only valid for proctype == 2 || proctype == 4 || proctype == 5 */ *epscale = 0.0; /* *epscale=0 translates to no scaling - see wrspec_output */ if ( P_getVarInfo(CURRENT, "d3", &info) ) { *epscale = 0.0; } else { epsdelay=(float *)malloc((info.size) * sizeof(float)); for( i=0; i< (int) info.size; i++ ) { P_getreal(CURRENT, "d3", &eps_tmp, i+1); epsdelay[i] = (float) eps_tmp; } *epscale = 1.0; deps1 = epsdelay[(elem1_num - 1) % info.size]; deps2 = epsdelay[(elem2_num - 1) % info.size]; deps1 = deps2 - deps1; deps2 = deps1; if ( deps2 < 0 ) { deps2 = -deps2; } if ( deps2 < NEW_AMP_TOL ) { *epscale = 0.0; } else { *epscale = 1.0/(360.0 * deps1); } /* true value */ free((char *) epsdelay); } EPRINT1(1, " wrspec: *epscale %f\n", *epscale ); /* if (*epscale < 0.0) { *epscale = -1.0 * *epscale; } */ return(0); }
static int getlines(int noneg) /*******************/ { vInfo info; double freq; double amp; double tmpfrq; int tmppos; int r; int index; int count=0; if ( (r=P_getVarInfo(CURRENT,"llfrq",&info)) ) { P_err(r,"llfrq",":"); return ERROR; } if (info.size >= 1) { if ((linefrq = (double *) allocateWithId(sizeof(double)*(info.size + 1),"dpf"))==0) { Werrprintf("cannot allocate buffer space"); return(0); } if ((lineamp = (double *) allocateWithId(sizeof(double)*(info.size + 1),"dpf"))==0) { Werrprintf("cannot allocate buffer space"); release(linefrq); return(0); } if ((linepos = (int *) allocateWithId(sizeof(int)*(info.size + 1),"dpf"))==0) { Werrprintf("cannot allocate buffer space"); release(linefrq); release(lineamp); return(0); } if (debug1) Wscrprintf("line freq amp position\n"); for (index = 1; index <= info.size; index++) { if ( (r=P_getreal(CURRENT,"llfrq",&freq,index)) ) { P_err(r,"llfrq",":"); return ERROR; } tmpfrq = freq - rflrfp; tmppos = dfpnt + dnpnt * (wp - tmpfrq + sp ) / wp; if ( (r=P_getreal(CURRENT,"llamp",&,index)) ) { P_err(r,"llamp",":"); return ERROR; } if (tmppos > dfpnt && tmppos < dfpnt+dnpnt && (amp >= 0 || !noneg)) { count++; linefrq[count] = tmpfrq; linepos[count] = tmppos; if (amp < 0.0) amp = 0.0; lineamp[count] = amp * scale; if (debug1) Wscrprintf("%d %g %g %d\n", count,linefrq[count],lineamp[count],linepos[count]); } } return(count); } else return(0); }
/*--------------------------------------- | | | i_fiddle() | | | +--------------------------------------*/ static int i_fiddle(int argc, char *argv[]) { short status_mask; int i,j; double v,np; vInfo info; int flag; FILE *satfile; int intcount; char nohilbert[] = "nohilbert"; /* These are to */ char noextrap[] = "noextrap"; /* define the */ char verbos[] = "verbose"; /* strings used */ char fittedbaseline[] = "fittedbaseline"; /* for the */ char stop1[] = "stop1"; /* fiddle */ char stop2[] = "stop2"; /* command line */ char stop3[] = "stop3"; char stop4[] = "stop4"; char displaycf[] = "displaycf"; char nodc[] = "nodc"; char inver[] = "invert"; char satellites[] = "satellites"; char writefid[] = "writefid"; char normalise[] = "normalise"; char alternate[] = "alternate"; char noaph[] = "noaph"; char readcf[] = "readcf"; char writecf[] = "writecf"; readcfflg=writecfflg=corfunc=noift=noftflag=invert=solvent=FALSE; dccorr=baseline=verbose=numsats=FALSE; apod=udifffg=difffg=firstfg=secondfg=nosub=FALSE; stopflag=0; halffg=hilbert=makereffg=ldcflag=extrap=aphflg=TRUE; altfg=flag2d=writefg=oflag=quantflag=FALSE; intcount=0; print=0; startno= -1; finishno=startno+1; stepno=1; sw1=0.0; rfl1=0.0; disp_status("IN"); if ((P_getreal(PROCESSED, "ni", &v, 1) == 0&&(v>1.0))|| (P_getreal(PROCESSED, "ni2", &v, 1) == 0&&(v>1.0)) ) { if (verbose) Wscrprintf("2D data\n"); if (P_getreal(CURRENT,"sw1",&sw1,1)||P_getreal(CURRENT,"rfl1",&rfl1,1)) { Werrprintf("Error accessing parameters\n"); return(ERROR); } } if ((int)strlen(argv[0])>(int)6) { if (argv[0][6] == 'd') { Wscrprintf("Calculating FIDDLE'd difference between spectra n and n-1.\nds(1) for corrected 1st spectrum, ds(n) for difference.\n"); difffg=TRUE; firstfg=TRUE; } if (argv[0][6] == 'u') { Wscrprintf("Calculating FIDDLE'd difference between spectra n and 1.\nds(1) for corrected 1st spectrum, ds(n) for difference \n"); udifffg=TRUE; difffg=TRUE; firstfg=TRUE; } if (argv[0][6] == '2') { Wscrprintf("2D FIDDLE processing\n"); flag2d=TRUE; quantflag=TRUE; extrap=FALSE; if (argv[0][8] == 'd') { Wscrprintf("... taking the difference between alternate fids\n"); firstfg=TRUE; difffg=TRUE; } } } if (argc>1) /* This is to check for the options used */ { for (i=1;i<argc;i++) { if (atoi(argv[i])>0) { intcount++; if (intcount==1) { startno=atoi(argv[i])-1; finishno=startno+1; stepno=1; } if (intcount==2) { finishno=atoi(argv[i]); stepno=1; } if (intcount==3) { stepno=atoi(argv[i]); } } else if (equal(argv[i],nohilbert)) { if (verbose) Wscrprintf("Not using Hilbert algorithm \n"); hilbert=FALSE; extrap=TRUE; } else if (equal(argv[i],noextrap)) { if (verbose) Wscrprintf("Not using extrapolation of dispersion mode reference signal \n"); extrap=FALSE; } else if (equal(argv[i],verbos)) { verbose=TRUE; Wscrprintf("Verbose: displaying information during FIDDLE.\n"); } else if (equal(argv[i],fittedbaseline)) { if (verbose) Wscrprintf("Fitted baseline used.\n"); baseline=TRUE; } else if (equal(argv[i],stop1)) { if (verbose) Wscrprintf("Display experimental reference fid.\n"); stopflag=1; noftflag=TRUE; } else if (equal(argv[i],stop2)) { if (verbose) Wscrprintf("Display correction function.\n"); stopflag=2; noftflag=TRUE; } else if (equal(argv[i],stop3)) { if (verbose) Wscrprintf("Display ideal reference fid.\n"); stopflag=3; noftflag=TRUE; } else if (equal(argv[i],stop4)) { if (verbose) Wscrprintf("Display first corrected fid.\n"); stopflag=4; } else if (equal(argv[i],alternate)) { if (verbose) Wscrprintf("Alternating phases of increments for hypercomplex 2D\n"); altfg=TRUE; } else if (equal(argv[i],displaycf)) { if (verbose) Wscrprintf("Display correction function in place of corrected spectrum\n"); corfunc=TRUE; noftflag=TRUE; } else if (equal(argv[i],nodc)) { if (verbose) Wscrprintf("No dc correction of reference region \n"); ldcflag=FALSE; } else if (equal(argv[i],inver)) { if (verbose) Wscrprintf("Corrected difference spectrum will be inverted \n"); invert=TRUE; } else if (equal(argv[i],satellites)) { if (verbose) Wscrprintf("Satellites will be included in the ideal reference \n"); numsats=TRUE; i++; if ((argc-1)<i) { Werrprintf("Satellite filename not specified"); return(ERROR); } sprintf(satname,"/vnmr/satellites/%s",argv[i]); if (verbose) Wscrprintf("Satellite file name is %s \n",argv[i]); } else if (equal(argv[i],writefid)) { if (verbose) Wscrprintf("Corrected fid will be written to disk \n"); writefg=TRUE; i++; if ((argc-1)<i) { Werrprintf("Destination filename not specified\n"); return(ERROR); } strcpy(writename,argv[i]); if (argv[i][0]!='/') { pathptr = get_cwd(); strcpy(writename,pathptr); strcat(writename,"/"); strcat(writename,argv[i]); } if (((int) (strlen(writename))<5)||(strcmp(&writename[strlen(writename)-4],".fid"))) strcat(writename,".fid"); sprintf(sysstr,"mkdir %s",writename); if(system(sysstr)) { sprintf(sysstr,"cd %s",writename); if(system(sysstr)) { Werrprintf("System error: %s",sysstr); return(ERROR); } } Wscrprintf("Writing corrected fid out; destination file: %s\n",writename); } else if (equal(argv[i],writecf)) { if (verbose) Wscrprintf("Correction function will be written to disk \n"); writecfflg=TRUE; i++; if ((argc-1)<i) { Werrprintf("Destination filename not specified\n"); return(ERROR); } strcpy(writecfname,argv[i]); if (argv[i][0]!='/') { pathptr = get_cwd(); strcpy(writecfname,pathptr); strcat(writecfname,"/"); strcat(writecfname,argv[i]); } if (((int) (strlen(writecfname))<5)||(strcmp(&writecfname[strlen(writecfname)-4], ".fid"))) strcat(writecfname,".fid"); sprintf(sysstr,"mkdir %s",writecfname); if(system(sysstr)) { sprintf(sysstr,"cd %s",writecfname); if(system(sysstr)) { Werrprintf("System error: %s",sysstr); return(ERROR); } } Wscrprintf("Writing correction function out; destination file: %s\n",writecfname); } else if (equal(argv[i],readcf)) { if (verbose) Wscrprintf("Correction function will be read from disk \n"); readcfflg=TRUE; i++; if ((argc-1)<i) { Werrprintf("Source filename not specified\n"); return(ERROR); } strcpy(readcfname,argv[i]); if (argv[i][0]!='/') { pathptr = get_cwd(); strcpy(readcfname,pathptr); strcat(readcfname,"/"); strcat(readcfname,argv[i]); } if (((int) (strlen(readcfname))<5)||(strcmp(&readcfname[strlen(readcfname)-4], ".fid"))) strcat(readcfname,".fid"); sprintf(sysstr,"cd %s",readcfname); if(system(sysstr)) { Werrprintf("System error: %s",sysstr); return(ERROR); } Wscrprintf("Reading correction function in; source file: %s\n",readcfname); } else if (equal(argv[i],noaph)) { if (verbose) Wscrprintf("Reference region(s) will not be automatically phased\n"); aphflg=FALSE; } else if (equal(argv[i],normalise)) { if (verbose) Wscrprintf("Corrected spectra will be normalised to 1st spectrum\n"); quantflag=TRUE; } else { Werrprintf("Option %s was not recognised ",argv[i]); } } } if (verbose&&numsats) printf("%s\n",satname); if (noift&&!stopflag) stopflag=2; if (stopflag==4&&!difffg) stopflag=3; if (difffg) finishno++; D_allrelease(); /* get parameters */ if ( P_getreal(PROCESSED,"fn",&fn,1)|| P_getreal(CURRENT,"ct",&ct,1)|| P_getreal(CURRENT,"sw",&sw,1)|| P_getreal(CURRENT,"cr",&cr,1)|| P_getreal(CURRENT,"delta",&delta,1)|| P_getreal(CURRENT,"rfl",&rfl,1)|| P_getreal(CURRENT,"rfp",&rfp,1)|| P_getreal(CURRENT,"rp",&rp,1)|| P_getreal(CURRENT,"lp",&lp,1)|| P_getreal(PROCESSED,"sfrq",&sfrq,1)|| P_getreal(PROCESSED,"np",&np,1) ) { Werrprintf("Error accessing parameters\n"); return(ERROR); } if (ct==0) { ct=1; Werrprintf("ct was zero; assumed to be 1\n"); } if (verbose) Wscrprintf("sw %lf, cr %lf, delta %lf, rfl %lf, rfp %lf, rp %lf, lp %lf\n", sw,cr,delta,rfl,rfp,rp,lp); if ((cr<rfp)||(cr-delta>rfp)) { Werrprintf("Please place cursors either side of reference and try again\n"); return(ERROR); } if (!aphflg) { if (flag2d) { if (P_getreal(CURRENT,"phinc",&rpinc,1)) { /* parameter phinc not created, so set phase increment to zero */ rpinc=0.0; } if (P_getreal(CURRENT,"rp2nd",&rp2nd,1)) { rp2nd=rp; } } } npi= (int)np; np0 = (int)fn; fn0 = np0; /* ! */ if (hilbert&&((int)np>fn0/2)) { if (verbose) Wscrprintf("np = %f ",np); if (verbose) Wscrprintf("fn = %f\n",fn); Werrprintf("Data should be zerofilled so that fn>=2*np for hilbert transform"); npi=(int) fn0/2; } if (hilbert) np0w=np0/2; else np0w=np0; /* calculate rest of params */ hzpp=sw/np0*2; refpos=2*(int)((sw-rfl)/hzpp); refposfr=((sw-rfl)/hzpp)-0.5*(double)refpos; leftpos=refpos-2*(int)((cr-rfp)/hzpp); rightpos=leftpos+2*(int)(delta/hzpp); if (verbose) Wscrprintf(" refposfr %g, hzpp %g, left %d, ref %d, right %d\n", refposfr,hzpp,leftpos,refpos,rightpos); /* read satellite file if used */ if (numsats) { if ((satfile=fopen(satname,"r"))==NULL) { Werrprintf("Error opening satellite file\n"); return(ERROR); } numsats=0; while(fscanf(satfile,"%f %f %f\n",&satpos[numsats], &satint[numsats],&satish[numsats])!=EOF) { if (verbose) printf("%f %f %f\n", satpos[numsats],satint[numsats],satish[numsats]); numsats++; } fclose(satfile); } /* access & check the file containing the original spectrum */ if ( (r = D_gethead(D_DATAFILE, &fidhead)) ) { if (r == D_NOTOPEN) { if (verbose) Wscrprintf("Original Spectrum had to be re-opened \n"); strcpy(path, curexpdir); strcat(path, "/datdir/data"); r = D_open(D_DATAFILE, path, &fidhead); /* open the file */ } if (r) { D_error(r); return(ERROR); } } status_mask = (S_DATA|S_SPEC|S_FLOAT|S_COMPLEX); if ( (fidhead.status & status_mask) != status_mask ) { Werrprintf("No spectrum in file: use ft before fiddle. fidhead.status = %d", fidhead.status); return(ERROR); } if (np0 != fidhead.np) { Werrprintf("Size of data inconsistent, np0 = %d, head.np = %d", np0, fidhead.np); return(ERROR); } if(writefg) getfidblockheadforwrite(); if(writecfflg) getfidblockheadforcf(); /* Set PHASFILE status to !S_DATA - this is required to force a recalculation of the display from the new data in DATAFILE (in the ds routine, see proc2d.c) */ if ( (r=D_gethead(D_PHASFILE,&phasehead)) ) { if (r==D_NOTOPEN) { Wscrprintf("phas NOTOPEN\n"); strcpy(path,curexpdir); strcat(path,"/datdir/phasefile"); r=D_open(D_PHASFILE,path,&phasehead); } if (r) { D_error(r); return(ERROR); } } phasehead.status=0; if ( (r=D_updatehead(D_PHASFILE,&phasehead)) ) { D_error(r); Wscrprintf("PHAS updatehead\n"); return(ERROR); } /* allocate memory for the temp buffers & weight func. */ if ( (data1=(float *)malloc(sizeof(float)*fn0))==0 ||(data2=(float *)malloc(sizeof(float)*fn0))==0 ||(data3=(float *)malloc(sizeof(float)*fn0))==0 ||(wtfunc=(float *)malloc(sizeof(float)*np0/2))==0) { Werrprintf("could not allocate memory\n"); difffg=FALSE; freall(TRUE); } if (difffg) { if ((data4=(float *)malloc(sizeof(float)*fn0))==0) { Werrprintf("could not allocate memory\n"); freall(TRUE); } } if (writefg||writecfflg||readcfflg) { if ((intbuf=(int *)malloc(sizeof(float)*fn0))==0) { Werrprintf("could not allocate memory\n"); freall(TRUE); } } if(readcfflg) setupreadcf(); /* setup weighting function for ideal fid */ if (init_wt1(&wtp,S_NP)) { Wscrprintf("ERROR: init_wt1(S_NP)\n"); freall(TRUE); } if (init_wt2(&wtp,wtfunc,np0/2,FALSE,S_NP,1.0,FALSE)) { Wscrprintf("ERROR: init_wt2()\n"); freall(TRUE); } /* setup for solvent rd */ if (solvent) { if (P_getVarInfo(CURRENT,"lifrq",&info)) { Werrprintf("Error accessing resets"); freall(TRUE); } numresets=(int)info.size; if (numresets<=1) { Werrprintf("Please provide some integral resets"); freall(TRUE); } if ((resets=(double *)malloc(sizeof(double)*(numresets+4)))==0 ||(spy=(double *)malloc(sizeof(double)*(numresets+4)))==0 ||(spx=(int *)malloc(sizeof(int)*(numresets+4)))==0 ||(spg=(double *)malloc(sizeof(double)*(numresets+4)))==0 ) { Werrprintf("error allocating memory"); freall(TRUE); } i=1; flag=0; for (j=1;j<numresets;j++) { if (P_getreal(CURRENT,"lifrq",&resets[i],j)) { Werrprintf("Error accessing lifrq(%d)\n",i); freall(TRUE); } if (resets[i]<(rfl-rfp+cr)&&flag==0) { resets[i+1]=resets[i]; resets[i]=rfl-rfp+cr; flag=1; i++; } if (resets[i]<rfl&&flag==1) { resets[i+1]=resets[i]; resets[i]=rfl; flag=2; i++; } if (resets[i]<(rfl-rfp+cr-delta)&&flag==2) { resets[i+1]=resets[i]; resets[i]=rfl-rfp+cr-delta; flag=3; i++; } /* if (resets[i]>(rfl-rfp+cr-delta)&&flag==TRUE) i--; */ if (resets[i]==resets[i-1]) i--; i++; } resets[0]=sw; numresets=i; resets[numresets]=hzpp; } disp_status(" "); return(COMPLETE); }
/* frqdimname; frequency dimension */ static int getspecparms(int dis_setup, int frqdimname) { char aig[5], dmg[5], dmg1[5]; int dim0,dim1; int r; double x0; // min, max sw values double minval, maxval; if(P_getmin(PROCESSED, "sw", &minval) ) minval = 200.0; if(P_getmax(PROCESSED, "sw", &maxval) ) maxval = 200.0; dim0 = FN0_DIM; dim1 = FN1_DIM; if (d2flag) { if (frqdimname == S_NP) { if (datahead.status & S_SPEC) { Werrprintf("Data file must first be re-initialized with FID data\n"); return(ERROR); } d2flag = FALSE; dim0 = FN0_DIM; dim1 = FN0_DIM; } else { if (ndflag == FOUR_D) { if (frqdimname & S_NP) { dim0 = FN0_DIM; if (frqdimname & S_NI) dim1 = FN1_DIM; else if (frqdimname & S_NI2) dim1 = FN2_DIM; else dim1 = FN3_DIM; } else if (frqdimname & S_NI) { dim0 = FN1_DIM; if (frqdimname & S_NI2) dim1 = FN2_DIM; else dim1 = FN3_DIM; } else { dim0 = FN2_DIM; dim1 = FN3_DIM; } } else if (frqdimname & S_NP) { dim0 = FN0_DIM; dim1 = ( (frqdimname & S_NI2) ? FN2_DIM : FN1_DIM ); } else if ( (~frqdimname) & S_NF ) { dim0 = FN2_DIM; dim1 = FN1_DIM; } else { Werrprintf("Invalid name for 2nd dimension\n"); return(ERROR); } } } /************************************************ * Set the normalization, processing mode, and * * display flags for either 1D or 2D data. * ************************************************/ if ( (r = P_getstring(CURRENT, "aig", aig, 1, 4)) ) { if ( expdir_to_expnum(curexpdir) > 0 ) P_err(r, "aig", ":"); return(ERROR); } if ( (r = P_getstring(CURRENT, "dmg", dmg, 1, 4)) ) { P_err(r, "dmg", ":"); return(ERROR); } normflag = (aig[0] == 'n'); dophase = doabsval = dopower = dophaseangle = dodbm = FALSE; dof1phase = dof1absval = dof1power = dof1phaseangle = FALSE; dophase = ((dmg[0] == 'p') && (dmg[1] == 'h')); if (!dophase) { doabsval = ((dmg[0] == 'a') && (dmg[1] == 'v')); if (!doabsval) { dopower = ((dmg[0] == 'p') && (dmg[1] == 'w')); if (!dopower) { dophaseangle = ((dmg[0] == 'p') && (dmg[1] == 'a')); if (!dophaseangle) { dodbm = ((dmg[0] == 'd') && (dmg[1] == 'b')); if (!dodbm) { Werrprintf("Invalid display mode for 1D spectral data"); return(ERROR); } } } } } if (d2flag) { r = P_getstring(CURRENT, "dmg1", dmg1, 1, 5); if (!r) { r = ( (strcmp(dmg1, "ph1") != 0) && (strcmp(dmg1, "av1") != 0) && (strcmp(dmg1, "pwr1") != 0) ); } if (r) { /* default to "dmg" */ if ( (r = P_getstring(CURRENT, "dmg", dmg1, 1, 4)) ) { P_err(r, "dmg", ":"); disp_status(" "); return(ERROR); } } dof1phase = ((dmg1[0] == 'p') && (dmg1[1] == 'h')); if (!dof1phase) { dof1absval = ((dmg1[0] == 'a') && (dmg1[1] == 'v')); if (!dof1absval) { dof1power = ((dmg1[0] == 'p') && (dmg1[1] == 'w')); if (!dof1power) { dof1phaseangle = ((dmg1[0] == 'p') && (dmg1[1] == 'a')); if (!dof1phaseangle) { Werrprintf("Invalid F1 display mode for 2D spectral data"); return(ERROR); } } } } } if (dis_setup) { /************************************ * Get current display parameters. * ************************************/ P_getreal(CURRENT,"vs",&vs,1); P_getreal(CURRENT,"vsproj",&vsproj,1); P_getreal(CURRENT,"vs2d",&vs2d,1); C_GETPAR("is", &is); C_GETPAR("io", &io); C_GETPAR("th", &th); C_GETPAR("vp", &vp); C_GETPAR("vo", &vo); C_GETPAR("ho", &ho); C_GETPAR("lvl", &lvl); C_GETPAR("tlt", &tlt); } if (d2flag) { /******************************************************* * Check whether the datafile contains FID's, half- * * transformed spectra, or fully transformed spectra. * *******************************************************/ if ( (~datahead.status) & S_SECND) { /* not fully transformed 2D spectrum */ dim1 = ( (datahead.status & S_NI2) ? SW2_DIM : SW1_DIM ); if ( (~datahead.status) & S_SPEC) dim0 = SW0_DIM; } } else { dim0 = FN0_DIM; dim1 = FN1_DIM; } if (d2flag && revflag) { set_spec_display(HORIZ,dim1,VERT,dim0); set_display_label(HORIZ,revchar,VERT,normchar); set_spec_proc(HORIZ,dim1,REVDIR, VERT,dim0,NORMDIR); } else { set_spec_display(HORIZ,dim0,VERT,dim1); set_display_label(HORIZ,normchar,VERT,revchar); set_spec_proc(HORIZ,dim0,NORMDIR, VERT,dim1,REVDIR); } get_sfrq(HORIZ,&sfrq); get_sfrq(VERT,&sfrq1); get_cursor_pars(HORIZ,&cr,&delta); get_phase_pars(HORIZ,&rp,&lp); get_ref_pars(HORIZ,&sw,&rflrfp,&fn); if(sw<=0 || sw>maxval) { Winfoprintf("Error sw out of bounds %f: 0 to %f",sw,maxval); return(ERROR); } get_scale_axis(HORIZ,&axisHoriz); get_scale_axis(VERT,&axisVert); { double axis_scl; int reversed; get_scale_pars(HORIZ,&sp,&wp,&axis_scl,&reversed); if (get_axis_freq(HORIZ)) set_sp_wp(&sp, &wp, sw, fn/2, rflrfp); else set_sf_wf(&sp, &wp, sw, fn/2); UpdateVal(HORIZ,WP_NAME,wp,NOSHOW); UpdateVal(HORIZ,SP_NAME,sp,NOSHOW); } if (d2flag) { get_phase_pars(VERT,&rp1,&lp1); get_ref_pars(VERT,&sw1,&rflrfp1,&fn1); if(dim1==FN1_DIM && (sw1<=0 || sw1>maxval)) { Winfoprintf("Error sw1 out of bounds %f: 0 to %f",sw1,maxval); return(ERROR); } { double axis_scl; int reversed; get_scale_pars(VERT,&sp1,&wp1,&axis_scl,&reversed); if (get_axis_freq(VERT)) set_sp_wp(&sp1, &wp1, sw1, fn1/2, rflrfp1); else set_sf_wf(&sp1, &wp1, sw1, fn1/2); UpdateVal(VERT,WP_NAME,wp1,NOSHOW); UpdateVal(VERT,SP_NAME,sp1,NOSHOW); } x0 = 1.0; if ( get_axis_freq(HORIZ) && get_axis_freq(VERT) ) { if (((axisHoriz == 'c') || (axisHoriz == 'm') || (axisHoriz == 'u')) && ((axisVert == 'c') || (axisVert == 'm') || (axisVert == 'u'))) { if (axisHoriz == 'c') x0 = 1.0; if (axisHoriz == 'm') x0 = 10.0; if (axisHoriz == 'u') x0 = 1e4; if (axisVert == 'c') x0 /= 1.0; if (axisVert == 'm') x0 /= 10.0; if (axisVert == 'u') x0 /= 1e4; } } aspect_ratio = (wp*sfrq1)/(x0*wp1*sfrq); } else { fn1 = fn; sw1 = 0.0; rflrfp1 = 0.0; aspect_ratio = 100.0; } normInt = 0; insval = 1.0; if (!P_getreal(CURRENT, "ins", &insval, 1)) { vInfo info; double tmp; if (!P_getreal(CURRENT, "insref", &tmp, 1)) { P_getVarInfo(CURRENT,"insref",&info); if (!info.active) normInt = 1; else if (tmp > 0.0) insval /= tmp; } } if (insval <= 0.0) insval = 1.0; if (!normInt) insval /= (double) fn; normInt2 = 0; ins2val = 1.0; if (!P_getreal(CURRENT, "ins2", &ins2val, 1)) { vInfo info; double tmp; if (!P_getreal(CURRENT, "ins2ref", &tmp, 1)) { P_getVarInfo(CURRENT,"ins2ref",&info); if (!info.active) normInt2 = 1; else if (tmp > 0.0) ins2val /= tmp; } } if (ins2val <= 0.0) ins2val = 1.0; if (!normInt2) ins2val /= ((double)fn * (double)fn1); return(COMPLETE); }
static void dialog_sync_func(int cmd, int argc, char **argv) { int r, this_expnum, cpid; int gfd; double dval; char *retStr; DLIST *dlist; vInfo info; int ret, tree; char dstr[256]; if (debug > 1) fprintf(stderr, " dialog_sync_func: cmd= %d argc= %d\n", cmd, argc); cpid = atoi(argv[3]); if (debug > 1) fprintf(stderr, " dialog command: %d, pid %d\n", cmd, cpid); dlist = dialog_list; gfd = -1; while (dlist != NULL) { if (dlist->pid == cpid) { gfd = dlist->fout; break; } dlist = dlist->next; } if (dlist == NULL || gfd < 0) { if (debug > 1) fprintf(stderr, " dialog_sync_func: could not find process\n"); return; } if (debug > 1) fprintf(stderr, " execute command: %d, pid %d\n", cmd, cpid); switch (cmd) { case PWD: retStr = get_cwd(); write(gfd, retStr, strlen(retStr)); break; case EXPDIR: write(gfd, curexpdir, strlen(curexpdir)); break; case GEXIT: dlist->used = 0; close_fd(dlist); dlist->pid = -1; break; case GOK: /* verify console is available */ this_expnum = expdir_to_expnum( curexpdir ); r = is_exp_active( this_expnum ); sprintf(data, "%d \n", r); write(gfd, data, strlen(data)); break; case GQUERY: if (argc < 5) { strcpy(data, "0 \n"); write(gfd, data, strlen(data)); return; } retStr = NULL; if (strstr(argv[4], "macro_value") != NULL) { retStr = modify_show_str(argv[4], dstr); } if (retStr == NULL) retStr = argv[4]; queryFlag = 0; sprintf(data, "if (%s) then dialog('SYNCFUNC', %d, %d, '1') else dialog('SYNCFUNC', %d, %d, '0') endif\n", retStr, GTEST,cpid, GTEST, cpid); execString(data); if (queryFlag == 0) { strcpy(data, "0 \n"); write(gfd, data, strlen(data)); } break; case GTEST: if (argc < 5) return; queryFlag = 1; if (debug > 1) fprintf(stderr, " write to dialog: '%s'\n", argv[4]); sprintf(data, "%s \n", argv[4]); write(gfd, data, strlen(data)); break; case VEXEC: if (argc < 5) return; execString(argv[4]); break; case VGET: sprintf(data, " \n"); if (argc < 5) { write(gfd, data, strlen(data)); return; } tree = CURRENT; if ( (ret = P_getVarInfo(tree, argv[4], &info)) ) { tree = GLOBAL; ret = P_getVarInfo(tree, argv[4], &info); } if (ret != 0) { write(gfd, data, strlen(data)); return; } if (info.basicType == T_STRING) { P_getstring(tree,argv[4],data,1,1023); if (strlen(data) < 4) strcat (data, " \n"); } else { dval = 0.0; P_getreal(tree,argv[4],&dval,1); sprintf(data, "%g\n", dval); } write(gfd, data, strlen(data)); break; } }
/*----------------------------------------------- | | | get_one_fid()/3 | | | | This function returns a pointer to the | | requested FID in a 1D, arrayed, or 2D | | experiment. | | | +----------------------------------------------*/ float *get_one_fid(int curfid, int *np, dpointers *c_block, int dcflag) { char filepath[MAXPATHL], dcrmv[4]; int res, lastfid, force_getfid, headok; float *fidptr; int cftemp; int cttemp; double tmp; vInfo info; ftparInfo ftpar; dfilehead fidhead, phasehead; force_getfid = (*np < 0); if (force_getfid) *np = -(*np); acqflag = FALSE; ftpar.np0 = *np; ftpar.fn0 = *np; ftpar.hypercomplex = FALSE; /* ==> will not work for hypercomplex 2D interferograms */ D_allrelease(); if ( (res = D_gethead(D_PHASFILE, &phasehead)) ) { if (res == D_NOTOPEN) { if ( (res = D_getfilepath(D_PHASFILE, filepath, curexpdir)) ) { D_error(res); return(NULL); } res = D_open(D_PHASFILE, filepath, &phasehead); /* open the file */ } if (res) { if ( new_phasefile(&phasehead, 0, 0, 0, 0, 0, ftpar.hypercomplex) ) return(NULL); } } cftemp = 1; if (!P_getreal(CURRENT, "cf", &tmp, 1)) { if (!P_getVarInfo(CURRENT, "cf", &info)) { if (info.active) cftemp = (int) tmp; } } cttemp = 0; if (!P_getreal(PROCESSED, "ct", &tmp, 1)) cttemp = (int) (tmp + 0.5); ls_ph_fid("lsfid", &(ftpar.lsfid0), "phfid", &(ftpar.phfid0), "lsfrq", &(ftpar.lsfrq0)); headok = ( (phasehead.status == (S_DATA|S_FLOAT|S_COMPLEX)) && (phasehead.ntraces == 1) && (phasehead.np == ftpar.np0) ); if (headok) { /* if phase file does contain fid data, open the file */ res = D_getbuf(D_PHASFILE, phasehead.nblocks, curfid, c_block); if (!res) { if ( (c_block->head->status == (S_DATA|S_FLOAT|S_COMPLEX)) && (c_block->head->rpval == (float) (ftpar.phfid0)) && (c_block->head->lpval == (float) (ftpar.lsfid0/2)) && (c_block->head->lvl == (float) (cftemp)) && (c_block->head->tlt == (float) (cttemp)) && !force_getfid ) { long_event(); return((float *)c_block->data); } } } /******************************************** * If phasefile does not contain FID data, * * open phasefile with the data handler. * ********************************************/ ftpar.zeroflag = FALSE; ftpar.arraydim = dim1count(); lastfid = ftpar.arraydim; ftpar.fn0 = ftpar.np0; if ( i_fid(&fidhead, &ftpar) ) /* open fid file with data handler */ return(NULL); if (ftpar.fn0 != ftpar.np0) headok = 0; *np = ftpar.np0; ftpar.fn0 = ftpar.np0; if (!headok) { if (new_phasefile(&phasehead, 0, ftpar.arraydim, 2*ftpar.np0, 1, (S_DATA|S_FLOAT|S_COMPLEX), ftpar.hypercomplex)) { return(NULL); } } if ( (res = D_allocbuf(D_PHASFILE, curfid, c_block)) ) { D_error(res); return(NULL); } fidptr = (float *)c_block->data; /******************************************* * provision for baseline offset removal * * using numbers reported by noise check * *******************************************/ ftpar.offset_flag = FALSE; if (!P_getstring(CURRENT,"dcrmv",dcrmv,1,4)) { if (dcrmv[0] == 'y') { ftpar.offset_flag = TRUE; } } ftpar.t2dc = dcflag; if ( getfid(curfid, fidptr, &ftpar, &fidhead, &lastfid) || (lastfid <= curfid) ) { return(NULL); } if (ftpar.lsfid0 > 0) zerofill(fidptr + ftpar.np0 - ftpar.lsfid0, ftpar.lsfid0); D_close(D_USERFILE); setheader(c_block, (S_DATA|S_FLOAT|S_COMPLEX), NP_PHMODE, curfid, ftpar.hypercomplex); c_block->head->rpval = (float) (ftpar.phfid0); c_block->head->lpval = (float) (ftpar.lsfid0/2); c_block->head->lvl = (float) (ftpar.cf); c_block->head->tlt = (float) (ftpar.dspar.ctcount); if ( ftpar.cf != cftemp) { /* cf is misset or inactive - just set it = 1 */ Werrprintf("cf = %d is inconsistent with data",cftemp); P_setreal(CURRENT, "cf", 1.0, 0); P_setreal(PROCESSED,"cf", 1.0, 0); } if ( (res = D_markupdated(D_PHASFILE, curfid)) ) { D_error(res); return(NULL); } return(fidptr); }
void setGlobalPars() { char addr[MAXPATH]; vInfo info; int e; e=P_setstring(GLOBAL,"userdir",userdir,0); if (e==-2) { P_creatvar(GLOBAL,"userdir",ST_STRING); P_setlimits(GLOBAL,"userdir",(double)MAXPATH,0.0,0.0); P_setstring(GLOBAL,"userdir",userdir,0); P_setprot(GLOBAL,"userdir",0); } e=P_setstring(GLOBAL,"curexp",curexpdir,0); if (e==-2) { P_creatvar(GLOBAL,"curexp",ST_STRING); P_setlimits(GLOBAL,"curexp",(double)MAXPATH,0.0,0.0); P_setstring(GLOBAL,"curexp",curexpdir,0); P_setprot(GLOBAL,"curexp",0); } #ifdef VNMRJ jcurwin_setGlobalPars(); #endif e=P_setstring(GLOBAL,"systemdir",systemdir,0); if (e==-2) { P_creatvar(GLOBAL,"systemdir",ST_STRING); P_setlimits(GLOBAL,"systemdir",(double)MAXPATH,0.0,0.0); P_setstring(GLOBAL,"systemdir",systemdir,0); P_setprot(GLOBAL,"systemdir",0); } e=P_setstring(GLOBAL,"auto",(mode_of_vnmr == AUTOMATION) ? "y" : "n",0); if (e==-2) { P_creatvar(GLOBAL,"auto",ST_STRING); P_setlimits(GLOBAL,"auto",(double)STR64,0.0,0.0); P_setstring(GLOBAL,"auto",(mode_of_vnmr == AUTOMATION) ? "y" : "n",0); P_setprot(GLOBAL,"auto",7); /* do not allow any user change */ P_Esetstring(GLOBAL,"auto","n",1); P_Esetstring(GLOBAL,"auto","y",2); } if (mode_of_vnmr == AUTOMATION) { getAutoDir(addr, MAXPATH); e=P_setstring(GLOBAL,"autodir",addr,0); } else { e=P_getstring(GLOBAL,"autodir",addr,1,MAXPATH); } if (e==-2) { P_creatvar(GLOBAL,"autodir",ST_STRING); P_setlimits(GLOBAL,"autodir",(double)MAXPATH,0.0,0.0); if (mode_of_vnmr == AUTOMATION) P_setstring(GLOBAL,"autodir",addr,0); P_setprot(GLOBAL,"autodir",3); } GET_VNMR_ADDR(addr); e=P_setstring(GLOBAL,"vnmraddr",addr,0); if (e==-2) { P_creatvar(GLOBAL,"vnmraddr",ST_STRING); P_setlimits(GLOBAL,"vnmraddr",(double)STR128,0.0,0.0); P_setstring(GLOBAL,"vnmraddr",addr,0); P_setprot(GLOBAL,"vnmraddr",4); /* do not allow any user change */ } GET_ACQ_ADDR(addr); e=P_setstring(GLOBAL,"acqaddr",addr,0); if (e==-2) { P_creatvar(GLOBAL,"acqaddr",ST_STRING); P_setlimits(GLOBAL,"acqaddr",(double)STR128,0.0,0.0); P_setstring(GLOBAL,"acqaddr",addr,0); P_setprot(GLOBAL,"acqaddr",4); /* do not allow any user change */ } e=P_setstring(GLOBAL,"owner",UserName,0); if (e==-2) { P_creatvar(GLOBAL,"owner",ST_STRING); P_setlimits(GLOBAL,"owner",(double)STR128,0.0,0.0); P_setstring(GLOBAL,"owner",UserName,0); P_setprot(GLOBAL,"owner",P_VAL+P_GLO); /* do not allow any user change */ } e=P_setstring(GLOBAL,"operator",OperatorName,0); if (e==-2) { P_creatvar(GLOBAL,"operator",ST_STRING); P_setlimits(GLOBAL,"operator",(double)STR128,0.0,0.0); P_setstring(GLOBAL,"operator",UserName,0); P_setprot(GLOBAL,"operator",P_VAL+P_GLO); /* do not allow any user change */ } e=P_getVarInfo(GLOBAL,"department",&info); /* do not set value, read from file */ if (e==-2) { P_creatvar(GLOBAL,"department",ST_STRING); P_setlimits(GLOBAL,"department",(double)STR128,0.0,0.0); P_setstring(GLOBAL,"department","nmr",0); P_setprot(GLOBAL,"department",P_VAL+P_GLO); /* do not allow any user change */ } }