inline Matrix<T>
Riemann( Int n )
{
Matrix<T> R;
Riemann( R, n );
return R;
}
inline DistMatrix<T,U,V>
Riemann( const Grid& g, Int n )
{
DistMatrix<T,U,V> R(g);
Riemann( R, n );
return R;
}
void upwindGodunovStep() {
int i, j;
// find fluxes using Riemann solver
for (j = 0; j < N - 1; j++){
Riemann(U[j], U[j + 1], F[j]);
}
// update U
for (j = 1; j < N - 1; j++){
for (i = 0; i < 3; i++){
U[j][i] -= tau / h * (F[j][i] - F[j - 1][i]);
}
}
}
void upwindGodunovStep() {
int i, j;
// find fluxes using Riemann solver
for (j = 1; j < N - 1; j++){
/**************************************************************************/
//codigo modificado
/**************************************************************************/
if (cMax > 0)
Riemann(U[j], U[j + 1], F[j-1]);
else
Riemann(U[j], U[j + 1], F[j+1]);
/**************************************************************************/
//código original
/**************************************************************************/
// Riemann(U[j], U[j + 1], F[j]);
/**************************************************************************/
}
// update U
for (j = 1; j < N - 1; j++){
for (i = 0; i < 3; i++){
/**************************************************************************/
/*modificación de prueba*/
/**************************************************************************/
//if (cMax > 0)
//U[j][0] -= tau*(F[j][0] - F[j-1][0])/h;
//else
//U[j][0] -= tau*(F[j+1][0] - F[j][0])/h;
/**************************************************************************/
/**************************************************************************/
//código original
/**************************************************************************/
U[j][i] -= tau / h * (F[j][i] - F[j - 1][i]);
/**************************************************************************/
}
}
}
