include/ewalena/numerics/crystal_field_base.h

Go to the documentation of this file.

// -------------------------------------------------------------------
// @author Toby D. Young
// @version $Id: crystal_field_base.h 988 2012-11-26 19:09:39Z oneliefleft $
//
// Copyright 2009, 2010, 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.
// -------------------------------------------------------------------

#ifndef __ewalena_crystal_field_base_h
#define __ewalena_crystal_field_base_h

#include <cassert>
#include <map>
#include <vector>

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

#include <ewalena/lac/vector.h>
#include <ewalena/lac/matrix.h>
#include <ewalena/base/tensor.h>

namespace ewalena
{
  
  namespace Crystal
  {
    
    /* TODO: Investigate how a union can constructed to access
       combinations of flags using group number. */
    
    enum SymmetryFlag
    {
      
      null         = 0,     
      
      triclinic    = 0x0001,
      
      monoclinic   = 0x0002,
      
      orthorhombic = 0x0003, 
      
      tetragonal   = 0x0004, 
      
      trigonal     = 0x0005,     
      
      hexagonal    = 0x0006,     
      
      cubic        = 0x0007,
      
      
      k32          = 0x0035
      
    }; /* Crystal */
    
    
    
    /*-------------- Inline and Other Functions -----------------------*/  
    
    template <class STREAM>
      inline
      STREAM &operator << (STREAM &stream, const SymmetryFlag symmetry_flag)
      {
        stream << "   SymmetryFlag::Crystal ";
        
        if (symmetry_flag &SymmetryFlag::null)         stream << "null";
        
        if (symmetry_flag &SymmetryFlag::triclinic)    stream << "triclinic";
        if (symmetry_flag &SymmetryFlag::monoclinic)   stream << "monoclinic";
        if (symmetry_flag &SymmetryFlag::orthorhombic) stream << "orthorhombic";
        if (symmetry_flag &SymmetryFlag::tetragonal)   stream << "tetragonal";
        if (symmetry_flag &SymmetryFlag::trigonal)     stream << "trigonal";
        if (symmetry_flag &SymmetryFlag::hexagonal)    stream << "hexagonal";
        if (symmetry_flag &SymmetryFlag::cubic)        stream << "cubic";
        
        if (symmetry_flag &SymmetryFlag::k32)          stream << "k32";
        
        return symmetry_flag;
      }
    
    
    template <int dim, int rank, typename ValueType = double>
      class CrystalFieldBase
      :
      public Tensor<dim, rank, ValueType>
      {
        
      private:
      
      protected:
      
      Vector<ValueType> moduli_; 
      
      SymmetryFlag symmetry_flags_;
      
      SymmetryFlag group_flags_;
      
      
      virtual void assign_moduli (const Vector<ValueType> &moduli);
      
      public:
      
      CrystalFieldBase (const Vector<ValueType>     &moduli         = Vector<ValueType> (),
                        const SymmetryFlag          &symmetry_flags = SymmetryFlag::null,
                        const SymmetryFlag          &group_flags    = SymmetryFlag::null) 
      : 
      Tensor<dim, rank, ValueType> (),
      moduli_ (moduli),
      symmetry_flags_ (symmetry_flags),
      group_flags_ (group_flags)
      {}
      
      virtual ~CrystalFieldBase ();
      
      SymmetryFlag symmetry_flags () const; 
      
      SymmetryFlag group_flags () const; 
      
      virtual void assign_symmetry_flags (const SymmetryFlag &symmetry_flags,
                                          const SymmetryFlag &group_flags    = null);
      
      virtual void distribute_moduli (const Vector<ValueType> &moduli); 
      
      unsigned int n_components () const; 
      
      void write_gnuplot (std::ostream &out) const;
      
      CrystalFieldBase<dim, rank, ValueType> &operator = (const CrystalFieldBase<dim, rank, ValueType> &T);
      
      inline
      Tensor<dim, rank, ValueType> operator* () const
      {
        return (*this);
      }
      
      }; /* CrystalFieldBase */
    
    /*-------------- Inline and Other Functions -----------------------*/
    
    template <int dim, typename ValueType>
      inline
      Tensor<dim, 2, ValueType> 
      contract (const CrystalFieldBase<dim, 4, ValueType> &T_a,
                const Tensor<dim, 2, ValueType>           &T_b) 
      {
        return contract (*T_a, T_b);
      } 

  } /* namespace Crystal */

} /* namespace ewalena */

#endif /* __ewalena_crystal_field_h */