// ******************************************************************************
   //
   // Title:       Force Field X.
   // Description: Force Field X - Software for Molecular Biophysics.
   // Copyright:   Copyright (c) Michael J. Schnieders 2001-2025.
   //
   // This file is part of Force Field X.
   //
   // Force Field X is free software; you can redistribute it and/or modify it
  // under the terms of the GNU General Public License version 3 as published by
  // the Free Software Foundation.
  //
  // Force Field X is distributed in the hope that it will be useful, but WITHOUT
  // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  // details.
  //
  // You should have received a copy of the GNU General Public License along with
  // Force Field X; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA 02111-1307 USA
  //
  // Linking this library statically or dynamically with other modules is making a
  // combined work based on this library. Thus, the terms and conditions of the
  // GNU General Public License cover the whole combination.
  //
  // As a special exception, the copyright holders of this library give you
  // permission to link this library with independent modules to produce an
  // executable, regardless of the license terms of these independent modules, and
  // to copy and distribute the resulting executable under terms of your choice,
  // provided that you also meet, for each linked independent module, the terms
  // and conditions of the license of that module. An independent module is a
  // module which is not derived from or based on this library. If you modify this
  // library, you may extend this exception to your version of the library, but
  // you are not obligated to do so. If you do not wish to do so, delete this
  // exception statement from your version.
  //
  // ******************************************************************************
  package ffx.realspace;
  
  import ffx.crystal.Crystal;
  import ffx.crystal.CrystalPotential;
  import ffx.potential.bonded.Atom;
  import ffx.potential.bonded.LambdaInterface;
  import ffx.xray.refine.RefinementModel;
  
  import java.util.logging.Logger;
  
  import static java.lang.String.format;
  
  /**
   * Combine the Real Space target and chemical potential energy.
   *
   * @author Timothy D. Fenn
   * @author Michael J. Schnieders
   * @since 1.0
   */
  public class RealSpaceEnergy implements LambdaInterface, CrystalPotential {
  
    private static final Logger logger = Logger.getLogger(RealSpaceEnergy.class.getName());
  
    /**
     * The Real Space data to refine against.
     */
    private final RealSpaceData realSpaceData;
    /**
     * The Refinement Model that contains info on mapping between alternate conformers.
     */
    private final RefinementModel refinementModel;
    /**
     * Value of the lambda state variable.
     */
    protected double lambda = 1.0;
    /**
     * The number of parameters that are being refined.
     */
    private final int nXYZ;
    /**
     * Optimization scaling used to improve convergence.
     */
    private double[] optimizationScaling = null;
    /**
     * Total energy of the refinement.
     */
    private double totalEnergy;
    /**
     * The RealSpaceEnergy is updated with FAST varying energy terms.
     */
    private STATE state = STATE.BOTH;
  
    /**
     * Diffraction data energy target
     *
     * @param realSpaceData {@link ffx.realspace.RealSpaceData} object to associate with the target
     */
    public RealSpaceEnergy(RealSpaceData realSpaceData) {
      this.realSpaceData = realSpaceData;
      refinementModel = realSpaceData.getRefinementModel();
      nXYZ = refinementModel.getNumCoordParameters();
    }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public boolean destroy() {
     return realSpaceData.destroy();
   }
 
   /**
    * The parameters passed in are only for "active" atoms.
    *
    * <p>{@inheritDoc}
    */
   @Override
   public double energy(double[] x) {
     // Unscale the coordinates.
     unscaleCoordinates(x);
 
     // Set the parameters.
     refinementModel.setParameters(x);
 
     // Target function for real space refinement.
     double e = realSpaceData.computeRealSpaceTarget();
 
     // Scale the coordinates.
     scaleCoordinates(x);
 
     totalEnergy = e;
     return e;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double energyAndGradient(double[] x, double[] g) {
     // Unscale the coordinates.
     unscaleCoordinates(x);
 
     // Set model parameters.
     refinementModel.setParameters(x);
 
     // Zero out the gradient.
     refinementModel.zeroGradient();
 
     // Target function for real space refinement
     double e = realSpaceData.computeRealSpaceTarget();
 
     // Pack the gradient into gradient array
     refinementModel.getGradient(g);
 
     // Scale the coordinates and gradients.
     scaleCoordinatesAndGradient(x, g);
 
     totalEnergy = e;
     return e;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double[] getAcceleration(double[] acceleration) {
     int n = getNumberOfVariables();
     if (acceleration == null || acceleration.length < n) {
       acceleration = new double[n];
     }
     int index = 0;
     double[] acc = new double[3];
     for (Atom a : refinementModel.getActiveAtoms()) {
       a.getAcceleration(acc);
       acceleration[index++] = acc[0];
       acceleration[index++] = acc[1];
       acceleration[index++] = acc[2];
     }
     return acceleration;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double[] getCoordinates(double[] x) {
     int n = getNumberOfVariables();
     if (x == null || x.length < n) {
       x = new double[n];
     }
     int index = 0;
     for (Atom a : refinementModel.getActiveAtoms()) {
       x[index++] = a.getX();
       x[index++] = a.getY();
       x[index++] = a.getZ();
     }
     return x;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public ffx.crystal.Crystal getCrystal() {
     realSpaceData.getCrystal();
     return null;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void setCrystal(Crystal crystal) {
     logger.severe(" RealSpaceEnergy does implement setCrystal yet.");
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public STATE getEnergyTermState() {
     return state;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void setEnergyTermState(STATE state) {
     this.state = state;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double getLambda() {
     return lambda;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void setLambda(double lambda) {
     if (lambda <= 1.0 && lambda >= 0.0) {
       this.lambda = lambda;
       realSpaceData.setLambda(lambda);
     } else {
       String message = format(" Lambda value %8.3f is not in the range [0..1].", lambda);
       logger.warning(message);
     }
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double[] getMass() {
     double[] mass = new double[nXYZ];
     refinementModel.getMass(mass);
     return mass;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public int getNumberOfVariables() {
     return nXYZ;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double[] getPreviousAcceleration(double[] previousAcceleration) {
     int n = getNumberOfVariables();
     if (previousAcceleration == null || previousAcceleration.length < n) {
       previousAcceleration = new double[n];
     }
     int index = 0;
     double[] prev = new double[3];
     for (Atom a : refinementModel.getActiveAtoms()) {
       a.getPreviousAcceleration(prev);
       previousAcceleration[index++] = prev[0];
       previousAcceleration[index++] = prev[1];
       previousAcceleration[index++] = prev[2];
     }
     return previousAcceleration;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double[] getScaling() {
     return optimizationScaling;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void setScaling(double[] scaling) {
     optimizationScaling = scaling;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double getTotalEnergy() {
     return totalEnergy;
   }
 
   /**
    * {@inheritDoc}
    *
    * <p>Return a reference to each variables type.
    */
   @Override
   public VARIABLE_TYPE[] getVariableTypes() {
     int nActive = refinementModel.getActiveAtoms().length;
     VARIABLE_TYPE[] type = new VARIABLE_TYPE[nActive * 3];
     int index = 0;
     for (int i = 0; i < nActive; i++) {
       type[index++] = VARIABLE_TYPE.X;
       type[index++] = VARIABLE_TYPE.Y;
       type[index++] = VARIABLE_TYPE.Z;
     }
     return type;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double[] getVelocity(double[] velocity) {
     int n = getNumberOfVariables();
     if (velocity == null || velocity.length < n) {
       velocity = new double[n];
     }
     int index = 0;
     double[] v = new double[3];
     for (Atom a : refinementModel.getActiveAtoms()) {
       a.getVelocity(v);
       velocity[index++] = v[0];
       velocity[index++] = v[1];
       velocity[index++] = v[2];
     }
     return velocity;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double getd2EdL2() {
     return 0.0;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public double getdEdL() {
     return realSpaceData.getdEdL();
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void getdEdXdL(double[] gradient) {
     realSpaceData.getdEdXdL(gradient);
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void setAcceleration(double[] acceleration) {
     if (acceleration == null) {
       return;
     }
     int index = 0;
     double[] accel = new double[3];
     for (Atom a : refinementModel.getActiveAtoms()) {
       accel[0] = acceleration[index++];
       accel[1] = acceleration[index++];
       accel[2] = acceleration[index++];
       a.setAcceleration(accel);
     }
   }
 
   /**
    * Set atomic coordinates positions.
    *
    * @param x an array of coordinates for active atoms.
    */
   public void setCoordinates(double[] x) {
     if (x == null) {
       return;
     }
     refinementModel.setParameters(x);
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void setPreviousAcceleration(double[] previousAcceleration) {
     if (previousAcceleration == null) {
       return;
     }
     int index = 0;
     double[] prev = new double[3];
     for (Atom a : refinementModel.getActiveAtoms()) {
       prev[0] = previousAcceleration[index++];
       prev[1] = previousAcceleration[index++];
       prev[2] = previousAcceleration[index++];
       a.setPreviousAcceleration(prev);
     }
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void setVelocity(double[] velocity) {
     if (velocity == null) {
       return;
     }
     int index = 0;
     double[] vel = new double[3];
     for (Atom a : refinementModel.getActiveAtoms()) {
       vel[0] = velocity[index++];
       vel[1] = velocity[index++];
       vel[2] = velocity[index++];
       a.setVelocity(vel);
     }
   }
 }