Sacado_Wrapper::SymTensor< dim > Class Template Reference

#include <Sacado_Wrapper.h>

Inheritance diagram for Sacado_Wrapper::SymTensor< dim >:

Collaboration diagram for Sacado_Wrapper::SymTensor< dim >:

Public Member Functions
	SymTensor ()
void	init (SymmetricTensor< 2, dim > &tensor_double)
void	set_dofs (unsigned int nbr_total_dofs=n_dofs)
void	get_tangent (SymmetricTensor< 4, dim > &Tangent, SymmetricTensor< 2, dim, fad_double > &sigma)
void	get_tangent (SymmetricTensor< 2, dim > &Tangent, fad_double &argument)
void	get_values (SymmetricTensor< 2, dim > &tensor_double)
SymmetricTensor< 2, dim >	get_value ()

Public Attributes
std::map< unsigned int, std::pair< unsigned int, unsigned int > >	std_map_indicies
unsigned int	start_index = 0

Static Public Attributes
static const unsigned int	n_dofs = ((dim==2)?3:6)

Constructor & Destructor Documentation

SymTensor()

template<int dim>

Sacado_Wrapper::SymTensor< dim >::SymTensor ( )

inline

        {
            get_index_map<dim>( std_map_indicies );
        }

Member Function Documentation

get_tangent() [1/2]

template<int dim>

void Sacado_Wrapper::SymTensor< dim >::get_tangent	(	SymmetricTensor< 4, dim > &	Tangent,
		SymmetricTensor< 2, dim, fad_double > &	sigma
	)

Referenced by sacado_test_10(), sacado_test_3B(), and sacado_test_4().

    {
        for ( unsigned int i=0; i<dim; ++i)
            for ( unsigned int j=0; j<dim; ++j )
            {
                double *derivs = &sigma[i][j].fastAccessDx(0); // Access the derivatives of the (i,j)-th component of \a sigma

                // We loop over all the dofs. To be able to use this independent of the chosen dimension \a dim, we use a ternary operator
                // to decide whether we have to loop over 6 derivatives or just 3.
                for(unsigned int x=start_index;x<(start_index+n_dofs);++x)
                {
                    unsigned int k=std_map_indicies[x].first;
                    unsigned int l=std_map_indicies[x].second;

                    if(k!=l)/*Compare to Voigt notation since only SymmetricTensor instead of Tensor*/
                    {
                        Tangent[i][j][k][l] = 0.5*derivs[x];
                        Tangent[i][j][l][k] = 0.5*derivs[x];
                    }
                    else
                        Tangent[i][j][k][l] = derivs[x];
                }
            }
    }

get_tangent() [2/2]

template<int dim>

void Sacado_Wrapper::SymTensor< dim >::get_tangent	(	SymmetricTensor< 2, dim > &	Tangent,
		fad_double &	argument
	)

    {
        double *derivs = &argument.fastAccessDx(0); // Access derivatives
        for(unsigned int x=start_index;x<(start_index+n_dofs);++x)
        {
            unsigned int k=std_map_indicies[x].first;
            unsigned int l=std_map_indicies[x].second;

            Tangent[k][l] = derivs[x]; // ToDo: check whether the 0.5* is necessary here too

            // Correct the off-diagonal terms by the factor of 0.5
             if(k!=l)/*Compare to Voigt notation since only SymmetricTensor instead of Tensor*/
                Tangent[k][l] *= 0.5; // ToDo: check whether the 0.5* is necessary here too
        }
    }

get_value()

template<int dim>

SymmetricTensor< 2, dim > Sacado_Wrapper::SymTensor< dim >::get_value

(

)

References Sacado_Wrapper::SymTensor< dim >::get_values().

    {
        SymmetricTensor<2,dim> tmp;
        (*this).get_values(tmp);
        return tmp;
    }

get_values()

template<int dim>

void Sacado_Wrapper::SymTensor< dim >::get_values

(

SymmetricTensor< 2, dim > &

tensor_double

)

Referenced by Sacado_Wrapper::SymTensor< dim >::get_value().

    {
        for ( unsigned int i=0; i<dim; ++i)
            for ( unsigned int j=0; j<dim; ++j )
                tensor_double[i][j] = ((*this)[i][j]).val();
    }

init()

template<int dim>

void Sacado_Wrapper::SymTensor< dim >::init

(

SymmetricTensor< 2, dim > &

tensor_double

)

Referenced by sacado_test_10(), sacado_test_3B(), and sacado_test_4().

    {
         for ( unsigned int i=0; i<dim; ++i)
            for ( unsigned int j=0; j<dim; ++j )
                (*this)[i][j] = tensor_double[i][j];
    }

set_dofs()

template<int dim>

void Sacado_Wrapper::SymTensor< dim >::set_dofs

(

unsigned int

nbr_total_dofs = n_dofs

)

Referenced by sacado_test_10(), sacado_test_3B(), and Sacado_Wrapper::DoFs_summary< dim >::set_dofs().

    {
        // Instead of calling the *.diff(*) on the components one-by-one we could also use the following for-loop, so
        // we also use the map to set the dofs
        for ( unsigned int x=start_index; x<(start_index+n_dofs); ++x )
        {
            unsigned int i=std_map_indicies[x].first;
            unsigned int j=std_map_indicies[x].second;
            (*this)[i][j].diff(x,nbr_total_dofs);
        }
    }

Member Data Documentation

n_dofs

template<int dim>

const unsigned int Sacado_Wrapper::SymTensor< dim >::n_dofs = ((dim==2)?3:6)

static

Referenced by Sacado_Wrapper::DoFs_summary< dim >::set_dofs().

start_index

template<int dim>

unsigned int Sacado_Wrapper::SymTensor< dim >::start_index = 0

Referenced by Sacado_Wrapper::DoFs_summary< dim >::set_dofs().

std_map_indicies

template<int dim>

std::map<unsigned int,std::pair<unsigned int,unsigned int> > Sacado_Wrapper::SymTensor< dim >::std_map_indicies

---

The documentation for this class was generated from the following file:

• Sacado_Wrapper.h