void test_rq(size_t m, size_t n){
typedef typename RNP::Traits<T>::real_type real_type;
real_type rsnrm(1./((m*n) * RNP::Traits<real_type>::eps()));
T *A = new T[m*n];
for(size_t j = 0; j < n; ++j){
RNP::Random::GenerateVector(RNP::Random::Distribution::Uniform_11, m, &A[0+j*m]);
}
T *Afac = new T[m*n];
// Workspace
T *B = new T[m*n];
if(0){
std::cout << "Original A:" << std::endl;
RNP::Matrix<T> mA(m, n, A, m);
std::cout << RNP::IO::Chop(mA) << std::endl << std::endl;
}
T *tau = new T[m];
T *work = NULL;
size_t lwork = 0;
RNP::BLAS::Copy(m, n, A, m, Afac, m);
RNP::LA::RQ::Factor(m, n, Afac, m, tau, &lwork, work);
//lwork = m;
std::cout << "lwork = " << lwork << std::endl;
work = new T[lwork];
RNP::LA::RQ::Factor(m, n, Afac, m, tau, &lwork, work);
//RNP::LA::RQ::Factor_unblocked(m, n, Afac, m, tau, work);
//int info; zgerq2_(m, n, Afac, m, tau, work, &info);
//int info;
if(0){
std::cout << "Factored A:" << std::endl;
RNP::Matrix<T> mA(m, n, Afac, m);
std::cout << RNP::IO::Chop(mA) << std::endl << std::endl;
}
// Apply Q' to the right of original A (use B for workspace)
RNP::BLAS::Copy(m, n, A, m, B, m);
delete [] work; work = NULL; lwork = 0;
RNP::LA::RQ::MultQ("R", "C", m, n, m, Afac, m, tau, B, m, &lwork, work);
//lwork = m;
work = new T[lwork];
RNP::LA::RQ::MultQ("R", "C", m, n, m, Afac, m, tau, B, m, &lwork, work);
//RNP::LA::RQ::MultQ_unblocked("R", "C", m, n, n, &Afac[m-n+0*m], m, tau, B, m, work);
//dormr2_("R", "T", m, n, n, &Afac[m-n+0*m], m, tau, B, m, work, &info);
//zunmr2_("R", "C", m, n, n, &Afac[m-n+0*m], m, tau, B, m, work, &info);
if(0){
std::cout << "Q' * origA:" << std::endl;
RNP::Matrix<T> mB(m, n, B, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
// Check to see if the upper trapezoid is correct
if(1){
T sum = 0;
for(size_t j = n-m; j < n; ++j){
size_t i;
for(i = 0; i <= j-(n-m); ++i){
sum += RNP::Traits<T>::abs(Afac[i+j*m] - B[i+j*m]);
}
for(; i < m; ++i){ // check for zero lower triangle
sum += RNP::Traits<T>::abs(B[i+j*m]);
}
}
std::cout << "R norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Apply Q to the right of R
RNP::BLAS::Set(m, n, T(0), T(0), B, m);
RNP::LA::Triangular::Copy("U", m, m, &Afac[0+(n-m)*m], m, &B[0+(n-m)*m], m);
if(0){
std::cout << "B = R:" << std::endl;
RNP::Matrix<T> mB(m, n, B, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
RNP::LA::RQ::MultQ("R", "N", m, n, m, Afac, m, tau, B, m, &lwork, work);
if(0){
std::cout << "B = R*Q:" << std::endl;
RNP::Matrix<T> mB(m, n, B, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
// We should recover the original matrix
if(1){
T sum = 0;
for(size_t j = 0; j < n; ++j){
for(size_t i = 0; i < m; ++i){
sum += RNP::Traits<T>::abs(A[i+j*m] - B[i+j*m]);
}
}
std::cout << "(A - R*Q) norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Now treat B as a n-by-m matrix, and copy A' into it,
// and apply Q from the left
for(size_t j = 0; j < m; ++j){
for(size_t i = 0; i < n; ++i){
B[i+j*n] = RNP::Traits<T>::conj(A[j+i*m]);
}
}
if(0){
std::cout << "B = A':" << std::endl;
RNP::Matrix<T> mB(n, m, B, n);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
RNP::LA::RQ::MultQ("L", "N", n, m, m, Afac, m, tau, B, n, &lwork, work);
if(0){
std::cout << "B = R':" << std::endl;
RNP::Matrix<T> mB(n, m, B, n);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
// We should recover R'
if(1){
T sum = 0;
for(size_t j = n-m; j < n; ++j){
for(size_t i = 0; i <= j-(n-m); ++i){
sum += RNP::Traits<T>::abs(Afac[i+j*m] - RNP::Traits<T>::conj(B[j+i*n]));
}
}
std::cout << "R' norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Now set B = L', and apply Q' from the left to get A'
RNP::BLAS::Set(n, m, T(0), T(0), B, n);
for(size_t j = n-m; j < n; ++j){
for(size_t i = 0; i <= j-(n-m); ++i){
B[j+i*n] = RNP::Traits<T>::conj(Afac[i+j*m]);
}
}
RNP::LA::RQ::MultQ("L", "C", n, m, m, Afac, m, tau, B, n, &lwork, work);
// We should recover A'
if(1){
T sum = 0;
for(size_t j = 0; j < n; ++j){
for(size_t i = 0; i < m; ++i){
sum += RNP::Traits<T>::abs(A[i+j*m] - RNP::Traits<T>::conj(B[j+i*n]));
}
}
std::cout << "A' norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Make Q
T *Q = new T[n*n];
RNP::BLAS::Copy(m, n, Afac, m, Q, m);
delete [] work; work = NULL; lwork = 0;
RNP::LA::RQ::GenerateQ(m, n, m, Q, m, tau, &lwork, work);
//lwork = n;
work = new T[lwork];
RNP::LA::RQ::GenerateQ(m, n, m, Q, m, tau, &lwork, work);
//RNP::LA::RQ::GenerateQ_unblocked(m, n, m, Q, m, tau, work);
if(0){
std::cout << "Q:" << std::endl;
RNP::Matrix<T> mQ(m, n, Q, m);
std::cout << RNP::IO::Chop(mQ) << std::endl << std::endl;
}
// Form Q'*Q
T *QQ = new T[n*n];
RNP::BLAS::MultMM("N", "C", m, m, n, 1., Q, m, Q, m, 0., QQ, m);
if(0){
std::cout << "Q' * Q:" << std::endl;
RNP::Matrix<T> mQQ(m, m, QQ, m);
std::cout << RNP::IO::Chop(mQQ) << std::endl << std::endl;
}
// Check to see if we get I
if(1){
T sum = 0;
for(size_t j = 0; j < m; ++j){
for(size_t i = 0; i < m; ++i){
T delta = (i == j ? 1 : 0);
sum += RNP::Traits<T>::abs(QQ[i+j*m] - delta);
}
}
std::cout << "Q' * Q - I norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Form R*Q in B
// Form R in QQ
RNP::BLAS::Set(m, m, T(0), T(0), QQ, m);
RNP::LA::Triangular::Copy("U", m, m, &Afac[0+(n-m)*m], m, QQ, m);
if(0){
std::cout << "QQ = R:" << std::endl;
RNP::Matrix<T> mB(m, m, QQ, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
RNP::BLAS::MultMM("N", "N", m, n, m, T(1), QQ, m, Q, m, T(0), B, m);
if(0){
std::cout << "B = R*Q:" << std::endl;
RNP::Matrix<T> mB(m, n, B, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
// We should recover the original matrix
if(1){
T sum = 0;
for(size_t j = 0; j < n; ++j){
for(size_t i = 0; i < m; ++i){
sum += RNP::Traits<T>::abs(A[i+j*m] - B[i+j*m]);
}
}
std::cout << "(A - R*Q) norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Generate the rows of Q corresponding to the nullspace of A
RNP::BLAS::Set(n, n, T(0), T(1), Q, n);
RNP::LA::RQ::MultQ("L", "N", n, n, m, Afac, m, tau, Q, n, &lwork, work);
if(0){
std::cout << "Q:" << std::endl;
RNP::Matrix<T> mQ(n, n, Q, n);
std::cout << RNP::IO::Chop(mQ) << std::endl << std::endl;
}
// The first n-m rows of Q span the nullspace of A
RNP::BLAS::MultMM("N", "C", m, n-m, n, T(1), A, m, Q, n, T(0), QQ, m);
if(1){
T sum = 0;
for(size_t j = 0; j < n-m; ++j){
for(size_t i = 0; i < m; ++i){
sum += RNP::Traits<T>::abs(QQ[i+j*m]);
}
}
std::cout << "A*Qn norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
delete [] QQ;
delete [] Q;
delete [] B;
delete [] Afac;
delete [] A;
delete [] tau;
delete [] work;
}
void test_ql(size_t m, size_t n){
typedef typename RNP::Traits<T>::real_type real_type;
real_type rsnrm(1./((m*n) * RNP::Traits<real_type>::eps()));
T *A = new T[m*n];
for(size_t j = 0; j < n; ++j){
RNP::Random::GenerateVector(RNP::Random::Distribution::Uniform_11, m, &A[0+j*m]);
}
T *Afac = new T[m*n];
// Workspace
T *B = new T[m*n];
if(0){
std::cout << "Original A:" << std::endl;
RNP::Matrix<T> mA(m, n, A, m);
std::cout << RNP::IO::Chop(mA) << std::endl << std::endl;
}
T *tau = new T[m];
T *work = NULL;
size_t lwork = 0;
RNP::BLAS::Copy(m, n, A, m, Afac, m);
RNP::LA::QL::Factor(m, n, Afac, m, tau, &lwork, work);
//lwork = n;
std::cout << "lwork = " << lwork << std::endl;
work = new T[lwork];
RNP::LA::QL::Factor(m, n, Afac, m, tau, &lwork, work);
//int info; dgeql2_(m, n, Afac, m, tau, work, &info); std::cout << "info = " << info << std::endl;
if(0){
std::cout << "Factored A:" << std::endl;
RNP::Matrix<T> mA(m, n, Afac, m);
std::cout << RNP::IO::Chop(mA) << std::endl << std::endl;
}
// Apply Q' to the left of original A (use B for workspace)
RNP::BLAS::Copy(m, n, A, m, B, m);
delete [] work; work = NULL; lwork = 0;
RNP::LA::QL::MultQ("L", "C", m, n, m, &Afac[0+(n-m)*m], m, tau, B, m, &lwork, work);
//lwork = n;
work = new T[lwork];
RNP::LA::QL::MultQ("L", "C", m, n, m, &Afac[0+(n-m)*m], m, tau, B, m, &lwork, work);
//dorm2l_("L", "T", m, n, m, &Afac[0+(n-m)*m], m, tau, B, m, work, &info); std::cout << "info = " << info << std::endl;
if(0){
std::cout << "Q' * origA:" << std::endl;
RNP::Matrix<T> mB(m, n, B, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
// Check to see if the lower triangle is correct
if(1){
T sum = 0;
for(size_t j = 0; j < n; ++j){
const size_t i0 = (j > n-m ? j-(n-m) : 0);
for(size_t i = i0; i < m; ++i){
sum += RNP::Traits<T>::abs(Afac[i+j*m] - B[i+j*m]);
}
}
std::cout << "L norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Apply Q to the left of L
RNP::BLAS::Set(m, n, T(0), T(0), B, m);
RNP::BLAS::Copy(m, n-m, Afac, m, B, m);
RNP::LA::Triangular::Copy("L", m, m, &Afac[0+(n-m)*m], m, &B[0+(n-m)*m], m);
if(0){
std::cout << "B = L:" << std::endl;
RNP::Matrix<T> mB(m, n, B, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
RNP::LA::QL::MultQ("L", "N", m, n, m, &Afac[0+(n-m)*m], m, tau, B, m, &lwork, work);
if(0){
std::cout << "B = Q*L:" << std::endl;
RNP::Matrix<T> mB(m, n, B, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
// We should recover the original matrix
if(1){
T sum = 0;
for(size_t j = 0; j < n; ++j){
for(size_t i = 0; i < m; ++i){
sum += RNP::Traits<T>::abs(A[i+j*m] - B[i+j*m]);
}
}
std::cout << "(A - Q*L) norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Now treat B as a n-by-m matrix, and copy A' into it,
// and apply Q from the right
for(size_t j = 0; j < m; ++j){
for(size_t i = 0; i < n; ++i){
B[i+j*n] = RNP::Traits<T>::conj(A[j+i*m]);
}
}
if(0){
std::cout << "B = A':" << std::endl;
RNP::Matrix<T> mB(n, m, B, n);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
RNP::LA::QL::MultQ("R", "N", n, m, m, &Afac[0+(n-m)*m], m, tau, B, n, &lwork, work);
if(0){
std::cout << "B = L':" << std::endl;
RNP::Matrix<T> mB(n, m, B, n);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
// We should recover L'
if(1){
T sum = 0;
for(size_t j = 0; j < n; ++j){
const size_t i0 = (j > n-m ? j-(n-m) : 0);
for(size_t i = i0; i < m; ++i){
sum += RNP::Traits<T>::abs(Afac[i+j*m] - RNP::Traits<T>::conj(B[j+i*n]));
}
}
std::cout << "L' norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Now set B = L', and apply Q' from the right to get A'
RNP::BLAS::Set(n, m, T(0), T(0), B, n);
for(size_t j = 0; j < n; ++j){
const size_t i0 = (j > n-m ? j-(n-m) : 0);
for(size_t i = i0; i < m; ++i){
B[j+i*n] = RNP::Traits<T>::conj(Afac[i+j*m]);
}
}
RNP::LA::QL::MultQ("R", "C", n, m, m, &Afac[0+(n-m)*m], m, tau, B, n, &lwork, work);
// We should recover A'
if(1){
T sum = 0;
for(size_t j = 0; j < n; ++j){
for(size_t i = 0; i < m; ++i){
sum += RNP::Traits<T>::abs(A[i+j*m] - RNP::Traits<T>::conj(B[j+i*n]));
}
}
std::cout << "A' norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Make Q
T *Q = new T[m*m];
RNP::BLAS::Copy(m, m, &Afac[0+(n-m)*m], m, Q, m);
delete [] work; work = NULL; lwork = 0;
RNP::LA::QL::GenerateQ(m, m, m, Q, m, tau, &lwork, work);
//lwork = n;
work = new T[lwork];
RNP::LA::QL::GenerateQ(m, m, m, Q, m, tau, &lwork, work);
if(0){
std::cout << "Q:" << std::endl;
RNP::Matrix<T> mQ(m, m, Q, m);
std::cout << RNP::IO::Chop(mQ) << std::endl << std::endl;
}
// Form Q'*Q
T *QQ = new T[m*n];
RNP::BLAS::MultMM("C", "N", m, m, m, 1., Q, m, Q, m, 0., QQ, m);
if(0){
std::cout << "Q' * Q:" << std::endl;
RNP::Matrix<T> mQQ(m, m, QQ, m);
std::cout << RNP::IO::Chop(mQQ) << std::endl << std::endl;
}
// Check to see if we get I
if(1){
T sum = 0;
for(size_t j = 0; j < m; ++j){
for(size_t i = 0; i < m; ++i){
T delta = (i == j ? 1 : 0);
sum += RNP::Traits<T>::abs(QQ[i+j*m] - delta);
}
}
std::cout << "Q' * Q - I norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
// Form Q*L
// Put L in QQ for now
RNP::BLAS::Set(m, n, T(0), T(0), QQ, m);
RNP::BLAS::Copy(m, n-m, Afac, m, QQ, m);
RNP::LA::Triangular::Copy("L", m, m, &Afac[0+(n-m)*m], m, &QQ[0+(n-m)*m], m);
if(0){
std::cout << "QQ = L:" << std::endl;
RNP::Matrix<T> mB(m, n, QQ, n);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
RNP::BLAS::MultMM("N", "N", m, n, m, T(1), Q, m, QQ, m, T(0), B, m);
if(0){
std::cout << "B = Q*L:" << std::endl;
RNP::Matrix<T> mB(m, n, B, m);
std::cout << RNP::IO::Chop(mB) << std::endl << std::endl;
}
// We should recover the original matrix
if(1){
T sum = 0;
for(size_t j = 0; j < n; ++j){
for(size_t i = 0; i < m; ++i){
sum += RNP::Traits<T>::abs(A[i+j*m] - B[i+j*m]);
}
}
std::cout << "(A - Q*L) norm-1 error: " << std::abs(sum)*rsnrm << std::endl;
}
delete [] QQ;
delete [] Q;
delete [] B;
delete [] Afac;
delete [] A;
delete [] tau;
delete [] work;
}
void CILDMModifiedMethod::step(const double & deltaT)
{
C_INT dim = mData.dim;
C_INT fast = 0;
C_INT slow = dim - fast;
C_INT slow2, fast2;
slow2 = dim;
fast2 = dim - slow2;
C_INT i, j;
mY_initial.resize(dim);
mJacobian_initial.resize(dim, dim);
mQ.resize(dim, dim);
mR.resize(dim, dim);
mTd.resize(dim, dim);
mTdInverse.resize(dim, dim);
mQz.resize(dim, dim);
mTd_save.resize(dim, dim);
mTdInverse_save.resize(dim, dim);
mpModel->updateSimulatedValues(mReducedModel);
// TO REMOVE : mpModel->applyAssignments();
mpModel->calculateJacobianX(mJacobian, 1e-6, 1e-12);
C_INT flag_jacob;
flag_jacob = 1; // Set flag_jacob=0 to print Jacobian
C_FLOAT64 number2conc = mpModel->getNumber2QuantityFactor() / mpModel->getCompartments()[0]->getInitialValue();
//C_FLOAT64 number2conc = 1.;
//this is an ugly hack that only makes sense if all metabs are in the same compartment
//at the moment is is the only case the algorithm deals with
CVector<C_FLOAT64> Xconc; //current state converted to concentrations
Xconc.resize(dim);
for (i = 0; i < dim; ++i)
Xconc[i] = mY[i] * number2conc;
for (i = 0; i < dim; i++)
mY_initial[i] = mY[i];
CVector<C_FLOAT64> Xconc_initial; //current state converted to concentrations
Xconc_initial.resize(dim);
for (i = 0; i < dim; ++i)
Xconc_initial[i] = mY_initial[i] * number2conc;
// save initial Jacobian before next time step
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
mJacobian_initial(i, j) = mJacobian(i, j);
// Next time step
integrationStep(deltaT);
mpModel->updateSimulatedValues(mReducedModel);
// TO REMOVE : mpModel->applyAssignments();
// Calculate Jacobian for time step control
mpModel->calculateJacobianX(mJacobian, 1e-6, 1e-12);
//CMatrix<C_FLOAT64> mTd_save;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTd_save(i, j) = 0;
mTdInverse_save(i, j) = 0;
}
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTd(i, j) = 0;
mTdInverse(i, j) = 0;
}
/** Schur Decomposition of Jacobian (reordered).
Output: mQ - transformation matrix mR - block upper triangular matrix (with ordered eigenvalues) */
C_INT failed = 0;
C_INT info_schur = 0;
C_INT number, k;
C_INT failed_while = 0;
C_INT flag_deufl;
flag_deufl = 1;
C_FLOAT64 max = 0.;
//C_FLOAT64 max = 0;
CVector<C_FLOAT64> re;
CVector<C_FLOAT64> dxdt_relax;
CVector<C_FLOAT64> x_relax;
CVector<C_FLOAT64> x_help;
CVector<C_FLOAT64> dxdt;
CVector<C_FLOAT64> x_zero;
CVector<C_FLOAT64> dxdt_zero;
CVector<C_FLOAT64> dxdt_real;
CVector<C_FLOAT64> help;
CVector<C_INT> index;
CVector<C_INT> index_temp;
CMatrix<C_FLOAT64> orthog_prove;
orthog_prove.resize(dim, dim);
C_INT info;
CVector<C_INT> index_metab;
index_metab.resize(dim);
/** Schur transformation of Jacobian */
schur(info_schur);
if (info_schur)
{
CCopasiMessage(CCopasiMessage::WARNING,
MCTSSAMethod + 9, mTime - deltaT);
goto integration;
}
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
mTdInverse(i, j) = mQ(j, i);
C_INT flag_schur;
flag_schur = 1; // set flag_schur = 0 to print Schur decomposition of jacobian (matrices mR and transformation mQ)
mY_cons.resize(dim); // consistent initial vector for DAE
/* If complex eigenvalues */
//BUG 873
if (mR(dim - 1, dim - 1) == mR(dim - 2 , dim - 2))
if (dim == 2)
{
slow = dim;
goto integration;
}
// If positive eigenvalues
if (mR(dim - 1, dim - 1) >= 0)
{
slow = dim;
fast = 0;
CCopasiMessage(CCopasiMessage::WARNING,
MCTSSAMethod + 10, mTime - deltaT);
failed = 1;
goto integration;
}
// Iterations to determine the number of slow metabolites
while ((slow2 > 1))
{
slow2 = slow2 - 1;
fast2 = dim - slow2;
if (mR(dim - fast2, dim - fast2) >= 0)
{
failed = 1;
goto integration;
}
deuflhard_metab(slow2, info);
if (info)
{
failed_while = 1;
goto integration;
}
}
//end of iterations to determine the number of slow metabolites
/** end of the block %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
/** %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
integration:
slow = slow2;
fast = fast2;
if ((failed == 1) || (failed_while == 1))
{
if (slow < dim)
{
fast = fast - 1;
slow = dim - fast;
if ((fast >= 1) && (mR(slow - 1, slow - 1) == mR(slow , slow)))
fast = fast - 1;
slow = dim - fast;
}
}
mSlow = slow;
if (slow == dim)
CCopasiMessage(CCopasiMessage::WARNING,
MCTSSAMethod + 11, mTime);
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
// mTdInverse(i,j) = mQ(i,j);
mTd(i, j) = mQ(i, j);
// Flag for print Tabs
mat_anal_mod(slow);
mat_anal_metab(slow);
mat_anal_mod_space(slow);
mat_anal_fast_space(slow);
// This block proves which metabolite could be considered as QSS. In development
/** Begin of the block %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
C_INT flag_dev;
flag_dev = 1;
if (flag_dev == 0)
{
C_INT temp;
temp = dim - 1;
// Mode Analysis to find the dominant metabolites in the modes
mat_anal_mod(temp);
//index_metab = -1, if there is no dominant metabolites in corresponding mode,
//and is equal
// to the number of dominant metabolite in opposite case
// Dominant metabolite - its contribution to the mode is larger as 70%
for (j = 0; j < dim; j++)
index_metab[j] = -1;
for (i = 0; i < dim ; i ++)
for (j = 0; j < dim; j++)
if (mVslow(dim - i - 1, j) > 70)
index_metab[i] = j;
C_FLOAT64 y_cons;
info = 0;
k = 0;
number = index_metab[k];
if (number > - 1)
newton_for_timestep(number, y_cons, info);
while (k < dim - 1)
{
if (number > -1)
{
dxdt.resize(dim);
for (j = 0; j < dim; j++)
dxdt[j] = 0.;
//CVector<C_FLOAT64> x_help;
x_help.resize(dim);
for (j = 0; j < dim; j++)
{
x_help[j] = mY_initial[j] * number2conc;
}
calculateDerivativesX(x_help.array(), dxdt.array());
info = 0;
//NEWTON: Looking for consistent initial value for DAE system
//Output: y_cons, info
newton_for_timestep(number, y_cons, info);
if (info)
{
// TODO info: newton iteration stop
}
if (info == 0)
{
// CVector<C_FLOAT64> x_relax;
x_relax.resize(dim);
for (i = 0; i < dim; i ++)
if (i == number)
x_relax[i] = y_cons;
else
x_relax[i] = x_help[i];
//CVector<C_FLOAT64> dxdt_relax;
dxdt_relax.resize(dim);
calculateDerivativesX(x_relax.array(), dxdt_relax.array());
//CVector<C_FLOAT64> re;
re.resize(dim);
C_FLOAT64 eps;
eps = 1 / fabs(mR(dim - k - 1 , dim - k - 1));
// stop criterion for slow reaction modes
for (i = 0; i < dim; i++)
{
if (i == number)
re[i] = 0;
else
{
re[i] = fabs(dxdt_relax[i] - dxdt[i]);
re[i] = re[i] * eps;
}
}
//C_FLOAT64 max = 0.;
for (i = 0; i < dim; i++)
if (max < re[i])
max = re[i];
if (max >= mDtol)
info = 1;
else
info = 0;
}
}
k = k + 1;
number = index_metab[k];
max = 0;
}
}
/** end of the of block %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
/** %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
mpModel->updateSimulatedValues(mReducedModel);
// TO REMOVE : mpModel->applyAssignments();
// Calculate Jacobian for time step control
mpModel->calculateJacobianX(mJacobian, 1e-6, 1e-12);
// new entry for every entry contains the current data of currently step
setVectors(slow);
// set the stepcounter
mCurrentStep += 1;
return;
}
void CILDMMethod::step(const double & deltaT)
{
C_INT failed_while = 0;
C_INT dim = mData.dim;
C_INT fast = 0;
C_INT slow = dim - fast;
C_INT i, j, k, info_schur = 0;
mY_initial.resize(dim);
mJacobian_initial.resize(dim, dim);
mQ.resize(dim, dim);
mR.resize(dim, dim);
mQ_desc.resize(dim, dim);
mR_desc.resize(dim, dim);
mTd.resize(dim, dim);
mTdInverse.resize(dim, dim);
mQz.resize(dim, dim);
mTd_save.resize(dim, dim);
mTdInverse_save.resize(dim, dim);
mpModel->updateSimulatedValues(mReducedModel);
// TO REMOVE : mpModel->applyAssignments();
mpModel->calculateJacobianX(mJacobian, 1e-6, 1e-12);
C_INT flag_jacob;
flag_jacob = 1; // Set flag_jacob=0 to printing Jacobian
// To get the reduced Stoichiometry Matrix;
CMatrix<C_FLOAT64> Stoichiom;
Stoichiom = mpModel -> getRedStoi();
// const CCopasiVector< CReaction > & reacs = copasiModel->getReactions();
C_INT32 reacs_size = mpModel -> getRedStoi().size();
reacs_size = reacs_size / dim; //TODO what is this?
/* the vector mY is the current state of the system*/
C_FLOAT64 number2conc = 1.; //= mpModel->getNumber2QuantityFactor()
// / mpModel->getCompartments()[0]->getInitialValue();
//this is an ugly hack that only makes sense if all metabs are in the same compartment
//at the moment is is the only case the algorithm deals with
CVector<C_FLOAT64> Xconc; //current state converted to concentrations
Xconc.resize(dim);
for (i = 0; i < dim; ++i)
Xconc[i] = mY[i] * number2conc;
for (i = 0; i < dim; i++)
mY_initial[i] = mY[i];
CVector<C_FLOAT64> Xconc_initial; //current state converted to concentrations
Xconc_initial.resize(dim);
for (i = 0; i < dim; ++i)
Xconc_initial[i] = mY_initial[i] * number2conc;
// save initial Jacobian before next time step
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
mJacobian_initial(i, j) = mJacobian(i, j);
// Next time step
integrationStep(deltaT);
mpModel->updateSimulatedValues(mReducedModel);
// TO REMOVE : mpModel->applyAssignments();
// Calculate Jacobian for time step control
mpModel->calculateJacobianX(mJacobian, 1e-6, 1e-12);
#ifdef ILDMDEBUG
if (flag_jacob == 0)
{
std::cout << "Jacobian_next:" << std::endl;
std::cout << mJacobian << std::endl;
}
#endif
// to be removed
CMatrix<C_FLOAT64> Jacobian_for_test;
Jacobian_for_test.resize(dim, dim);
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
Jacobian_for_test(i, j) = mJacobian_initial(i, j);
// save initial Jacobian before next time step
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
mJacobian_initial(i, j) = mJacobian(i, j);
schur(info_schur);
#ifdef ILDMDEBUG
std::cout << "Eigenvalues of next Jacobian" << std::endl;
for (i = 0; i < dim; i++)
std::cout << mR(i, i) << std::endl;
#endif
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
mJacobian_initial(i, j) = Jacobian_for_test(i, j);
//end to be removed
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTd_save(i, j) = 0;
mTdInverse_save(i, j) = 0;
}
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTd(i, j) = 0;
mTdInverse(i, j) = 0;
}
/** Schur Decomposition of Jacobian (reordered).
Output: mQ - transformation matrix mR - block upper triangular matrix (with ordered eigenvalues) */
C_INT failed = 0;
// C_INT info_schur = 0;
schur(info_schur); // TO DO : move the test to the TSSAMethod
if (info_schur)
{
CCopasiMessage(CCopasiMessage::WARNING,
MCTSSAMethod + 5, mTime - deltaT);
goto integration;
}
C_INT flag_schur;
flag_schur = 0;
#ifdef ILDMDEBUG
std::cout << "Eigenvalues of initial Jacobian" << std::endl;
for (i = 0; i < dim; i++)
std::cout << mR(i, i) << std::endl;
if (flag_schur == 1)
{
std::cout << "Schur Decomposition" << std::endl;
std::cout << "mR - block upper triangular matrix :" << std::endl;
std::cout << mR << std::endl;
}
#endif
/* If complex eigenvalues */
//BUG 873
if (mR(dim - 1, dim - 1) == mR(dim - 2 , dim - 2))
if (dim == 2)
{
slow = dim;
goto integration;
}
// No reduction if the smallest eigenvalue is positive
if (mR(dim - 1, dim - 1) >= 0)
{
slow = dim;
fast = 0;
CCopasiMessage(CCopasiMessage::WARNING,
MCTSSAMethod + 6, mTime - deltaT);
failed = 1;
goto integration;
}
// C_INT number, k;
/** Classical ILDM iterations. The number of slow variables is decreased until the Deuflhard criterium holds */
/* do START slow iterations */
while (slow > 1)
{
fast = fast + 1;
slow = dim - fast;
if (fast < dim - 1)
if (mR(slow, slow) == mR(slow - 1 , slow - 1))
fast = fast + 1;
slow = dim - fast;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTd_save(i, j) = mTd(i, j);
mTdInverse_save(i, j) = mTdInverse(i, j);
}
C_INT info = 0;
failed_while = 0;
if (slow == 0)
{
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTdInverse(i, j) = mQ(j, i);
mTd(i, j) = mQ(i, j);
mQz(i, j) = mR(i, j);
}
}
else
{
/** Solution of Sylvester equation for given slow, mQ,mR
Output: mTd, mTdinverse and mQz (mQz is used later for newton iterations) */
sylvester(slow, info);
if (info)
{
CCopasiMessage(CCopasiMessage::WARNING,
MCTSSAMethod + 7, slow, mTime - deltaT);
failed_while = 1;
goto integration;
}
}
/* Check real parts of eigenvalues of Jacobian */
for (i = slow ; i < dim; i++)
if (mR(i , i) >= 0)
{
failed_while = 1;
goto integration;
}
if (fast > 0)
mEPS = 1 / fabs(mR(slow , slow));
mCfast.resize(fast);
/** Deuflhard Iteration: Prove Deuflhard criteria, find consistent initial value for DAE
output: info - if Deuflhard is satisfied for this slow;
transformation matrices mTd and mTdinverse */
info = 0;
C_INT help;
help = 0;
deuflhard(slow, info);
help = help + 1;
failed_while = 0;
if (info)
{
failed_while = 1;
goto integration;
}
}
/** end of iterations to find the number of slow modes */
integration:
if ((failed == 1) || (failed_while == 1))
{
if (slow < dim)
{
fast = fast - 1;
slow = dim - fast;
if ((fast >= 1) && (mR(slow - 1, slow - 1) == mR(slow , slow)))
fast = fast - 1;
slow = dim - fast;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTd(i, j) = mTd_save(i, j);
mTdInverse(i, j) = mTdInverse_save(i, j);
}
}
}
mSlow = slow;
if (slow == dim)
CCopasiMessage(CCopasiMessage::WARNING,
MCTSSAMethod + 8, mTime);
// test for orthogonality of the slow space
C_INT flag_orthog = 1;
if (flag_orthog == 0)
{
CMatrix<C_FLOAT64> orthog_prove;
orthog_prove.resize(dim, dim);
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
orthog_prove(i, j) = orthog(i, j);
}
C_INT flag_develop;
flag_develop = 0; //1;
if (flag_develop == 0)
{
C_INT info_schur_desc = 0;
/** Schur Decomposition of Jacobian (with another sorting: from fast to slow).
Output: mQ_desc - transformation matrix
mR_desc - block upper triangular matrix (with ordered eigenvalues) */
schur_desc(info_schur_desc);
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTd_save(i, j) = mTd(i, j);
mTdInverse_save(i, j) = mTdInverse(i, j);
}
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTdInverse(i, j) = mQ_desc(j, i);
mTd(i, j) = mQ_desc(i, j);
}
C_INT slow_desc;
slow_desc = fast;
mat_anal_fast_space(slow_desc);
mat_anal_mod_space(slow_desc);
CVector<C_FLOAT64> Reac_slow_space_orth;
Reac_slow_space_orth.resize(reacs_size);
for (i = 0; i < reacs_size; i ++)
{
Reac_slow_space_orth[i] = 0;
for (j = 0; j < dim; j++)
{
Reac_slow_space_orth[i] = Reac_slow_space_orth[i] + mVfast_space[j] * Stoichiom(j, i);
}
}
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
{
mTd(i, j) = mTd_save(i, j);
mTdInverse(i, j) = mTdInverse_save(i, j);
}
}
// end of test
// Post Analysis
mat_anal_mod(slow);
mat_anal_metab(slow);
mat_anal_mod_space(slow);
mat_anal_fast_space(slow);
/** This part corresponds to the investigation of fast and slow reactions. In development at
the moment. To activate the calculations take flag_develop = 0;
*/
if (flag_develop == 0)
{
CMatrix<C_FLOAT64> Slow_react_contr;
Slow_react_contr.resize(dim, reacs_size);
CMatrix<C_FLOAT64> Mode_react_contr;
Mode_react_contr.resize(dim, reacs_size);
CVector<C_FLOAT64> Reac_slow_space;
Reac_slow_space.resize(reacs_size);
CVector<C_FLOAT64> Reac_fast_space;
Reac_fast_space.resize(reacs_size);
mReacSlowSpace.resize(reacs_size); //NEW TAB
for (i = 0; i < dim; i ++)
for (j = 0; j < reacs_size; j++)
{
Slow_react_contr(i, j) = 0;
for (k = 0; k < dim; k++)
Slow_react_contr(i, j) = Slow_react_contr(i, j) + mVslow(i, k) * Stoichiom(k, j);
}
CVector<C_FLOAT64> denom_mode;
denom_mode.resize(dim);
for (j = 0; j < dim; j++)
denom_mode[j] = 0;
for (i = 0; i < dim; i++)
for (j = 0; j < reacs_size; j++)
denom_mode[i] = denom_mode[i] + fabs(Slow_react_contr(i, j));
for (i = 0; i < dim; i++)
for (j = 0; j < reacs_size; j++)
{
if (denom_mode[i] == 0)
Mode_react_contr(i, j) = 0;
else
Mode_react_contr(i, j) = (Slow_react_contr(i, j)) / denom_mode[i] * 100;
}
CVector<C_FLOAT64> denom_reac;
denom_reac.resize(reacs_size);
for (j = 0; j < reacs_size; j++)
denom_reac[j] = 0;
for (i = 0; i < reacs_size; i++)
for (j = 0; j < dim; j++)
denom_reac[i] = denom_reac[i] + fabs(Slow_react_contr(j, i));
for (i = 0; i < reacs_size; i++)
for (j = 0; j < dim; j++)
{
if (denom_reac[i] == 0)
Slow_react_contr(j, i) = 0;
else
Slow_react_contr(j, i) = (Slow_react_contr(j , i)) / denom_reac[i] * 100;
}
for (i = 0; i < reacs_size; i ++)
{
Reac_slow_space[i] = 0;
for (j = 0; j < dim; j++)
{
Reac_slow_space[i] = Reac_slow_space[i] + mVslow_space[j] * Stoichiom(j, i);
}
}
C_FLOAT64 length;
length = 0;
for (i = 0; i < reacs_size; i++)
length = length + fabs(Reac_slow_space[i]);
for (i = 0; i < reacs_size; i++)
if (length > 0)
mReacSlowSpace[i] = Reac_slow_space[i] / length * 100;
else
mReacSlowSpace[i] = 0;
for (i = 0; i < reacs_size; i ++)
{
Reac_fast_space[i] = 0;
for (j = 0; j < dim; j++)
Reac_fast_space[i] = Reac_fast_space[i] + mVfast_space[j] * Stoichiom(j, i);
}
length = 0;
for (i = 0; i < reacs_size; i++)
length = length + fabs(Reac_fast_space[i]);
for (i = 0; i < reacs_size; i++)
if (length > 0)
Reac_fast_space[i] = Reac_fast_space[i] / length * 100;
else
Reac_fast_space[i] = 0;
#ifdef ILDMDEBUG
std::cout << "**********************************************************" << std::endl;
std::cout << "**********************************************************" << std::endl;
std::cout << std::endl;
std::cout << std::endl;
#endif
mTMP1.resize(reacs_size, dim);
mTMP2.resize(reacs_size, dim);
mTMP3.resize(reacs_size, 1);
for (i = 0; i < dim; i++)
for (j = 0; j < reacs_size; j++)
{
mTMP1(j, i) = Mode_react_contr(i, j);
mTMP2(j, i) = Slow_react_contr(i, j);
}
for (j = 0; j < reacs_size; j++)
mTMP3(j, 0) = Reac_fast_space[j];
}
// End of reaction analysis
mpModel->updateSimulatedValues(mReducedModel);
// TO REMOVE : mpModel->applyAssignments();
// Calculate Jacobian for time step control
mpModel->calculateJacobianX(mJacobian, 1e-6, 1e-12);
// new entry for every entry contains the current data of currently step
setVectors(slow);
// set the stepcounter
mCurrentStep += 1;
return;
}
void denseFisherMetric::checkEvolution(const double epsilon)
{
baseHamiltonian::checkEvolution(epsilon);
// Metric
std::cout.precision(6);
int width = 12;
int nColumn = 6;
std::cout << "Gradient of the Fisher-Rao metric (dG^{jk}/dq^{i}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Component"
<< std::setw(width) << std::left << "Row"
<< std::setw(width) << std::left << "Column"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta /"
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "(j)"
<< std::setw(width) << std::left << "(k)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Stepsize^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
for(int k = 0; k < mDim; ++k)
{
fComputeG();
fComputeGradG(k);
MatrixXd temp = MatrixXd::Zero(mDim, mDim);
mQ(k) += epsilon;
fComputeG();
temp += mG;
mQ(k) -= 2.0 * epsilon;
fComputeG();
temp -= mG;
mQ(k ) += epsilon;
temp /= 2.0 * epsilon;
for(int i = 0; i < mDim; ++i)
{
for(int j = 0; j < mDim; ++j)
{
std::cout << " "
<< std::setw(width) << std::left << k
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << j
<< std::setw(width) << std::left << mGradG(i, j)
<< std::setw(width) << std::left << temp(i, j)
<< std::setw(width) << std::left << (mGradG(i, j) - temp(i, j)) / (epsilon * epsilon)
<< std::endl;
}
}
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
// Hamiltonian
fComputeCholeskyG();
mC = mGL.solve(mP);
gradV();
std::cout << "pDot (-dH/dq^{i}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Component"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta /"
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Stepsize^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
for(int i = 0; i < mDim; ++i)
{
// Finite Differences
double temp = 0.0;
mQ(i) += epsilon;
temp -= H();
mQ(i) -= 2.0 * epsilon;
temp += H();
mQ(i) += epsilon;
temp /= 2.0 * epsilon;
// Exact
fComputeGradG(i);
double minusGradH = -0.5 * mGL.solve(mGradG).trace();
mAuxVector = mGradG * mC;
minusGradH += 0.5 * mC.dot(mAuxVector);
minusGradH -= mGradV(i);
std::cout << " "
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << minusGradH
<< std::setw(width) << std::left << temp
<< std::setw(width) << std::left << (minusGradH - temp) / (epsilon * epsilon)
<< std::endl;
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
}
antlr::RefToken FMTLexer::nextToken()
{
antlr::RefToken theRetToken;
for (;;) {
antlr::RefToken theRetToken;
int _ttype = antlr::Token::INVALID_TYPE;
resetText();
try { // for lexical and char stream error handling
switch ( LA(1)) {
case 0x22 /* '\"' */ :
case 0x27 /* '\'' */ :
{
mSTRING(true);
theRetToken=_returnToken;
break;
}
case 0x28 /* '(' */ :
{
mLBRACE(true);
theRetToken=_returnToken;
break;
}
case 0x29 /* ')' */ :
{
mRBRACE(true);
theRetToken=_returnToken;
break;
}
case 0x2f /* '/' */ :
{
mSLASH(true);
theRetToken=_returnToken;
break;
}
case 0x2c /* ',' */ :
{
mCOMMA(true);
theRetToken=_returnToken;
break;
}
case 0x41 /* 'A' */ :
case 0x61 /* 'a' */ :
{
mA(true);
theRetToken=_returnToken;
break;
}
case 0x3a /* ':' */ :
{
mTERM(true);
theRetToken=_returnToken;
break;
}
case 0x24 /* '$' */ :
{
mNONL(true);
theRetToken=_returnToken;
break;
}
case 0x46 /* 'F' */ :
case 0x66 /* 'f' */ :
{
mF(true);
theRetToken=_returnToken;
break;
}
case 0x44 /* 'D' */ :
case 0x64 /* 'd' */ :
{
mD(true);
theRetToken=_returnToken;
break;
}
case 0x45 /* 'E' */ :
case 0x65 /* 'e' */ :
{
mE(true);
theRetToken=_returnToken;
break;
}
case 0x47 /* 'G' */ :
case 0x67 /* 'g' */ :
{
mG(true);
theRetToken=_returnToken;
break;
}
case 0x49 /* 'I' */ :
case 0x69 /* 'i' */ :
{
mI(true);
theRetToken=_returnToken;
break;
}
case 0x4f /* 'O' */ :
case 0x6f /* 'o' */ :
{
mO(true);
theRetToken=_returnToken;
break;
}
case 0x42 /* 'B' */ :
case 0x62 /* 'b' */ :
{
mB(true);
theRetToken=_returnToken;
break;
}
case 0x5a /* 'Z' */ :
{
mZ(true);
theRetToken=_returnToken;
break;
}
case 0x7a /* 'z' */ :
{
mZZ(true);
theRetToken=_returnToken;
break;
}
case 0x51 /* 'Q' */ :
case 0x71 /* 'q' */ :
{
mQ(true);
theRetToken=_returnToken;
break;
}
case 0x48 /* 'H' */ :
case 0x68 /* 'h' */ :
{
mH(true);
theRetToken=_returnToken;
break;
}
case 0x54 /* 'T' */ :
case 0x74 /* 't' */ :
{
mT(true);
theRetToken=_returnToken;
break;
}
case 0x4c /* 'L' */ :
case 0x6c /* 'l' */ :
{
mL(true);
theRetToken=_returnToken;
break;
}
case 0x52 /* 'R' */ :
case 0x72 /* 'r' */ :
{
mR(true);
theRetToken=_returnToken;
break;
}
case 0x58 /* 'X' */ :
case 0x78 /* 'x' */ :
{
mX(true);
theRetToken=_returnToken;
break;
}
case 0x2e /* '.' */ :
{
mDOT(true);
theRetToken=_returnToken;
break;
}
case 0x9 /* '\t' */ :
case 0x20 /* ' ' */ :
{
mWHITESPACE(true);
theRetToken=_returnToken;
break;
}
case 0x2b /* '+' */ :
case 0x2d /* '-' */ :
case 0x30 /* '0' */ :
case 0x31 /* '1' */ :
case 0x32 /* '2' */ :
case 0x33 /* '3' */ :
case 0x34 /* '4' */ :
case 0x35 /* '5' */ :
case 0x36 /* '6' */ :
case 0x37 /* '7' */ :
case 0x38 /* '8' */ :
case 0x39 /* '9' */ :
{
mNUMBER(true);
theRetToken=_returnToken;
break;
}
default:
if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x4d /* 'M' */ ) && (LA(3) == 0x4f /* 'O' */ ) && (LA(4) == 0x41 /* 'A' */ )) {
mCMOA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x4d /* 'M' */ ) && (LA(3) == 0x4f /* 'O' */ ) && (LA(4) == 0x49 /* 'I' */ )) {
mCMOI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x4d /* 'M' */ ) && (LA(3) == 0x6f /* 'o' */ )) {
mCMoA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x44 /* 'D' */ ) && (LA(3) == 0x49 /* 'I' */ )) {
mCDI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x4d /* 'M' */ ) && (LA(3) == 0x49 /* 'I' */ )) {
mCMI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x53 /* 'S' */ ) && (LA(3) == 0x49 /* 'I' */ )) {
mCSI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x53 /* 'S' */ ) && (LA(3) == 0x46 /* 'F' */ )) {
mCSF(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x44 /* 'D' */ ) && (LA(3) == 0x57 /* 'W' */ )) {
mCDWA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x44 /* 'D' */ ) && (LA(3) == 0x77 /* 'w' */ )) {
mCDwA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x41 /* 'A' */ ) && (LA(3) == 0x50 /* 'P' */ )) {
mCAPA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x41 /* 'A' */ ) && (LA(3) == 0x70 /* 'p' */ )) {
mCApA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x25 /* '%' */ ) && (LA(2) == 0x22 /* '\"' */ || LA(2) == 0x27 /* '\'' */ )) {
mCSTRING(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x6d /* 'm' */ )) {
mCmoA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x59 /* 'Y' */ )) {
mCYI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x48 /* 'H' */ )) {
mCHI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x68 /* 'h' */ )) {
mChI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x64 /* 'd' */ )) {
mCdwA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x61 /* 'a' */ )) {
mCapA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ || LA(1) == 0x63 /* 'c' */ ) && (true)) {
mC(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x25 /* '%' */ ) && (true)) {
mPERCENT(true);
theRetToken=_returnToken;
}
else {
if (LA(1)==EOF_CHAR)
{
uponEOF();
_returnToken = makeToken(antlr::Token::EOF_TYPE);
}
else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
}
}
if ( !_returnToken )
goto tryAgain; // found SKIP token
_ttype = _returnToken->getType();
_ttype = testLiteralsTable(_ttype);
_returnToken->setType(_ttype);
return _returnToken;
}
catch (antlr::RecognitionException& e) {
throw antlr::TokenStreamRecognitionException(e);
}
catch (antlr::CharStreamIOException& csie) {
throw antlr::TokenStreamIOException(csie.io);
}
catch (antlr::CharStreamException& cse) {
throw antlr::TokenStreamException(cse.getMessage());
}
tryAgain:;
}
}
void softAbsMetric::checkEvolution(const double epsilon)
{
baseHamiltonian::checkEvolution(epsilon);
// Hessian
std::cout.precision(6);
int width = 12;
int nColumn = 5;
std::cout << "Potential Hessian (d^{2}V/dq^{i}dq^{j}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Row"
<< std::setw(width) << std::left << "Column"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta / "
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "(j)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Stepsize^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
fComputeH();
for(int i = 0; i < mDim; ++i)
{
VectorXd temp = VectorXd::Zero(mDim);
mQ(i) += epsilon;
temp += gradV();
mQ(i) -= 2.0 * epsilon;
temp -= gradV();
mQ(i) += epsilon;
temp /= 2.0 * epsilon;
for(int j = 0; j < mDim; ++j)
{
std::cout << " "
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << j
<< std::setw(width) << std::left << mH(i, j)
<< std::setw(width) << std::left << temp(j)
<< std::setw(width) << std::left << (mH(i, j) - temp(j)) / (epsilon * epsilon)
<< std::endl;
}
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
// Gradient of the Hessian
std::cout.precision(6);
width = 12;
nColumn = 6;
std::cout << "Gradient of the Hessian (d^{3}V/dq^{i}dq^{j}dq^{k}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Component"
<< std::setw(width) << std::left << "Row"
<< std::setw(width) << std::left << "Column"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta /"
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "(j)"
<< std::setw(width) << std::left << "(k)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Stepsize^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
for(int k = 0; k < mDim; ++k)
{
mAuxMatrixOne.setZero();
mQ(k) += epsilon;
fComputeH();
mAuxMatrixOne += mH;
mQ(k) -= 2.0 * epsilon;
fComputeH();
mAuxMatrixOne -= mH;
mQ(k) += epsilon;
mAuxMatrixOne /= 2.0 * epsilon;
fComputeGradH(k);
for(int i = 0; i < mDim; ++i)
{
for(int j = 0; j < mDim; ++j)
{
std::cout << " "
<< std::setw(width) << std::left << k
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << j
<< std::setw(width) << std::left << mGradH.block(0, k * mDim, mDim, mDim)(i, j)
<< std::setw(width) << std::left << mAuxMatrixOne(i, j)
<< std::setw(width) << std::left << (mGradH.block(0, k * mDim, mDim, mDim)(i, j) - mAuxMatrixOne(i, j)) / (epsilon * epsilon)
<< std::endl;
}
}
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
// Metric
std::cout.precision(6);
width = 12;
nColumn = 6;
std::cout << "Gradient of the metric (dLambda^{jk}/dq^{i}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Component"
<< std::setw(width) << std::left << "Row"
<< std::setw(width) << std::left << "Column"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta /"
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "(j)"
<< std::setw(width) << std::left << "(k)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Epsilon^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
fComputeMetric();
fPrepareSpatialGradients();
for(int k = 0; k < mDim; ++k)
{
// Approximate metric gradient
MatrixXd temp = MatrixXd::Zero(mDim, mDim);
MatrixXd G = MatrixXd::Zero(mDim, mDim);
mQ(k) += epsilon;
fComputeMetric();
G.noalias() = mEigenDeco.eigenvectors() * mSoftAbsLambda.asDiagonal() * mEigenDeco.eigenvectors().transpose();
temp += G;
mQ(k) -= 2.0 * epsilon;
fComputeMetric();
G.noalias() = mEigenDeco.eigenvectors() * mSoftAbsLambda.asDiagonal() * mEigenDeco.eigenvectors().transpose();
temp -= G;
mQ(k) += epsilon;
temp /= 2.0 * epsilon;
// Exact metric gradient
fComputeMetric();
fComputeGradH(k);
mAuxMatrixOne.noalias() = mGradH.block(0, k * mDim, mDim, mDim) * mEigenDeco.eigenvectors();
mAuxMatrixTwo.noalias() = mEigenDeco.eigenvectors().transpose() * mAuxMatrixOne;
mAuxMatrixOne.noalias() = mPseudoJ.cwiseProduct(mAuxMatrixTwo);
mCacheMatrix.noalias() = mAuxMatrixOne * mEigenDeco.eigenvectors().transpose();
MatrixXd gradG = mEigenDeco.eigenvectors() * mCacheMatrix;
// Compare
for(int i = 0; i < mDim; ++i)
{
for(int j = 0; j < mDim; ++j)
{
std::cout << " "
<< std::setw(width) << std::left << k
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << j
<< std::setw(width) << std::left << gradG(i, j)
<< std::setw(width) << std::left << temp(i, j)
<< std::setw(width) << std::left << (gradG(i, j) - temp(i, j)) / (epsilon * epsilon)
<< std::endl;
}
}
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
// Hamiltonian
VectorXd gradH = dTaudq();
gradH += dPhidq();
std::cout << "pDot (-dH/dq^{i}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Component"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta /"
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Epsilon^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
for(int i = 0; i < mDim; ++i)
{
// Finite Differences
double temp = 0.0;
mQ(i) += epsilon;
temp -= H();
mQ(i) -= 2.0 * epsilon;
temp += H();
mQ(i) += epsilon;
temp /= 2.0 * epsilon;
// Exact
double minusGradH = -gradH(i);
std::cout << " "
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << minusGradH
<< std::setw(width) << std::left << temp
<< std::setw(width) << std::left << (minusGradH - temp) / (epsilon * epsilon)
<< std::endl;
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
}
