include/ewalena/base/tensor_tools.h

Go to the documentation of this file.

// -------------------------------------------------------------------
// @author Toby D. Young
// @version $Id: tensor.h 808 2012-06-27 18:32:20Z oneliefleft $
//
// Copyright 2012 namespace ewalena authors. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above
//    copyright notice, this list of conditions and the following
//    disclaimer in the documentation and/or other materials provided
//    with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE NAMEPSACE EWALENA AUTHORS ``AS
// IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// NAMESPACE EWALENA AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The views and conclusions contained in the software and
// documentation are those of the authors and should not be
// interpreted as representing official policies, either expressed or
// implied, of the namespace ewalena authors.
// -------------------------------------------------------------------

#include <cassert>
#include <map>
#include <cmath>
#include <iostream>

#ifndef __ewalena_tensor_tools_h
#define __ewalena_tensor_tools_h

#ifdef EWALENA_HAVE_CONFIG_H
#include <ewalena/base/config.h>
#endif

#include <ewalena/base/tensor.h>

#include <ewalena/lac/matrix.h>

namespace ewalena
{
  
  namespace TensorTools
  {

    class VoightMap
    {
      
    public:
      
      typedef std::map<std::pair<const unsigned int, const unsigned int>, const unsigned int> IndexSetMap;
      
      static IndexSetMap voight_map;
      
      typedef IndexSetMap::iterator VoightMapIterator;
      
      inline
        VoightMap operator* () const
      {
        return (*this);
      }
      
      inline
        VoightMapIterator begin () const
      {
        assert (!voight_map.empty ());
        return voight_map.begin ();
      }
      
      inline
        VoightMapIterator end () const
      {
        assert (!voight_map.empty ());
        return voight_map.end ();
      }
      
      inline
        unsigned int operator () (const unsigned int i, const unsigned int j) const
      {
        VoightMapIterator iterator = voight_map.find ({i, j});
        assert (iterator != voight_map.end ()); 

        return (iterator)->second;
      }      

    };

    /*-------------- Inline and Other Functions -----------------------*/

    template <int dim, typename ValueType>
      Matrix<ValueType> voight_fold (const Tensor<dim, 2, ValueType> &T)
    {
      Matrix<ValueType> M (T.voight_components ());
      
      TensorTools::VoightMap voight_map; 

      for (unsigned int i=0; i<dim; ++i)  
        for (unsigned int j=i; j<dim; ++j)  
          {
            assert (T(i,j) == T(j,i));
            M(0,voight_map(i,j)) += T(i,j); 
          }

      return M; 
    } 
    
    template <int dim, typename ValueType>
      Matrix<ValueType> voight_fold (const Tensor<dim, 3, ValueType> &T,
                                     const unsigned int               symmetry_direction = 0)
    {
       Matrix<ValueType> M; 

       TensorTools::VoightMap voight_map; 

       switch (symmetry_direction) 
        { 
        case 0: 
          M.reinit (T.voight_components ().first, T.voight_components ().second); 

          for (unsigned int i=0; i<dim; ++i)  
            for (unsigned int j=0; j<dim; ++j)  
              for (unsigned int k=j; k<dim; ++k)  
                { 
                  assert (T(i,j,k) == T(i,k,j));  
                  M(i,voight_map(j, k)) += T(i,j,k);  
                } 
          break; 
          
        case 1: 
          M.reinit (T.voight_components ().second, T.voight_components ().first); 
          
          for (unsigned int i=0; i<dim; ++i)  
            for (unsigned int j=0; j<dim; ++j)  
              for (unsigned int k=j; k<dim; ++k)  
                { 
                  assert (T(i,j,k) == T(j,i,k)); 
                  M(voight_map(i, j), k) += T(i,j,k);  
                } 
          
          break; 
          
        default: 
          assert (false); 
        } 
       
       return M;
    }  
    
    template <int dim, typename ValueType>
      Matrix<ValueType> voight_fold (const Tensor<dim, 4, ValueType> &T)
    {
      Matrix<ValueType> M (T.voight_components ());      
      TensorTools::VoightMap voight_map;

      for (unsigned int i=0; i<dim; ++i) 
        for (unsigned int j=i; j<dim; ++j) 
          for (unsigned int k=0; k<dim; ++k) 
            for (unsigned int l=k; l<dim; ++l) 
              {
                assert (T(i,j,k,l) == T(j,i,l,k));
                M(voight_map(i, j), voight_map(k, l)) += T(i,j,k,l); 
              }
      
       return M;
    }  

  } /* namespace TensorTools */

} /* namespace ewalena */
  
#endif /* __ewalena_tensor_tools_h */