void send_assign(int tid, tassign *assign) {
int bufid, datasize, i, toint[ASSIGN_NINT];
double *tdbl, todbl[ASSIGN_NDBL];
float *tflt;
toint[ASSIGN_ID] = (int)(assign->id);
toint[ASSIGN_CHANS] = (int)(assign->chans);
toint[ASSIGN_FRAMES] = (int)(assign->frames);
toint[ASSIGN_EPOCHS] = (int)(assign->epochs);
toint[ASSIGN_BIAS] = (int)(assign->bias);
toint[ASSIGN_SIGNS] = (int)(assign->signs);
toint[ASSIGN_EXTENDED] = (int)(assign->extended);
toint[ASSIGN_EXTBLOCKS] = (int)(assign->extblocks);
toint[ASSIGN_PDFSIZE] = (int)(assign->pdfsize);
toint[ASSIGN_NSUB] = (int)(assign->nsub);
toint[ASSIGN_VERBOSE] = (int)(assign->verbose);
toint[ASSIGN_BLOCK] = (int)(assign->block);
toint[ASSIGN_MAXSTEPS] = (int)(assign->maxsteps);
todbl[ASSIGN_LRATE] = (double)(assign->lrate);
todbl[ASSIGN_ANNEALSTEP] = (double)(assign->annealstep);
todbl[ASSIGN_ANNEALDEG] = (double)(assign->annealdeg);
todbl[ASSIGN_NOCHANGE] = (double)(assign->nochange);
todbl[ASSIGN_MOMENTUM] = (double)(assign->momentum);
bufid = pvm_initsend(PvmDataDefault);
pvm_pkint(toint,ASSIGN_NINT,1);
pvm_pkdouble(todbl,ASSIGN_NDBL,1);
datasize = assign->chans * assign->frames * assign->epochs;
if (sizeof(float) != sizeof(doublereal)) {
tflt = (float*)malloc(datasize*sizeof(float));
for (i=0 ; i<datasize ; i++) tflt[i] = (float)(assign->data[i]);
pvm_pkfloat(tflt,datasize,1);
free(tflt);
}
else
pvm_pkfloat((float*)(assign->data),datasize,1);
datasize = assign->chans * assign->chans;
if (sizeof(double) != sizeof(doublereal)) {
tdbl = (double*)malloc(datasize*sizeof(double));
for (i=0 ; i<datasize ; i++) tdbl[i] = (double)(assign->weights[i]);
pvm_pkdouble(tdbl,datasize,1);
free(tdbl);
}
else
pvm_pkdouble((double*)(assign->weights),datasize,1);
pvm_send(tid,1);
pvm_freebuf(bufid);
}
// Send the bits of the genome to the task that requested them. First we send
// the number of bits, then we send the bits themselves. Note that we can
// handle genomes of varying lengths with this setup. We also pack the score
// and stuff that in as well (so that they don't have to do an eval at the
// other end). If we did this as a member function we could save the hassle
// of an extra copy of the bits...
// Returns negative number (error code) if failure.
int
PackIndividual(GAGenome& g) {
GA1DBinaryStringGenome& genome = (GA1DBinaryStringGenome&)g;
static int* bits = 0;
static int nbits = 0;
int status = 0;;
if(nbits < genome.length()){
nbits = genome.length();
delete [] bits;
bits = new int [nbits];
}
int length = genome.length();
for(int i=0; i<length; i++)
bits[i] = genome.gene(i);
status = pvm_pkint(&length, 1, 1);
status = pvm_pkint(bits, length, 1);
float score = g.score();
status = pvm_pkfloat(&score, 1, 1);
return status;
}
int send_float_array(float *array, int size)
{
int info;
PVM_FUNC(info, pvm_pkfloat(array, size, 1));
return(info);
}
// Send only the score of the genome to the specified task.
int
SendGenomeScore(GAGenome& g, int tid) {
int status = 0;
float score = g.score();
status = pvm_initsend(PvmDataDefault);
status = pvm_pkfloat(&score, 1, 1);
status = pvm_send(tid, MSG_GENOME_SCORE);
return status;
}
void SendFloat(float *FloatBuf, int n, int tid, int MsgType)
{
int info;
info = pvm_initsend(PvmDataDefault);
/* pvm_pkbyte((char *)FloatBuf, n*sizeof(float), 1); */
if (info)
{
pvm_pkfloat(FloatBuf, n, 1);
pvm_send(tid, MsgType);
}
else
{
fprintf(stderr, "Problems with SendFloat : Message type %d\n", MsgType);
}
}
int main (int argc, char **argv)
{
int nt; /* number of time samples */
int nz; /* number of migrated depth samples */
int nx,nxshot; /* number of midpoints,shotgathers, the folds in a shot
gather */
int flag=1; /*flag to use ft or meter as the unit*/
int dip=65; /*maximum dip angle to migrate*/
int iz,iw,ix,it,oldsx; /* loop counters*/
int ntfft; /* fft size*/
int nw; /* number of wave numbers */
int mytid,tids[NNTASKS],msgtype,rc,i;/*variable for PVM function*/
int nw1,task;
int lpad=9999,rpad=9999; /*zero-traces padded on left and right sides*/
float f1,f2,f3,f4; /*frequencies to build the Hamming window*/
int nf1,nf2,nf3,nf4; /*the index for above frequencies*/
int NTASKS=0; /*number of slave tasks to start*/
char cpu_name[NNTASKS][80]; /*strings to store the computers' name*/
int flag_cpu=0; /*flag to control if using NTASKS variable*/
float sx,gxmin,gxmax; /*location of geophone and receivers*/
int isx,nxo,ifx=0; /*index for geophone and receivers*/
int ix1,ix2,ix3,il,ir; /*dummy index*/
float *wl,*wtmp; /*pointers for the souce function*/
float Fmax=25; /*peak frequency to make the Ricker wavelet*/
int ntw,truenw; /*number of frequencies to be migrated*/
float dt=0.004,dz; /*time, depth sampling interval*/
float ft; /*first time sample*/
float dw; /*frequency sampling interval*/
float fw; /*first frequency*/
float dx; /*spatial sampling interval*/
float **p,**cresult,**result_tmp; /* input, output data*/
float **v; /*double pointer direct to velocity structure*/
complex *wlsp,**cp,**cq,**cq1; /*pointers for internal usage*/
char *vfile=""; /* name of file containing velocities */
char *cpufile=""; /* name of file containing CPU name */
FILE *vfp,*cpu_fp;
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(1);
/* get optional parameters */
if (!getparfloat("ft",&ft)) ft = 0.0;
if (!getparint("nz",&nz)) err("nz must be specified");
if (!getparfloat("dz",&dz)) err("dz must be specified");
if (!getparstring("vfile", &vfile)) err("vfile must be specified");
if (!getparint("nxo",&nxo)) err("nxo must be specified");
if (!getparint("nxshot",&nxshot)) err("nshot must be specified");
if (!getparfloat("Fmax",&Fmax)) err("Fmax must be specified");
if (!getparfloat("f1",&f1)) f1 = 10.0;
if (!getparfloat("f2",&f2)) f2 = 20.0;
if (!getparfloat("f3",&f3)) f3 = 40.0;
if (!getparfloat("f4",&f4)) f4 = 50.0;
if (!getparint("lpad",&lpad)) lpad=9999;
if (!getparint("rpad",&rpad)) rpad=9999;
if (!getparint("flag",&flag)) flag=1;
if (!getparint("dip",&dip)) dip=65;
if (getparstring("cpufile", &cpufile)){
cpu_fp=fopen(cpufile,"r");
NTASKS=0;
while(!feof(cpu_fp)){
fscanf(cpu_fp,"%s",cpu_name[NTASKS]);
NTASKS++;
}
NTASKS-=1;
flag_cpu=1;
}
else /*if cpufile not specified, the use NTASKS*/
if (!getparint("NTASKS",&NTASKS)) err("No CPUfile specified, NTASKS must be specified");
/*allocate space for the velocity profile*/
tshot=nxshot;
v=alloc2float(nxo,nz);
/*load velicoty file*/
vfp=efopen(vfile,"r");
efread(v[0],FSIZE,nz*nxo,vfp);
efclose(vfp);
/*PVM communication starts here*/
mytid=pvm_mytid(); /*get my pid*/
task=NTASKS;
warn("\n %d",task);
rc=0;
/*spawn slave processes here*/
if(!flag_cpu){
rc=pvm_spawn(child,NULL,PvmTaskDefault,"",task,tids);
}
else{
for(i=0;i<NTASKS;i++){
rc+=pvm_spawn(child,NULL,PvmTaskHost,cpu_name[i],1,&tids[i]);
}
}
/*show the pid of slaves if*/
for(i=0;i<NTASKS;i++){
if(tids[i]<0)warn("\n %d",tids[i]);
else warn("\nt%x\t",tids[i]);
}
/*if not all the slaves start, then quit*/
if(rc<NTASKS){ warn("error");pvm_exit();exit(1);}
/*broadcast the global parameters nxo,nz,dip to all slaves*/
pvm_initsend(PvmDataDefault);
rc=pvm_pkint(&nxo,1,1);
rc=pvm_pkint(&nz,1,1);
rc=pvm_pkint(&dip,1,1);
msgtype=PARA_MSGTYPE;
task=NTASKS;
rc=pvm_mcast(tids,task,msgtype);
/*broadcast the velocity profile to all slaves*/
pvm_initsend(PvmDataDefault);
rc=pvm_pkfloat(v[0],nxo*nz,1);
msgtype=VEL_MSGTYPE;
rc=pvm_mcast(tids,task,msgtype);
/*free the space for velocity profile*/
free2float(v);
/*loop over shot gathers begin here*/
loop:
/* get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
/* let user give dt and/or dx from command line */
if (!getparfloat("dt", &dt)) {
if (tr.dt) { /* is dt field set? */
dt = ((double) tr.dt)/1000000.0;
} else { /* dt not set, assume 4 ms */
dt = 0.004;
warn("tr.dt not set, assuming dt=0.004");
}
}
if (!getparfloat("dx",&dx)) {
if (tr.d2) { /* is d2 field set? */
dx = tr.d2;
} else {
dx = 1.0;
warn("tr.d2 not set, assuming d2=1.0");
}
}
sx=tr.sx;
isx=sx/dx;
gxmin=gxmax=tr.gx;
oldsx=sx;
/* determine frequency sampling interval*/
ntfft = npfar(nt);
nw = ntfft/2+1;
dw = 2.0*PI/(ntfft*dt);
/*compute the index of the frequency to be migrated*/
fw=2.0*PI*f1;
nf1=fw/dw+0.5;
fw=2.0*PI*f2;
nf2=fw/dw+0.5;
fw=2.0*PI*f3;
nf3=fw/dw+0.5;
fw=2.0*PI*f4;
nf4=fw/dw+0.5;
/*the number of frequency to migrated*/
truenw=nf4-nf1+1;
fw=0.0+nf1*dw;
warn("nf1=%d nf2=%d nf3=%d nf4=%d nw=%d",nf1,nf2,nf3,nf4,truenw);
fw=0.0;
/* allocate space */
wl=alloc1float(ntfft);
wlsp=alloc1complex(nw);
/*generate the Ricker wavelet*/
wtmp=ricker(Fmax,dt,&ntw);
for(it=0;it<ntfft;it++)
wl[it]=0.0;
for(it=0;it<ntw-12;it++)
wl[it]=wtmp[it+12];
free1float( wtmp);
/*Fourier transform the Ricker wavelet to frequency domain*/
pfarc(-1,ntfft,wl,wlsp);
/* allocate space */
p = alloc2float(ntfft,nxo);
cp = alloc2complex(nw,nxo);
for (ix=0; ix<nxo; ix++)
for (it=0; it<ntfft; it++)
p[ix][it] = 0.0;
/*read in a single shot gather*/
ix=tr.gx/dx;
memcpy( (void *) p[ix], (const void *) tr.data,nt*FSIZE);
nx = 0;
while(gettr(&tr)){
int igx;
if(tr.sx!=oldsx){ fseek(stdin,(long)(-240-nt*4),SEEK_CUR); break;}
igx=tr.gx/dx;
memcpy( (void *) p[igx], (const void *) tr.data,nt*FSIZE);
if(gxmin>tr.gx)gxmin=tr.gx;
if(gxmax<tr.gx)gxmax=tr.gx;
nx++;
oldsx=tr.sx;
}
warn("\nnx= %d",nx);
warn("sx %f , gxmin %f gxmax %f",sx,gxmin,gxmax);
/*transform the shot gather from time to frequency domain*/
pfa2rc(1,1,ntfft,nxo,p[0],cp[0]);
/*compute the most left and right index for the migrated section*/
ix1=sx/dx;
ix2=gxmin/dx;
ix3=gxmax/dx;
if(ix1>=ix3)ix3=ix1;
if(ix1<=ix2)ix2=ix1;
il=ix2;
ir=ix3;
ix2-=lpad;
ix3+=rpad;
if(ix2<0)ix2=0;
if(ix3>nxo-1)ix3=nxo-1;
/*the total traces to be migrated*/
nx=ix3-ix2+1;
/*allocate space*/
cq = alloc2complex(nx,nw);
cq1 = alloc2complex(nx,nw);
/*transpose the frequency domain data from data[ix][iw] to data[iw][ix] and
apply a Hamming at the same time*/
for (ix=0; ix<nx; ix++)
for (iw=0; iw<nw; iw++){
float tmpp=0.0,tmppp=0.0;
if(iw<nf1||iw>nf4)
cq[iw][ix]=cmplx(0.0,0.0);
else{
if(iw>=nf1&&iw<=nf2){tmpp=PI/(nf2-nf1);tmppp=tmpp*(iw-nf1)-PI;tmpp=0.54+0.46*cos(tmppp);
cq[iw][ix]=crmul(cp[ix+ix2][iw],tmpp);}
else{
if(iw>=nf3&&iw<=nf4){tmpp=PI/(nf4-nf3);tmppp=tmpp*(iw-nf3);tmpp=0.54+0.46*cos(tmppp);
cq[iw][ix]=crmul(cp[ix+ix2][iw],tmpp);}
else
{cq[iw][ix]=cp[ix+ix2][iw];}
}
}
cq[iw][ix]=cp[ix+ix2][iw];
cq1[iw][ix]=cmplx(0.0,0.0);
}
ix=sx/dx-ifx;
warn("ix %d",ix);
for(iw=0;iw<nw;iw++){
cq1[iw][ix-ix2]=wlsp[iw];
}
free2float(p);
free2complex(cp);
free1float(wl);
free1complex(wlsp);
/*if the horizontal spacing interval is in feet, convert it to meter*/
if(!flag)
dx*=0.3048;
/*start of the timing function*/
time(&t1);
/* send local parameters to all slaves*/
pvm_initsend(PvmDataDefault);
ix=15;
rc=pvm_pkint(&ix,1,1);
rc=pvm_pkint(&ntfft,1,1);
rc=pvm_pkint(&ix2,1,1);
rc=pvm_pkint(&ix3,1,1);
rc=pvm_pkint(&isx,1,1);
rc=pvm_pkint(&il,1,1);
rc=pvm_pkint(&ir,1,1);
rc=pvm_pkfloat(&dx,1,1);
rc=pvm_pkfloat(&dz,1,1);
rc=pvm_pkfloat(&dw,1,1);
rc=pvm_pkfloat(&dt,1,1);
msgtype=PARA_MSGTYPE;
task=NTASKS;
rc=pvm_mcast(tids,task,msgtype);
/* send all the frequency to slaves*/
count=NTASKS*5; /*count is the number of frequency components in a shot
gather*/
nw=truenw;
nw1=nw/(count);
if(nw1==0)nw1=1;
total=count=ceil(nw*1.0/nw1);
/* if it is the first shot gather, send equal data to all the slaves, then for
the following shot gathers, only send data when slave requests*/
if(nxshot==tshot){
for(i=0;i<NTASKS;i++){
float *tmpp;
float fw1;
int nww,byte,nwww;
pvm_initsend(PvmDataDefault);
nww=nf1+i*nw1;fw1=fw+nww*dw;
nwww=nw1;
byte=UnDone;
rc=pvm_pkint(&byte,1,1);
rc=pvm_pkfloat(&fw1,1,1);
rc=pvm_pkint(&nwww,1,1);
rc=pvm_pkfloat((float *)cq[nww],nx*nwww*2,1);
rc=pvm_pkfloat((float *)cq1[nww],nx*nwww*2,1);
msgtype=DATA_MSGTYPE;
pvm_send(tids[i],msgtype);
}
count-=NTASKS;
}
while(count){
int tid0,bufid;
float *tmpp;
float fw1;
int nww,byte,nwww;
int i;
i=total-count;
msgtype=COM_MSGTYPE;
bufid=pvm_recv(-1,msgtype);
rc=pvm_upkint(&tid0,1,1);
pvm_freebuf(bufid);
pvm_initsend(PvmDataDefault);
nww=nf1+i*nw1;fw1=fw+nww*dw;
if(i==total-1)nwww=nw-nw1*i;
else nwww=nw1;
byte=UnDone;
rc=pvm_pkint(&byte,1,1);
rc=pvm_pkfloat(&fw1,1,1);
rc=pvm_pkint(&nwww,1,1);
rc=pvm_pkfloat((float *)cq[nww],nx*nwww*2,1);
rc=pvm_pkfloat((float *)cq1[nww],nx*nwww*2,1);
msgtype=DATA_MSGTYPE;
pvm_send(tid0,msgtype);
count--;
}
ix=Done;
pvm_initsend(PvmDataDefault);
rc=pvm_pkint(&ix,1,1);
msgtype=DATA_MSGTYPE;
pvm_mcast(tids,task,msgtype);
free2complex(cq);
free2complex(cq1);
time(&t2);
warn("\n %d shot been finished in %f seconds, Ntask=%d",nxshot,difftime(t2,t1),NTASKS);
nxshot--;
if(nxshot)goto loop;
/*when all the shot gathers done, send signal to all slaves to request the
partial imaging*/
ix=FinalDone;
pvm_initsend(PvmDataDefault);
rc=pvm_pkint(&ix,1,1);
msgtype=PARA_MSGTYPE;
pvm_mcast(tids,task,msgtype);
/*allocate space for the final image*/
cresult = alloc2float(nz,nxo);
for(ix=0;ix<nxo;ix++)
for(iz=0;iz<nz;iz++)
{ cresult[ix][iz]=0.0;
}
result_tmp= alloc2float(nz,nxo);
/*receive partial image from all the slaves*/
msgtype=RESULT_MSGTYPE;
i=0;
while(i<NTASKS){
int bufid;
bufid=pvm_recv(-1,msgtype);
rc=pvm_upkfloat(result_tmp[0],nxo*nz,1);
pvm_freebuf(bufid);
for(ix=0;ix<nxo;ix++)
for(iz=0;iz<nz;iz++)
{
cresult[ix][iz]+=result_tmp[ix][iz];
}
i=i+1;
warn("\n i=%d been received",i);
}
/*send signal to all slaves to kill themselves*/
pvm_initsend(PvmDataDefault);
pvm_mcast(tids,task,COM_MSGTYPE);
/*output the final image*/
for(ix=0; ix<nxo; ix++){
tr.ns = nz ;
tr.dt = dz*1000000.0 ;
tr.d2 = dx;
tr.offset = 0;
tr.cdp = tr.tracl = ix;
memcpy( (void *) tr.data, (const void *) cresult[ix],nz*FSIZE);
puttr(&tr);
}
pvm_exit();
return EXIT_SUCCESS;
}
int
main(void)
{
struct p7trace_s *tr; /* traceback of an alignment */
int master_tid; /* PVM TID of our master */
char *hmmfile; /* file to read HMM(s) from */
HMMFILE *hmmfp; /* opened hmmfile for reading */
struct plan7_s *hmm;
char *seq;
char *dsq;
int len;
int nhmm; /* number of HMM to work on */
float sc;
int my_idx = -1; /* my index, 0..nslaves-1 */
float globT; /* T parameter: keep only hits > globT bits */
double globE; /* E parameter: keep hits < globE E-value */
double pvalue; /* Z*pvalue = Evalue */
int Z; /* nseq to base E value calculation on */
int send_trace; /* TRUE if score is significant */
int do_xnu; /* TRUE to do XNU filter on seq */
int do_forward; /* TRUE to use Forward() scores not Viterbi */
int do_null2; /* TRUE to correct scores w/ ad hoc null2 */
int alphatype; /* alphabet type, hmmAMINO or hmmNUCLEIC */
int code; /* return code after initialization */
/* Register leave_pvm() cleanup function so any exit() call
* first calls pvm_exit().
*/
if (atexit(leave_pvm) != 0) { pvm_exit(); Die("slave couldn't register leave_pvm()"); }
/*****************************************************************
* initialization.
* Master broadcasts to us:
* 1) len of HMM file name (int)
* 2) name of HMM file (string)
* 3) length of sequence string (int)
* 4) sequence (string)
* 5) globT threshold
* 6) globE threshold
* 7) Z
* 8) do_xnu flag
* 9) do_forward flag
* 10) do_null2 flag
* 11) alphabet type
* We receive the broadcast and open the files.
******************************************************************/
master_tid = pvm_parent(); /* who's our master? */
pvm_recv(master_tid, HMMPVM_INIT);
pvm_upkint(&len, 1, 1);
hmmfile = MallocOrDie(sizeof(char *) * (len+1));
pvm_upkstr(hmmfile);
pvm_upkint(&len, 1, 1);
seq = MallocOrDie(sizeof(char *) * (len+1));
pvm_upkstr(seq);
pvm_upkfloat(&globT, 1, 1);
pvm_upkdouble(&globE, 1, 1);
pvm_upkint(&Z, 1, 1);
pvm_upkint(&do_xnu, 1, 1);
pvm_upkint(&do_forward, 1, 1);
pvm_upkint(&do_null2, 1, 1);
pvm_upkint(&alphatype, 1, 1);
SetAlphabet(alphatype);
/* Open HMM file (maybe in HMMERDB) */
code = HMMPVM_OK;
if ((hmmfp = HMMFileOpen(hmmfile, "HMMERDB")) == NULL)
code = HMMPVM_NO_HMMFILE;
else if (hmmfp->gsi == NULL)
code = HMMPVM_NO_INDEX;
/* report our status.
*/
pvm_initsend(PvmDataDefault);
pvm_pkint(&code, 1, 1);
pvm_send(master_tid, HMMPVM_RESULTS);
dsq = DigitizeSequence(seq, len);
if (do_xnu) XNU(dsq, len);
/*****************************************************************
* Main loop.
* Receive an integer 0..nhmm-1 for which HMM to search against.
* If we receive a -1, we shut down.
*****************************************************************/
for (;;)
{
pvm_recv(master_tid, HMMPVM_WORK);
pvm_upkint(&nhmm, 1, 1);
if (my_idx < 0) my_idx = nhmm; /* first time thru, remember what index we are. */
if (nhmm == -1) break; /* shutdown signal */
/* move to our assigned HMM in the HMM file, and read it
*/
HMMFilePositionByIndex(hmmfp, nhmm);
if (! HMMFileRead(hmmfp, &hmm)) Die("unexpected end of HMM file");
if (hmm == NULL) Die("unexpected failure to parse HMM file");
P7Logoddsify(hmm, TRUE);
/* Score sequence, do alignment (Viterbi), recover trace
*/
if (P7ViterbiSize(len, hmm->M) <= RAMLIMIT)
{
SQD_DPRINTF1(("P7Viterbi(): Estimated size %d Mb\n", P7ViterbiSize(len, hmm->M)));
sc = P7Viterbi(dsq, len, hmm, &tr);
}
else
{
SQD_DPRINTF1(("P7SmallViterbi() called; %d Mb > %d\n", P7ViterbiSize(len, hmm->M), RAMLIMIT));
sc = P7SmallViterbi(dsq, len, hmm, &tr);
}
if (do_forward) sc = P7Forward(dsq, len, hmm, NULL);
if (do_null2) sc -= TraceScoreCorrection(hmm, tr, dsq);
pvalue = PValue(hmm, sc);
send_trace = (sc > globT && pvalue * (float) Z < globE) ? 1 : 0;
/* return output
*/
pvm_initsend(PvmDataDefault);
pvm_pkint(&my_idx, 1, 1); /* tell master who we are */
pvm_pkstr(hmm->name); /* double check that we did the right thing */
pvm_pkfloat(&sc, 1, 1);
pvm_pkdouble(&pvalue, 1, 1);
pvm_pkint(&send_trace, 1, 1); /* flag for whether a trace structure is coming */
if (send_trace) PVMPackTrace(tr);
pvm_send(master_tid, HMMPVM_RESULTS);
/* cleanup
*/
FreePlan7(hmm);
P7FreeTrace(tr);
}
/***********************************************
* Cleanup, return.
***********************************************/
HMMFileClose(hmmfp);
free(seq);
free(dsq);
free(hmmfile);
return 0;
}
int main (int argc, char **argv)
{
int Finish,dip=65;
int nz; /* number of migrated depth samples */
int nxo,nx; /* number of midpoints */
int iz,iw,ix,ix2,ix3,ixshot; /* loop counters*/
int ntfft; /* fft size*/
int nw; /* number of frequency*/
int mytid,msgtype,rc,parent_tid;
float dt=0.004,dz; /*time and depth sampling interval*/
float dw; /*frequency sampling interval */
float fw; /* first frequency*/
float w; /* frequency*/
float dx; /* spatial sampling interval*/
float **cresult; /*output data*/
float v1;
float para;
double kz2;
float **vp,**v;
complex cshift2;
complex **cp,**cp1; /* complex input,output */
/*get my and father pids*/
mytid=pvm_mytid();
parent_tid=pvm_parent();
/*receive global parameters*/
msgtype=PARA_MSGTYPE;
rc=pvm_recv(-1,msgtype);
rc=pvm_upkint(&nxo,1,1);
rc=pvm_upkint(&nz,1,1);
rc=pvm_upkint(&dip,1,1);
rc=pvm_upkfloat(¶,1,1);
/*allocate space for velocity profile and receive velocity from father*/
vp=alloc2float(nxo,nz);
msgtype=VEL_MSGTYPE;
rc=pvm_recv(-1,msgtype);
rc=pvm_upkfloat(vp[0],nxo*nz,1);
/*allocate space for the storage of partial image and zero it out now*/
cresult = alloc2float(nz,nxo);
for(ix=0;ix<nxo;ix++)
for(iz=0;iz<nz;iz++)
cresult[ix][iz]=0.0;
/*loop over shotgather*/
loop:
/*receive parameters for each shot gather*/
msgtype=PARA_MSGTYPE;
rc=pvm_recv(parent_tid,msgtype);
rc=pvm_upkint(&Finish,1,1);
if(Finish==FinalDone)goto end;
rc=pvm_upkint(&ntfft,1,1);
rc=pvm_upkint(&ix2,1,1);
rc=pvm_upkint(&ix3,1,1);
rc=pvm_upkint(&ixshot,1,1);
nx=ix3-ix2+1;
rc=pvm_upkfloat(&dx,1,1);
rc=pvm_upkfloat(&dz,1,1);
rc=pvm_upkfloat(&dw,1,1);
rc=pvm_upkfloat(&dt,1,1);
/*allocate space for velocity profile within the aperature*/
v=alloc2float(nx,nz);
for(iz=0;iz<nz;iz++)
for(ix=0;ix<nx;ix++){
v[iz][ix]=vp[iz][ix+ix2];
}
while(1){
/*receive parameters and data for processing*/
msgtype=DATA_MSGTYPE;
rc=pvm_recv(parent_tid,msgtype);
rc=pvm_upkint(&Finish,1,1);
if(Finish==Done) {free2float(v);goto loop; }
rc=pvm_upkfloat(&fw,1,1);
rc=pvm_upkint(&nw,1,1);
cp = alloc2complex(nx,nw);
cp1 = alloc2complex(nx,nw);
rc=pvm_upkfloat((float *)cp[0],nx*nw*2,1);
rc=pvm_upkfloat((float *)cp1[0],nx*nw*2,1);
/* loops over depth */
for(iz=0;iz<nz;++iz){
/*the imaging condition*/
/* for(ix=0;ix<nx;ix++){
for(iw=0,w=fw;iw<nw;w+=dw,iw++){
complex tmp;
float ratio=10.0;
if(fabs(ix+ix2-ixshot)*dx<ratio*iz*dz)
tmp=cmul(cp[iw][ix],cp1[iw][ix]);
else tmp=cmplx(0.0,0.0);
cresult[ix+ix2][iz]+=tmp.r/ntfft;
}
}
*/
/* anothe imaging condition, slightly different from the above one, but not quite
slow*/
for(iw=0,w=fw;iw<nw;w+=dw,iw++){
float kk=0.0;
complex tmp;
float ratio=1.5;
if(dip<80)ratio=1.5;
else ratio=1.5;
for(ix=0;ix<nx;ix++){
kk+=(pow(cp1[iw][ix].i,2.0)+pow(cp1[iw][ix].r,2.0))/nx;
}
for(ix=0;ix<nx;ix++){
tmp=cmul(cp[iw][ix],cp1[iw][ix]);
if(fabs(ix+ix2-ixshot)*dx<ratio*iz*dz)
tmp=crmul(tmp,1.0/(kk+1.0e-10));
else tmp=cmplx(0.0,0.0);
cresult[ix+ix2][iz]+=tmp.r/ntfft;
}
}
/*get the average velocity*/
v1=0.0;
for(ix=0;ix<nx;++ix)
{v1+=v[iz][ix]/nx;}
/*compute time-invariant wavefield*/
/* for(ix=0;ix<nx;++ix)
for(iw=0,w=fw;iw<nw;w+=dw,++iw) {
kz2=-(1.0/v1)*w*dz;
cshift2=cmplx(cos(kz2),sin(kz2));
cp[iw][ix]=cmul(cp[iw][ix],cshift2);
cp1[iw][ix]=cmul(cp1[iw][ix],cshift2);
}
*/
/*wave-propagation using finite-difference method*/
fdmig( cp, nx, nw,v[iz],fw,dw,dz,dx,dt,dip,para);
fdmig( cp1,nx, nw,v[iz],fw,dw,dz,dx,dt,dip,para);
/*apply thin lens term here*/
for(ix=0;ix<nx;++ix)
for(iw=0,w=fw;iw<nw;w+=dw,++iw){
float Wi=-dw;
kz2=-(1.0/v[iz][ix])*dz;
/* kz2=-(1.0/v[iz][ix]-1.0/v1)*w*dz;
cshift2=cmplx(cos(kz2),sin(kz2));*/
cshift2=cexp(cmplx(-Wi*kz2,w*kz2));
cp[iw][ix]=cmul(cp[iw][ix],cshift2);
cp1[iw][ix]=cmul(cp1[iw][ix],cshift2);
}
}
/*finish a portion of the data, request more*/
pvm_initsend(PvmDataDefault);
pvm_pkint(&mytid,1,1);
msgtype=COM_MSGTYPE;
pvm_send(parent_tid,msgtype);
free2complex(cp);
free2complex(cp1);
}
end:
/*everything done,send back partial image and wait for signal to kill itself*/
pvm_initsend(PvmDataDefault);
pvm_pkfloat(cresult[0],nxo*nz,1);
msgtype=RESULT_MSGTYPE;
pvm_send(parent_tid,msgtype);
msgtype=COM_MSGTYPE;
pvm_recv(-1,msgtype);
pvm_exit();
exit(0);
}
int
main(void)
{
int master_tid; /* PVM TID of our master */
int slaveidx; /* my slave index (0..nslaves-1) */
struct plan7_s *hmm; /* HMM to calibrate, sent from master */
struct histogram_s *hist; /* score histogram */
int hmmidx; /* index of this HMM */
char *seq; /* synthetic random sequence */
char *dsq; /* digitized seq */
int len; /* length of seq */
float sc; /* score of seq aligned to HMM */
float max; /* maximum score seen in sample */
int seed; /* random number seed */
int nsample; /* number of seqs to sample */
int fixedlen; /* if nonzero, fixed length of seq */
float lenmean; /* Gaussian mean length of seq */
float lensd; /* Gaussian length std. dev. for seq */
int fitok; /* TRUE if EVD fit was OK */
float randomseq[MAXABET]; /* iid frequencies of residues */
float p1;
int alphatype; /* alphabet type, hmmAMINO or hmmNUCLEIC */
int idx;
int code;
/* Register leave_pvm() cleanup function so any exit() call
* first calls pvm_exit().
*/
if (atexit(leave_pvm) != 0) { pvm_exit(); Die("slave couldn't register leave_pvm()"); }
/*****************************************************************
* initialization.
* Master broadcasts the problem to us: parameters of the
* HMM calibration.
******************************************************************/
master_tid = pvm_parent(); /* who's our master? */
pvm_recv(master_tid, HMMPVM_INIT);
pvm_upkint(&nsample, 1, 1);
pvm_upkint(&fixedlen, 1, 1);
pvm_upkfloat(&lenmean, 1, 1);
pvm_upkfloat(&lensd, 1, 1);
/* tell the master we're OK and ready to go (or not)
*/
code = HMMPVM_OK;
pvm_initsend(PvmDataDefault);
pvm_pkint(&code, 1, 1);
pvm_send(master_tid, HMMPVM_RESULTS);
/*****************************************************************
* Main loop.
* Receive a random number seed, then an HMM to search against.
* If we receive a -1 seed, we shut down.
*****************************************************************/
slaveidx = -1;
for (;;)
{
pvm_recv(master_tid, HMMPVM_WORK);
pvm_upkint(&seed, 1, 1);
if (seed == -1) break; /* shutdown signal */
pvm_upkint(&hmmidx, 1, 1);
pvm_upkint(&alphatype,1, 1);
SetAlphabet(alphatype);
hmm = PVMUnpackHMM();
if (hmm == NULL) Die("oh no, the HMM never arrived");
if (slaveidx == -1) slaveidx = hmmidx;
P7DefaultNullModel(randomseq, &p1);
sre_srandom(seed);
P7Logoddsify(hmm, TRUE);
hist = AllocHistogram(-200, 200, 100);
max = -FLT_MAX;
for (idx = 0; idx < nsample; idx++)
{
/* choose length of random sequence */
if (fixedlen) len = fixedlen;
else do len = (int) Gaussrandom(lenmean, lensd); while (len < 1);
/* generate it */
seq = RandomSequence(Alphabet, randomseq, Alphabet_size, len);
dsq = DigitizeSequence(seq, len);
if (P7ViterbiSize(len, hmm->M) <= RAMLIMIT)
sc = P7Viterbi(dsq, len, hmm, NULL);
else
sc = P7SmallViterbi(dsq, len, hmm, NULL);
AddToHistogram(hist, sc);
if (sc > max) max = sc;
free(seq);
free(dsq);
}
/* Fit an EVD to the observed histogram.
* The TRUE left-censors and fits only the right slope of the histogram.
* The 9999. is an arbitrary high number that means we won't trim outliers
* on the right.
*/
fitok = ExtremeValueFitHistogram(hist, TRUE, 9999.);
/* Return output to master.
* Currently we don't send the histogram back, but we could.
*/
pvm_initsend(PvmDataDefault);
pvm_pkint(&slaveidx, 1, 1);
pvm_pkint(&hmmidx, 1, 1);
PVMPackString(hmm->name);
pvm_pkint(&fitok, 1, 1);
pvm_pkfloat(&(hist->param[EVD_MU]), 1, 1);
pvm_pkfloat(&(hist->param[EVD_LAMBDA]), 1, 1);
pvm_pkfloat(&max, 1, 1);
pvm_send(master_tid, HMMPVM_RESULTS);
/* cleanup
*/
FreeHistogram(hist);
FreePlan7(hmm);
}
/***********************************************
* Cleanup, return.
***********************************************/
return 0; /* pvm_exit() is called by atexit() registration. */
}
/* Function: main_loop_pvm()
* Date: SRE, Wed Aug 19 13:59:54 1998 [St. Louis]
*
* Purpose: Given an HMM and parameters for synthesizing random
* sequences; return a histogram of scores.
* (PVM version)
*
* Args: hmm - an HMM to calibrate.
* seed - random number seed
* nsample - number of seqs to synthesize
* lumpsize- # of seqs per slave exchange; controls granularity
* lenmean - mean length of random sequence
* lensd - std dev of random seq length
* fixedlen- if nonzero, override lenmean, always this len
* hist - RETURN: the score histogram
* ret_max - RETURN: highest score seen in simulation
* extrawatch - RETURN: total CPU time spend in slaves.
* ret_nslaves- RETURN: number of PVM slaves run.
*
* Returns: (void)
* hist is alloc'ed here, and must be free'd by caller.
*/
static void
main_loop_pvm(struct plan7_s *hmm, int seed, int nsample, int lumpsize,
float lenmean, float lensd, int fixedlen,
struct histogram_s **ret_hist, float *ret_max,
Stopwatch_t *extrawatch, int *ret_nslaves)
{
struct histogram_s *hist;
int master_tid;
int *slave_tid;
int nslaves;
int nsent; /* # of seqs we've asked for so far */
int ndone; /* # of seqs we've got results for so far */
int packet; /* # of seqs to have a slave do */
float max;
int slaveidx; /* id of a slave */
float *sc; /* scores returned by a slave */
Stopwatch_t slavewatch;
int i;
StopwatchZero(extrawatch);
hist = AllocHistogram(-200, 200, 100);
max = -FLT_MAX;
/* Initialize PVM
*/
if ((master_tid = pvm_mytid()) < 0)
Die("pvmd not responding -- do you have PVM running?");
#if DEBUGLEVEL >= 1
pvm_catchout(stderr); /* catch output for debugging */
#endif
PVMSpawnSlaves("hmmcalibrate-pvm", &slave_tid, &nslaves);
/* Initialize the slaves
*/
pvm_initsend(PvmDataDefault);
pvm_pkfloat(&lenmean, 1, 1);
pvm_pkfloat(&lensd, 1, 1);
pvm_pkint( &fixedlen, 1, 1);
pvm_pkint( &Alphabet_type, 1, 1);
pvm_pkint( &seed, 1, 1);
if (! PVMPackHMM(hmm)) Die("Failed to pack the HMM");
pvm_mcast(slave_tid, nslaves, HMMPVM_INIT);
SQD_DPRINTF1(("Initialized %d slaves\n", nslaves));
/* Confirm slaves' OK status.
*/
PVMConfirmSlaves(slave_tid, nslaves);
SQD_DPRINTF1(("Slaves confirm that they're ok...\n"));
/* Load the slaves
*/
nsent = ndone = 0;
for (slaveidx = 0; slaveidx < nslaves; slaveidx++)
{
packet = (nsample - nsent > lumpsize ? lumpsize : nsample - nsent);
pvm_initsend(PvmDataDefault);
pvm_pkint(&packet, 1, 1);
pvm_pkint(&slaveidx, 1, 1);
pvm_send(slave_tid[slaveidx], HMMPVM_WORK);
nsent += packet;
}
SQD_DPRINTF1(("Loaded %d slaves\n", nslaves));
/* Receive/send loop
*/
sc = MallocOrDie(sizeof(float) * lumpsize);
while (nsent < nsample)
{
/* integrity check of slaves */
PVMCheckSlaves(slave_tid, nslaves);
/* receive results */
SQD_DPRINTF2(("Waiting for results...\n"));
pvm_recv(-1, HMMPVM_RESULTS);
pvm_upkint(&slaveidx, 1, 1);
pvm_upkint(&packet, 1, 1);
pvm_upkfloat(sc, packet, 1);
SQD_DPRINTF2(("Got results.\n"));
ndone += packet;
/* store results */
for (i = 0; i < packet; i++) {
AddToHistogram(hist, sc[i]);
if (sc[i] > max) max = sc[i];
}
/* send new work */
packet = (nsample - nsent > lumpsize ? lumpsize : nsample - nsent);
pvm_initsend(PvmDataDefault);
pvm_pkint(&packet, 1, 1);
pvm_pkint(&slaveidx, 1, 1);
pvm_send(slave_tid[slaveidx], HMMPVM_WORK);
SQD_DPRINTF2(("Told slave %d to do %d more seqs.\n", slaveidx, packet));
nsent += packet;
}
/* Wait for the last output to come in.
*/
while (ndone < nsample)
{
/* integrity check of slaves */
PVMCheckSlaves(slave_tid, nslaves);
/* receive results */
SQD_DPRINTF1(("Waiting for final results...\n"));
pvm_recv(-1, HMMPVM_RESULTS);
pvm_upkint(&slaveidx, 1, 1);
pvm_upkint(&packet, 1, 1);
pvm_upkfloat(sc, packet, 1);
SQD_DPRINTF2(("Got some final results.\n"));
ndone += packet;
/* store results */
for (i = 0; i < packet; i++) {
AddToHistogram(hist, sc[i]);
if (sc[i] > max) max = sc[i];
}
}
/* Shut down the slaves: send -1,-1,-1.
*/
pvm_initsend(PvmDataDefault);
packet = -1;
pvm_pkint(&packet, 1, 1);
pvm_pkint(&packet, 1, 1);
pvm_pkint(&packet, 1, 1);
pvm_mcast(slave_tid, nslaves, HMMPVM_WORK);
/* Collect stopwatch results; quit the VM; return.
*/
for (i = 0; i < nslaves; i++)
{
pvm_recv(-1, HMMPVM_RESULTS);
pvm_upkint(&slaveidx, 1, 1);
StopwatchPVMUnpack(&slavewatch);
SQD_DPRINTF1(("Slave %d finished; says it used %.2f cpu, %.2f sys\n",
slaveidx, slavewatch.user, slavewatch.sys));
StopwatchInclude(extrawatch, &slavewatch);
}
free(slave_tid);
free(sc);
pvm_exit();
*ret_hist = hist;
*ret_max = max;
*ret_nslaves = nslaves;
return;
}
void main (int argc, char** argv)
{
int Message_counter ; /* counter for message packing */
int My_tid ; /* my task id */
/* show start up message */
printf ("\n-=> Fractal Terrain Engine version 2.1 release 2 <=-\n\n") ;
/* read the config files */
read_config (argc,argv) ;
/* set up the pixel buffer and it's variables */
Pixel_buffer_width=User_view.X_size/Number_of_workers;
Pixel_buffer_size=
Pixel_buffer_width*User_view.Y_size*3*sizeof(unsigned char) ;
Pixel_buffer=(unsigned char *) malloc(Pixel_buffer_size) ;
/* set up worker tids array */
Worker_tids=(int *)malloc(Number_of_workers*sizeof(int)) ;
/* set up the image buffer */
Image_buffer=(unsigned char *) malloc
((User_view.X_size*User_view.Y_size*3*sizeof(unsigned char))) ;
/* start up pvm */
if ((My_tid = pvm_mytid()) < 0)
{
exit(1);
}
/* start up the workers */
pvm_spawn(WORKER_NAME,(char**)0,PvmTaskDefault,"",
Number_of_workers,Worker_tids) ;
printf ("INFO:Spawned %i Workers\n",Number_of_workers) ;
/* tell the worker what values to use for the terrain function */
pvm_initsend(PvmDataDefault) ;
pvm_pkdouble(&H,1,1) ;
pvm_pkdouble(&Lacunarity,1,1);
pvm_pkdouble(&Octaves,1,1);
pvm_pkdouble(&Offset,1,1) ;
pvm_pkfloat(&Ambient_light,1,1) ;
pvm_pkfloat(&Fog.Red,1,1) ;
pvm_pkfloat(&Fog.Green,1,1);
pvm_pkfloat(&Fog.Blue,1,1) ;
pvm_pkfloat(&Sky.Red,1,1) ;
pvm_pkfloat(&Sky.Green,1,1) ;
pvm_pkfloat(&Sky.Blue,1,1) ;
pvm_pkfloat(&Horizon.Red,1,1) ;
pvm_pkfloat(&Horizon.Green,1,1) ;
pvm_pkfloat(&Horizon.Blue,1,1) ;
pvm_pkdouble(Colour_boundaries,NUMBER_OF_TERRAIN_COLOURS,1) ;
for ( Message_counter = 0 ;
Message_counter<NUMBER_OF_TERRAIN_COLOURS ;
Message_counter++ )
{
pvm_pkfloat(&Terrain_colours[Message_counter].Red,1,1) ;
pvm_pkfloat(&Terrain_colours[Message_counter].Green,1,1) ;
pvm_pkfloat(&Terrain_colours[Message_counter].Blue,1,1) ;
}
pvm_pkdouble(&Fog_start,1,1) ;
pvm_pkdouble(&Fog_end,1,1) ;
/* tell the worker what values to use for the display */
pvm_pkdouble(&Ray_step,1,1) ;
pvm_pkdouble(&X_view_angle,1,1) ;
pvm_pkdouble(&Y_view_angle,1,1) ;
pvm_pkint(&Pixel_buffer_width,1,1) ;
pvm_pkint(&User_view.Y_size,1,1) ;
pvm_pkdouble(&X_ray_angle,1,1) ;
pvm_pkdouble(&Y_ray_angle,1,1) ;
/* send the message to all the workers */
pvm_mcast (Worker_tids,Number_of_workers,INFO) ;
/* set up light source */
normalize_3d(Light_source) ;
/* set the light source */
Light_source[0]=0.1 ;
Light_source[1]=0.4 ;
Light_source[2]=0.3 ;
/* tell the worker what values to use for the light source */
pvm_initsend(PvmDataDefault) ;
pvm_pkdouble(Light_source,3,1) ;
pvm_mcast (Worker_tids,Number_of_workers,NEW_LIGHT_SOURCE) ;
/* set up the users view point */
Height=1.0 ;
User.X=0 ;
User.Y=0 ;
User.Z=Height ;
User.X_angle=0.0 ;
User.Y_angle=0.0 ;
User.Z_angle=0.0 ;
/* set up window */
open_window() ;
print_keys() ;
/* */
/* set up the keyboard,Reshape and display routines */
/* */
auxKeyFunc(AUX_Q,kill_workers) ;
auxKeyFunc(AUX_q,kill_workers) ;
auxKeyFunc(AUX_ESCAPE,kill_workers) ;
auxKeyFunc(AUX_LEFT,left) ;
auxKeyFunc(AUX_RIGHT,right) ;
auxKeyFunc(AUX_UP,forwards) ;
auxKeyFunc(AUX_DOWN,backwards) ;
auxKeyFunc(AUX_a,up) ;
auxKeyFunc(AUX_A,up) ;
auxKeyFunc(AUX_Z,down) ;
auxKeyFunc(AUX_z,down) ;
auxKeyFunc(AUX_J,save_image) ;
auxKeyFunc(AUX_j,save_image) ;
auxMainLoop(display_loop) ;
}
