void test_energy_gradient(){
g = Array<double>(x.size());
gnum = Array<double>(g.size());
double e = pot->get_energy_gradient(x, g);
EXPECT_NEAR(e, etrue, 1e-10);
pot->numerical_gradient(x, gnum, 1e-6);
for (size_t k=0; k<6; ++k){
EXPECT_NEAR(g[k], gnum[k], 1e-6);
}
}
FindLowestEigenvalue::FindLowestEigenvalue(std::shared_ptr<pele::BasePotential> landscape_potential, const size_t boxdimension,
const pele::Array<double> ranvec, const size_t lbfgsniter)
: m_lowesteigpot(std::make_shared<pele::LowestEigPotential>(landscape_potential, ranvec.copy(), boxdimension)),
m_ranvec((ranvec.copy() /= norm(ranvec))),
m_lbfgs(m_lowesteigpot, m_ranvec.copy())
{
if (isinf(double(1) / norm(ranvec))) {
throw std::runtime_error("FindLowestEigenvalue: 1/norm(ranvec) is isinf");
}
m_lbfgs.set_max_iter(lbfgsniter);
}
MODIFIED_FIRE::MODIFIED_FIRE(std::shared_ptr<pele::BasePotential> potential,
pele::Array<double>& x0, double dtstart, double dtmax, double maxstep,
size_t Nmin, double finc, double fdec, double fa, double astart, double
tol, bool stepback)
: GradientOptimizer(potential,x0,tol), //call GradientOptimizer constructor
_dtstart(dtstart), _dt(dtstart),
_dtmax(dtmax), _maxstep(maxstep), _Nmin(Nmin),
_finc(finc), _fdec(fdec), _fa(fa),
_astart(astart), _a(astart), _fold(f_),
_ifnorm(0),_vnorm(0),
_v(x0.size(),0), _dx(x0.size()), _xold(x0.copy()),_gold(g_.copy()),
_fire_iter_number(0), _N(x_.size()),
_stepback(stepback)
{}
/*
* computes the static pressure tensor, ignoring the momenta of the atoms
* the momentum component can be added
* */
double pressure_tensor(std::shared_ptr<pele::BasePotential> pot_,
pele::Array<double> x,
pele::Array<double> ptensor,
const double volume)
{
pele::SimplePairwisePotentialInterface* pot = dynamic_cast<pele::SimplePairwisePotentialInterface*>(pot_.get());
if (pot == NULL) {
throw std::runtime_error("pressure_tensor: illegal potential");
}
const size_t ndim = pot->get_ndim();
const size_t natoms = x.size() / ndim;
if (ndim * natoms != x.size()) {
throw std::runtime_error("x is not divisible by the number of dimensions");
}
if (ptensor.size() != ndim * ndim) {
throw std::runtime_error("ptensor must have size ndim * ndim");
}
double gij;
double dr[ndim];
ptensor.assign(0.);
for (size_t atomi = 0; atomi < natoms; ++atomi) {
size_t const i1 = ndim * atomi;
for (size_t atomj = 0; atomj < atomi; ++atomj) {
size_t const j1 = ndim * atomj;
pot->get_rij(dr, &x[i1], &x[j1]);
double r2 = 0;
for (size_t k = 0; k < ndim; ++k) {
r2 += dr[k] * dr[k];
}
pot->get_interaction_energy_gradient(r2, &gij, atomi, atomj);
for (size_t k = 0; k < ndim; ++k) {
for (size_t l = k; l < ndim; ++l) {
ptensor[k * ndim + l] += dr[k] * gij * dr[l];
ptensor[l * ndim + k] = ptensor[k * ndim + l];
}
}
}
}
ptensor /= volume;
//pressure is the average of the trace of the pressure tensor divived by the volume, here we return only the trace
double traceP = 0.;
for (size_t i = 0; i < ndim; ++i) {
traceP += ptensor[i * ndim + i];
}
return traceP / ndim;
}
double bench_potential(std::shared_ptr<pele::BasePotential> pot, pele::Array<double> x, size_t neval)
{
auto grad = x.copy();
Timer t;
t.start();
for (size_t i = 0; i < neval; ++i) {
// change x by some amount and recompute the energy
double dx = .1;
if (i % 5 == 0) dx *= -1;
x[i % x.size()] += dx;
pot->get_energy_gradient(x, grad);
// if (i % 500 == 0) {
// std::cout << i << " energy " << energy << "\n";
// }
}
t.stop();
return t.get();
}
double GetDisplacementPerParticle::compute_mean_particle_displacement(pele::Array<double> new_coords)
{
if (new_coords.size() != m_initial_coordinates.size()) {
throw std::runtime_error("GetMeanRMSDisplacement::compute_mean_rsm_displacement: illegal new coords");
}
Moments mom;
for (size_t particle = 0; particle < m_nr_particles; ++particle) {
mom.update(get_particle_displ(particle, new_coords));
}
return mom.mean();
}
void RecordCoordsTimeseries::action(pele::Array<double> &coords, double energy, bool accepted, MC* mc)
{
if (coords.size() != m_ndof) {
throw std::runtime_error("RecordCoordsTimeseries::action: ndof and new coords have different size");
}
size_t counter = mc->get_iterations_count();
if (counter > m_eqsteps){
this->m_update_mean_coord_vector(coords);
if (counter % m_record_every == 0) {
m_record_vector_value(this->get_recorded_vector(coords, energy, accepted, mc));
}
}
}
void test_energy_gradient_hessian(){
g = Array<double>(x.size());
gnum = Array<double>(g.size());
h = Array<double>(x.size()*x.size());
hnum = Array<double>(h.size());
double e = pot->get_energy_gradient_hessian(x, g, h);
double ecomp = pot->get_energy(x);
pot->numerical_gradient(x, gnum);
pot->numerical_hessian(x, hnum);
EXPECT_NEAR(e, ecomp, 1e-10);
for (size_t i=0; i<g.size(); ++i){
ASSERT_NEAR(g[i], gnum[i], 1e-6);
}
for (size_t i=0; i<h.size(); ++i){
ASSERT_NEAR(h[i], hnum[i], 1e-3);
}
}
virtual void SetUp(){
c6 = 1.2;
c12 = 2.3;
rcut = 2.5;
natoms = 4;
ntypeA = 2;
atomsA = pele::Array<size_t>(ntypeA);
for (size_t i =0; i<atomsA.size(); ++i){
atomsA[i] = i;
}
size_t ntypeB = natoms - ntypeA;
atomsB = pele::Array<size_t>(ntypeB);
for (size_t i = 0; i<ntypeB; ++i){
atomsB[i] = i + ntypeA;
}
x = pele::Array<double>(3*natoms);
x[0] = 0.1;
x[1] = 0.2;
x[2] = 0.3;
x[3] = 0.44;
x[4] = 0.55;
x[5] = 1.66;
x[6] = 0;
x[7] = 0;
x[8] = -3.;
x[9] = 1.38;
x[10] = 0.55;
x[11] = 1.66;
x[9] = .4;
x[10] = 1.57;
x[11] = 1.66;
etrue = 0.65332411282951708;
setup_potential();
}
void MC::set_coordinates(pele::Array<double>& coords, double energy)
{
m_coords = coords.copy();
m_energy = energy;
}
GetDisplacementPerParticle::GetDisplacementPerParticle(pele::Array<double> initial_coordinates_,
const size_t boxdimension_)
: m_initial_coordinates(initial_coordinates_.copy()),
m_boxdimension(boxdimension_),
m_nr_particles(initial_coordinates_.size() / boxdimension_)
{}