* \param[in] scaleToLattice the coordinate transformation into the spreading lattice
* \returns A Gauss-transform kernel shape
*/
-GaussianSpreadKernelParameters::Shape
-makeSpreadKernel(real sigma, real nSigma, const ScaleCoordinates &scaleToLattice)
+GaussianSpreadKernelParameters::Shape makeSpreadKernel(real sigma, real nSigma, const ScaleCoordinates& scaleToLattice)
{
- RVec sigmaInLatticeCoordinates {
- sigma, sigma, sigma
- };
- scaleToLattice( { &sigmaInLatticeCoordinates, &sigmaInLatticeCoordinates + 1 });
- return {
- DVec {
- sigmaInLatticeCoordinates[XX], sigmaInLatticeCoordinates[YY], sigmaInLatticeCoordinates[ZZ]
- }, nSigma
- };
+ RVec sigmaInLatticeCoordinates{ sigma, sigma, sigma };
+ scaleToLattice({ &sigmaInLatticeCoordinates, &sigmaInLatticeCoordinates + 1 });
+ return { DVec{ sigmaInLatticeCoordinates[XX], sigmaInLatticeCoordinates[YY],
+ sigmaInLatticeCoordinates[ZZ] },
+ nSigma };
}
-} // namespace
+} // namespace
/********************************************************************
* DensityFittingForceProvider::Impl
class DensityFittingForceProvider::Impl
{
- public:
- //! \copydoc DensityFittingForceProvider(const DensityFittingParameters ¶meters)
- Impl(const DensityFittingParameters ¶meters,
- basic_mdspan<const float, dynamicExtents3D> referenceDensity,
- const TranslateAndScale &transformationToDensityLattice,
- const LocalAtomSet &localAtomSet,
- int pbcType,
- double simulationTimeStep,
- const DensityFittingForceProviderState &state);
- ~Impl();
- void calculateForces(const ForceProviderInput &forceProviderInput, ForceProviderOutput *forceProviderOutput);
-
- DensityFittingForceProviderState state();
-
- private:
- const DensityFittingParameters ¶meters_;
- DensityFittingForceProviderState state_;
- LocalAtomSet localAtomSet_;
-
- GaussianSpreadKernelParameters::Shape spreadKernel_;
- GaussTransform3D gaussTransform_;
- DensitySimilarityMeasure measure_;
- DensityFittingForce densityFittingForce_;
- //! the local atom coordinates transformed into the grid coordinate system
- std::vector<RVec> transformedCoordinates_;
- std::vector<RVec> forces_;
- DensityFittingAmplitudeLookup amplitudeLookup_;
- TranslateAndScale transformationToDensityLattice_;
- RVec referenceDensityCenter_;
- int pbcType_;
-
- //! Optionally scale the force according to a moving average of the similarity
- compat::optional<ExponentialMovingAverage> expAverageSimilarity_;
+public:
+ //! \copydoc DensityFittingForceProvider(const DensityFittingParameters ¶meters)
+ Impl(const DensityFittingParameters& parameters,
+ basic_mdspan<const float, dynamicExtents3D> referenceDensity,
+ const TranslateAndScale& transformationToDensityLattice,
+ const LocalAtomSet& localAtomSet,
+ int pbcType,
+ double simulationTimeStep,
+ const DensityFittingForceProviderState& state);
+ ~Impl();
+ void calculateForces(const ForceProviderInput& forceProviderInput,
+ ForceProviderOutput* forceProviderOutput);
+
+ DensityFittingForceProviderState state();
+
+private:
+ const DensityFittingParameters& parameters_;
+ DensityFittingForceProviderState state_;
+ LocalAtomSet localAtomSet_;
+
+ GaussianSpreadKernelParameters::Shape spreadKernel_;
+ GaussTransform3D gaussTransform_;
+ DensitySimilarityMeasure measure_;
+ DensityFittingForce densityFittingForce_;
+ //! the local atom coordinates transformed into the grid coordinate system
+ std::vector<RVec> transformedCoordinates_;
+ std::vector<RVec> forces_;
+ DensityFittingAmplitudeLookup amplitudeLookup_;
+ TranslateAndScale transformationToDensityLattice_;
+ RVec referenceDensityCenter_;
+ int pbcType_;
+
+ //! Optionally scale the force according to a moving average of the similarity
+ compat::optional<ExponentialMovingAverage> expAverageSimilarity_;
};
DensityFittingForceProvider::Impl::~Impl() = default;
-DensityFittingForceProvider::Impl::Impl(const DensityFittingParameters ¶meters,
+DensityFittingForceProvider::Impl::Impl(const DensityFittingParameters& parameters,
basic_mdspan<const float, dynamicExtents3D> referenceDensity,
- const TranslateAndScale &transformationToDensityLattice,
- const LocalAtomSet &localAtomSet,
- int pbcType,
- double simulationTimeStep,
- const DensityFittingForceProviderState &state) :
+ const TranslateAndScale& transformationToDensityLattice,
+ const LocalAtomSet& localAtomSet,
+ int pbcType,
+ double simulationTimeStep,
+ const DensityFittingForceProviderState& state) :
parameters_(parameters),
state_(state),
localAtomSet_(localAtomSet),
{
if (parameters_.adaptiveForceScaling_)
{
- GMX_ASSERT(simulationTimeStep > 0, "Simulation time step must be larger than zero for adaptive for scaling.");
+ GMX_ASSERT(simulationTimeStep > 0,
+ "Simulation time step must be larger than zero for adaptive for scaling.");
expAverageSimilarity_.emplace(ExponentialMovingAverage(
- parameters_.adaptiveForceScalingTimeConstant_
- / (simulationTimeStep * parameters_.calculationIntervalInSteps_),
- state.exponentialMovingAverageState_));
+ parameters_.adaptiveForceScalingTimeConstant_
+ / (simulationTimeStep * parameters_.calculationIntervalInSteps_),
+ state.exponentialMovingAverageState_));
}
- referenceDensityCenter_ = {
- real(referenceDensity.extent(XX))/2,
- real(referenceDensity.extent(YY))/2,
- real(referenceDensity.extent(ZZ))/2
- };
+ referenceDensityCenter_ = { real(referenceDensity.extent(XX)) / 2,
+ real(referenceDensity.extent(YY)) / 2,
+ real(referenceDensity.extent(ZZ)) / 2 };
transformationToDensityLattice_.scaleOperationOnly().inverseIgnoringZeroScale(
{ &referenceDensityCenter_, &referenceDensityCenter_ + 1 });
// correct the reference density center for a shift
referenceDensityCenter_ -= referenceDensityOriginShift;
}
-void DensityFittingForceProvider::Impl::calculateForces(const ForceProviderInput &forceProviderInput,
- ForceProviderOutput *forceProviderOutput)
+void DensityFittingForceProvider::Impl::calculateForces(const ForceProviderInput& forceProviderInput,
+ ForceProviderOutput* forceProviderOutput)
{
// do nothing but count number of steps when not in density fitting step
if (state_.stepsSinceLastCalculation_ % parameters_.calculationIntervalInSteps_ != 0)
}
transformedCoordinates_.resize(localAtomSet_.numAtomsLocal());
// pick and copy atom coordinates
- std::transform(std::cbegin(localAtomSet_.localIndex()),
- std::cend(localAtomSet_.localIndex()),
+ std::transform(std::cbegin(localAtomSet_.localIndex()), std::cend(localAtomSet_.localIndex()),
std::begin(transformedCoordinates_),
[&forceProviderInput](int index) { return forceProviderInput.x_[index]; });
{
t_pbc pbc;
set_pbc(&pbc, pbcType_, forceProviderInput.box_);
- for (RVec &x : transformedCoordinates_)
+ for (RVec& x : transformedCoordinates_)
{
rvec dx;
pbc_dx(&pbc, x, referenceDensityCenter_, dx);
// spread atoms on grid
gaussTransform_.setZero();
- std::vector<real> amplitudes = amplitudeLookup_(forceProviderInput.mdatoms_, localAtomSet_.localIndex());
+ std::vector<real> amplitudes =
+ amplitudeLookup_(forceProviderInput.mdatoms_, localAtomSet_.localIndex());
if (parameters_.normalizeDensities_)
{
{
gmx_sum(1, &sum, &forceProviderInput.cr_);
}
- for (real &litude : amplitudes)
+ for (real& amplitude : amplitudes)
{
amplitude /= sum;
}
auto amplitudeIterator = amplitudes.cbegin();
- for (const auto &r : transformedCoordinates_)
+ for (const auto& r : transformedCoordinates_)
{
gaussTransform_.add({ r, *amplitudeIterator });
++amplitudeIterator;
}
// calculate grid derivative
- const DensitySimilarityMeasure::density &densityDerivative =
- measure_.gradient(gaussTransform_.constView());
+ const DensitySimilarityMeasure::density& densityDerivative =
+ measure_.gradient(gaussTransform_.constView());
// calculate forces
forces_.resize(localAtomSet_.numAtomsLocal());
std::transform(
- std::begin(transformedCoordinates_),
- std::end(transformedCoordinates_),
- std::begin(amplitudes),
- std::begin(forces_),
- [&densityDerivative, this](const RVec r, real amplitude)
- {
- return densityFittingForce_.evaluateForce({r, amplitude}, densityDerivative);
- }
- );
+ std::begin(transformedCoordinates_), std::end(transformedCoordinates_), std::begin(amplitudes),
+ std::begin(forces_), [&densityDerivative, this](const RVec r, real amplitude) {
+ return densityFittingForce_.evaluateForce({ r, amplitude }, densityDerivative);
+ });
transformationToDensityLattice_.scaleOperationOnly().inverseIgnoringZeroScale(forces_);
- auto densityForceIterator = forces_.cbegin();
- const real effectiveForceConstant = state_.adaptiveForceConstantScale_ *
- parameters_.calculationIntervalInSteps_ * parameters_.forceConstant_;
+ auto densityForceIterator = forces_.cbegin();
+ const real effectiveForceConstant = state_.adaptiveForceConstantScale_ * parameters_.calculationIntervalInSteps_
+ * parameters_.forceConstant_;
for (const auto localAtomIndex : localAtomSet_.localIndex())
{
- forceProviderOutput->forceWithVirial_.force_[localAtomIndex]
- += effectiveForceConstant * *densityForceIterator;
+ forceProviderOutput->forceWithVirial_.force_[localAtomIndex] +=
+ effectiveForceConstant * *densityForceIterator;
++densityForceIterator;
}
// calculate corresponding potential energy
- const float similarity = measure_.similarity(gaussTransform_.constView());
- const real energy = -similarity * parameters_.forceConstant_ * state_.adaptiveForceConstantScale_;
+ const float similarity = measure_.similarity(gaussTransform_.constView());
+ const real energy = -similarity * parameters_.forceConstant_ * state_.adaptiveForceConstantScale_;
forceProviderOutput->enerd_.term[F_DENSITYFITTING] += energy;
if (expAverageSimilarity_.has_value())
}
}
-DensityFittingForceProviderState
-DensityFittingForceProvider::Impl::state()
+DensityFittingForceProviderState DensityFittingForceProvider::Impl::state()
{
if (expAverageSimilarity_.has_value())
{
DensityFittingForceProvider::~DensityFittingForceProvider() = default;
-DensityFittingForceProvider::DensityFittingForceProvider(const DensityFittingParameters ¶meters,
+DensityFittingForceProvider::DensityFittingForceProvider(const DensityFittingParameters& parameters,
basic_mdspan<const float, dynamicExtents3D> referenceDensity,
- const TranslateAndScale &transformationToDensityLattice,
- const LocalAtomSet &localAtomSet,
- int pbcType,
- double simulationTimeStep,
- const DensityFittingForceProviderState &state)
- : impl_(new Impl(parameters, referenceDensity, transformationToDensityLattice, localAtomSet, pbcType, simulationTimeStep, state))
-{}
-
-void DensityFittingForceProvider::calculateForces(const ForceProviderInput &forceProviderInput,
- ForceProviderOutput * forceProviderOutput)
+ const TranslateAndScale& transformationToDensityLattice,
+ const LocalAtomSet& localAtomSet,
+ int pbcType,
+ double simulationTimeStep,
+ const DensityFittingForceProviderState& state) :
+ impl_(new Impl(parameters, referenceDensity, transformationToDensityLattice, localAtomSet, pbcType, simulationTimeStep, state))
+{
+}
+
+void DensityFittingForceProvider::calculateForces(const ForceProviderInput& forceProviderInput,
+ ForceProviderOutput* forceProviderOutput)
{
impl_->calculateForces(forceProviderInput, forceProviderOutput);
}
biod.pnpi.spb.ru / alexxy / gromacs.git / blobdiff