void AMultiCF::agetX(CovarInput* Xout) const
{
//1. determine size of Xout
muint_t trows = Kdim();
muint_t tcols = getNumberDimensions();
(*Xout).resize(trows,tcols);
//2. loop through and fill
muint_t c0=0;
muint_t cols;
for(ACovarVec::const_iterator iter = vecCovariances.begin(); iter!=vecCovariances.end();iter++)
{
PCovarianceFunction cp = iter[0];
if (cp!=nullptr)
{
cols = cp->getNumberDimensions();
//ignore covariances with 0 columns
if (cols==0)
continue;
(*Xout).block(0,c0,trows,cols) = cp->getX();
//move pointer on
c0+=cols;
}
}
}
void AMultiCF::setXcol(const CovarInput& X,muint_t col)
{
if(((col+(muint_t)X.cols())>getNumberDimensions()) || ((muint_t)X.rows()!=this->Kdim()))
{
std::ostringstream os;
os << "setXcol out of range. Current X:"<<col<< "..."<<col+X.cols()<<" own:"<<this->getNumberDimensions() <<")";
throw CLimixException(os.str());
}
if (X.cols()>1)
{
std::ostringstream os;
os << "setXcol (Combinator CF) only suports setting individual columns" << "\n";
throw CLimixException(os.str());
}
muint_t c0=0;
muint_t cols;
//loop through covariances and assign
for(ACovarVec::iterator iter = vecCovariances.begin(); iter!=vecCovariances.end();iter++)
{
PCovarianceFunction cp = iter[0];
if (cp!=nullptr)
{
cols = cp->getNumberDimensions();
//skip covaraince with 0 dimensions
if (cols==0)
continue;
if ((c0+cols)>=col)
{
cp->setXcol(X,col-c0);
break;
}
c0+=cols;
}
}
}
inline std::vector<size_t> DataSpace::getDimensions() const{
std::vector<hsize_t> dims(getNumberDimensions());
if( H5Sget_simple_extent_dims(_hid, &(dims[0]), NULL) <0){
HDF5ErrMapper::ToException<DataSetException>("Unable to get dataspace dimensions");
}
std::vector<size_t> res(dims.size());
std::copy(dims.begin(), dims.end(), res.begin());
return res;
}
void HartenLaxLeerContactSolver::solve(FluidArray& F, const FluidArray& Q_l, const FluidArray& Q_r, double a_l2, double a_r2, double gamma, int dim) const {
std::pair<double, double> S = characteristicWaveSpeeds(a_l2, a_r2, Q_l, Q_r, gamma, dim);
double S_l = S.first;
double S_r = S.second;
int nd = getNumberDimensions();
if (S_l >= 0) {
FfromQ(F, Q_l, gamma, nd, dim);
}
else if (S_r <= 0) {
FfromQ(F, Q_r, gamma, nd, dim);
}
else {
double S_c = Q_r[UID::PRE]-Q_l[UID::PRE];
S_c += Q_l[UID::DEN]*Q_l[UID::VEL+dim]*(S_l-Q_l[UID::VEL+dim]);
S_c -= Q_r[UID::DEN]*Q_r[UID::VEL+dim]*(S_r-Q_r[UID::VEL+dim]);
S_c /= (Q_l[UID::DEN]*(S_l-Q_l[UID::VEL+dim])-Q_r[UID::DEN]*(S_r-Q_r[UID::VEL+dim]));
const FluidArray& Q_lr = (S_c >= 0) ? Q_l : Q_r;
double S_lr = (S_c >= 0) ? S_l : S_r;
FluidArray U_lr, F_lr;
for (unsigned int i = 0; i < U_lr.size(); ++i)
U_lr[i] = F_lr[i] = 0;
UfromQ(U_lr, Q_lr, gamma, nd);
FfromQ(F_lr, Q_lr, gamma, nd, dim);
double A_lr = Q_lr[UID::DEN]*(S_lr-Q_lr[UID::VEL+dim])/(S_lr-S_c);
FluidArray U_clr;
U_clr[UID::DEN] = A_lr;
for (int id = 0; id < nd; ++id)
U_clr[UID::VEL+id] = A_lr*Q_lr[UID::VEL+id];
U_clr[UID::VEL+dim] = A_lr*S_c;
U_clr[UID::PRE] = A_lr*((U_lr[UID::PRE]/Q_lr[UID::DEN]) + (S_c-Q_lr[UID::VEL+dim])*(S_c+Q_lr[UID::PRE]/(Q_lr[UID::DEN]*(S_lr-Q_lr[UID::VEL+dim]))));
U_clr[UID::HII] = A_lr*Q_lr[UID::HII];
U_clr[UID::ADV] = A_lr*Q_lr[UID::ADV];
for (int i = 0; i < UID::N; ++i)
F[i] = F_lr[i] + S_lr*(U_clr[i] - U_lr[i]);
if (nd < 3)
F[UID::VEL+2] = 0;
if (nd < 2)
F[UID::VEL+1] = 0;
}
if ( F[UID::HII] != F[UID::HII] ) {
std::stringstream out;
out << "HartenLaxLeerContactSolver::solve: HII flux is NaN\n";
for (int iu = 0; iu < UID::N; ++iu)
out << "F[" << iu << "] = " << F[iu] << '\n';
out << "Q_l is: \n" << printQ(Q_l) << "Q_r is: \n" << printQ(Q_r) << '\n';
throw std::runtime_error(out.str());
}
}
void HartenLaxLeerSolver::solve(FluidArray& F, const FluidArray& Q_l, const FluidArray& Q_r, double a_l2, double a_r2, double gamma, int dim) const {
std::pair<double, double> S = characteristicWaveSpeeds(a_l2, a_r2, Q_l, Q_r, gamma, dim);
double S_l = S.first;
double S_r = S.second;
if (S_r <= 0) {
FfromQ(F, Q_r, gamma, getNumberDimensions(), dim);
}
else if (S_l >= 0) {
FfromQ(F, Q_l, gamma, getNumberDimensions(), dim);
}
else {
FluidArray U_l, U_r, F_l, F_r;
for(int i = 0; i < UID::N; ++i)
U_l[i] = U_r[i] = F_l[i] = F_r[i] = 0;
UfromQ(U_l, Q_l, gamma, getNumberDimensions());
UfromQ(U_r, Q_r, gamma, getNumberDimensions());
FfromQ(F_l, Q_l, gamma, getNumberDimensions(), dim);
FfromQ(F_r, Q_r, gamma, getNumberDimensions(), dim);
for (int i = 0; i < UID::N; ++i)
F[i] = (S_r*F_l[i] - S_l*F_r[i] + S_l*S_r*(U_r[i]-U_l[i]))/(S_r-S_l);
}
if ( F[UID::HII] != F[UID::HII] ) {
std::stringstream out;
out << "HartenLaxLeerSolver::solve: HII flux is NaN.\n";
for (int iu = 0; iu < UID::N; ++iu)
out << "F[" << iu << "] = " << F[iu] << '\n';
out << "Q_l is: \n";
out << printQ(Q_l);
out << "Q_r is: \n";
out << printQ(Q_r) << '\n';
throw std::runtime_error(out.str());
}
}
