variable_factory.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// GRINS - General Reacting Incompressible Navier-Stokes
//
// Copyright (C) 2014-2017 Paul T. Bauman, Roy H. Stogner
// Copyright (C) 2010-2013 The PECOS Development Team
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Version 2.1 GNU Lesser General
// Public License as published by the Free Software Foundation.
//
// This library 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.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc. 51 Franklin Street, Fifth Floor,
// Boston, MA  02110-1301  USA
//
//-----------------------------------------------------------------------el-

#ifndef GRINS_VARIABLE_FACTORY_H
#define GRINS_VARIABLE_FACTORY_H

// GRINS
#include "grins/factory_with_getpot.h"
#include "grins/fe_variables_base.h"
#include "grins/materials_parsing.h"

// libMesh
#include "libmesh/factory.h"

namespace GRINS
{
  // According to the standard, we need a declaration of the
  // specialization which precedes any automatic instantiation.
  template<> const GetPot* FactoryWithGetPot<FEVariablesBase>::_input;

  class VariableFactoryAbstract : public FactoryWithGetPot<FEVariablesBase>
  {
  public:

    VariableFactoryAbstract( const std::string& name )
      : FactoryWithGetPot<FEVariablesBase>(name)
    {}

    ~VariableFactoryAbstract(){};

    virtual libMesh::UniquePtr<FEVariablesBase> create();


    static std::vector<std::string> build_var_names( const std::string& name );

    static std::string parse_fe_family( const std::string& name );

    static std::string parse_fe_order( const std::string& name );

    static void set_var_names( const std::vector<std::string>& var_names )
    { _var_names = &var_names; }

    static void set_var_indices( const std::vector<VariableIndex>& var_indices )
    { _var_indices = &var_indices; }


    static void set_var_section( const std::string& var_section )
    { _var_section = var_section; }

    static void set_subdomain_ids( const std::set<libMesh::subdomain_id_type>& subdomain_ids )
    { _subdomain_ids = &subdomain_ids; }

  protected:

    virtual void check_create_state() const;

    virtual void reset_create_state();

    static void check_build_parse_state();

    static void reset_build_parse_state();


    virtual libMesh::UniquePtr<FEVariablesBase> build_fe_var( const std::vector<std::string>& var_names,
                                                              const std::vector<VariableIndex>& var_indices,
                                                              const std::set<libMesh::subdomain_id_type>& subdomain_ids ) =0;

    // Subclasses implement this to parse the variable component name(s)
    virtual std::vector<std::string> parse_var_names( const GetPot& input, const std::string& var_section ) =0;

    virtual std::string parse_fe_family_impl( const GetPot& input, const std::string& var_section ) =0;

    virtual std::string parse_fe_order_impl( const GetPot& input, const std::string& var_section ) =0;

    std::string parse_var_option( const GetPot& input,
                                  const std::string& var_section,
                                  const std::string& option,
                                  const std::string& default_val ) const
    {
      std::string input_sec = var_section+"/"+option;
      if(!input.have_variable(input_sec))
        libmesh_error_msg("ERROR: Could not find Variable input option "+input_sec);

      return input(input_sec,default_val);
    }


    static const std::vector<std::string>* _var_names;

    static const std::vector<VariableIndex>* _var_indices;

    static std::string _var_section;

    static const std::set<libMesh::subdomain_id_type>* _subdomain_ids;

  private:

    VariableFactoryAbstract();

  };

  class VariableFactoryBase : public VariableFactoryAbstract
  {
  public:

    VariableFactoryBase( const std::string& name )
      : VariableFactoryAbstract(name)
    {}

    ~VariableFactoryBase(){}

  protected:

    virtual std::string parse_fe_family_impl( const GetPot& input, const std::string& var_section )
    {
      return this->parse_var_option(input,var_section,std::string("fe_family"),std::string("DIE!"));
    }

    virtual std::string parse_fe_order_impl( const GetPot& input, const std::string& var_section )
    {
      return this->parse_var_option(input,var_section,std::string("order"),std::string("DIE!"));
    }

  };

