/*----------------------------------------------------------------------------
*----------------------------------------------------------------------------
* Main Program
*----------------------------------------------------------------------------
*----------------------------------------------------------------------------
* Modifications:
* Robb Matzke, 1999-04-09
* Added argument parsing to control the driver which is used.
*
*---------------------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int x,y;
int m,s;
int err, mixc;
int i, driver=DB_PDB, reorder=0;
char filename[64], *file_ext=".pdb";
int show_all_errors = FALSE;
DBfile *db;
/* Parse command-line */
for (i=1; i<argc; i++) {
if (!strncmp(argv[i], "DB_PDB", 6)) {
driver = StringToDriver(argv[i]);
file_ext = ".pdb";
} else if (!strncmp(argv[i], "DB_HDF5", 7)) {
driver = StringToDriver(argv[i]);
file_ext = ".h5";
} else if (!strcmp(argv[i], "reorder")) {
reorder = 1;
} else if (!strcmp(argv[i], "show-all-errors")) {
show_all_errors = 1;
} else if (!strcmp(argv[i], "difftol")) {
difftol = strtod(argv[i+1], 0);
i++;
} else if (argv[i][0] != '\0') {
fprintf(stderr, "%s: ignored argument `%s'\n", argv[0], argv[i]);
}
}
if (show_all_errors) DBShowErrors(DB_ALL_AND_DRVR, 0);
Mesh_Create(&mesh,20,20);
/* -=-=-=-=-=-=-=-=-=- */
/* Setup Coordinates */
/* -=-=-=-=-=-=-=-=-=- */
printf("Creating the mesh\n");
for (x=0;x<mesh.nx;x++) {
for (y=0;y<mesh.ny;y++) {
float xx = (x-10);
float yy = ((xx-8.5)*xx*(xx+8.5))/40. + (y-10);
mesh.node[x][y].x = xx*2+(yy*yy/50 - 3);
mesh.node[x][y].y = yy;
}
}
/* -=-=-=-=-=-=-=-=-=- */
/* Do Mesh Variables */
/* -=-=-=-=-=-=-=-=-=- */
printf("Creating the variables\n");
/* do zone vars */
for (x=0;x<mesh.zx;x++) {
for (y=0;y<mesh.zy;y++) {
mesh.zone[x][y].vars[ZV_P] = sqrt((mesh.node[x][y].x*mesh.node[x][y].x) +
(mesh.node[x][y].y*mesh.node[x][y].y));
mesh.zone[x][y].vars[ZV_D] = 10. / (mesh.zone[x][y].vars[ZV_P]+5);
}
}
/* do node vars */
for (x=0;x<mesh.nx;x++) {
for (y=0;y<mesh.ny;y++) {
mesh.node[x][y].vars[NV_U] = mesh.node[x][y].x;
mesh.node[x][y].vars[NV_V] = mesh.node[x][y].y;
}
}
/* -=-=-=-=-=-=-=-=-=- */
/* Do Materials */
/* -=-=-=-=-=-=-=-=-=- */
printf("Overlaying materials\n");
/* initialize */
for (x=0;x<mesh.zx;x++) {
for (y=0;y<mesh.zy;y++) {
mesh.zone[x][y].nmats=0;
}
}
/* do it */
for (m=1; m<=nmat; m++) {
for (x=0;x<mesh.zx;x++) {
for (y=0;y<mesh.zy;y++) {
float x00=mesh.zone[x][y].n[0][0]->x;
float y00=mesh.zone[x][y].n[0][0]->y;
float x10=mesh.zone[x][y].n[1][0]->x;
float y10=mesh.zone[x][y].n[1][0]->y;
float x01=mesh.zone[x][y].n[0][1]->x;
float y01=mesh.zone[x][y].n[0][1]->y;
float x11=mesh.zone[x][y].n[1][1]->x;
float y11=mesh.zone[x][y].n[1][1]->y;
int i,j;
int c=0;
float vf=0.;
double vfd=0.;
const int RES=40; /* subsampling resolution */
/* Subsample the zone at RESxRES to *
* get a more accurate volume fraction */
for (i=0;i<=RES;i++) {
for (j=0;j<=RES;j++) {
float ii=(float)i/(float)RES;
float jj=(float)j/(float)RES;
float xc = (x00*ii + x10*(1.-ii))*jj +
(x01*ii + x11*(1.-ii))*(1.-jj);
float yc = (y00*ii + y10*(1.-ii))*jj +
(y01*ii + y11*(1.-ii))*(1.-jj);
switch (m) {
case 1:
if (xc>-15 && yc>2) vf++;
break;
case 2:
if (xc>-15 && yc<=2 && xc-5>yc) vf++;
break;
case 3:
if (xc>-15 && yc<=2 && xc-5<=yc) vf++;
break;
case 4:
if (xc<= -15) vf++;
break;
default:
break;
}
c++;
}
}
vfd = vf;
vf /= (float)c;
vfd /= (double)c;
mesh.zone[x][y].matvf[m]=vf;
mesh.zone[x][y].matvfd[m]=vfd;
if (vf)
mesh.zone[x][y].nmats++;
}
}
}
/* check for errors in mat-assigning code! */
err=0;
for (x=0;x<mesh.zx;x++) {
for (y=0;y<mesh.zy;y++) {
float vf=0;
for (m=1; m<=nmat; m++) {
vf += mesh.zone[x][y].matvf[m];
}
if (vf<.99 || vf>1.01) {
printf("Error in zone x=%d y=%d: vf = %f\n",x,y,vf);
err++;
}
}
}
if (err) exit(err);
/* -=-=-=-=-=-=-=-=-=- */
/* do species stuff! */
/* -=-=-=-=-=-=-=-=-=- */
printf("Overlaying material species\n");
err=0;
for (m=1;m<=nmat;m++) {
for (x=0;x<mesh.zx;x++) {
for (y=0;y<mesh.zy;y++) {
if (mesh.zone[x][y].matvf[m]>0.) {
float mftot=0.;
for (s=0; s<nspec[m-1]; s++) {
float x00=mesh.zone[x][y].n[0][0]->x;
float y00=mesh.zone[x][y].n[0][0]->y;
float x10=mesh.zone[x][y].n[1][0]->x;
float y10=mesh.zone[x][y].n[1][0]->y;
float x01=mesh.zone[x][y].n[0][1]->x;
float y01=mesh.zone[x][y].n[0][1]->y;
float x11=mesh.zone[x][y].n[1][1]->x;
float y11=mesh.zone[x][y].n[1][1]->y;
float xx=(x00+x10+x01+x11)/4.;
float yy=(y00+y10+y01+y11)/4.;
double xxd=(x00+x10+x01+x11)/4.;
double yyd=(y00+y10+y01+y11)/4.;
float mf=0.;
double mfd=0.;
float g,g1,g2; /* gradient values */
double gd,g1d,g2d; /* gradient values */
switch (m) {
case 1:
g=lim01((xx+20.)/40.);
gd=lim01((xxd+20.)/40.);
switch (s) {
case 0: mf=g; mfd=gd; break;
case 1: mf=1.-g; mfd=1.-gd; break;
default: exit(-1);
}
break;
case 2:
g=lim01((yy+20.)/40.);
gd=lim01((yyd+20.)/40.);
switch (s) {
case 0: mf=.2+g/2.; mfd=.2+gd/2.; break;
case 1: mf=.5-g/2.; mfd=.5-gd/2.; break;
case 2: mf=.2; mfd=.2; break;
case 3: mf=.1; mfd=.1; break;
default: exit(-1);
}
break;
case 3:
g1=lim01((xx-5+yy+40.)/80.);
g2=lim01((xx-5-yy+40.)/80.);
g1d=lim01((xxd-5+yyd+40.)/80.);
g2d=lim01((xxd-5-yyd+40.)/80.);
switch (s) {
case 0: mf=g1/2.; mfd=g1d/2.; break;
case 1: mf=g2/4.; mfd=g2d/4.; break;
case 2: mf=.5-g1/2.; mfd=.5-g1d/2.; break;
case 3: mf=.25-g2/4.; mfd=.25-g2d/4.; break;
case 4: mf=.25; mfd=.25; break;
default: exit(-1);
}
break;
case 4:
switch (s) {
case 0: mf=1.0; mfd=1.0; break;
default: exit(-1);
}
break;
default:
exit(-1);
break;
}
mesh.zone[x][y].specmf[m][s] = mf;
mesh.zone[x][y].specmfd[m][s] = mfd;
mftot += mf;
}
if (mftot < .99 || mftot > 1.01) {
printf("Error in zone x=%d y=%d mat=%d: mf = %f\n",x,y,m,mftot);
err++;
}
}
}
}
}
if (err) exit(err);
/* -=-=-=-=-=-=-=-=-=- */
/* write to silo files */
/* -=-=-=-=-=-=-=-=-=- */
sprintf(filename, "specmix_quad%s", file_ext);
printf("Writing %s using curvilinear mesh.\n", filename);
db=DBCreate(filename, DB_CLOBBER, DB_LOCAL, "Mixed zone species test", driver);
mixc=domatspec(db, doWrite, 0);
writemesh_curv2d(db,mixc,reorder);
DBClose(db);
sprintf(filename, "specmix_ucd%s", file_ext);
printf("Writing %s using unstructured mesh.\n", filename);
db=DBCreate(filename, DB_CLOBBER, DB_LOCAL, "Mixed zone species test", driver);
mixc=domatspec(db, doWrite, 0);
writemesh_ucd2d(db,mixc,reorder);
DBClose(db);
/* Test read-back of species */
printf("Reading %s with Force Single off.\n", filename);
db=DBOpen(filename, driver, DB_READ);
domatspec(db, doReadAndCheck, 0);
DBClose(db);
printf("Reading %s with Force Single ON.\n", filename);
DBForceSingle(1);
db=DBOpen(filename, driver, DB_READ);
domatspec(db, doReadAndCheck, 1);
DBClose(db);
printf("Done!\n");
for (x=0;x<mesh.nx;x++)
free(mesh.node[x]);
free(mesh.node);
for (x=0;x<mesh.zx;x++)
free(mesh.zone[x]);
free(mesh.zone);
CleanupDriverStuff();
return 0;
}
//------------------------------------------------------------------------------
// receive() -- process received emissions
//------------------------------------------------------------------------------
void Rwr::receive(const LCreal dt)
{
BaseClass::receive(dt);
// clear the back buffer
clearRays(0);
// Receiver losses
#if 0
LCreal noise = getRfRecvNoise();
#else
LCreal noise = getRfRecvNoise() * getRfReceiveLoss();
#endif
// Process received emissions
TrackManager* tm = getTrackManager();
Emission* em = 0;
LCreal signal = 0;
// Get an emission from the queue
lcLock(packetLock);
if (np > 0) {
np--; // Decrement 'np', now the array index
em = packets[np];
signal = signals[np];
}
lcUnlock(packetLock);
while (em != 0) {
//std::cout << "Rwr::receive(" << em->getOwnship() << "): ";
//std::cout << " pwr=" << em->getPower();
//std::cout << " gain=" << em->getGain();
//std::cout << " rl=" << rl;
//std::cout << " pulses=" << pulses;
//std::cout << " losses=" << losses;
//std::cout << " signal=" << signal;
//std::cout << " recvN=" << getRfRecvNoise();
//std::cout << " sn=" << sn;
//std::cout << " snDbl=" << snDbl;
//std::cout << " thrs=" << getRfThreshold();
//std::cout << std::endl;
// CGB, if "signal <= 0.0", then "snDbl" is probably invalid
if (signal > 0.0 && dt != 0.0) {
// Signal over noise (equation 3-5)
LCreal sn = signal / noise;
LCreal snDbl = 10.0f * lcLog10(sn);
// Is S/N above receiver threshold ## dpg -- for now, don't include ECM emissions
if (snDbl > getRfThreshold() && !em->isECM() && rptQueue.isNotFull()) {
// Send report to the track manager
if (tm != 0) {
tm->newReport(em, snDbl);
}
// Get Angle Of Arrival
LCreal aoa= em->getAzimuthAoi();
// Store received power for real-beam display
LCreal sigDbl = 10.0f * lcLog10(signal);
LCreal signal10 = (sigDbl + 50.0f)/50.f;
int idx = getRayIndex( static_cast<LCreal>(Basic::Angle::R2DCC * aoa) );
rays[0][idx] = lim01(rays[0][idx] + signal10);
//if (idx == 0 && getOwnship()->getID() == 1011) {
// std::cout << "sig = " << signal10 << std::endl;
//}
// Send to the track list processor
em->ref(); // ref() for track list processing
rptQueue.put(em);
}
}
// finished
em->unref(); // this unref() undoes the ref() done by RfSystem::rfReceivedEmission
em = 0;
// Get another emission from the queue
lcLock(packetLock);
if (np > 0) {
np--;
em = packets[np];
signal = signals[np];
}
lcUnlock(packetLock);
}
// Transfer the rays
xferRays();
}
