MATRIX_T *get_score_matrix(
char *score_filename, /* name of score file */
ALPH_T alph, /* alphabet */
int dist /* PAM distance (ignored if filename != NULL) */
)
{
char *alpha1; /* initial alphabet */
MATRIX_T *tmp; /* temporary score matrix */
MATRIX_T *matrix; /* score matrix */
assert(alph == DNA_ALPH || alph == PROTEIN_ALPH);
if (score_filename) { /* read matrix from file */
tmp = read_score_matrix(score_filename, &alpha1);
/* reorder the matrix to standard alphabet */
matrix = reorder_matrix(alpha1, alph_string(alph), tmp);
free_matrix(tmp);
free(alpha1);
} else { /* generate PAM matrix */
matrix = gen_pam_matrix(alph, dist, TRUE);
}
return(matrix);
} /* get_score_matrix */
std::shared_ptr<Matrix> MultiExcitonHamiltonian<VecType>::compute_inter_2e(DSubSpace& AB, DSubSpace& ApBp) {
const int nstatesA = AB.template nstates<0>();
const int nstatesB = AB.template nstates<1>();
const int nstates = nstatesA * nstatesB;
const int nstatesAp = ApBp.template nstates<0>();
const int nstatesBp = ApBp.template nstates<1>();
const int nstatesp = nstatesAp * nstatesBp;
// alpha-alpha
Matrix gamma_AA_alpha = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateAlpha, GammaSQ::CreateAlpha);
Matrix gamma_BB_alpha = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateAlpha, GammaSQ::CreateAlpha);
// beta-beta
Matrix gamma_AA_beta = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateBeta, GammaSQ::CreateBeta);
Matrix gamma_BB_beta = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateBeta, GammaSQ::CreateBeta);
// build J and K matrices
std::shared_ptr<const Matrix> Jmatrix = jop_->coulomb_matrix<0,1,0,1>();
std::shared_ptr<const Matrix> Kmatrix = jop_->coulomb_matrix<0,1,1,0>();
Matrix tmp(nstatesA*nstatesAp, nstatesB*nstatesBp);
tmp += (gamma_AA_alpha + gamma_AA_beta) * (*Jmatrix) ^ (gamma_BB_alpha + gamma_BB_beta);
tmp -= gamma_AA_alpha * (*Kmatrix) ^ gamma_BB_alpha;
tmp -= gamma_AA_beta * (*Kmatrix) ^ gamma_BB_beta;
auto out = std::make_shared<Matrix>(nstates, nstatesp);
reorder_matrix(tmp.data(), out->data(), nstatesA, nstatesAp, nstatesB, nstatesBp);
return out;
}
int main(int, char **)
{
srand(42);
std::cout << "-- Generating matrix --" << std::endl;
std::size_t dof_per_dim = 64; //number of grid points per coordinate direction
std::size_t n = dof_per_dim * dof_per_dim * dof_per_dim; //total number of unknowns
std::vector< std::map<int, double> > matrix = gen_3d_mesh_matrix(dof_per_dim, dof_per_dim, dof_per_dim, false); //If last parameter is 'true', a tetrahedral grid instead of a hexahedral grid is used.
/**
* Shuffle the generated matrix
**/
std::vector<int> r = generate_random_reordering(n);
std::vector< std::map<int, double> > matrix2 = reorder_matrix(matrix, r);
/**
* Print some statistics about the generated matrix:
**/
std::cout << " * Unknowns: " << n << std::endl;
std::cout << " * Initial bandwidth: " << calc_bw(matrix) << std::endl;
std::cout << " * Randomly reordered bandwidth: " << calc_bw(matrix2) << std::endl;
/**
* Reorder using Cuthill-McKee algorithm and print new bandwidth:
**/
std::cout << "-- Cuthill-McKee algorithm --" << std::endl;
r = viennacl::reorder(matrix2, viennacl::cuthill_mckee_tag());
r = viennacl::reorder(matrix2, viennacl::cuthill_mckee_tag());
std::cout << " * Reordered bandwidth: " << calc_reordered_bw(matrix2, r) << std::endl;
/**
* Reorder using advanced Cuthill-McKee algorithm and print new bandwidth:
**/
std::cout << "-- Advanced Cuthill-McKee algorithm --" << std::endl;
double a = 0.0;
std::size_t gmax = 1;
r = viennacl::reorder(matrix2, viennacl::advanced_cuthill_mckee_tag(a, gmax));
std::cout << " * Reordered bandwidth: " << calc_reordered_bw(matrix2, r) << std::endl;
/**
* Reorder using Gibbs-Poole-Stockmeyer algorithm and print new bandwidth:
**/
std::cout << "-- Gibbs-Poole-Stockmeyer algorithm --" << std::endl;
r = viennacl::reorder(matrix2, viennacl::gibbs_poole_stockmeyer_tag());
std::cout << " * Reordered bandwidth: " << calc_reordered_bw(matrix2, r) << std::endl;
/**
* That's it.
**/
std::cout << "!!!! TUTORIAL COMPLETED SUCCESSFULLY !!!!" << std::endl;
return EXIT_SUCCESS;
}
std::shared_ptr<Matrix> MultiExcitonHamiltonian<VecType>::compute_bbET(DSubSpace& AB, DSubSpace& ApBp) {
auto out = std::make_shared<Matrix>(AB.dimerstates(), ApBp.dimerstates());
Matrix gamma_A = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), GammaSQ::CreateBeta, GammaSQ::CreateBeta);
Matrix gamma_B = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateBeta, GammaSQ::AnnihilateBeta);
std::shared_ptr<const Matrix> Jmatrix = jop_->coulomb_matrix<0,0,1,1>();
Matrix tmp = gamma_A * (*Jmatrix) ^ gamma_B;
tmp *= -0.5;
reorder_matrix(tmp.data(), out->data(), AB.template nstates<0>(), ApBp.template nstates<0>(), AB.template nstates<1>(), ApBp.template nstates<1>());
return out;
}
std::shared_ptr<Matrix> MultiExcitonHamiltonian<VecType>::compute_bET(DSubSpace& AB, DSubSpace& ApBp) {
auto out = std::make_shared<Matrix>(AB.dimerstates(), ApBp.dimerstates());
Matrix tmp(AB.template nstates<0>() * ApBp.template nstates<0>(), AB.template nstates<1>() * ApBp.template nstates<1>());
// One-body bET
{
Matrix gamma_A = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), GammaSQ::CreateBeta);
Matrix gamma_B = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateBeta);
std::shared_ptr<const Matrix> Fmatrix = jop_->cross_mo1e();
tmp += gamma_A * (*Fmatrix) ^ gamma_B;
}
//Two-body bET, type 1
{
Matrix gamma_A = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), GammaSQ::CreateBeta);
Matrix gamma_B1 = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateAlpha, GammaSQ::AnnihilateBeta, GammaSQ::CreateAlpha);
Matrix gamma_B2 = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateBeta, GammaSQ::AnnihilateBeta, GammaSQ::CreateBeta);
std::shared_ptr<const Matrix> Jmatrix = jop_->coulomb_matrix<0,1,1,1>();
tmp -= gamma_A * (*Jmatrix) ^ (gamma_B1 + gamma_B2);
}
//Two-body aET, type 2
{
Matrix gamma_A1 = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateAlpha, GammaSQ::CreateAlpha, GammaSQ::CreateBeta);
Matrix gamma_A2 = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateBeta, GammaSQ::CreateBeta, GammaSQ::CreateBeta);
Matrix gamma_B = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateBeta);
std::shared_ptr<const Matrix> Jmatrix = jop_->coulomb_matrix<0,0,1,0>();
tmp += (gamma_A1 + gamma_A2) * (*Jmatrix) ^ gamma_B;
}
reorder_matrix(tmp.data(), out->data(), AB.template nstates<0>(), ApBp.template nstates<0>(), AB.template nstates<1>(), ApBp.template nstates<1>());
const int neleA = AB.template ci<0>()->det()->nelea() + AB.template ci<0>()->det()->neleb();
if ((neleA % 2) == 1) out->scale(-1.0);
return out;
}
std::shared_ptr<Matrix> MultiExcitonHamiltonian<VecType>::compute_abFlip(DSubSpace& AB, DSubSpace& ApBp) {
auto out = std::make_shared<Matrix>(AB.dimerstates(), ApBp.dimerstates());
const int nstatesA = AB.template nstates<0>();
const int nstatesAp = ApBp.template nstates<0>();
const int nstatesB = AB.template nstates<1>();
const int nstatesBp = ApBp.template nstates<1>();
Matrix gamma_A = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateAlpha, GammaSQ::CreateBeta);
Matrix gamma_B = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), GammaSQ::AnnihilateBeta, GammaSQ::CreateAlpha);
std::shared_ptr<const Matrix> Kmatrix = jop_->coulomb_matrix<0,1,1,0>();
Matrix tmp = gamma_A * (*Kmatrix) ^ gamma_B;
tmp *= -1.0;
reorder_matrix(tmp.data(), out->data(), nstatesA, nstatesAp, nstatesB, nstatesBp);
return out;
}
std::shared_ptr<Matrix> MultiExcitonHamiltonian<VecType>::compute_offdiagonal_1e(const DSubSpace& AB, const DSubSpace& ApBp, std::shared_ptr<const Matrix> hAB) const {
Coupling term_type = coupling_type(AB,ApBp);
GammaSQ operatorA;
GammaSQ operatorB;
int neleA = AB.template ci<0>()->det()->nelea() + AB.template ci<0>()->det()->neleb();
switch(term_type) {
case Coupling::aET :
operatorA = GammaSQ::CreateAlpha;
operatorB = GammaSQ::AnnihilateAlpha;
break;
case Coupling::inv_aET :
operatorA = GammaSQ::AnnihilateAlpha;
operatorB = GammaSQ::CreateAlpha;
--neleA;
break;
case Coupling::bET :
operatorA = GammaSQ::CreateBeta;
operatorB = GammaSQ::AnnihilateBeta;
break;
case Coupling::inv_bET :
operatorA = GammaSQ::AnnihilateBeta;
operatorB = GammaSQ::CreateBeta;
--neleA;
break;
default :
return std::make_shared<Matrix>(AB.dimerstates(), ApBp.dimerstates());
}
Matrix gamma_A = *gammaforest_->template get<0>(AB.offset(), ApBp.offset(), operatorA);
Matrix gamma_B = *gammaforest_->template get<1>(AB.offset(), ApBp.offset(), operatorB);
Matrix tmp = gamma_A * (*hAB) ^ gamma_B;
auto out = std::make_shared<Matrix>(AB.dimerstates(), ApBp.dimerstates());
reorder_matrix(tmp.data(), out->data(), AB.template nstates<0>(), ApBp.template nstates<0>(), AB.template nstates<1>(), ApBp.template nstates<1>());
if ( (neleA % 2) == 1 ) out->scale(-1.0);
return out;
}
