/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.36
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


using System;
using System.Runtime.InteropServices;

public class OBForceField : OBPlugin {
  private HandleRef swigCPtr;

  internal OBForceField(IntPtr cPtr, bool cMemoryOwn) : base(openbabelPINVOKE.OBForceFieldUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }

  internal static HandleRef getCPtr(OBForceField obj) {
    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
  }

  ~OBForceField() {
    Dispose();
  }

  public override void Dispose() {
    lock(this) {
      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
        swigCMemOwn = false;
        openbabelPINVOKE.delete_OBForceField(swigCPtr);
      }
      swigCPtr = new HandleRef(null, IntPtr.Zero);
      GC.SuppressFinalize(this);
      base.Dispose();
    }
  }

  public static OBForceField Default() {
    IntPtr cPtr = openbabelPINVOKE.OBForceField_Default();
    OBForceField ret = (cPtr == IntPtr.Zero) ? null : new OBForceField(cPtr, false);
    return ret;
  }

  public static OBForceField FindType(string ID) {
    IntPtr cPtr = openbabelPINVOKE.OBForceField_FindType(ID);
    OBForceField ret = (cPtr == IntPtr.Zero) ? null : new OBForceField(cPtr, false);
    return ret;
  }

  public virtual OBForceField MakeNewInstance() {
    IntPtr cPtr = openbabelPINVOKE.OBForceField_MakeNewInstance(swigCPtr);
    OBForceField ret = (cPtr == IntPtr.Zero) ? null : new OBForceField(cPtr, false);
    return ret;
  }

  public string TypeID() {
    string ret = openbabelPINVOKE.OBForceField_TypeID(swigCPtr);
    return ret;
  }

  public static OBForceField FindForceField(string ID) {
    IntPtr cPtr = openbabelPINVOKE.OBForceField_FindForceField__SWIG_0(ID);
    OBForceField ret = (cPtr == IntPtr.Zero) ? null : new OBForceField(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetParameterFile(string filename) {
    openbabelPINVOKE.OBForceField_SetParameterFile(swigCPtr, filename);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public virtual string GetUnit() {
    string ret = openbabelPINVOKE.OBForceField_GetUnit(swigCPtr);
    return ret;
  }

  public virtual bool HasAnalyticalGradients() {
    bool ret = openbabelPINVOKE.OBForceField_HasAnalyticalGradients(swigCPtr);
    return ret;
  }

  public bool Setup(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_Setup__SWIG_0(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool Setup(OBMol mol, OBFFConstraints constraints) {
    bool ret = openbabelPINVOKE.OBForceField_Setup__SWIG_1(swigCPtr, OBMol.getCPtr(mol), OBFFConstraints.getCPtr(constraints));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public virtual bool ParseParamFile() {
    bool ret = openbabelPINVOKE.OBForceField_ParseParamFile(swigCPtr);
    return ret;
  }

  public virtual bool SetTypes() {
    bool ret = openbabelPINVOKE.OBForceField_SetTypes(swigCPtr);
    return ret;
  }

  public virtual bool SetFormalCharges() {
    bool ret = openbabelPINVOKE.OBForceField_SetFormalCharges(swigCPtr);
    return ret;
  }

  public virtual bool SetPartialCharges() {
    bool ret = openbabelPINVOKE.OBForceField_SetPartialCharges(swigCPtr);
    return ret;
  }

  public virtual bool SetupCalculations() {
    bool ret = openbabelPINVOKE.OBForceField_SetupCalculations(swigCPtr);
    return ret;
  }

  public virtual bool SetupPointers() {
    bool ret = openbabelPINVOKE.OBForceField_SetupPointers(swigCPtr);
    return ret;
  }

  public bool IsSetupNeeded(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_IsSetupNeeded(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool GetAtomTypes(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_GetAtomTypes(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool GetPartialCharges(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_GetPartialCharges(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool GetCoordinates(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_GetCoordinates(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool UpdateCoordinates(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_UpdateCoordinates(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool GetConformers(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_GetConformers(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool UpdateConformers(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_UpdateConformers(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool SetCoordinates(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_SetCoordinates(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool SetConformers(OBMol mol) {
    bool ret = openbabelPINVOKE.OBForceField_SetConformers(swigCPtr, OBMol.getCPtr(mol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBGridData GetGrid(double step, double padding, string type, double pchg) {
    IntPtr cPtr = openbabelPINVOKE.OBForceField_GetGrid(swigCPtr, step, padding, type, pchg);
    OBGridData ret = (cPtr == IntPtr.Zero) ? null : new OBGridData(cPtr, false);
    return ret;
  }

  public void AddIntraGroup(OBBitVec group) {
    openbabelPINVOKE.OBForceField_AddIntraGroup(swigCPtr, OBBitVec.getCPtr(group));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void AddInterGroup(OBBitVec group) {
    openbabelPINVOKE.OBForceField_AddInterGroup(swigCPtr, OBBitVec.getCPtr(group));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void AddInterGroups(OBBitVec group1, OBBitVec group2) {
    openbabelPINVOKE.OBForceField_AddInterGroups(swigCPtr, OBBitVec.getCPtr(group1), OBBitVec.getCPtr(group2));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void ClearGroups() {
    openbabelPINVOKE.OBForceField_ClearGroups(swigCPtr);
  }

  public bool HasGroups() {
    bool ret = openbabelPINVOKE.OBForceField_HasGroups(swigCPtr);
    return ret;
  }

  public void EnableCutOff(bool enable) {
    openbabelPINVOKE.OBForceField_EnableCutOff(swigCPtr, enable);
  }

  public bool IsCutOffEnabled() {
    bool ret = openbabelPINVOKE.OBForceField_IsCutOffEnabled(swigCPtr);
    return ret;
  }

  public void SetVDWCutOff(double r) {
    openbabelPINVOKE.OBForceField_SetVDWCutOff(swigCPtr, r);
  }

  public double GetVDWCutOff() {
    double ret = openbabelPINVOKE.OBForceField_GetVDWCutOff(swigCPtr);
    return ret;
  }

  public void SetElectrostaticCutOff(double r) {
    openbabelPINVOKE.OBForceField_SetElectrostaticCutOff(swigCPtr, r);
  }

  public double GetElectrostaticCutOff() {
    double ret = openbabelPINVOKE.OBForceField_GetElectrostaticCutOff(swigCPtr);
    return ret;
  }

  public void SetUpdateFrequency(int f) {
    openbabelPINVOKE.OBForceField_SetUpdateFrequency(swigCPtr, f);
  }

  public int GetUpdateFrequency() {
    int ret = openbabelPINVOKE.OBForceField_GetUpdateFrequency(swigCPtr);
    return ret;
  }

  public void UpdatePairsSimple() {
    openbabelPINVOKE.OBForceField_UpdatePairsSimple(swigCPtr);
  }

  public uint GetNumPairs() {
    uint ret = openbabelPINVOKE.OBForceField_GetNumPairs(swigCPtr);
    return ret;
  }

  public void EnableAllPairs() {
    openbabelPINVOKE.OBForceField_EnableAllPairs(swigCPtr);
  }

  public virtual double Energy(bool arg0) {
    double ret = openbabelPINVOKE.OBForceField_Energy__SWIG_0(swigCPtr, arg0);
    return ret;
  }

  public virtual double Energy() {
    double ret = openbabelPINVOKE.OBForceField_Energy__SWIG_1(swigCPtr);
    return ret;
  }

  public virtual double E_Bond(bool arg0) {
    double ret = openbabelPINVOKE.OBForceField_E_Bond__SWIG_0(swigCPtr, arg0);
    return ret;
  }

  public virtual double E_Bond() {
    double ret = openbabelPINVOKE.OBForceField_E_Bond__SWIG_1(swigCPtr);
    return ret;
  }

  public virtual double E_Angle(bool arg0) {
    double ret = openbabelPINVOKE.OBForceField_E_Angle__SWIG_0(swigCPtr, arg0);
    return ret;
  }

  public virtual double E_Angle() {
    double ret = openbabelPINVOKE.OBForceField_E_Angle__SWIG_1(swigCPtr);
    return ret;
  }

  public virtual double E_StrBnd(bool arg0) {
    double ret = openbabelPINVOKE.OBForceField_E_StrBnd__SWIG_0(swigCPtr, arg0);
    return ret;
  }

  public virtual double E_StrBnd() {
    double ret = openbabelPINVOKE.OBForceField_E_StrBnd__SWIG_1(swigCPtr);
    return ret;
  }

  public virtual double E_Torsion(bool arg0) {
    double ret = openbabelPINVOKE.OBForceField_E_Torsion__SWIG_0(swigCPtr, arg0);
    return ret;
  }

  public virtual double E_Torsion() {
    double ret = openbabelPINVOKE.OBForceField_E_Torsion__SWIG_1(swigCPtr);
    return ret;
  }

  public virtual double E_OOP(bool arg0) {
    double ret = openbabelPINVOKE.OBForceField_E_OOP__SWIG_0(swigCPtr, arg0);
    return ret;
  }

  public virtual double E_OOP() {
    double ret = openbabelPINVOKE.OBForceField_E_OOP__SWIG_1(swigCPtr);
    return ret;
  }

  public virtual double E_VDW(bool arg0) {
    double ret = openbabelPINVOKE.OBForceField_E_VDW__SWIG_0(swigCPtr, arg0);
    return ret;
  }

  public virtual double E_VDW() {
    double ret = openbabelPINVOKE.OBForceField_E_VDW__SWIG_1(swigCPtr);
    return ret;
  }

  public virtual double E_Electrostatic(bool arg0) {
    double ret = openbabelPINVOKE.OBForceField_E_Electrostatic__SWIG_0(swigCPtr, arg0);
    return ret;
  }

  public virtual double E_Electrostatic() {
    double ret = openbabelPINVOKE.OBForceField_E_Electrostatic__SWIG_1(swigCPtr);
    return ret;
  }

  public void PrintTypes() {
    openbabelPINVOKE.OBForceField_PrintTypes(swigCPtr);
  }

  public void PrintFormalCharges() {
    openbabelPINVOKE.OBForceField_PrintFormalCharges(swigCPtr);
  }

  public void PrintPartialCharges() {
    openbabelPINVOKE.OBForceField_PrintPartialCharges(swigCPtr);
  }

  public void PrintVelocities() {
    openbabelPINVOKE.OBForceField_PrintVelocities(swigCPtr);
  }

  public bool SetLogFile(SWIGTYPE_p_std__ostream pos) {
    bool ret = openbabelPINVOKE.OBForceField_SetLogFile(swigCPtr, SWIGTYPE_p_std__ostream.getCPtr(pos));
    return ret;
  }

  public bool SetLogLevel(int level) {
    bool ret = openbabelPINVOKE.OBForceField_SetLogLevel(swigCPtr, level);
    return ret;
  }

  public int GetLogLevel() {
    int ret = openbabelPINVOKE.OBForceField_GetLogLevel(swigCPtr);
    return ret;
  }

  public void OBFFLog(string msg) {
    openbabelPINVOKE.OBForceField_OBFFLog__SWIG_0(swigCPtr, msg);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void DistanceGeometry() {
    openbabelPINVOKE.OBForceField_DistanceGeometry(swigCPtr);
  }

  public void SystematicRotorSearch(uint geomSteps) {
    openbabelPINVOKE.OBForceField_SystematicRotorSearch__SWIG_0(swigCPtr, geomSteps);
  }

  public void SystematicRotorSearch() {
    openbabelPINVOKE.OBForceField_SystematicRotorSearch__SWIG_1(swigCPtr);
  }

  public int SystematicRotorSearchInitialize(uint geomSteps) {
    int ret = openbabelPINVOKE.OBForceField_SystematicRotorSearchInitialize__SWIG_0(swigCPtr, geomSteps);
    return ret;
  }

  public int SystematicRotorSearchInitialize() {
    int ret = openbabelPINVOKE.OBForceField_SystematicRotorSearchInitialize__SWIG_1(swigCPtr);
    return ret;
  }

  public bool SystematicRotorSearchNextConformer(uint geomSteps) {
    bool ret = openbabelPINVOKE.OBForceField_SystematicRotorSearchNextConformer__SWIG_0(swigCPtr, geomSteps);
    return ret;
  }

  public bool SystematicRotorSearchNextConformer() {
    bool ret = openbabelPINVOKE.OBForceField_SystematicRotorSearchNextConformer__SWIG_1(swigCPtr);
    return ret;
  }

  public void RandomRotorSearch(uint conformers, uint geomSteps) {
    openbabelPINVOKE.OBForceField_RandomRotorSearch__SWIG_0(swigCPtr, conformers, geomSteps);
  }

  public void RandomRotorSearch(uint conformers) {
    openbabelPINVOKE.OBForceField_RandomRotorSearch__SWIG_1(swigCPtr, conformers);
  }

  public void RandomRotorSearchInitialize(uint conformers, uint geomSteps) {
    openbabelPINVOKE.OBForceField_RandomRotorSearchInitialize__SWIG_0(swigCPtr, conformers, geomSteps);
  }

  public void RandomRotorSearchInitialize(uint conformers) {
    openbabelPINVOKE.OBForceField_RandomRotorSearchInitialize__SWIG_1(swigCPtr, conformers);
  }

  public bool RandomRotorSearchNextConformer(uint geomSteps) {
    bool ret = openbabelPINVOKE.OBForceField_RandomRotorSearchNextConformer__SWIG_0(swigCPtr, geomSteps);
    return ret;
  }

  public bool RandomRotorSearchNextConformer() {
    bool ret = openbabelPINVOKE.OBForceField_RandomRotorSearchNextConformer__SWIG_1(swigCPtr);
    return ret;
  }

  public void WeightedRotorSearch(uint conformers, uint geomSteps) {
    openbabelPINVOKE.OBForceField_WeightedRotorSearch(swigCPtr, conformers, geomSteps);
  }

  public void SetLineSearchType(int type) {
    openbabelPINVOKE.OBForceField_SetLineSearchType(swigCPtr, type);
  }

  public int GetLineSearchType() {
    int ret = openbabelPINVOKE.OBForceField_GetLineSearchType(swigCPtr);
    return ret;
  }

  public vector3 LineSearch(OBAtom atom, vector3 direction) {
    vector3 ret = new vector3(openbabelPINVOKE.OBForceField_LineSearch__SWIG_0(swigCPtr, OBAtom.getCPtr(atom), vector3.getCPtr(direction)), true);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public double LineSearch(SWIGTYPE_p_double currentCoords, SWIGTYPE_p_double direction) {
    double ret = openbabelPINVOKE.OBForceField_LineSearch__SWIG_1(swigCPtr, SWIGTYPE_p_double.getCPtr(currentCoords), SWIGTYPE_p_double.getCPtr(direction));
    return ret;
  }

  public double Newton2NumLineSearch(SWIGTYPE_p_double direction) {
    double ret = openbabelPINVOKE.OBForceField_Newton2NumLineSearch(swigCPtr, SWIGTYPE_p_double.getCPtr(direction));
    return ret;
  }

  public void LineSearchTakeStep(SWIGTYPE_p_double origCoords, SWIGTYPE_p_double direction, double step) {
    openbabelPINVOKE.OBForceField_LineSearchTakeStep(swigCPtr, SWIGTYPE_p_double.getCPtr(origCoords), SWIGTYPE_p_double.getCPtr(direction), step);
  }

  public void SteepestDescent(int steps, double econv, int method) {
    openbabelPINVOKE.OBForceField_SteepestDescent__SWIG_0(swigCPtr, steps, econv, method);
  }

  public void SteepestDescent(int steps, double econv) {
    openbabelPINVOKE.OBForceField_SteepestDescent__SWIG_1(swigCPtr, steps, econv);
  }

  public void SteepestDescent(int steps) {
    openbabelPINVOKE.OBForceField_SteepestDescent__SWIG_2(swigCPtr, steps);
  }

  public void SteepestDescentInitialize(int steps, double econv, int method) {
    openbabelPINVOKE.OBForceField_SteepestDescentInitialize__SWIG_0(swigCPtr, steps, econv, method);
  }

  public void SteepestDescentInitialize(int steps, double econv) {
    openbabelPINVOKE.OBForceField_SteepestDescentInitialize__SWIG_1(swigCPtr, steps, econv);
  }

  public void SteepestDescentInitialize(int steps) {
    openbabelPINVOKE.OBForceField_SteepestDescentInitialize__SWIG_2(swigCPtr, steps);
  }

  public void SteepestDescentInitialize() {
    openbabelPINVOKE.OBForceField_SteepestDescentInitialize__SWIG_3(swigCPtr);
  }

  public bool SteepestDescentTakeNSteps(int n) {
    bool ret = openbabelPINVOKE.OBForceField_SteepestDescentTakeNSteps(swigCPtr, n);
    return ret;
  }

  public void ConjugateGradients(int steps, double econv, int method) {
    openbabelPINVOKE.OBForceField_ConjugateGradients__SWIG_0(swigCPtr, steps, econv, method);
  }

  public void ConjugateGradients(int steps, double econv) {
    openbabelPINVOKE.OBForceField_ConjugateGradients__SWIG_1(swigCPtr, steps, econv);
  }

  public void ConjugateGradients(int steps) {
    openbabelPINVOKE.OBForceField_ConjugateGradients__SWIG_2(swigCPtr, steps);
  }

  public void ConjugateGradientsInitialize(int steps, double econv, int method) {
    openbabelPINVOKE.OBForceField_ConjugateGradientsInitialize__SWIG_0(swigCPtr, steps, econv, method);
  }

  public void ConjugateGradientsInitialize(int steps, double econv) {
    openbabelPINVOKE.OBForceField_ConjugateGradientsInitialize__SWIG_1(swigCPtr, steps, econv);
  }

  public void ConjugateGradientsInitialize(int steps) {
    openbabelPINVOKE.OBForceField_ConjugateGradientsInitialize__SWIG_2(swigCPtr, steps);
  }

  public void ConjugateGradientsInitialize() {
    openbabelPINVOKE.OBForceField_ConjugateGradientsInitialize__SWIG_3(swigCPtr);
  }

  public bool ConjugateGradientsTakeNSteps(int n) {
    bool ret = openbabelPINVOKE.OBForceField_ConjugateGradientsTakeNSteps(swigCPtr, n);
    return ret;
  }

  public void GenerateVelocities() {
    openbabelPINVOKE.OBForceField_GenerateVelocities(swigCPtr);
  }

  public void CorrectVelocities() {
    openbabelPINVOKE.OBForceField_CorrectVelocities(swigCPtr);
  }

  public void MolecularDynamicsTakeNSteps(int n, double T, double timestep, int method) {
    openbabelPINVOKE.OBForceField_MolecularDynamicsTakeNSteps__SWIG_0(swigCPtr, n, T, timestep, method);
  }

  public void MolecularDynamicsTakeNSteps(int n, double T, double timestep) {
    openbabelPINVOKE.OBForceField_MolecularDynamicsTakeNSteps__SWIG_1(swigCPtr, n, T, timestep);
  }

  public void MolecularDynamicsTakeNSteps(int n, double T) {
    openbabelPINVOKE.OBForceField_MolecularDynamicsTakeNSteps__SWIG_2(swigCPtr, n, T);
  }

  public OBFFConstraints GetConstraints() {
    OBFFConstraints ret = new OBFFConstraints(openbabelPINVOKE.OBForceField_GetConstraints(swigCPtr), false);
    return ret;
  }

  public void SetConstraints(OBFFConstraints constraints) {
    openbabelPINVOKE.OBForceField_SetConstraints(swigCPtr, OBFFConstraints.getCPtr(constraints));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetFixAtom(int index) {
    openbabelPINVOKE.OBForceField_SetFixAtom(swigCPtr, index);
  }

  public void UnsetFixAtom() {
    openbabelPINVOKE.OBForceField_UnsetFixAtom(swigCPtr);
  }

  public void SetIgnoreAtom(int index) {
    openbabelPINVOKE.OBForceField_SetIgnoreAtom(swigCPtr, index);
  }

  public void UnsetIgnoreAtom() {
    openbabelPINVOKE.OBForceField_UnsetIgnoreAtom(swigCPtr);
  }

  public static bool IgnoreCalculation(int a, int b) {
    bool ret = openbabelPINVOKE.OBForceField_IgnoreCalculation__SWIG_0(a, b);
    return ret;
  }

  public static bool IgnoreCalculation(int a, int b, int c) {
    bool ret = openbabelPINVOKE.OBForceField_IgnoreCalculation__SWIG_1(a, b, c);
    return ret;
  }

  public static bool IgnoreCalculation(int a, int b, int c, int d) {
    bool ret = openbabelPINVOKE.OBForceField_IgnoreCalculation__SWIG_2(a, b, c, d);
    return ret;
  }

  public bool DetectExplosion() {
    bool ret = openbabelPINVOKE.OBForceField_DetectExplosion(swigCPtr);
    return ret;
  }

  public vector3 ValidateLineSearch(OBAtom atom, vector3 direction) {
    vector3 ret = new vector3(openbabelPINVOKE.OBForceField_ValidateLineSearch(swigCPtr, OBAtom.getCPtr(atom), vector3.getCPtr(direction)), true);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void ValidateSteepestDescent(int steps) {
    openbabelPINVOKE.OBForceField_ValidateSteepestDescent(swigCPtr, steps);
  }

  public void ValidateConjugateGradients(int steps) {
    openbabelPINVOKE.OBForceField_ValidateConjugateGradients(swigCPtr, steps);
  }

  public virtual bool Validate() {
    bool ret = openbabelPINVOKE.OBForceField_Validate(swigCPtr);
    return ret;
  }

  public virtual bool ValidateGradients() {
    bool ret = openbabelPINVOKE.OBForceField_ValidateGradients(swigCPtr);
    return ret;
  }

  public vector3 ValidateGradientError(vector3 numgrad, vector3 anagrad) {
    vector3 ret = new vector3(openbabelPINVOKE.OBForceField_ValidateGradientError(swigCPtr, vector3.getCPtr(numgrad), vector3.getCPtr(anagrad)), true);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static double VectorBondDerivative(SWIGTYPE_p_double pos_a, SWIGTYPE_p_double pos_b, SWIGTYPE_p_double force_a, SWIGTYPE_p_double force_b) {
    double ret = openbabelPINVOKE.OBForceField_VectorBondDerivative(SWIGTYPE_p_double.getCPtr(pos_a), SWIGTYPE_p_double.getCPtr(pos_b), SWIGTYPE_p_double.getCPtr(force_a), SWIGTYPE_p_double.getCPtr(force_b));
    return ret;
  }

  public static double VectorDistanceDerivative(SWIGTYPE_p_double pos_i, SWIGTYPE_p_double pos_j, SWIGTYPE_p_double force_i, SWIGTYPE_p_double force_j) {
    double ret = openbabelPINVOKE.OBForceField_VectorDistanceDerivative(SWIGTYPE_p_double.getCPtr(pos_i), SWIGTYPE_p_double.getCPtr(pos_j), SWIGTYPE_p_double.getCPtr(force_i), SWIGTYPE_p_double.getCPtr(force_j));
    return ret;
  }

  public static double VectorLengthDerivative(vector3 a, vector3 b) {
    double ret = openbabelPINVOKE.OBForceField_VectorLengthDerivative(vector3.getCPtr(a), vector3.getCPtr(b));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static double VectorAngleDerivative(SWIGTYPE_p_double pos_a, SWIGTYPE_p_double pos_b, SWIGTYPE_p_double pos_c, SWIGTYPE_p_double force_a, SWIGTYPE_p_double force_b, SWIGTYPE_p_double force_c) {
    double ret = openbabelPINVOKE.OBForceField_VectorAngleDerivative__SWIG_0(SWIGTYPE_p_double.getCPtr(pos_a), SWIGTYPE_p_double.getCPtr(pos_b), SWIGTYPE_p_double.getCPtr(pos_c), SWIGTYPE_p_double.getCPtr(force_a), SWIGTYPE_p_double.getCPtr(force_b), SWIGTYPE_p_double.getCPtr(force_c));
    return ret;
  }

  public static double VectorAngleDerivative(vector3 a, vector3 b, vector3 c) {
    double ret = openbabelPINVOKE.OBForceField_VectorAngleDerivative__SWIG_1(vector3.getCPtr(a), vector3.getCPtr(b), vector3.getCPtr(c));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static double VectorOOPDerivative(SWIGTYPE_p_double pos_a, SWIGTYPE_p_double pos_b, SWIGTYPE_p_double pos_c, SWIGTYPE_p_double pos_d, SWIGTYPE_p_double force_a, SWIGTYPE_p_double force_b, SWIGTYPE_p_double force_c, SWIGTYPE_p_double force_d) {
    double ret = openbabelPINVOKE.OBForceField_VectorOOPDerivative__SWIG_0(SWIGTYPE_p_double.getCPtr(pos_a), SWIGTYPE_p_double.getCPtr(pos_b), SWIGTYPE_p_double.getCPtr(pos_c), SWIGTYPE_p_double.getCPtr(pos_d), SWIGTYPE_p_double.getCPtr(force_a), SWIGTYPE_p_double.getCPtr(force_b), SWIGTYPE_p_double.getCPtr(force_c), SWIGTYPE_p_double.getCPtr(force_d));
    return ret;
  }

  public static double VectorOOPDerivative(vector3 a, vector3 b, vector3 c, vector3 d) {
    double ret = openbabelPINVOKE.OBForceField_VectorOOPDerivative__SWIG_1(vector3.getCPtr(a), vector3.getCPtr(b), vector3.getCPtr(c), vector3.getCPtr(d));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static double VectorTorsionDerivative(SWIGTYPE_p_double pos_a, SWIGTYPE_p_double pos_b, SWIGTYPE_p_double pos_c, SWIGTYPE_p_double pos_d, SWIGTYPE_p_double force_a, SWIGTYPE_p_double force_b, SWIGTYPE_p_double force_c, SWIGTYPE_p_double force_d) {
    double ret = openbabelPINVOKE.OBForceField_VectorTorsionDerivative__SWIG_0(SWIGTYPE_p_double.getCPtr(pos_a), SWIGTYPE_p_double.getCPtr(pos_b), SWIGTYPE_p_double.getCPtr(pos_c), SWIGTYPE_p_double.getCPtr(pos_d), SWIGTYPE_p_double.getCPtr(force_a), SWIGTYPE_p_double.getCPtr(force_b), SWIGTYPE_p_double.getCPtr(force_c), SWIGTYPE_p_double.getCPtr(force_d));
    return ret;
  }

  public static double VectorTorsionDerivative(vector3 a, vector3 b, vector3 c, vector3 d) {
    double ret = openbabelPINVOKE.OBForceField_VectorTorsionDerivative__SWIG_1(vector3.getCPtr(a), vector3.getCPtr(b), vector3.getCPtr(c), vector3.getCPtr(d));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void VectorSubtract(SWIGTYPE_p_double i, SWIGTYPE_p_double j, SWIGTYPE_p_double result) {
    openbabelPINVOKE.OBForceField_VectorSubtract__SWIG_0(SWIGTYPE_p_double.getCPtr(i), SWIGTYPE_p_double.getCPtr(j), SWIGTYPE_p_double.getCPtr(result));
  }

  public static void VectorAdd(SWIGTYPE_p_double i, SWIGTYPE_p_double j, SWIGTYPE_p_double result) {
    openbabelPINVOKE.OBForceField_VectorAdd(SWIGTYPE_p_double.getCPtr(i), SWIGTYPE_p_double.getCPtr(j), SWIGTYPE_p_double.getCPtr(result));
  }

  public static void VectorDivide(SWIGTYPE_p_double i, double n, SWIGTYPE_p_double result) {
    openbabelPINVOKE.OBForceField_VectorDivide(SWIGTYPE_p_double.getCPtr(i), n, SWIGTYPE_p_double.getCPtr(result));
  }

  public static void VectorMultiply(SWIGTYPE_p_double i, double n, SWIGTYPE_p_double result) {
    openbabelPINVOKE.OBForceField_VectorMultiply__SWIG_0(SWIGTYPE_p_double.getCPtr(i), n, SWIGTYPE_p_double.getCPtr(result));
  }

  public static void VectorSelfMultiply(SWIGTYPE_p_double i, double n) {
    openbabelPINVOKE.OBForceField_VectorSelfMultiply(SWIGTYPE_p_double.getCPtr(i), n);
  }

  public static void VectorNormalize(SWIGTYPE_p_double i) {
    openbabelPINVOKE.OBForceField_VectorNormalize(SWIGTYPE_p_double.getCPtr(i));
  }

  public static void VectorCopy(SWIGTYPE_p_double from, SWIGTYPE_p_double to) {
    openbabelPINVOKE.OBForceField_VectorCopy(SWIGTYPE_p_double.getCPtr(from), SWIGTYPE_p_double.getCPtr(to));
  }

  public static double VectorLength(SWIGTYPE_p_double i) {
    double ret = openbabelPINVOKE.OBForceField_VectorLength(SWIGTYPE_p_double.getCPtr(i));
    return ret;
  }

  public static double VectorDistance(SWIGTYPE_p_double pos_i, SWIGTYPE_p_double pos_j) {
    double ret = openbabelPINVOKE.OBForceField_VectorDistance(SWIGTYPE_p_double.getCPtr(pos_i), SWIGTYPE_p_double.getCPtr(pos_j));
    return ret;
  }

  public static double VectorAngle(SWIGTYPE_p_double i, SWIGTYPE_p_double j, SWIGTYPE_p_double k) {
    double ret = openbabelPINVOKE.OBForceField_VectorAngle(SWIGTYPE_p_double.getCPtr(i), SWIGTYPE_p_double.getCPtr(j), SWIGTYPE_p_double.getCPtr(k));
    return ret;
  }

  public static double VectorTorsion(SWIGTYPE_p_double i, SWIGTYPE_p_double j, SWIGTYPE_p_double k, SWIGTYPE_p_double l) {
    double ret = openbabelPINVOKE.OBForceField_VectorTorsion(SWIGTYPE_p_double.getCPtr(i), SWIGTYPE_p_double.getCPtr(j), SWIGTYPE_p_double.getCPtr(k), SWIGTYPE_p_double.getCPtr(l));
    return ret;
  }

  public static double VectorOOP(SWIGTYPE_p_double i, SWIGTYPE_p_double j, SWIGTYPE_p_double k, SWIGTYPE_p_double l) {
    double ret = openbabelPINVOKE.OBForceField_VectorOOP(SWIGTYPE_p_double.getCPtr(i), SWIGTYPE_p_double.getCPtr(j), SWIGTYPE_p_double.getCPtr(k), SWIGTYPE_p_double.getCPtr(l));
    return ret;
  }

  public static void VectorClear(SWIGTYPE_p_double i) {
    openbabelPINVOKE.OBForceField_VectorClear(SWIGTYPE_p_double.getCPtr(i));
  }

  public static double VectorDot(SWIGTYPE_p_double i, SWIGTYPE_p_double j) {
    double ret = openbabelPINVOKE.OBForceField_VectorDot(SWIGTYPE_p_double.getCPtr(i), SWIGTYPE_p_double.getCPtr(j));
    return ret;
  }

  public static void VectorCross(SWIGTYPE_p_double i, SWIGTYPE_p_double j, SWIGTYPE_p_double result) {
    openbabelPINVOKE.OBForceField_VectorCross(SWIGTYPE_p_double.getCPtr(i), SWIGTYPE_p_double.getCPtr(j), SWIGTYPE_p_double.getCPtr(result));
  }

  public static void PrintVector(SWIGTYPE_p_double i) {
    openbabelPINVOKE.OBForceField_PrintVector(SWIGTYPE_p_double.getCPtr(i));
  }

}
