SolutionInstance TubeMCM::Integrate(d dt){ // Integrate using
// MacCormack method
d t=sol.getTime();
d newt=t+dt;
d lambda=dt/dx;
SolutionInstance predictor(gp);
{ // Predictor step
const vd& oldrho=sol.rho();
const vd& oldm=sol.m();
const vd& oldrhoE=sol.rhoE();
vd& prho=predictor.rho_ref();
vd& pm=predictor.m_ref();
vd& prhoE=predictor.rhoE_ref();
// Fluxes from previous solution
vd Cflux=sol.Cflux();
vd Mflux=sol.Mflux();
vd Eflux=sol.Eflux();
// Density
prho.tail(gp-1)=oldrho.tail(gp-1)
-lambda*(Cflux.tail(gp-1)-Cflux.head(gp-1));
// The first element
prho(0)=oldrho(0)-lambda*(Cflux(1)-Cflux(0));
// Momentum
d oldu0=oldm(0)/oldrho(0);
d momfluxl = pow(oldm(0), 2)/oldrho(0) + pleft(t);
pm.tail(gp-1)=oldm.tail(gp-1)
-lambda*(Mflux.tail(gp-1)-Mflux.head(gp-1));
// The first element
pm(0)=oldm(0)-lambda*(Mflux(1)-momfluxl);
pm(gp-1)=0;
// Energy
prhoE.tail(gp-1)=oldrhoE.tail(gp-1)
-lambda*(Eflux.tail(gp-1)-Eflux.head(gp-1));
// The first element
prhoE(0)=oldrhoE(0)-lambda*(Eflux(1)-Eflux(0));
}
SolutionInstance corrector(gp);
// Temp test hack:
corrector=predictor;
corrector.setTime(newt);
return corrector;
} // Integrate(dt)
void Forces::WriteTens(char *FTens,int Comp,double InvNFile){
double InvValues = 1. / Tens.NSlab;
double InvVolume = prho()*CUBE(Tens.NSlab)/pVol();
if(VAR_IF_TYPE(Tens.CalcMode,CALC_2d)){
#ifdef OMPI_MPI_H
MPI_Allreduce(MPI_IN_PLACE,Tens.Pre[Comp],SQR(Tens.NSlab),MPI_DOUBLE,MPI_SUM,Proc->CommGrid);
for(int t=0;t<2;t++){
MPI_Allreduce(MPI_IN_PLACE,Tens.Dens[t],SQR(Tens.NSlab),MPI_DOUBLE,MPI_SUM,Proc->CommGrid);
}
int Rank=0;
MPI_Comm_rank(Proc->CommGrid, &Rank);
if(Rank==0){
#endif
FILE *FWrite = fopen(FTens,"w");
WriteTens2d(FWrite,Comp,InvNFile);
fclose(FWrite);
for(int s=0;s<SQR(Tens.NSlab);s++){
Tens.Pre[Comp][s] = 0.;
Tens.Dens[0][s] = 0.;
Tens.Dens[1][s] = 0.;
}
#ifdef OMPI_MPI_H
}
#endif
}
if(VAR_IF_TYPE(Tens.CalcMode,CALC_3d)){
#ifdef OMPI_MPI_H
MPI_Allreduce(MPI_IN_PLACE,Tens.Pre[Comp],CUB(Tens.NSlab),MPI_DOUBLE,MPI_SUM,Proc->CommGrid);
for(int t=0;t<2;t++){
MPI_Allreduce(MPI_IN_PLACE,Tens.Dens[t],CUB(Tens.NSlab),MPI_DOUBLE,MPI_SUM,Proc->CommGrid);
}
int Rank=0;
MPI_Comm_rank(Proc->CommGrid, &Rank);
if(Rank==0){
#endif
FILE *FWrite = fopen(FTens,"w");
fprintf(FWrite,"# l(%.1f %.1f %.1f) r(%.2f %.2f %.2f) v[%d] d[color]\n",pEdge(0),pEdge(1),pEdge(2),Tens.RefPos[0],Tens.RefPos[1],Tens.RefPos[2],Tens.NSlab);
for(int sx=0;sx<Tens.NSlab;sx++){
double x = sx*InvValues*pEdge(CLat1);
for(int sy=0;sy<Tens.NSlab;sy++){
double y = sy*InvValues*pEdge(CLat2);
for(int sz=0;sz<Tens.NSlab;sz++){
double z = sz*InvValues*pEdge(CNorm);
int v = (sx*Tens.NSlab+sy)*Tens.NSlab+sz;
if(Tens.Dens[0][v] <= 0 && Tens.Dens[1][v] <= 0 && ABS(Tens.Pre[Comp][v]) <= 0) continue;
fprintf(FWrite,"{x(%.3f %.3f %.3f)",x,y,z);
fprintf(FWrite," v( %lf %.2f %.2f)}\n",
-Tens.Pre[Comp][v]*InvNFile*InvVolume,
Tens.Dens[0][v]*InvNFile*InvVolume,
Tens.Dens[1][v]*InvNFile*InvVolume);
}
}
}
fclose(FWrite);
for(int s=0;s<CUB(Tens.NSlab);s++){
Tens.Pre[Comp][s] = 0.;
Tens.Dens[0][s] = 0.;
Tens.Dens[1][s] = 0.;
}
}
#ifdef OMPI_MPI_H
}
#endif
}
int rho_factor(unsigned long *factors, mpz_t n)
/********************************************************************/
{ int numFactors=0, res, sorted=1, i, retVal;
static mpz_t stack[32];
static int initialized=0, stackSize=0;
long c;
if (!(initialized)) {
mpz_init(div1); mpz_init(div2); mpz_init(remain);
for (i=0; i<32; i++) mpz_init(stack[i]);
initialized=1;
}
if (mpz_cmp_ui(n, 1)==0) {
factors[0]=1; return 0;
}
mpz_abs(remain, n);
while (mpz_even_p(remain)) {
factors[numFactors++]=2;
mpz_tdiv_q_2exp(remain, remain, 1);
}
if (mpz_probab_prime_p(remain, 1)) {
if (mpz_fits_ulong_p(remain)) {
factors[numFactors++] = mpz_get_ui(remain);
return numFactors;
} else return -1;
}
/* 50000 is sufficient for all primes below 100,000,000. */
c = 1;
do {
if (c <= 2)
res = prho(div1, div2, remain, c, 50000);
else
res = prho(div1, div2, remain, c, c*50000);
c++;
} while (res && (c <4));
if (res) {
#define _QUIET
#ifndef _QUIET
printf("Gave up on factoring "); mpz_out_str(stdout, 10, remain);
printf(" (useTrialDivision = %d)\n", useTrialDivision);
#endif
return -1;
}
if (mpz_cmp(div1, div2) > 0) mpz_swap(div1, div2);
if (mpz_probab_prime_p(div1, 1)) {
if (mpz_fits_ulong_p(div1)) {
factors[numFactors++] = mpz_get_ui(div1);
} else return -1; /* Prime factor that doesn't fit in a long. */
} else {
mpz_set(stack[stackSize++], div2);
retVal = rho_factor(&factors[numFactors], div1);
mpz_set(div2, stack[--stackSize]);
if (retVal >=0) numFactors += retVal;
else return retVal;
}
if (mpz_probab_prime_p(div2, 1)) {
if (mpz_fits_ulong_p(div2)) {
factors[numFactors++] = mpz_get_ui(div2);
} else return -1; /* Prime factor that doesn't fit in a long. */
} else {
retVal = rho_factor(&factors[numFactors], div2);
if (retVal >=0) numFactors += retVal;
else return retVal;
}
/* Here we should sort the factors. */
for (i=0; i<(numFactors-1); i++)
if (factors[i] > factors[i+1])
sorted=0;
if (!(sorted)) {
/***********************************************************/
/* This will only happen very very rarely, so it's ok to */
/* use quick sort, even though it's only a small number of */
/* integers, and we could sort it much faster in an ad-hoc */
/* way. */
/***********************************************************/
qsort(factors, numFactors, sizeof(long), cmpUL);
}
return numFactors;
}
