casesUtils.h

Go to the documentation of this file.

#ifndef HPP_CASESUTILS_H
#define HPP_CASESUTILS_H

#include <hpp/config.h>
#include <hpp/tensor.h>
#include <hpp/rotation.h>
#include <functional>
#include <stdexcept>
#include <memory>

namespace hpp 
{

template <typename U>
Tensor2<U> simpleShearDeformationGradient(U t, U shear_rate) {
    Tensor2<U> F = identityTensor2<U>(3);
    F(0,1) = shear_rate*t;
    return F;
}

template <typename U>
Tensor2<U> simpleShearVelocityGradient(U t, U shear_rate) {
    Tensor2<U> L(3,3);
    L(0,1) = shear_rate;
    return L;
}

template <typename U>
Tensor2<U> simpleCompressionDeformationGradient(U t, U comp_rate) {
    Tensor2<U> F(3,3);
    F(0,0) = std::exp(-0.5*comp_rate*t);
    F(1,1) = std::exp(-0.5*comp_rate*t);
    F(2,2) = std::exp(1.0*comp_rate*t);
    return F;
}

template <typename U>
Tensor2<U> simpleCompressionVelocityGradient(U t, U comp_rate) {
    Tensor2<U> L(3,3);
    L(0,0) = -0.5*comp_rate;
    L(1,1) = -0.5*comp_rate;
    L(2,2) = 1.0*comp_rate;
    return L;
}

template <typename U>
Tensor2<U> planeStrainCompressionDeformationGradient(U t, U comp_rate) {
    Tensor2<U> F(3,3);
    F(0,0) = std::exp(1.0*comp_rate*t);
    F(1,1) = 1.0;
    F(2,2) = std::exp(-1.0*comp_rate*t);
    return F;
}

template <typename U>
Tensor2<U> planeStrainCompressionVelocityGradient(U t, U comp_rate) {
    Tensor2<U> L(3,3);
    L(0,0) = 1.0*comp_rate;
    L(2,2) = -1.0*comp_rate;
    return L;
}

template <typename U>
Tensor2<U> staticDeformationGradient(U t) {
    Tensor2<U> F = identityTensor2<U>(3);
    return F;
}

template <typename U>
Tensor2<U> staticVelocityGradient(U t) {
    Tensor2<U> L(3,3);
    return L;
}

template <typename U>
class OrientationGenerator {
    public:
        virtual void generateNext(Tensor2<U>& rotMatrix) = 0;
        virtual void generateNext(EulerAngles<U>& angles) {
            Tensor2<U> rotMatrix(3,3);
            this->generateNext(rotMatrix);
            angles = getEulerZXZAngles(rotMatrix);
        }
        virtual ~OrientationGenerator() {};
};

template <typename U>
class RandomOrientationGenerator : public OrientationGenerator<U> {
    public:
        RandomOrientationGenerator() {;}
        virtual void generateNext(Tensor2<U>& rotMatrix) {
            randomRotationTensorInPlace(3, rotMatrix, true);
        } 
};

template <typename U>
class GridOrientationGenerator : public OrientationGenerator<U> {
    public:
        GridOrientationGenerator(int nTheta=8, int nPhi=4);
        virtual void generateNext(EulerAngles<U>& angles) {
            // Get angles
            U theta = iTheta*dTheta;
            U phi = iPhi*dPhi;
            angles = polarToEuler(theta, phi);
            
            // Prepare next angle
            iPhi++;
            if (iPhi == nPhi) {
                iPhi = 0;
                iTheta++;
                iTheta = iTheta % nTheta;
            }
        };
        virtual void generateNext(Tensor2<U>& rotMatrix) {
            EulerAngles<U> angles;
            this->generateNext(angles);
            rotMatrix = EulerZXZRotationMatrix(angles);
        };
        
    private:        
        int nTheta; 
        int nPhi; 
        int iTheta = 0; 
        int iPhi = 0; 
        U dTheta; 
        U dPhi; 
};

template <typename U>
class Experiment {
    
    public:
        explicit Experiment(std::string experimentName);
        U tStart; 
        U tEnd; 
        U strainRate; 
        std::function<Tensor2<U>(U)> F_of_t;
        std::function<Tensor2<U>(U)> L_of_t;
        std::shared_ptr<OrientationGenerator<U>> orientationGenerator;
        
        // Generating next orientation
        void generateNextOrientationInPlace(Tensor2<U>& rotMatrix) {this->orientationGenerator->generateNext(rotMatrix);}
        void generateNextOrientationInPlace(EulerAngles<U>& angles) {this->orientationGenerator->generateNext(angles);}
        EulerAngles<U> generateNextOrientationAngles() {
            EulerAngles<U> angles;
            this->orientationGenerator->generateNext(angles);
            return angles;
        }
        
        // Getters/setters (mainly intended for Python interface)
        U getTStart() const {return tStart;}
        U getTEnd() const {return tEnd;}
        U getStrainRate() const {return strainRate;}
        std::function<Tensor2<U>(U)> getF_of_t() const {return F_of_t;}
        std::function<Tensor2<U>(U)> getL_of_t() const {return L_of_t;}
};

} // END NAMESPACE hpp

#endif /* HPP_CASESUTILS_H */