void Read::calculate(){
std::string smin, smax;
for(unsigned i=0;i<readvals.size();++i){
ifile->scanField( readvals[i] );
getPntrToComponent(i)->set( readvals[i]->get() );
if( readvals[i]->isPeriodic() ){
readvals[i]->getDomain( smin, smax );
getPntrToComponent(i)->setDomain( smin, smax );
}
}
}
void Mapping::calculateNumericalDerivatives( ActionWithValue* a ){
if( getNumberOfAtoms()>0 ){
ActionWithArguments::calculateNumericalDerivatives( a );
}
if( getNumberOfAtoms()>0 ){
Matrix<double> save_derivatives( getNumberOfComponents(), getNumberOfArguments() );
for(unsigned j=0;j<getNumberOfComponents();++j){
for(unsigned i=0;i<getNumberOfArguments();++i) save_derivatives(j,i)=getPntrToComponent(j)->getDerivative(i);
}
calculateAtomicNumericalDerivatives( a, getNumberOfArguments() );
for(unsigned j=0;j<getNumberOfComponents();++j){
for(unsigned i=0;i<getNumberOfArguments();++i) getPntrToComponent(j)->addDerivative( i, save_derivatives(j,i) );
}
}
}
void Colvar::requestAtoms(const vector<AtomNumber> & a){
plumed_massert(!isEnergy,"request atoms should not be called if this is energy");
// Tell actionAtomistic what atoms we are getting
ActionAtomistic::requestAtoms(a);
// Resize the derivatives of all atoms
for(int i=0;i<getNumberOfComponents();++i) getPntrToComponent(i)->resizeDerivatives(3*a.size()+9);
}
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 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]);
}
void Sprint::apply() {
std::vector<Vector>& f(modifyForces());
Tensor& v(modifyVirial());
unsigned nat=getNumberOfAtoms();
std::vector<double> forces( 3*getNumberOfAtoms() + 9 );
for(int i=0; i<getNumberOfComponents(); ++i) {
if( getPntrToComponent(i)->applyForce( forces ) ) {
for(unsigned j=0; j<nat; ++j) {
f[j][0]+=forces[3*j+0];
f[j][1]+=forces[3*j+1];
f[j][2]+=forces[3*j+2];
}
v(0,0)+=forces[3*nat+0];
v(0,1)+=forces[3*nat+1];
v(0,2)+=forces[3*nat+2];
v(1,0)+=forces[3*nat+3];
v(1,1)+=forces[3*nat+4];
v(1,2)+=forces[3*nat+5];
v(2,0)+=forces[3*nat+6];
v(2,1)+=forces[3*nat+7];
v(2,2)+=forces[3*nat+8];
}
}
}
void Colvar::apply(){
vector<Vector>& f(modifyForces());
Tensor& v(modifyVirial());
unsigned nat=getNumberOfAtoms();
for(unsigned i=0;i<f.size();i++){
f[i][0]=0.0;
f[i][1]=0.0;
f[i][2]=0.0;
}
v.zero();
if(!isEnergy){
for(int i=0;i<getNumberOfComponents();++i){
if( getPntrToComponent(i)->applyForce( forces ) ){
for(unsigned j=0;j<nat;++j){
f[j][0]+=forces[3*j+0];
f[j][1]+=forces[3*j+1];
f[j][2]+=forces[3*j+2];
}
v(0,0)+=forces[3*nat+0];
v(0,1)+=forces[3*nat+1];
v(0,2)+=forces[3*nat+2];
v(1,0)+=forces[3*nat+3];
v(1,1)+=forces[3*nat+4];
v(1,2)+=forces[3*nat+5];
v(2,0)+=forces[3*nat+6];
v(2,1)+=forces[3*nat+7];
v(2,2)+=forces[3*nat+8];
}
}
} else if( isEnergy ){
forces.resize(1);
if( getPntrToComponent(0)->applyForce( forces ) ) modifyForceOnEnergy()+=forces[0];
}
}
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();
}
// calculator
void Energy::calculate() {
setValue( getEnergy() );
getPntrToComponent(0)->addDerivative(0,1.0);
}
void Colvar::apply(){
vector<Vector>& f(modifyForces());
Tensor& v(modifyVirial());
const unsigned nat=getNumberOfAtoms();
const unsigned ncp=getNumberOfComponents();
const unsigned fsz=f.size();
for(unsigned i=0;i<fsz;i++) f[i].zero();
v.zero();
unsigned stride=1;
unsigned rank=0;
if(ncp>comm.Get_size()) {
stride=comm.Get_size();
rank=comm.Get_rank();
}
unsigned nt=OpenMP::getNumThreads();
if(nt>ncp/(2.*stride)) nt=1;
if(!isEnergy){
#pragma omp parallel num_threads(nt)
{
vector<Vector> omp_f(fsz);
Tensor omp_v;
vector<double> forces(3*nat+9);
#pragma omp for
for(unsigned i=rank;i<ncp;i+=stride){
if(getPntrToComponent(i)->applyForce(forces)){
for(unsigned j=0;j<nat;++j){
omp_f[j][0]+=forces[3*j+0];
omp_f[j][1]+=forces[3*j+1];
omp_f[j][2]+=forces[3*j+2];
}
omp_v(0,0)+=forces[3*nat+0];
omp_v(0,1)+=forces[3*nat+1];
omp_v(0,2)+=forces[3*nat+2];
omp_v(1,0)+=forces[3*nat+3];
omp_v(1,1)+=forces[3*nat+4];
omp_v(1,2)+=forces[3*nat+5];
omp_v(2,0)+=forces[3*nat+6];
omp_v(2,1)+=forces[3*nat+7];
omp_v(2,2)+=forces[3*nat+8];
}
}
#pragma omp critical
{
for(unsigned j=0;j<nat;++j) f[j]+=omp_f[j];
v+=omp_v;
}
}
if(ncp>comm.Get_size()) {
if(fsz>0) comm.Sum(&f[0][0],3*fsz);
comm.Sum(&v[0][0],9);
}
} else if( isEnergy ){
vector<double> forces(1);
if(getPntrToComponent(0)->applyForce(forces)) modifyForceOnEnergy()+=forces[0];
}
}
void Function::addComponentWithDerivatives( const std::string& name ) {
plumed_massert( getNumberOfArguments()!=0, "for functions you must requestArguments before adding values");
ActionWithValue::addComponentWithDerivatives(name);
getPntrToComponent(name)->resizeDerivatives(getNumberOfArguments());
}
void PathMSDBase::calculate(){
if(neigh_size>0 && getExchangeStep()) error("Neighbor lists for this collective variable are not compatible with replica exchange, sorry for that!");
//log.printf("NOW CALCULATE! \n");
// resize the list to full
if(imgVec.empty()){ // this is the signal that means: recalculate all
imgVec.resize(nframes);
for(unsigned i=0;i<nframes;i++){
imgVec[i].property=indexvec[i];
imgVec[i].index=i;
}
}
// THIS IS THE HEAVY PART (RMSD STUFF)
unsigned stride=comm.Get_size();
unsigned rank=comm.Get_rank();
unsigned nat=pdbv[0].size();
plumed_assert(nat>0);
plumed_assert(nframes>0);
plumed_assert(imgVec.size()>0);
std::vector<double> tmp_distances(imgVec.size(),0.0);
std::vector<Vector> tmp_derivs;
// this array is a merge of all tmp_derivs, so as to allow a single comm.Sum below
std::vector<Vector> tmp_derivs2(imgVec.size()*nat);
// if imgVec.size() is less than nframes, it means that only some msd will be calculated
for(unsigned i=rank;i<imgVec.size();i+=stride){
// store temporary local results
tmp_distances[i]=msdv[imgVec[i].index].calculate(getPositions(),tmp_derivs,true);
plumed_assert(tmp_derivs.size()==nat);
for(unsigned j=0;j<nat;j++) tmp_derivs2[i*nat+j]=tmp_derivs[j];
}
// reduce over all processors
comm.Sum(tmp_distances);
comm.Sum(tmp_derivs2);
// assign imgVec[i].distance and imgVec[i].distder
for(unsigned i=0;i<imgVec.size();i++){
imgVec[i].distance=tmp_distances[i];
imgVec[i].distder.assign(&tmp_derivs2[i*nat],nat+&tmp_derivs2[i*nat]);
}
// END OF THE HEAVY PART
vector<Value*> val_s_path;
if(labels.size()>0){
for(unsigned i=0;i<labels.size();i++){ val_s_path.push_back(getPntrToComponent(labels[i].c_str()));}
}else{
val_s_path.push_back(getPntrToComponent("sss"));
}
Value* val_z_path=getPntrToComponent("zzz");
vector<double> s_path(val_s_path.size());for(unsigned i=0;i<s_path.size();i++)s_path[i]=0.;
double partition=0.;
double tmp;
// clean vector
for(unsigned i=0;i< derivs_z.size();i++){derivs_z[i].zero();}
typedef vector< class ImagePath >::iterator imgiter;
for(imgiter it=imgVec.begin();it!=imgVec.end();++it){
(*it).similarity=exp(-lambda*((*it).distance));
//log<<"DISTANCE "<<(*it).distance<<"\n";
for(unsigned i=0;i<s_path.size();i++){
s_path[i]+=((*it).property[i])*(*it).similarity;
}
partition+=(*it).similarity;
}
for(unsigned i=0;i<s_path.size();i++){ s_path[i]/=partition; val_s_path[i]->set(s_path[i]) ;}
val_z_path->set(-(1./lambda)*std::log(partition));
for(unsigned j=0;j<s_path.size();j++){
// clean up
for(unsigned i=0;i< derivs_s.size();i++){derivs_s[i].zero();}
// do the derivative
for(imgiter it=imgVec.begin();it!=imgVec.end();++it){
double expval=(*it).similarity;
tmp=lambda*expval*(s_path[j]-(*it).property[j])/partition;
for(unsigned i=0;i< derivs_s.size();i++){ derivs_s[i]+=tmp*(*it).distder[i] ;}
if(j==0){for(unsigned i=0;i< derivs_z.size();i++){ derivs_z[i]+=(*it).distder[i]*expval/partition;}}
}
for(unsigned i=0;i< derivs_s.size();i++){
setAtomsDerivatives (val_s_path[j],i,derivs_s[i]);
if(j==0){setAtomsDerivatives (val_z_path,i,derivs_z[i]);}
}
}
for(unsigned i=0;i<val_s_path.size();++i) setBoxDerivativesNoPbc(val_s_path[i]);
setBoxDerivativesNoPbc(val_z_path);
//
// here set next round neighbors
//
if (neigh_size>0){
//if( int(getStep())%int(neigh_stride/getTimeStep())==0 ){
// enforce consistency: the stride is in time steps
if( int(getStep())%int(neigh_stride)==0 ){
// next round do it all:empty the vector
imgVec.clear();
}
// time to analyze the results:
if(imgVec.size()==nframes){
//sort by msd
sort(imgVec.begin(), imgVec.end(), imgOrderByDist());
//resize
imgVec.resize(neigh_size);
}
}
//log.printf("CALCULATION DONE! \n");
}
void DistanceFromContour::apply(){
if( getPntrToComponent("dist")->applyForce( forces ) ) setForcesOnAtoms( forces );
}
void ManyRestraintsBase::apply() {
plumed_dbg_assert( getNumberOfComponents()==1 );
getPntrToComponent(0)->addForce( -1.0*getStride() );
}