  template<typename VariableType>
  class VariableFactoryBasic : public VariableFactoryBase
  {
  public:

    VariableFactoryBasic( const std::string& name )
      : VariableFactoryBase(name)
    {}

    ~VariableFactoryBasic(){}

  protected:

    virtual libMesh::UniquePtr<FEVariablesBase>
    build_fe_var( const std::vector<std::string>& var_names,
                  const std::vector<VariableIndex>& var_indices,
                  const std::set<libMesh::subdomain_id_type>& subdomain_ids )
    {
      return libMesh::UniquePtr<FEVariablesBase>( new VariableType(var_names,var_indices,subdomain_ids) );
    }

    virtual std::vector<std::string>
    parse_var_names( const GetPot& input, const std::string& var_section );

  };


  template<typename VariableType>
  class ScalarVariableFactory : public VariableFactoryBasic<VariableType>
  {
  public:

    ScalarVariableFactory( const std::string& name )
      : VariableFactoryBasic<VariableType>(name)
    {}

    ~ScalarVariableFactory(){}

  protected:

    virtual std::string parse_fe_family_impl( const GetPot& input, const std::string& var_section )
    {
      if( input.have_variable(var_section+"/fe_family") )
        libmesh_error_msg("ERROR: Cannot specify fe_family for ScalarVariable. It is implicitly SCALAR!");

      return std::string("SCALAR");
    }
  };



  template<typename VariableType>
  class SpeciesVariableFactory : public VariableFactoryBase
  {
  public:

    SpeciesVariableFactory( const std::string& name )
      : VariableFactoryBase(name)
    {}

    ~SpeciesVariableFactory(){}

  protected:


    virtual std::vector<std::string> parse_var_names( const GetPot& input, const std::string& var_section );

    virtual libMesh::UniquePtr<FEVariablesBase> build_fe_var( const std::vector<std::string>& var_names,
                                                              const std::vector<VariableIndex>& var_indices,
                                                              const std::set<libMesh::subdomain_id_type>& subdomain_ids )
    { return libMesh::UniquePtr<FEVariablesBase>( new VariableType(var_names,var_indices,_prefix,_material,subdomain_ids) ); }

    std::string _prefix;

    std::string _material;
  };

  template<typename VariableType>
  inline
  std::vector<std::string> VariableFactoryBasic<VariableType>::parse_var_names( const GetPot& input,
                                                                                const std::string& var_section )
  {
    std::vector<std::string> var_names;

    std::string input_sec = var_section+"/names";

    // Make sure the names are present
    if( !input.have_variable(input_sec) )
      libmesh_error_msg("ERROR: Could not find input parameter "+input_sec);

    unsigned int n_names = input.vector_variable_size(input_sec);

    var_names.resize(n_names);
    for( unsigned int i = 0; i < n_names; i++ )
      var_names[i] = input(input_sec,std::string("DIE!"),i);

    return var_names;
  }

  template<typename VariableType>
  inline
  std::vector<std::string> SpeciesVariableFactory<VariableType>::parse_var_names( const GetPot& input,
                                                                                  const std::string& var_section )
  {
    // Make sure the prefix is present
    std::string prefix_sec = var_section+"/names";
    if( !input.have_variable(prefix_sec) )
      libmesh_error_msg("ERROR: Could not find input parameter "+prefix_sec+" for species prefix!");

    // Make sure the material is present
    std::string material_sec = var_section+"/material";
    if( !input.have_variable(material_sec) )
      libmesh_error_msg("ERROR: Could not find input parameter "+material_sec+" for species material!");

    this->_prefix = input(prefix_sec,std::string("DIE!"));
    this->_material = input(material_sec,std::string("DIE!"));

    std::vector<std::string> var_names;
    MaterialsParsing::parse_species_varnames(input,this->_material,this->_prefix,var_names);

    return var_names;
  }

} // end namespace GRINS

#endif // GRINS_VARIABLE_FACTORY_H