void kdOutGTP(KD kd,char *pszFile,int bStandard)
{
FILE *fp;
GROUP_STAT *grp;
int pi,i,j;
struct dump h;
struct star_particle sp;
double d,d2;
XDR xdrs;
fp = fopen(pszFile,"w");
assert(fp != NULL);
grp = malloc(kd->nGroup*sizeof(GROUP_STAT));
assert(grp != NULL);
for (i=1;i<kd->nGroup;++i) {
for (j=0;j<3;++j) grp[i].r[j] = 0.0;
for (j=0;j<3;++j) grp[i].v[j] = 0.0;
grp[i].m = 0.0;
grp[i].rm = 0.0;
}
for (pi=0;pi<kd->nActive;++pi) {
i = kd->p[pi].iGroup;
if (!i) continue;
for (j=0;j<3;++j) {
grp[i].rel[j] = kd->p[pi].r[j];
}
}
for (pi=0;pi<kd->nActive;++pi) {
i = kd->p[pi].iGroup;
if (!i) continue;
grp[i].m += kd->p[pi].fMass;
for (j=0;j<3;++j) {
d = kd->p[pi].r[j] - grp[i].rel[j];
if (d > 0.5*kd->fPeriod[j]) d -= kd->fPeriod[j];
if (d <= -0.5*kd->fPeriod[j]) d += kd->fPeriod[j];
grp[i].r[j] += kd->p[pi].fMass*d;
}
for (j=0;j<3;++j) grp[i].v[j] += kd->p[pi].fMass*kd->p[pi].v[j];
}
for (i=1;i<kd->nGroup;++i) {
for (j=0;j<3;++j) {
grp[i].r[j] /= grp[i].m;
grp[i].r[j] += grp[i].rel[j];
if (grp[i].r[j] > kd->fCenter[j]+0.5*kd->fPeriod[j])
grp[i].r[j] -= kd->fPeriod[j];
if (grp[i].r[j] <= kd->fCenter[j]-0.5*kd->fPeriod[j])
grp[i].r[j] += kd->fPeriod[j];
}
for (j=0;j<3;++j) grp[i].v[j] /= grp[i].m;
}
for (pi=0;pi<kd->nActive;++pi) {
i = kd->p[pi].iGroup;
if (!i) continue;
d2 = 0.0;
for (j=0;j<3;++j) {
d = kd->p[pi].r[j] - grp[i].r[j];
if (d > 0.5*kd->fPeriod[j]) d -= kd->fPeriod[j];
if (d <= -0.5*kd->fPeriod[j]) d += kd->fPeriod[j];
d2 += d*d;
}
if (d2 > grp[i].rm) grp[i].rm = d2;
}
h.time = kd->fTime;
h.nbodies = kd->nGroup-1;
h.nsph = 0;
h.ndark = 0;
h.nstar = h.nbodies;
h.ndim = 3;
if (bStandard) {
assert(sizeof(Real)==sizeof(float)); /* Else this XDR stuff
ain't gonna work */
xdrstdio_create(&xdrs, fp, XDR_ENCODE);
xdrHeader(&xdrs,&h);
}
else {
fwrite(&h,sizeof(struct dump),1,fp);
}
for (i=1;i<kd->nGroup;++i) {
sp.mass = grp[i].m;
for (j=0;j<3;++j) sp.pos[j] = grp[i].r[j];
for (j=0;j<3;++j) sp.vel[j] = grp[i].v[j];
sp.eps = sqrt(grp[i].rm);
sp.tform = kd->fTime;
sp.metals = 0.0;
sp.phi = 0.0;
if (bStandard) {
xdr_vector(&xdrs, (char *) &sp,
sizeof(struct star_particle)/sizeof(Real),
sizeof(Real), (xdrproc_t)xdr_float);
}
else {
fwrite(&sp,sizeof(struct star_particle),1,fp);
}
}
if (bStandard) xdr_destroy(&xdrs);
free(grp);
fclose(fp);
}
void kdReadTipsy(KD kd,FILE *fp,int bDark,int bGas,int bStar,int bStandard)
{
int i,j,nCnt;
struct dump h;
struct gas_particle gp;
struct dark_particle dp;
struct star_particle sp;
XDR xdrs;
if (bStandard) {
assert(sizeof(Real)==sizeof(float)); /* Otherwise, this XDR stuff
ain't gonna work */
xdrstdio_create(&xdrs, fp, XDR_DECODE);
xdrHeader(&xdrs,&h);
} else {
fread(&h,sizeof(struct dump),1,fp);
}
kd->nParticles = h.nbodies;
kd->nDark = h.ndark;
kd->nGas = h.nsph;
kd->nStar = h.nstar;
kd->fTime = h.time;
kd->nActive = 0;
if (bDark) kd->nActive += kd->nDark;
if (bGas) kd->nActive += kd->nGas;
if (bStar) kd->nActive += kd->nStar;
kd->bDark = bDark;
kd->bGas = bGas;
kd->bStar = bStar;
/*
** Allocate particles.
*/
kd->p = (PARTICLE *)malloc(kd->nActive*sizeof(PARTICLE));
assert(kd->p != NULL);
/*
** Read Stuff!
*/
nCnt = 0;
for (i=0;i<h.nsph;++i) {
if (bStandard) {
xdr_vector(&xdrs, (char *) &gp,
sizeof(struct gas_particle)/sizeof(Real),
sizeof(Real), (xdrproc_t)xdr_float);
} else {
fread(&gp,sizeof(struct gas_particle),1,fp);
}
if (bGas) {
kd->p[nCnt].iOrder = nCnt;
kd->p[nCnt].fMass = gp.mass;
for (j=0;j<3;++j) kd->p[nCnt].r[j] = gp.pos[j];
for (j=0;j<3;++j) kd->p[nCnt].v[j] = gp.vel[j];
++nCnt;
}
}
for (i=0;i<h.ndark;++i) {
if (bStandard) {
xdr_vector(&xdrs, (char *) &dp,
sizeof(struct dark_particle)/sizeof(Real),
sizeof(Real), (xdrproc_t)xdr_float);
} else {
fread(&dp,sizeof(struct dark_particle),1,fp);
}
if (bDark) {
kd->p[nCnt].iOrder = nCnt;
kd->p[nCnt].fMass = dp.mass;
for (j=0;j<3;++j) kd->p[nCnt].r[j] = dp.pos[j];
for (j=0;j<3;++j) kd->p[nCnt].v[j] = dp.vel[j];
++nCnt;
}
}
for (i=0;i<h.nstar;++i) {
if (bStandard) {
xdr_vector(&xdrs, (char *) &sp,
sizeof(struct star_particle)/sizeof(Real),
sizeof(Real), (xdrproc_t)xdr_float);
} else {
fread(&sp,sizeof(struct star_particle),1,fp);
}
if (bStar) {
kd->p[nCnt].iOrder = nCnt;
kd->p[nCnt].fMass = sp.mass;
for (j=0;j<3;++j) kd->p[nCnt].r[j] = sp.pos[j];
for (j=0;j<3;++j) kd->p[nCnt].v[j] = sp.vel[j];
++nCnt;
}
}
if (bStandard) xdr_destroy(&xdrs);
}
struct dump kdReadTipsy(KD kdg, KD kds, KD kdd, char *filename, int bStandard, int bSmbh, int bAux)
{
PINIT *pg, *pd, *ps;
int i,j;
struct dump h;
struct gas_particle gp;
struct dark_particle dp;
struct star_particle sp;
float *fTimeForm, *fMassForm, *fTimeCoolIsOffUntil, *fNSN, *fMFracOxygen, *fMFracIron, *HI, *HeI, *HeII;
long *iGasOrder;
XDR xdrs;
FILE *fp;
if (kdg->bOutDiag) puts(">> kdReadTipsy()");
fflush(stdout);
if(fp = fopen(filename,"r"));
else {
fprintf(stderr, "file \'%s\' not found - exiting promptly\n", filename);
exit(-1);
}
if (bStandard) {
assert(sizeof(Real)==sizeof(float)); /* Otherwise, this XDR stuff
ain't gonna work */
xdrstdio_create(&xdrs, fp, XDR_DECODE);
xdrHeader(&xdrs,&h);
}
else {
fread(&h,sizeof(struct dump),1,fp);
}
/*
** Initialize and allocate arrays for the gas kd
*/
kdg->nDark = h.ndark;
kdg->nGas = h.nsph;
kdg->nStar = h.nstar;
kdg->fTime = h.time;
kdg->inType = GAS;
kdg->nParticles = kdg->nGas; // ONLY CONSIDERING GAS IN THIS CASE
kdg->nInitActive = kdg->nParticles;
kdg->pInit = (PINIT *)malloc(kdg->nParticles*sizeof(PINIT));
assert(kdg->pInit != NULL);
/*
** Initialize and allocate arrays for the dark matter kd
*/
kdd->nDark = h.ndark;
kdd->nGas = h.nsph;
kdd->nStar = h.nstar;
kdd->fTime = h.time;
kdd->inType = DARK;
kdd->nParticles = kdd->nDark; // ONLY CONSIDERING DM IN THIS CASE
kdd->nInitActive = kdd->nParticles;
kdd->pInit = (PINIT *)malloc(kdd->nParticles*sizeof(PINIT));
assert(kdd->pInit != NULL);
/*
** Initialize and allocate arrays for the stars kd
*/
kds->nDark = h.ndark;
kds->nGas = h.nsph;
kds->nStar = h.nstar;
kds->fTime = h.time;
kds->inType = STAR;
kds->nParticles = kds->nStar; // ONLY CONSIDERING STARS IN THIS CASE
kds->nInitActive = kds->nParticles;
kds->pInit = (PINIT *)malloc(kds->nParticles*sizeof(PINIT));
assert(kds->pInit != NULL);
printf("nDark:%d nGas:%d nStar:%d\n",kdg->nDark,kdg->nGas,kdg->nStar);
fflush(stdout);
pg = kdg->pInit;
ps = kds->pInit;
pd = kdd->pInit;
/*
** Read Stuff!
*/
/* Read in the auxiliary files */
if(bAux) {
fTimeCoolIsOffUntil = kdReadFloatArray(filename,0,"coolontime");
fTimeForm = kdReadFloatArray(filename, 0, "timeform");
fMassForm = kdReadFloatArray(filename, 0, "massform");
fNSN = kdReadFloatArray(filename, 0, "ESNRate");
fMFracOxygen = kdReadFloatArray(filename, 0, "OxMassFrac");
fMFracIron = kdReadFloatArray(filename, 0, "FeMassFrac");
iGasOrder = kdReadLongArray(filename, 0, "igasorder");
HI = kdReadFloatArray(filename, 0, "HI");
HeI = kdReadFloatArray(filename, 0, "HeI");
HeII = kdReadFloatArray(filename, 0, "HeII");
}
for(i=0;i<kdg->nParticles;i++){
pg[i].iOrder = i;
pg[i].fDensity = 0.0;
if (bStandard) {
xdr_vector(&xdrs, (char *) &gp, 12,
sizeof(Real), (xdrproc_t) xdr_float);
}
else {
fread(&gp,sizeof(struct gas_particle),1,fp);
}
pg[i].fMass = gp.mass;
pg[i].fSoft = gp.hsmooth;
pg[i].fTemp = gp.temp;
pg[i].fMetals = gp.metals;
for (j=0;j<3;++j) {
pg[i].r[j] = gp.pos[j];
pg[i].v[j] = gp.vel[j];
}
if(bAux) {
pg[i].fTimeCoolIsOffUntil = fTimeCoolIsOffUntil[i];
pg[i].fNSN = fNSN[i];
pg[i].fMFracOxygen = fMFracOxygen[i];
pg[i].fMFracIron = fMFracIron[i];
pg[i].iGasOrder = iGasOrder[i];
pg[i].CoolParticle.Y_HI = HI[i];
pg[i].CoolParticle.Y_HeI = HeI[i];
pg[i].CoolParticle.Y_HeII = HeII[i];
}
}
for(i=0;i<kdd->nParticles;i++){
if (bStandard) {
xdr_vector(&xdrs, (char *) &dp, 9,
sizeof(Real), (xdrproc_t) xdr_float);
}
else {
fread(&dp,sizeof(struct dark_particle),1,fp);
}
pd[i].fMass = dp.mass;
pd[i].fSoft = dp.eps;
pd[i].fTemp = 0.0;
for (j=0;j<3;++j) {
pd[i].r[j] = dp.pos[j];
pd[i].v[j] = dp.vel[j];
}
}
for(i=0;i<kds->nParticles;i++){
if (bStandard) {
xdr_vector(&xdrs, (char *) &sp, 11,
sizeof(Real), (xdrproc_t) xdr_float);
}
else {
fread(&sp,sizeof(struct star_particle),1,fp);
}
ps[i].fMass = sp.mass;
ps[i].fSoft = sp.eps;
ps[i].fTemp = 0.0;
ps[i].fMetals = sp.metals;
ps[i].fTimeForm = sp.tform;
for (j=0;j<3;++j) {
ps[i].r[j] = sp.pos[j];
ps[i].v[j] = sp.vel[j];
}
}
if (bStandard) xdr_destroy(&xdrs);
kdcofm(kdg, kdd, kds, bSmbh);
if (kdg->bOutDiag) puts("<< kdReadTipsy()");
fflush(stdout);
fclose(fp);
return h;
}
