/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | Copyright (C) 1991-2005 OpenCFD Ltd.
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
    Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.

    OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Application
    elasticPlasticNonLinULSolidFoam

Description
    Finite volume structural solver employing a incremental strain updated
    Lagrangian approach.
    
    Valid for small strains, finite displacements and finite rotations.

    Note: the reason the solver is not strictly valid for large strains is because
    the constitutive stiffness tensor is not rotated.
    For an updated Lagrangian solver which does rotate the stiffness tensor, and
    hence is strictly Valid for large strains, use elasticOrthoNonLinULSolidFoam.
    
Author
    Philip Cardiff UCD
    philip.cardiff@gmail.com

\*---------------------------------------------------------------------------*/

#include "fvCFD.H"
#include "constitutiveModel.H"
#include "volPointInterpolation.H"
#include "pointPatchInterpolation.H"
#include "primitivePatchInterpolation.H"
#include "pointFields.H"
#include "twoDPointCorrector.H"
#include "leastSquaresVolPointInterpolation.H"
#include "transformGeometricField.H"
#include "solidContactFvPatchVectorField.H"
#include "pointMesh.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
# include "createFields.H"
# include "createHistory.H"
# include "readDivDSigmaExpMethod.H"
# include "readDivDSigmaNonLinExpMethod.H"
# include "readMoveMeshMethod.H"

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

  Info << "\nStarting time loop\n" << endl;
  
  for (runTime++; !runTime.end(); runTime++)
    {
      Info<< "Time = " << runTime.timeName() << nl << endl;
      	  
#     include "readStressedFoamControls.H"

      int iCorr = 0;
      lduMatrix::solverPerformance solverPerf;
      scalar initialResidual = 0;
      scalar relativeResidual = GREAT;
      lduMatrix::debug = 0;

      //- to minimise accumulation of errors
      // volVectorField divSigmaOld = fvc::div(sigma);
      
      do
	{ 
	  DU.storePrevIter();

#         include "calculateDivDSigmaExp.H"	  
#         include "calculateDivDSigmaNonLinExp.H"

	  //----------------------------------------------------//
	  //- updated lagrangian large strain momentum equation
	  //----------------------------------------------------//
	  fvVectorMatrix DUEqn
	    (
	     fvm::d2dt2(rho,DU)
	     ==
	     fvm::laplacian(2*muf + lambdaf, DU, "laplacian(DDU,DU)")
	     + divDSigmaExp
	     + divDSigmaNonLinExp
	     //- fvc::div(2*mu*DEpsilonP, "div(sigma)")
	     - fvc::div(2*muf*( mesh.Sf() & fvc::interpolate(DEpsilonP)) )
	     );
	  
	  if(nonLinearSemiImplicit)
	    {
	      // experimental
	      // we can treat the nonlinear term (gradDU & gradDU.T()) in a
	      // semi-implicit over-relaxed manner
	      // this should improve convergence when gradDU is large
	      // but maybe not execution time
	      DUEqn -=
		fvm::laplacian((2*mu + lambda)*gradDU, DU, "laplacian(DDU,DU)")
		- fvc::div( (2*mu + lambda)*(gradDU&gradDU), "div(sigma)");
	    }

	  solverPerf = DUEqn.solve();

	  if(iCorr == 0)
            {
	      initialResidual = solverPerf.initialResidual();
            }
	 
          if(aitkenRelax)
            {
#             include "aitkenRelaxation.H"
            }
          else
            {
              DU.relax();
            }

	  gradDU = fvc::grad(DU);

	  // correct plasticty term
	  rheology.correct();

	  // correct elastic properties
	  // for nonlinear elastic materials
	  //mu = rheology.newMu();
	  //lambda = rheology.newLambda();
	  //muf = fvc::interpolate(mu);
	  //lambdaf = fvc::interpolate(lambda);
	  
#         include "calculateDEpsilonDSigma.H"
#         include "calculateRelativeResidual.H"
	  	  
          if(iCorr % infoFrequency == 0)
            {
              Info << "\tTime " << runTime.value()
                   << ", Corrector " << iCorr
                   << ", Solving for " << DU.name()
                   << " using " << solverPerf.solverName()
                   << ", res = " << solverPerf.initialResidual()
                   << ", rel res = " << relativeResidual;
              if(aitkenRelax) Info << ", aitken = " << aitkenTheta;
              Info << ", iters = " << solverPerf.nIterations() << endl;
            }
        }
      while
        (
         iCorr++ < 2
         ||
         (//solverPerf.initialResidual() > convergenceTolerance
          relativeResidual > convergenceTolerance
          &&
          iCorr < nCorr)
	 );

      lduMatrix::debug = 1;
            
      Info << nl << "Time " << runTime.value() << ", Solving for " << DU.name() 
	   << ", Initial residual = " << initialResidual 
	   << ", Final residual = " << solverPerf.initialResidual()
	   << ", Final rel residual = " << relativeResidual
	   << ", No outer iterations " << iCorr << endl;

      rheology.updateYieldStress();

      U += DU;
      epsilon += DEpsilon;
      epsilonP += DEpsilonP;
      sigma += DSigma;

#     include "moveMesh.H"
#     include "rotateFields.H"
#     include "writeFields.H"
#     include "writeHistory.H"

      Info << nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
	   << "  ClockTime = " << runTime.elapsedClockTime() << " s" 
	   << endl;
    }
  
  Info<< "End\n" << endl;
  
  return(0);
}

// ************************************************************************* //