em_material.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013-2015:  G-CSC, Goethe University Frankfurt
 * Author: Dmitry Logashenko
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__UG__PLUGINS__ELECTROMAGNETISM__EM_DATA__
#define __H__UG__PLUGINS__ELECTROMAGNETISM__EM_DATA__
 
#include <vector>
#include <map>
 
#include "common/common.h"
#include "common/util/smart_pointer.h"
 
#include "lib_grid/tools/subset_group.h"
#include "lib_grid/algorithms/subset_dim_util.h"
 
#include "lib_disc/spatial_disc/constraints/constraint_interface.h"
 
namespace ug{
namespace Electromagnetism{
 
 
template <typename TDomain>
class EMaterial
{
private:
  typedef EMaterial<TDomain> this_type;
  
  typedef TDomain domain_type;
 
  typedef typename domain_type::subset_handler_type subset_handler_type;
  
  static const int dim = domain_type::dim;
 
public:
  EMaterial
  (
    ConstSmartPtr<domain_type> domain 
  );
  
  void add
  (
    const char * subsets, 
    number mu, 
    number sigma 
  );
 
  void add
  (
    const char * subsets, 
    number mu 
  )
  {
    add (subsets, mu, (number) 0);
  }
  void add {…}
 
  void close ();
  
  ConstSmartPtr<subset_handler_type> subset_handler () const
  {
    return m_spDomain->subset_handler ();
  }
  ConstSmartPtr<subset_handler_type> subset_handler () const {…}
 
  const char * subset_names () const
  {
    if (! m_bClosed)
      UG_THROW ("EMaterial: The object has not been closed.");
    return m_sSsNames.c_str ();
  }
  const char * subset_names () const {…}
 
  bool finalized () const {return m_bClosed;}
  
  ConstSmartPtr<domain_type> domain () const {return m_spDomain;}
  
  bool get_mu_sigma
  (
    int si, 
    number& mu, 
    number& sigma 
  ) const;
 
  const std::vector<int> & min_conductor_ssi () const
  {
    return m_minCondSsI;
  }
  const std::vector<int> & min_conductor_ssi () const {…}
  
  int min_conductor_ssi
  (
    int si 
  ) const
  {
    return m_minCondSsI [si];
  }
  int min_conductor_ssi {…}
  
  const std::vector<int> & base_conductors () const
  {
    return m_baseConductors;
  }
  const std::vector<int> & base_conductors () const {…}
  
  const std::vector<int> & base_conductor_index () const
  {
    return m_baseCondInd;
  }
  const std::vector<int> & base_conductor_index () const {…}
  
  int base_conductor_index
  (
    int si 
  ) const
  {
    return m_baseCondInd [si];
  }
  int base_conductor_index {…}
  
private:
  
  void connectivity
  (
    std::vector<int> & minCondInd 
  );
  
  void analyze_topology ();
 
private:
  ConstSmartPtr<domain_type> m_spDomain;
  
  struct TSubdomData
  {
    std::string ssNames; 
    SubsetGroup ssGrp; 
    
    number mu; 
    number sigma; 
    
    TSubdomData
    (
      ConstSmartPtr<subset_handler_type> pSH,
      const char * names, // the names
      number the_mu, // magnetic permeability
      number the_sigma // electric conductivity
    )
    : ssNames (names), ssGrp (pSH),
      mu (the_mu), sigma (the_sigma)
    {};
    TSubdomData {…}
  };
  struct TSubdomData {…};
 
  std::vector<TSubdomData> m_vSdD;
  
  typedef std::map<int, TSubdomData *> t_data_map;
 
  t_data_map m_mUserDataBC;
  
  bool m_bClosed;
  
  std::string m_sSsNames;
  
  std::vector<int> m_minCondSsI;
  
  std::vector<int> m_baseConductors;
  
  std::vector<int> m_baseCondInd;
};
class EMaterial {…};
 
 
template <typename TDomain, typename TAlgebra>
class EMDirichlet
  : public IDomainConstraint<TDomain, TAlgebra>
{
public:
  
  virtual void get_dirichlet_subsets
  (
    SubsetGroup & dirichlet_ssgrp 
  ) const = 0;
};
class EMDirichlet {…};
 
} // end namespace Electromagnetism
} // end namespace ug
 
#include "em_material_impl.h"
 
#endif // __H__UG__PLUGINS__ELECTROMAGNETISM__EM_DATA__
 
/* End of File */