void Bias::apply() {
const unsigned noa=getNumberOfArguments();
const unsigned ncp=getNumberOfComponents();
if(onStep()) {
double gstr = static_cast<double>(getStride());
for(unsigned i=0; i<noa; ++i) {
getPntrToArgument(i)->addForce(gstr*outputForces[i]);
}
}
// additional forces on the bias component
std::vector<double> f(noa,0.0);
std::vector<double> forces(noa);
bool at_least_one_forced=false;
for(unsigned i=0; i<ncp; ++i) {
if(getPntrToComponent(i)->applyForce(forces)) {
at_least_one_forced=true;
for(unsigned j=0; j<noa; j++) f[j]+=forces[j];
}
}
if(at_least_one_forced && !onStep()) error("you are biasing a bias with an inconsistent STRIDE");
if(at_least_one_forced) for(unsigned i=0; i<noa; ++i) {
getPntrToArgument(i)->addForce(f[i]);
}
}
void AdaptivePath::update() {
double weight2 = -1.*mypathv->dx;
double weight1 = 1.0 + mypathv->dx;
if( weight1>1.0 ) {
weight1=1.0; weight2=0.0;
} else if( weight2>1.0 ) {
weight1=0.0; weight2=1.0;
}
// Add projections to dispalcement accumulators
ReferenceConfiguration* myref = getReferenceConfiguration( mypathv->iclose1 );
myref->extractDisplacementVector( getPositions(), getArguments(), mypathv->cargs, false, displacement );
getReferenceConfiguration( mypathv->iclose2 )->extractDisplacementVector( myref->getReferencePositions(), getArguments(), myref->getReferenceArguments(), false, displacement2 );
displacement.addDirection( -mypathv->dx, displacement2 );
pdisplacements[mypathv->iclose1].addDirection( weight1, displacement );
pdisplacements[mypathv->iclose2].addDirection( weight2, displacement );
// Update weight accumulators
wsum[mypathv->iclose1] *= fadefact;
wsum[mypathv->iclose2] *= fadefact;
wsum[mypathv->iclose1] += weight1;
wsum[mypathv->iclose2] += weight2;
// This does the update of the path if it is time to
if( (getStep()>0) && (getStep()%update_str==0) ) {
wsum[fixedn[0]]=wsum[fixedn[1]]=0.;
for(unsigned inode=0; inode<getNumberOfReferencePoints(); ++inode) {
if( wsum[inode]>0 ) {
// First displace the node by the weighted direction
getReferenceConfiguration( inode )->displaceReferenceConfiguration( 1./wsum[inode], pdisplacements[inode] );
// Reset the displacement
pdisplacements[inode].zeroDirection();
}
}
// Now ensure all the nodes of the path are equally spaced
PathReparameterization myspacings( getPbc(), getArguments(), getAllReferenceConfigurations() );
myspacings.reparameterize( fixedn[0], fixedn[1], tolerance );
}
if( (getStep()>0) && (getStep()%wstride==0) ) {
pathfile.printf("# PATH AT STEP %d TIME %f \n", getStep(), getTime() );
std::vector<std::unique_ptr<ReferenceConfiguration>>& myconfs=getAllReferenceConfigurations();
std::vector<SetupMolInfo*> moldat=plumed.getActionSet().select<SetupMolInfo*>();
if( moldat.size()>1 ) error("you should only have one MOLINFO action in your input file");
SetupMolInfo* mymoldat=NULL; if( moldat.size()==1 ) mymoldat=moldat[0];
std::vector<std::string> argument_names( getNumberOfArguments() );
for(unsigned i=0; i<getNumberOfArguments(); ++i) argument_names[i] = getPntrToArgument(i)->getName();
PDB mypdb; mypdb.setArgumentNames( argument_names );
for(unsigned i=0; i<myconfs.size(); ++i) {
pathfile.printf("REMARK TYPE=%s\n", myconfs[i]->getName().c_str() );
mypdb.setAtomPositions( myconfs[i]->getReferencePositions() );
for(unsigned j=0; j<getNumberOfArguments(); ++j) mypdb.setArgumentValue( getPntrToArgument(j)->getName(), myconfs[i]->getReferenceArgument(j) );
mypdb.print( atoms.getUnits().getLength()/0.1, mymoldat, pathfile, ofmt );
}
pathfile.flush();
}
}
void Function::apply()
{
const unsigned noa=getNumberOfArguments();
const unsigned ncp=getNumberOfComponents();
const unsigned cgs=comm.Get_size();
vector<double> f(noa,0.0);
unsigned stride=1;
unsigned rank=0;
if(ncp>4*cgs) {
stride=comm.Get_size();
rank=comm.Get_rank();
}
unsigned at_least_one_forced=0;
#pragma omp parallel num_threads(OpenMP::getNumThreads()) shared(f)
{
vector<double> omp_f(noa,0.0);
vector<double> forces(noa);
#pragma omp for reduction( + : at_least_one_forced)
for(unsigned i=rank; i<ncp; i+=stride) {
if(getPntrToComponent(i)->applyForce(forces)) {
at_least_one_forced+=1;
for(unsigned j=0; j<noa; j++) omp_f[j]+=forces[j];
}
}
#pragma omp critical
for(unsigned j=0; j<noa; j++) f[j]+=omp_f[j];
}
if(noa>0&&ncp>4*cgs) { comm.Sum(&f[0],noa); comm.Sum(at_least_one_forced); }
if(at_least_one_forced>0) for(unsigned i=0; i<noa; ++i) getPntrToArgument(i)->addForce(f[i]);
}
std::string Mapping::getArgumentName( unsigned& iarg ){
if( iarg < getNumberOfArguments() ) return getPntrToArgument(iarg)->getName();
unsigned iatom=iarg - getNumberOfArguments();
std::string atnum; Tools::convert( getAbsoluteIndex(iatom).serial(),atnum);
unsigned icomp=iatom%3;
if(icomp==0) return "pos" + atnum + "x";
if(icomp==1) return "pos" + atnum + "y";
return "pos" + atnum + "z";
}
Bias::Bias(const ActionOptions&ao):
Action(ao),
ActionPilot(ao),
ActionWithValue(ao),
ActionWithArguments(ao),
outputForces(getNumberOfArguments(),0.0)
{
if(getStride()>1) error("Using bias with stride!=1 is not currently supported");
for(unsigned i=0;i<getNumberOfArguments();++i){
(getPntrToArgument(i)->getPntrToAction())->turnOnDerivatives();
}
}
Bias::Bias(const ActionOptions&ao):
Action(ao),
ActionPilot(ao),
ActionWithValue(ao),
ActionWithArguments(ao),
outputForces(getNumberOfArguments(),0.0)
{
addComponentWithDerivatives("bias");
componentIsNotPeriodic("bias");
valueBias=getPntrToComponent("bias");
if(getStride()>1) {
log<<" multiple time step "<<getStride()<<" ";
log<<cite("Ferrarotti, Bottaro, Perez-Villa, and Bussi, J. Chem. Theory Comput. 11, 139 (2015)")<<"\n";
}
for(unsigned i=0; i<getNumberOfArguments(); ++i) {
(getPntrToArgument(i)->getPntrToAction())->turnOnDerivatives();
}
turnOnDerivatives();
}
void Bias::apply(){
if(onStep()) for(unsigned i=0;i<getNumberOfArguments();++i){
getPntrToArgument(i)->addForce(getStride()*outputForces[i]);
}
}