void free_preconditioner(struct preconditioner *precon, int id)
{
if (id == 0) {
free_3d_array(precon->inverse_mass);
for (int i = 0; i < precon->nlevels; ++i) {
free_3d_array(precon->poisson_diag[i]);
free_3d_array(precon->helmholtz_diag[i]);
free_3d_array(precon->stiffsum_scale[i]);
free_3d_array(precon->dirichlet_mask[i]);
}
}
for (int i = 1; i < precon->nlevels; ++i) {
if (precon->geom[i])
free_geometry(precon->geom[i]);
if (precon->sendcounts[i])
free_int_array(precon->sendcounts[i]);
if (precon->senddispls[i])
free_int_array(precon->senddispls[i]);
}
for (int i = 1; i < (2 * precon->nlevels - 1); ++i)
if (precon->basis[i])
free_basis(precon->basis[i]);
free_ptr_array(precon->basis, 0, NULL);
free_ptr_array(precon->geom, 0, NULL);
free_ptr_array(precon->poisson_diag, 0, NULL);
free_ptr_array(precon->helmholtz_diag, 0, NULL);
free_ptr_array(precon->stiffsum_scale, 0, NULL);
free_ptr_array(precon->dirichlet_mask, 0, NULL);
free_ptr_array(precon->sendcounts, 0, NULL);
free_ptr_array(precon->senddispls, 0, NULL);
free_int_array(precon->nmg);
free_1d_array(precon->poisson_eigen_max);
free_1d_array(precon->helmholtz_eigen_max);
free(precon);
}
int surfw_res(PROT prot, int ir, float probe_rad)
{ int i, j, k;
PROBE_RAD = probe_rad; /* get parameters */
grid_interval = PROBE_RAD + ATOM_RAD;
num_pts = 122;
set_vdw_rad(prot, PROBE_RAD);
/* make the surface for each atom */
for (j = 0; j < prot.res[ir].n_conf; j++) {
for (i=0; i<prot.res[ir].n_conf; i++) {
if (i==j) prot.res[ir].conf[i].on = 1;
else prot.res[ir].conf[i].on = 0;
}
get_pdb_size(prot);
extend_grid();
calc_gsize();
gindex.x = gsize.x - 1;
gindex.y = gsize.y - 1;
gindex.z = gsize.z - 1;
alloc_3d_array(gsize.x, gsize.y, gsize.z);
fill_grid(prot);
for (k = 0; k < prot.res[ir].conf[j].n_atom; k++) {
if (!(prot.res[ir].conf[j].atom[k].on)) continue;
mkacc(&(prot.res[ir].conf[j].atom[k]));
}
free_3d_array(gsize.x, gsize.y, gsize.z);
}
/* turn off conformers in this residue */
for (i=2; i<prot.res[ir].n_conf; i++) prot.res[ir].conf[i].on = 0;
if (prot.res[ir].n_conf > 1) prot.res[ir].conf[1].on = 1;
prot.res[ir].conf[0].on = 1;
reset_atom_rad(prot, PROBE_RAD);
return 0;
}
void problem(Grid *pGrid, Domain *pD)
{
int i, is=pGrid->is, ie = pGrid->ie;
int j, js=pGrid->js, je = pGrid->je;
int k, ks=pGrid->ks, ke = pGrid->ke;
rseed = (pGrid->my_id+1);
initialize(pGrid, pD);
tdrive = 0.0;
/* Initialize uniform density and momenta */
for (k=ks-nghost; k<=ke+nghost; k++) {
for (j=js-nghost; j<=je+nghost; j++) {
for (i=is-nghost; i<=ie+nghost; i++) {
pGrid->U[k][j][i].d = rhobar;
pGrid->U[k][j][i].M1 = 0.0;
pGrid->U[k][j][i].M2 = 0.0;
pGrid->U[k][j][i].M3 = 0.0;
}
}
}
#ifdef MHD
/* Initialize uniform magnetic field */
for (k=ks-nghost; k<=ke+nghost; k++) {
for (j=js-nghost; j<=je+nghost; j++) {
for (i=is-nghost; i<=ie+nghost; i++) {
pGrid->U[k][j][i].B1c = B0;
pGrid->U[k][j][i].B2c = 0.0;
pGrid->U[k][j][i].B3c = 0.0;
pGrid->B1i[k][j][i] = B0;
pGrid->B2i[k][j][i] = 0.0;
pGrid->B3i[k][j][i] = 0.0;
}
}
}
#endif /* MHD */
/* Set the initial perturbations. Note that we're putting in too much
* energy this time. This is okay since we're only interested in the
* saturated state. */
generate();
perturb(pGrid, dtdrive);
/* If decaying turbulence, no longer need the driving memory */
if (idrive == 1) {
ath_pout(0,"De-allocating driving memory.\n");
/* Free Athena-style arrays */
free_3d_array(dv1);
free_3d_array(dv2);
free_3d_array(dv3);
/* Free FFTW-style arrays */
ath_3d_fft_free(fv1);
ath_3d_fft_free(fv2);
ath_3d_fft_free(fv3);
}
return;
}
void dump_binary(MeshS *pM, OutputS *pOut)
{
GridS *pGrid;
PrimS ***W;
FILE *p_binfile;
char *fname,*plev=NULL,*pdom=NULL;
char levstr[8],domstr[8];
int n,ndata[7];
/* Upper and Lower bounds on i,j,k for data dump */
int i,j,k,il,iu,jl,ju,kl,ku,nl,nd;
Real dat[2],*datax,*datay,*dataz;
Real *pData,x1,x2,x3;
int coordsys = -1;
/* Loop over all Domains in Mesh, and output Grid data */
for (nl=0; nl<(pM->NLevels); nl++){
for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){
if (pM->Domain[nl][nd].Grid != NULL){
/* write files if domain and level match input, or are not specified (-1) */
if ((pOut->nlevel == -1 || pOut->nlevel == nl) &&
(pOut->ndomain == -1 || pOut->ndomain == nd)){
pGrid = pM->Domain[nl][nd].Grid;
il = pGrid->is, iu = pGrid->ie;
jl = pGrid->js, ju = pGrid->je;
kl = pGrid->ks, ku = pGrid->ke;
#ifdef WRITE_GHOST_CELLS
il = pGrid->is - nghost;
iu = pGrid->ie + nghost;
if(pGrid->Nx[1] > 1){
jl = pGrid->js - nghost;
ju = pGrid->je + nghost;
}
if(pGrid->Nx[2] > 1){
kl = pGrid->ks - nghost;
ku = pGrid->ke + nghost;
}
#endif /* WRITE_GHOST_CELLS */
ndata[0] = iu-il+1;
ndata[1] = ju-jl+1;
ndata[2] = ku-kl+1;
/* calculate primitive variables, if needed */
if(strcmp(pOut->out,"prim") == 0) {
if((W = (PrimS***)
calloc_3d_array(ndata[2],ndata[1],ndata[0],sizeof(PrimS))) == NULL)
ath_error("[dump_bin]: failed to allocate Prim array\n");
for (k=kl; k<=ku; k++) {
for (j=jl; j<=ju; j++) {
for (i=il; i<=iu; i++) {
W[k-kl][j-jl][i-il] = Cons_to_Prim(&(pGrid->U[k][j][i]));
}}}
}
/* construct filename, open file */
if (nl>0) {
plev = &levstr[0];
sprintf(plev,"lev%d",nl);
}
if (nd>0) {
pdom = &domstr[0];
sprintf(pdom,"dom%d",nd);
}
if((fname = ath_fname(plev,pM->outfilename,plev,pdom,num_digit,
pOut->num,NULL,"bin")) == NULL){
ath_error("[dump_binary]: Error constructing filename\n");
}
if((p_binfile = fopen(fname,"wb")) == NULL){
ath_error("[dump_binary]: Unable to open binary dump file\n");
return;
}
free(fname);
/* Write the coordinate system information */
#if defined CARTESIAN
coordsys = -1;
#elif defined CYLINDRICAL
coordsys = -2;
#elif defined SPHERICAL
coordsys = -3;
#endif
fwrite(&coordsys,sizeof(int),1,p_binfile);
/* Write number of zones and variables */
ndata[3] = NVAR;
ndata[4] = NSCALARS;
#ifdef SELF_GRAVITY
ndata[5] = 1;
#else
ndata[5] = 0;
#endif
#ifdef PARTICLES
ndata[6] = 1;
#else
ndata[6] = 0;
#endif
fwrite(ndata,sizeof(int),7,p_binfile);
/* Write (gamma-1) and isothermal sound speed */
#ifdef ISOTHERMAL
dat[0] = (Real)0.0;
dat[1] = (Real)Iso_csound;
#elif defined ADIABATIC
dat[0] = (Real)Gamma_1 ;
dat[1] = (Real)0.0;
#else
dat[0] = dat[1] = 0.0; /* Anything better to put here? */
#endif
fwrite(dat,sizeof(Real),2,p_binfile);
/* Write time, dt */
dat[0] = (Real)pGrid->time;
dat[1] = (Real)pGrid->dt;
fwrite(dat,sizeof(Real),2,p_binfile);
/* Allocate Memory */
if((datax = (Real *)malloc(ndata[0]*sizeof(Real))) == NULL){
ath_error("[dump_binary]: malloc failed for temporary array\n");
return;
}
if((datay = (Real *)malloc(ndata[1]*sizeof(Real))) == NULL){
ath_error("[dump_binary]: malloc failed for temporary array\n");
return;
}
if((dataz = (Real *)malloc(ndata[2]*sizeof(Real))) == NULL){
ath_error("[dump_binary]: malloc failed for temporary array\n");
return;
}
/* compute x,y,z coordinates of cell centers, and write out */
for (i=il; i<=iu; i++) {
cc_pos(pGrid,i,jl,kl,&x1,&x2,&x3);
pData = ((Real *) &(x1));
datax[i-il] = (Real)(*pData);
}
fwrite(datax,sizeof(Real),(size_t)ndata[0],p_binfile);
for (j=jl; j<=ju; j++) {
cc_pos(pGrid,il,j,kl,&x1,&x2,&x3);
pData = ((Real *) &(x2));
datay[j-jl] = (Real)(*pData);
}
fwrite(datay,sizeof(Real),(size_t)ndata[1],p_binfile);
for (k=kl; k<=ku; k++) {
cc_pos(pGrid,il,jl,k,&x1,&x2,&x3);
pData = ((Real *) &(x3));
dataz[k-kl] = (Real)(*pData);
}
fwrite(dataz,sizeof(Real),(size_t)ndata[2],p_binfile);
/* Write cell-centered data (either conserved or primitives) */
for (n=0;n<NVAR; n++) {
for (k=0; k<ndata[2]; k++) {
for (j=0; j<ndata[1]; j++) {
for (i=0; i<ndata[0]; i++) {
if (strcmp(pOut->out,"cons") == 0){
pData = ((Real*)&(pGrid->U[k+kl][j+jl][i+il])) + n;
} else if(strcmp(pOut->out,"prim") == 0) {
pData = ((Real*)&(W[k][j][i])) + n;
}
datax[i] = (Real)(*pData);
}
fwrite(datax,sizeof(Real),(size_t)ndata[0],p_binfile);
}}
}
#ifdef SELF_GRAVITY
for (k=0; k<ndata[2]; k++) {
for (j=0; j<ndata[1]; j++) {
for (i=0; i<ndata[0]; i++) {
pData = &(pGrid->Phi[k+kl][j+jl][i+il]);
datax[i] = (Real)(*pData);
}
fwrite(datax,sizeof(Real),(size_t)ndata[0],p_binfile);
}}
#endif
#ifdef PARTICLES
if (pOut->out_pargrid) {
for (k=0; k<ndata[2]; k++) {
for (j=0; j<ndata[1]; j++) {
for (i=0; i<ndata[0]; i++) {
datax[i] = pGrid->Coup[k+kl][j+jl][i+il].grid_d;
}
fwrite(datax,sizeof(Real),(size_t)ndata[0],p_binfile);
}}
for (k=0; k<ndata[2]; k++) {
for (j=0; j<ndata[1]; j++) {
for (i=0; i<ndata[0]; i++) {
datax[i] = pGrid->Coup[k+kl][j+jl][i+il].grid_v1;
}
fwrite(datax,sizeof(Real),(size_t)ndata[0],p_binfile);
}}
for (k=0; k<ndata[2]; k++) {
for (j=0; j<ndata[1]; j++) {
for (i=0; i<ndata[0]; i++) {
datax[i] = pGrid->Coup[k+kl][j+jl][i+il].grid_v2;
}
fwrite(datax,sizeof(Real),(size_t)ndata[0],p_binfile);
}}
for (k=0; k<ndata[2]; k++) {
for (j=0; j<ndata[1]; j++) {
for (i=0; i<ndata[0]; i++) {
datax[i] = pGrid->Coup[k+kl][j+jl][i+il].grid_v3;
}
fwrite(datax,sizeof(Real),(size_t)ndata[0],p_binfile);
}}
}
#endif
/* close file and free memory */
fclose(p_binfile);
free(datax);
free(datay);
free(dataz);
if(strcmp(pOut->out,"prim") == 0) free_3d_array(W);
}}
}
}
}
void problem(DomainS *pDomain)
{
GridS *pGrid = pDomain->Grid;
int i=0,j=0,k=0;
int is,ie,js,je,ks,ke,nx1,nx2,nx3,iprob;
Real x1c,x2c,x3c,x1f,x2f,x3f; /* cell- and face-centered coordinates */
Real x1size,x2size,x3size,lambda=0.0,ang_2=0.0,sin_a2=0.0,cos_a2=1.0,x,y;
Real rad,amp,vflow,drat,diag;
Real ***az,***ay,***ax;
#ifdef MHD
int ku;
#endif
#if (NSCALARS > 0)
int n;
#endif
is = pGrid->is; ie = pGrid->ie;
js = pGrid->js; je = pGrid->je;
ks = pGrid->ks; ke = pGrid->ke;
nx1 = (ie-is)+1 + 2*nghost;
nx2 = (je-js)+1 + 2*nghost;
nx3 = (ke-ks)+1 + 2*nghost;
if (((je-js) == 0)) {
ath_error("[field_loop]: This problem can only be run in 2D or 3D\n");
}
if ((ay = (Real***)calloc_3d_array(nx3, nx2, nx1, sizeof(Real))) == NULL) {
ath_error("[field_loop]: Error allocating memory for vector pot\n");
}
if ((az = (Real***)calloc_3d_array(nx3, nx2, nx1, sizeof(Real))) == NULL) {
ath_error("[field_loop]: Error allocating memory for vector pot\n");
}
if ((ax = (Real***)calloc_3d_array(nx3, nx2, nx1, sizeof(Real))) == NULL) {
ath_error("[field_loop]: Error allocating memory for vector pot\n");
}
/* Read initial conditions, diffusion coefficients (if needed) */
rad = par_getd("problem","rad");
amp = par_getd("problem","amp");
vflow = par_getd("problem","vflow");
drat = par_getd_def("problem","drat",1.0);
iprob = par_getd("problem","iprob");
#ifdef RESISTIVITY
eta_Ohm = par_getd_def("problem","eta_O",0.0);
Q_Hall = par_getd_def("problem","Q_H",0.0);
Q_AD = par_getd_def("problem","Q_AD",0.0);
#endif
#ifdef THERMAL_CONDUCTION
kappa_iso = par_getd_def("problem","kappa_iso",0.0);
kappa_aniso = par_getd_def("problem","kappa_aniso",0.0);
#endif
/* For (iprob=4) -- rotated cylinder in 3D -- set up rotation angle and
* wavelength of cylinder */
if(iprob == 4){
x1size = pDomain->RootMaxX[0] - pDomain->RootMinX[0];
x3size = pDomain->RootMaxX[2] - pDomain->RootMinX[2];
/* We put 1 wavelength in each direction. Hence the wavelength
* lambda = x1size*cos_a;
* AND lambda = x3size*sin_a;
* are both satisfied. */
if(x1size == x3size){
ang_2 = PI/4.0;
cos_a2 = sin_a2 = sqrt(0.5);
}
else{
ang_2 = atan(x1size/x3size);
sin_a2 = sin(ang_2);
cos_a2 = cos(ang_2);
}
/* Use the larger angle to determine the wavelength */
if (cos_a2 >= sin_a2) {
lambda = x1size*cos_a2;
} else {
lambda = x3size*sin_a2;
}
}
/* Use vector potential to initialize field loop */
for (k=ks; k<=ke+1; k++) {
for (j=js; j<=je+1; j++) {
for (i=is; i<=ie+1; i++) {
cc_pos(pGrid,i,j,k,&x1c,&x2c,&x3c);
x1f = x1c - 0.5*pGrid->dx1;
x2f = x2c - 0.5*pGrid->dx2;
x3f = x3c - 0.5*pGrid->dx3;
/* (iprob=1): field loop in x1-x2 plane (cylinder in 3D) */
if(iprob==1) {
ax[k][j][i] = 0.0;
ay[k][j][i] = 0.0;
if ((x1f*x1f + x2f*x2f) < rad*rad) {
az[k][j][i] = amp*(rad - sqrt(x1f*x1f + x2f*x2f));
} else {
az[k][j][i] = 0.0;
}
}
/* (iprob=2): field loop in x2-x3 plane (cylinder in 3D) */
if(iprob==2) {
if ((x2f*x2f + x3f*x3f) < rad*rad) {
ax[k][j][i] = amp*(rad - sqrt(x2f*x2f + x3f*x3f));
} else {
ax[k][j][i] = 0.0;
}
ay[k][j][i] = 0.0;
az[k][j][i] = 0.0;
}
/* (iprob=3): field loop in x3-x1 plane (cylinder in 3D) */
if(iprob==3) {
if ((x1f*x1f + x3f*x3f) < rad*rad) {
ay[k][j][i] = amp*(rad - sqrt(x1f*x1f + x3f*x3f));
} else {
ay[k][j][i] = 0.0;
}
ax[k][j][i] = 0.0;
az[k][j][i] = 0.0;
}
/* (iprob=4): rotated cylindrical field loop in 3D. Similar to iprob=1
* with a rotation about the x2-axis. Define coordinate systems (x1,x2,x3)
* and (x,y,z) with the following transformation rules:
* x = x1*cos(ang_2) + x3*sin(ang_2)
* y = x2
* z = -x1*sin(ang_2) + x3*cos(ang_2)
* This inverts to:
* x1 = x*cos(ang_2) - z*sin(ang_2)
* x2 = y
* x3 = x*sin(ang_2) + z*cos(ang_2)
*/
if(iprob==4) {
x = x1c*cos_a2 + x3f*sin_a2;
y = x2f;
/* shift x back to the domain -0.5*lambda <= x <= 0.5*lambda */
while(x > 0.5*lambda) x -= lambda;
while(x < -0.5*lambda) x += lambda;
if ((x*x + y*y) < rad*rad) {
ax[k][j][i] = amp*(rad - sqrt(x*x + y*y))*(-sin_a2);
} else {
ax[k][j][i] = 0.0;
}
ay[k][j][i] = 0.0;
x = x1f*cos_a2 + x3c*sin_a2;
y = x2f;
/* shift x back to the domain -0.5*lambda <= x <= 0.5*lambda */
while(x > 0.5*lambda) x -= lambda;
while(x < -0.5*lambda) x += lambda;
if ((x*x + y*y) < rad*rad) {
az[k][j][i] = amp*(rad - sqrt(x*x + y*y))*(cos_a2);
} else {
az[k][j][i] = 0.0;
}
}
/* (iprob=5): spherical field loop in rotated plane */
if(iprob==5) {
ax[k][j][i] = 0.0;
if ((x1f*x1f + x2c*x2c + x3f*x3f) < rad*rad) {
ay[k][j][i] = amp*(rad - sqrt(x1f*x1f + x2c*x2c + x3f*x3f));
} else {
ay[k][j][i] = 0.0;
}
if ((x1f*x1f + x2f*x2f + x3c*x3c) < rad*rad) {
az[k][j][i] = amp*(rad - sqrt(x1f*x1f + x2f*x2f + x3c*x3c));
} else {
az[k][j][i] = 0.0;
}
}
}}}
/* Initialize density and momenta. If drat != 1, then density and temperature
* will be different inside loop than background values
*/
x1size = pDomain->RootMaxX[0] - pDomain->RootMinX[0];
x2size = pDomain->RootMaxX[1] - pDomain->RootMinX[1];
x3size = pDomain->RootMaxX[2] - pDomain->RootMinX[2];
diag = sqrt(x1size*x1size + x2size*x2size + x3size*x3size);
for (k=ks; k<=ke; k++) {
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
pGrid->U[k][j][i].d = 1.0;
pGrid->U[k][j][i].M1 = pGrid->U[k][j][i].d*vflow*x1size/diag;
pGrid->U[k][j][i].M2 = pGrid->U[k][j][i].d*vflow*x2size/diag;
pGrid->U[k][j][i].M3 = pGrid->U[k][j][i].d*vflow*x3size/diag;
cc_pos(pGrid,i,j,k,&x1c,&x2c,&x3c);
if ((x1c*x1c + x2c*x2c + x3c*x3c) < rad*rad) {
pGrid->U[k][j][i].d = drat;
pGrid->U[k][j][i].M1 = pGrid->U[k][j][i].d*vflow*x1size/diag;
pGrid->U[k][j][i].M2 = pGrid->U[k][j][i].d*vflow*x2size/diag;
pGrid->U[k][j][i].M3 = pGrid->U[k][j][i].d*vflow*x3size/diag;
}
#if (NSCALARS > 0)
for (n=0; n<NSCALARS; n++) pGrid->U[k][j][i].s[n] = 0.0;
if ((x1c*x1c + x2c*x2c + x3c*x3c) < rad*rad) {
for (n=0; n<NSCALARS; n++) pGrid->U[k][j][i].s[n] = 1.0;
}
#endif
}}}
/* boundary conditions on interface B */
#ifdef MHD
for (k=ks; k<=ke; k++) {
for (j=js; j<=je; j++) {
for (i=is; i<=ie+1; i++) {
pGrid->B1i[k][j][i] = (az[k][j+1][i] - az[k][j][i])/pGrid->dx2 -
(ay[k+1][j][i] - ay[k][j][i])/pGrid->dx3;
}}}
for (k=ks; k<=ke; k++) {
for (j=js; j<=je+1; j++) {
for (i=is; i<=ie; i++) {
pGrid->B2i[k][j][i] = (ax[k+1][j][i] - ax[k][j][i])/pGrid->dx3 -
(az[k][j][i+1] - az[k][j][i])/pGrid->dx1;
}}}
if (ke > ks) {
ku = ke+1;
} else {
ku = ke;
}
for (k=ks; k<=ku; k++) {
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
pGrid->B3i[k][j][i] = (ay[k][j][i+1] - ay[k][j][i])/pGrid->dx1 -
(ax[k][j+1][i] - ax[k][j][i])/pGrid->dx2;
}}}
#endif
/* initialize total energy and cell-centered B */
#if defined MHD || !defined ISOTHERMAL
for (k=ks; k<=ke; k++) {
for (j=js; j<=je; j++) {
for (i=is; i<=ie; i++) {
#ifdef MHD
pGrid->U[k][j][i].B1c = 0.5*(pGrid->B1i[k][j][i ] +
pGrid->B1i[k][j][i+1]);
pGrid->U[k][j][i].B2c = 0.5*(pGrid->B2i[k][j ][i] +
pGrid->B2i[k][j+1][i]);
if (ke > ks)
pGrid->U[k][j][i].B3c = 0.5*(pGrid->B3i[k ][j][i] +
pGrid->B3i[k+1][j][i]);
else
pGrid->U[k][j][i].B3c = pGrid->B3i[k][j][i];
#endif
#ifndef ISOTHERMAL
pGrid->U[k][j][i].E = 1.0/Gamma_1
#ifdef MHD
+ 0.5*(SQR(pGrid->U[k][j][i].B1c) + SQR(pGrid->U[k][j][i].B2c)
+ SQR(pGrid->U[k][j][i].B3c))
#endif
+ 0.5*(SQR(pGrid->U[k][j][i].M1) + SQR(pGrid->U[k][j][i].M2)
+ SQR(pGrid->U[k][j][i].M3))/pGrid->U[k][j][i].d;
#endif /* ISOTHERMAL */
}
}
}
#endif
free_3d_array((void***)az);
free_3d_array((void***)ay);
free_3d_array((void***)ax);
}
int main(int argc, char* argv[]){
int i, j, k, n;
char *out_name=NULL;
if(argc < 5)
join_error("Usage: %s -o <out_name.vtk> file1.vtk file2.vtk ...\n",argv[0]);
file_count = argc-3; /* Number of input vtk files */
/* Parse the command line for the output filename */
for(i=1; i<argc-1; i++){
if(strcmp(argv[i],"-o") == 0){
i++; /* increment to the filename */
if((out_name = my_strdup(argv[i])) == NULL)
join_error("out_name = my_strdup(\"%s\") failed\n",argv[i]);
break;
}
}
/* An output filename is required */
if(out_name == NULL)
join_error("Usage: %s -o <out_name.vtk> file1.vtk file2.vtk ...\n",argv[0]);
printf("Output filename is \"%s\"\n",out_name);
printf("Found %d files on the command line\n",file_count);
/* ====================================================================== */
domain_1d = (VTK_Domain*)calloc(file_count,sizeof(VTK_Domain));
if(domain_1d == NULL)
join_error("calloc returned a NULL pointer for domain_1d\n");
/* Populate the 1d domain array with the filenames */
for(n=0, i=1; i<argc; i++){
if(strcmp(argv[i],"-o") == 0){
i++; /* increment to the filename */
}
else{
if((domain_1d[n].fname = my_strdup(argv[i])) == NULL){
join_error("domain_1d[%d].fname = my_strdup(\"%s\") failed\n",
n,argv[i]);
}
/* printf("domain_1d[%d].fname = \"%s\"\n",n,domain_1d[n].fname); */
n++; /* increment the domain counter */
}
}
init_domain_1d(); /* Read in the header information */
sort_domain_1d(); /* Sort the VTK_Domain elements in [k][j][i] order */
/* Allocate the domain_3d[][][] array */
domain_3d = (VTK_Domain***)
calloc_3d_array(NGrid_z, NGrid_y, NGrid_x, sizeof(VTK_Domain));
if(domain_3d == NULL)
join_error("calloc_3d_array() returned a NULL pointer\n");
/* Copy the contents of the domain_1d[] array to the domain_3d[][][] array */
n=0;
for(k=0; k<NGrid_z; k++){
for(j=0; j<NGrid_y; j++){
for(i=0; i<NGrid_x; i++){
domain_3d[k][j][i] = domain_1d[n++];
}
}
}
/* For debugging purposes, write out the origin for all of the grid
domains in what should now be an ascending order for a [k][j][i] array. */
/* This mimics the output in sort_domain_1d() and a diff should show
that they are exactly the same. */
/* for(k=0; k<NGrid_z; k++){
for(j=0; j<NGrid_y; j++){
for(i=0; i<NGrid_x; i++){
printf("[%d]: ox=%e oy=%e oz=%e\n",i + NGrid_x*(j + k*NGrid_y),
domain_3d[k][j][i].ox, domain_3d[k][j][i].oy,
domain_3d[k][j][i].oz);
}
}
} */
/* TO MAKE THIS CODE MORE BULLETPROOF ADD A CALL TO SOME FUNCTION TO
CHECK THAT THIS DOMAIN ARRAY SATISFIES A SET OF CONSISTENCY
CONDITIONS LIKE Nx IS CONSTANT ALONG Y- AND Z-DIRECTIONS, ETC. */
/* ====================================================================== */
write_joined_vtk(out_name);
/* ====================================================================== */
/* Now we need to do some cleanup */
free_3d_array((void ***)domain_3d);
domain_3d = NULL;
/* Now close the input files and free the input file names */
for(i=0; i<file_count; i++){
fclose(domain_1d[i].fp);
free(domain_1d[i].fname);
domain_1d[i].fname = NULL;
free(domain_1d[i].comment);
domain_1d[i].comment = NULL;
}
free(domain_1d);
domain_1d = NULL;
free(out_name);
out_name = NULL;
return(0) ;
}
