SlipSystem.cpp

Go to the documentation of this file.

/* This file is part of MoDELib, the Mechanics Of Defects Evolution Library.
 *
 *
 * MoDELib is distributed without any warranty under the
 * GNU General Public License (GPL) v2 <http://www.gnu.org/licenses/>.
 */
 
 
#ifndef model_SLIPSYSTEM_cpp_
#define model_SLIPSYSTEM_cpp_
 
#include <memory>
#include <assert.h>
#include <LatticeModule.h>
#include <DislocationMobilityBase.h>
#include <SlipSystem.h>
 
namespace model
{
 
    SlipSystem::SlipSystem(const GlidePlaneBase& n_in,
                           const RationalLatticeDirection<3>& slip_in,
                           const std::shared_ptr<DislocationMobility>& mobility_in,
                           const std::shared_ptr<GlidePlaneNoise>& planeNoise_in):
    /* init */ n(n_in)
    /* init */,s(slip_in)
    /* init */,unitNormal(n.cartesian().normalized())
    /* init */,unitSlip(s.cartesian().normalized())
    /* init */,unitSlipFull(n.primitiveVectors.first.cartesian().normalized())
    /* init */,G2Lfull((MatrixDim()<<unitSlipFull,unitNormal.cross(unitSlipFull),unitNormal).finished())
    /* init */,mobility(mobility_in)
    /* init */,planeNoise(planeNoise_in)
    {
        
        if(isPartial())
        {
            std::cout<<greenColor<<"Creating partial SlipSystem "<<this->sID<<defaultColor<<std::endl;
        }
        else
        {
            std::cout<<greenColor<<"Creating full SlipSystem "<<this->sID<<defaultColor<<std::endl;
        }
        
        std::cout<<"  s= "<<std::setprecision(15)<<std::scientific<<s.cartesian().transpose()<<std::endl;
        std::cout<<"  n= "<<std::setprecision(15)<<std::scientific<<n.cartesian().transpose()<<std::endl;
        std::cout<<"  mobility= "<<mobility->name<<std::endl;
        
        
        if(s.dot(n)!=0)
        {
            throw std::runtime_error("SlipSystem: PLANE NORMAL AND SLIP DIRECTION ARE NOT ORTHOGONAL.");
        }
        if(!mobility)
        {
            throw std::runtime_error("SlipSystem: MOBILITY CANNOT BE A NULLPTR.");
        }
        
        if((G2Lfull*G2Lfull.transpose()-MatrixDim::Identity()).squaredNorm()>FLT_EPSILON)
        {
            throw std::runtime_error("G2Lfull is not orthogonal.");
        }
        
    }
 
    bool SlipSystem::isPartial() const
    {
        return abs(s.rat.d)!=1;
    }
 
    bool SlipSystem::isSameAs(const RationalLatticeDirection<3>& s1,const ReciprocalLatticeDirection<3>& n1)
    {
        if(   ((s-s1).squaredNorm()==0 && (n-n1).base().squaredNorm()==0)
           || ((s+s1).squaredNorm()==0 && (n+n1).base().squaredNorm()==0)
           )
        {
            return true;
        }
        else
        {
            return false;
        }
    }
 
    Eigen::Matrix<double,2,1> SlipSystem::globalToLocal(const VectorDim& x) const
    {
        return (G2Lfull*x).template segment<2>(0);
    }
 
    Eigen::Matrix<double,3,1> SlipSystem::localToGlobal(const Eigen::Matrix<double,2,1>& x) const
    {
        return (G2Lfull.transpose()).template block<3,2>(0,0)*x;
    }
 
    std::tuple<Eigen::Matrix<double,3,3>,double,double> SlipSystem::gridInterp(const VectorDim& x) const
    {   // Added by Hyunsoo (hyunsol@g.clemson.edu)
        
        if(planeNoise)
        {
            const std::tuple<double,double,double> gridNoise(planeNoise->gridInterp(globalToLocal(x)));
            
            const Eigen::Matrix<double,3,3> ssStress( std::get<0>(gridNoise)*(G2Lfull.row(2).transpose()*G2Lfull.row(0)+G2Lfull.row(0).transpose()*G2Lfull.row(2))
                                                     +std::get<1>(gridNoise)*(G2Lfull.row(2).transpose()*G2Lfull.row(1)+G2Lfull.row(1).transpose()*G2Lfull.row(2)));
            const double ssRSS((ssStress*unitSlip).dot(unitNormal));
            return std::make_tuple(ssStress,ssRSS,std::get<2>(gridNoise));
        }
        else
        {
            return std::make_tuple(Eigen::Matrix<double,3,3>::Zero(),0.0,0.0);
        }
    }
 
    std::tuple<Eigen::Matrix<double,3,3>,double,double> SlipSystem::gridVal(const Eigen::Array<int,2,1>& idx) const
    {   // Added by Hyunsoo (hyunsol@g.clemson.edu)
        
        if(planeNoise)
        {
            const std::tuple<double,double,double> gridNoise(planeNoise->gridVal(idx));
            
            const Eigen::Matrix<double,3,3> ssStress( std::get<0>(gridNoise)*(G2Lfull.row(2).transpose()*G2Lfull.row(0)+G2Lfull.row(0).transpose()*G2Lfull.row(2))
                                                     +std::get<1>(gridNoise)*(G2Lfull.row(2).transpose()*G2Lfull.row(1)+G2Lfull.row(1).transpose()*G2Lfull.row(2)));
            const double ssRSS((ssStress*unitSlip).dot(unitNormal));
            return std::make_tuple(ssStress,ssRSS,std::get<2>(gridNoise));
        }
        else
        {
            return std::make_tuple(Eigen::Matrix<double,3,3>::Zero(),0.0,0.0);
        }
    }
 
double SlipSystem::velocity(const MatrixDim& S,const VectorDim& xi,const double& T) const
{
    return mobility? mobility->velocity(S,s.cartesian(),xi,unitNormal,T) : 0.0;
}
 
 
}
#endif