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; }