void Mean::finish(){
setOutputValue( getFinalValue(0) / getFinalValue(1) );
double denom=getFinalValue(1);
std::vector<double> df(2);
df[0] = 1.0 / denom;
if(diffweight) df[1] = -getFinalValue(0) / (denom*denom);
else df[1]=0.0;
mergeFinalDerivatives( df );
}
void SpathVessel::calculate( const unsigned& current, MultiValue& myvals, std::vector<double>& buffer, std::vector<unsigned>& der_index ) const {
double pp=mymap->getPropertyValue( current, getLabel() ), weight=myvals.get(0);
if( weight<getTolerance() ) return;
unsigned nderivatives=getFinalValue()->getNumberOfDerivatives();
buffer[bufstart] += weight*pp; buffer[bufstart+1+nderivatives] += weight;
if( getAction()->derivativesAreRequired() ) {
myvals.chainRule( 0, 0, 1, 0, pp, bufstart, buffer );
myvals.chainRule( 0, 1, 1, 0, 1.0, bufstart, buffer );
}
}
void FunctionVessel::resize(){
if( getAction()->derivativesAreRequired() ){
unsigned nderivatives=getAction()->getNumberOfDerivatives();
getFinalValue()->resizeDerivatives( nderivatives );
resizeBuffer( (1+nderivatives)*2 );
diffweight=getAction()->weightHasDerivatives;
} else {
resizeBuffer(2);
diffweight=false; // Don't need to worry about differentiable weights if no derivatives
}
}
void FunctionVessel::finish( const std::vector<double>& buffer ){
unsigned nderivatives=getFinalValue()->getNumberOfDerivatives();
if( norm && diffweight ){
double dv, val=finalTransform( buffer[bufstart], dv), weight=buffer[bufstart+1+nderivatives];
getFinalValue()->set( val / weight );
for(unsigned i=0;i<nderivatives;++i){
getFinalValue()->addDerivative( i, buffer[bufstart+1+i]/weight - val*buffer[bufstart+1+nderivatives+1+i]/(weight*weight) );
}
} else if( norm ){
double dv, val=finalTransform( buffer[bufstart], dv), weight=buffer[bufstart+1+nderivatives];
getFinalValue()->set( val / weight );
for(unsigned i=0;i<nderivatives;++i) getFinalValue()->addDerivative( i, buffer[bufstart+1+i]/weight );
} else {
double dv, val=finalTransform( buffer[bufstart], dv); getFinalValue()->set( val );
for(unsigned i=0;i<nderivatives;++i) getFinalValue()->addDerivative( i, dv*buffer[bufstart+1+i] );
}
}
void FunctionVessel::calculate( const unsigned& current, MultiValue& myvals, std::vector<double>& buffer, std::vector<unsigned>& der_list ) const {
unsigned nderivatives=getFinalValue()->getNumberOfDerivatives();
double weight=myvals.get(0);
plumed_dbg_assert( weight>=getTolerance() );
// This deals with the value
double dval, f=calcTransform( myvals.get(mycomp), dval );
if( norm ){
if( usetol && weight<getTolerance() ) return;
buffer[bufstart+1+nderivatives] += weight;
if( diffweight ) myvals.chainRule( 0, 1, 1, 0, 1.0, bufstart, buffer );
}
double contr=weight*f;
if( usetol && contr<getTolerance() ) return;
buffer[bufstart] += contr;
if( diffweight ) myvals.chainRule( 0, 0, 1, 0, f, bufstart, buffer );
if( getAction()->derivativesAreRequired() && fabs(dval)>0.0 ) myvals.chainRule( mycomp, 0, 1, 0, weight*dval, bufstart, buffer );
return;
}
void DHEnergy::finish(){
setOutputValue( getFinalValue(0) );
df[0]=1.0; df[1]=0.0;
mergeFinalDerivatives( df );
}
void ZpathVessel::finish(){
double sum = getFinalValue(0); std::vector<double> df(2);
setOutputValue( -invlambda*std::log( sum ) );
df[0] = -invlambda / sum; df[1] = 0.0;
mergeFinalDerivatives( df );
}
void Max::finish(){
double valin=getFinalValue(0); double dist=beta*std::log( valin );
setOutputValue( dist ); df[0]=beta/valin; df[1]=0.0;
mergeFinalDerivatives( df );
}
void GradientVessel::finish(){
der_interm=0; // Clear all interim derivatives
unsigned nder = getAction()->getNumberOfDerivatives();
if( isdens ){
for(unsigned iw=0;iw<nweights;++iw){
val_interm[iw] = getFinalValue( 2*iw );
if( getAction()->derivativesAreRequired() ){
unsigned wstart = 2*iw*(nder+1) + 1;
for(unsigned jder=0;jder<nder;++jder) der_interm( iw, jder ) += getBufferElement( wstart + jder );
}
}
} else {
for(unsigned iw=0;iw<nweights;++iw){
unsigned xx = (ncomponents+1)*iw;
double sum=0, ww=getFinalValue( xx );
for(unsigned jc=0;jc<ncomponents;++jc) val_interm[ iw*ncomponents + jc ] = getFinalValue( xx + 1 + jc ) / ww;
if( getAction()->derivativesAreRequired() ){
unsigned wstart = xx*(nder+1) + 1;
for(unsigned jc=0;jc<ncomponents;++jc){
unsigned bstart = ( xx + 1 + jc )*(nder+1) + 1;
double val = getFinalValue( xx + 1 + jc );
for(unsigned jder=0;jder<nder;++jder)
der_interm( iw*ncomponents + jc, jder ) = (1.0/ww)*getBufferElement( bstart + jder ) - (val/(ww*ww))*getBufferElement( wstart + jder );
}
}
}
}
double tmp, diff2=0.0;
if( getAction()->derivativesAreRequired() ){
for(unsigned j=0;j<starts.size()-1;++j){
for(unsigned bin=starts[j];bin<starts[j+1];++bin){
for(unsigned jc=0;jc<ncomponents;++jc){
if( bin==starts[j] ){
tmp=val_interm[(starts[j+1]-1)*ncomponents + jc] - val_interm[bin*ncomponents + jc];
for(unsigned jder=0;jder<nder;++jder){
addDerivativeToFinalValue( jder, +2.0*tmp*der_interm( (starts[j+1]-1)*ncomponents + jc, jder) );
addDerivativeToFinalValue( jder, -2.0*tmp*der_interm( bin*ncomponents + jc, jder ) );
}
} else {
tmp=val_interm[(bin-1)*ncomponents + jc] - val_interm[bin*ncomponents + jc];
for(unsigned jder=0;jder<nder;++jder){
addDerivativeToFinalValue( jder, +2.0*tmp*der_interm( (bin-1)*ncomponents + jc, jder) );
addDerivativeToFinalValue( jder, -2.0*tmp*der_interm( bin*ncomponents + jc, jder ) );
}
}
diff2+=tmp*tmp;
}
}
}
} else {
for(unsigned j=0;j<starts.size()-1;++j){
for(unsigned bin=starts[j];bin<starts[j+1];++bin){
for(unsigned jc=0;jc<ncomponents;++jc){
if( bin==starts[j] ) tmp=val_interm[(starts[j+1]-1)*ncomponents + jc] - val_interm[bin*ncomponents + jc];
else tmp=val_interm[(bin-1)*ncomponents + jc] - val_interm[bin*ncomponents + jc];
diff2+=tmp*tmp;
}
}
}
}
setOutputValue( diff2 );
}
