GRINS::PhysicsFactory Class Reference

Object for constructing list of physics for simulation. More...

#include <physics_factory.h>

Public Types
typedef std::tr1::shared_ptr< Physics >	PhysicsPtr
typedef std::pair< std::string, PhysicsPtr >	PhysicsPair

Public Member Functions
	PhysicsFactory ()
virtual	~PhysicsFactory ()
	Destructor does not need to delete std::tr1::shared_ptr's. More...
GRINS::PhysicsList	build (const GetPot &input)
	Builds PhysicsList. This is the primary function of this class. More...

Protected Member Functions
virtual void	add_physics (const GetPot &input, const std::string &physics_to_add, GRINS::PhysicsList &physics_list)
	Figures out which GRINS::Physics pointer to create. More...
virtual void	check_physics_consistency (const GRINS::PhysicsList &physics_list)
	Make sure the requested GRINS::Physics classes are consistent. More...
void	physics_consistency_error (const std::string physics_checked, const std::string physics_required) const
	Utility function. More...

Detailed Description

Object for constructing list of physics for simulation.

PhysicsFactory will construct the appropriate GRINS::PhysicsList to be handed to the GRINS::MultiphysicsSystem class. The list of GRINS::Physics objects constructed is set at run time.

Definition at line 45 of file physics_factory.h.

Member Typedef Documentation

typedef std::pair< std::string, PhysicsPtr > GRINS::PhysicsFactory::PhysicsPair

Definition at line 58 of file physics_factory.h.

typedef std::tr1::shared_ptr<Physics> GRINS::PhysicsFactory::PhysicsPtr

Definition at line 57 of file physics_factory.h.

Constructor & Destructor Documentation

GRINS::PhysicsFactory::PhysicsFactory

(

)

Definition at line 385 of file physics_factory.C.

  {
    return;
  }

GRINS::PhysicsFactory::~PhysicsFactory ( )

virtual

Destructor does not need to delete std::tr1::shared_ptr's.

Definition at line 390 of file physics_factory.C.

  {
    return;
  }

Member Function Documentation

void GRINS::PhysicsFactory::add_physics ( const GetPot &  input, const std::string &  physics_to_add, GRINS::PhysicsList &  physics_list  )

protectedvirtual

Figures out which GRINS::Physics pointer to create.

This is the primary method to override if the user wants to extend the physics capabilities. The strategy is to conditionally add the physics you want, then call the parent PhysicsFactory::add_physics function.

Definition at line 441 of file physics_factory.C.

References GRINS::averaged_fan, GRINS::averaged_fan_adjoint_stab, GRINS::averaged_turbine, GRINS::axisymmetric_boussinesq_buoyancy, GRINS::axisymmetric_heat_transfer, GRINS::boussinesq_buoyancy, GRINS::boussinesq_buoyancy_adjoint_stab, GRINS::boussinesq_buoyancy_spgsm_stab, GRINS::constant_source_term, GRINS::elastic_cable, GRINS::elastic_cable_constant_gravity, GRINS::elastic_membrane, GRINS::elastic_membrane_constant_pressure, GRINS::heat_transfer, GRINS::heat_transfer_adjoint_stab, GRINS::heat_transfer_source, GRINS::heat_transfer_spgsm_stab, GRINS::incompressible_navier_stokes, GRINS::incompressible_navier_stokes_adjoint_stab, GRINS::incompressible_navier_stokes_spgsm_stab, GRINS::low_mach_navier_stokes, GRINS::low_mach_navier_stokes_braack_stab, GRINS::low_mach_navier_stokes_spgsm_stab, GRINS::low_mach_navier_stokes_vms_stab, GRINS::new_mu_class< SpalartAllmaras >(), GRINS::parsed_source_term, GRINS::parsed_velocity_source, GRINS::parsed_velocity_source_adjoint_stab, GRINS::reacting_low_mach_navier_stokes, GRINS::scalar_ode, GRINS::spalart_allmaras, GRINS::spalart_allmaras_spgsm_stab, GRINS::stokes, GRINS::velocity_drag, GRINS::velocity_drag_adjoint_stab, GRINS::velocity_penalty, GRINS::velocity_penalty2, GRINS::velocity_penalty2_adjoint_stab, GRINS::velocity_penalty3, GRINS::velocity_penalty3_adjoint_stab, and GRINS::velocity_penalty_adjoint_stab.

Referenced by build().

  {
    if( physics_to_add == incompressible_navier_stokes )
      {
        physics_list[physics_to_add] =
          new_mu_class<IncompressibleNavierStokes>
            (physics_to_add, input);
      }
    else if( physics_to_add == stokes )
      {
        physics_list[physics_to_add] =
          new_mu_class<Stokes>
            (physics_to_add, input);
      }
    else if( physics_to_add == incompressible_navier_stokes_adjoint_stab )
      {
        physics_list[physics_to_add] =
          new_mu_class<IncompressibleNavierStokesAdjointStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == incompressible_navier_stokes_spgsm_stab )
      {
        physics_list[physics_to_add] =
          new_mu_class<IncompressibleNavierStokesSPGSMStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == velocity_drag )
      {
        physics_list[physics_to_add] =
          new_mu_class<VelocityDrag>
            (physics_to_add, input);
      }
    else if( physics_to_add == velocity_drag_adjoint_stab )
      {
        physics_list[physics_to_add] =
          new_mu_class<VelocityDragAdjointStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == velocity_penalty  ||
             physics_to_add == velocity_penalty2 ||
             physics_to_add == velocity_penalty3)
      {
        physics_list[physics_to_add] =
          new_mu_class<VelocityPenalty>
            (physics_to_add, input);
      }
    else if( physics_to_add == velocity_penalty_adjoint_stab  ||
             physics_to_add == velocity_penalty2_adjoint_stab ||
             physics_to_add == velocity_penalty3_adjoint_stab )
      {
        physics_list[physics_to_add] =
          new_mu_class<VelocityPenaltyAdjointStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == parsed_velocity_source )
      {
        physics_list[physics_to_add] =
          new_mu_class<ParsedVelocitySource>
            (physics_to_add, input);
      }
    else if( physics_to_add == parsed_velocity_source_adjoint_stab )
      {
        physics_list[physics_to_add] =
          new_mu_class<ParsedVelocitySourceAdjointStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == averaged_fan )
      {
        physics_list[physics_to_add] =
          new_mu_class<AveragedFan>
            (physics_to_add, input);
      }
    else if( physics_to_add == averaged_fan_adjoint_stab )
      {
        physics_list[physics_to_add] =
          new_mu_class<AveragedFanAdjointStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == averaged_turbine )
      {
        physics_list[physics_to_add] =
          new_mu_class<AveragedTurbine>
            (physics_to_add, input);
      }
    else if( physics_to_add == spalart_allmaras )
      {
        physics_list[physics_to_add] =
          new_mu_class<SpalartAllmaras>
            (physics_to_add, input);
      }
    else if( physics_to_add == spalart_allmaras_spgsm_stab )
      {
        physics_list[physics_to_add] =
          new_turb_mu_class<SpalartAllmarasSPGSMStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == scalar_ode )
      {
        physics_list[physics_to_add] =
          PhysicsPtr(new ScalarODE(physics_to_add,input));
      }
    else if( physics_to_add == heat_transfer )
      {
        physics_list[physics_to_add] =
          new_k_class<HeatTransfer>
            (physics_to_add, input);
      }
    else if( physics_to_add == heat_transfer_adjoint_stab )
      {
        physics_list[physics_to_add] =
          new_k_class<HeatTransferAdjointStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == heat_transfer_spgsm_stab )
      {
        physics_list[physics_to_add] =
          new_k_class<HeatTransferSPGSMStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == heat_transfer_source )
      {
        std::string source_function = input( "Physics/"+physics_to_add+"/source_function", "constant" );
        if( source_function == "constant")
          {
            physics_list[physics_to_add] =
              PhysicsPtr(new HeatTransferSource<ConstantSourceFunction>(physics_to_add,input));
          }
        else
          {
            std::cerr << "================================================================" << std::endl
                      << "Invalid combination of models for " << physics_to_add << std::endl
                      << "Source function  = " << source_function << std::endl
                      << "================================================================" << std::endl;
            libmesh_error();
          }
      }
    else if( physics_to_add == axisymmetric_heat_transfer )
      {
        physics_list[physics_to_add] =
          new_k_class<AxisymmetricHeatTransfer>
            (physics_to_add, input);
      }
    else if( physics_to_add == boussinesq_buoyancy )
      {
        physics_list[physics_to_add] =
          PhysicsPtr(new BoussinesqBuoyancy(physics_to_add,input));
      }
    else if( physics_to_add == boussinesq_buoyancy_adjoint_stab )
      {
        physics_list[physics_to_add] =
          new_mu_class<BoussinesqBuoyancyAdjointStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == boussinesq_buoyancy_spgsm_stab )
      {
        physics_list[physics_to_add] =
          new_mu_class<BoussinesqBuoyancySPGSMStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == axisymmetric_boussinesq_buoyancy)
      {
        physics_list[physics_to_add] =
          PhysicsPtr(new AxisymmetricBoussinesqBuoyancy(physics_to_add,input));
      }
    else if( physics_to_add == "HeatConduction" )
      {
        physics_list[physics_to_add] =
          new_k_class<HeatConduction>
            (physics_to_add, input);
      }
    else if(  physics_to_add == low_mach_navier_stokes )
      {
        physics_list[physics_to_add] =
          new_mu_cp_k_class<LowMachNavierStokes>
            (physics_to_add, input);
      }
    else if(  physics_to_add == low_mach_navier_stokes_spgsm_stab )
      {
        physics_list[physics_to_add] =
          new_mu_cp_k_class<LowMachNavierStokesSPGSMStabilization>
            (physics_to_add, input);
      }
    else if(  physics_to_add == low_mach_navier_stokes_vms_stab )
      {
        physics_list[physics_to_add] =
          new_mu_cp_k_class<LowMachNavierStokesVMSStabilization>
            (physics_to_add, input);
      }
    else if(  physics_to_add == low_mach_navier_stokes_braack_stab )
      {
        physics_list[physics_to_add] =
          new_mu_cp_k_class<LowMachNavierStokesBraackStabilization>
            (physics_to_add, input);
      }
    else if( physics_to_add == reacting_low_mach_navier_stokes )
      {
        physics_list[physics_to_add] =
          new_reacting_low_mach_class<ReactingLowMachNavierStokes>
             (physics_to_add, input);
      }
    else if( physics_to_add == elastic_membrane )
      {
        std::string elasticity_model = input("Physics/"+elastic_membrane+"/elasticity_model", "HookesLaw" );

        if( elasticity_model == std::string("HookesLaw") )
          {
            physics_list[physics_to_add] =
              PhysicsPtr(new ElasticMembrane<HookesLaw>(physics_to_add,input,false /*is_compressible*/));
          }
        else if( elasticity_model == std::string("MooneyRivlin") )
          {
            physics_list[physics_to_add] =
              // \lambda determined from incompressiblity
              PhysicsPtr(new ElasticMembrane<IncompressiblePlaneStressHyperelasticity<MooneyRivlin> >(physics_to_add,input,false /*is_compressible*/));
          }
        else
          {
            std::cerr << "Error: Invalid elasticity_model: " << elasticity_model << std::endl
                      << "       Valid selections are: Hookean" << std::endl;
            libmesh_error();
          }
      }
    else if( physics_to_add == elastic_membrane_constant_pressure )
      {
        physics_list[physics_to_add] =
          PhysicsPtr(new ElasticMembraneConstantPressure(physics_to_add,input));
      }
    else if( physics_to_add == elastic_cable )
      {
        std::string elasticity_model = input("Physics/"+elastic_cable+"/elasticity_model", "HookesLaw" );

        if( elasticity_model == std::string("HookesLaw") )
          {
            physics_list[physics_to_add] =
              PhysicsPtr(new ElasticCable<HookesLaw1D>(physics_to_add,input,false /*is_compressible*/));
          }
        else
          {
            std::cerr << "Error: Invalid elasticity_model: " << elasticity_model << std::endl
                      << "       Valid selections are: Hookean" << std::endl;
            libmesh_error();
          }
      }
    else if( physics_to_add == elastic_cable_constant_gravity )
      {
        physics_list[physics_to_add] =
          PhysicsPtr(new ElasticCableConstantGravity(physics_to_add,input));
      }
    else if( physics_to_add == constant_source_term )
      {
        physics_list[physics_to_add] =
          PhysicsPtr(new ConstantSourceTerm(physics_to_add,input));
      }
    else if( physics_to_add == parsed_source_term )
      {
        physics_list[physics_to_add] =
          PhysicsPtr(new ParsedSourceTerm(physics_to_add,input));
      }
    else
      {
        std::cerr << "Error: Invalid physics name " << physics_to_add << std::endl;
        libmesh_error();
      }

    return;
  }

PhysicsList GRINS::PhysicsFactory::build

(

const GetPot &

input

)

Builds PhysicsList. This is the primary function of this class.

Definition at line 395 of file physics_factory.C.

References add_physics(), and check_physics_consistency().

  {
    PhysicsList physics_list;

    int num_physics =  input.vector_variable_size("Physics/enabled_physics");

    if( num_physics < 1 )
      {
        std::cerr << "Error: Must enable at least one physics model" << std::endl;
        libmesh_error();
      }

    std::set<std::string> requested_physics;

    // Go through and create a physics object for each physics we're enabling
    for( int i = 0; i < num_physics; i++ )
      {
        requested_physics.insert( input("Physics/enabled_physics", "NULL", i ) );
      }

    for( std::set<std::string>::const_iterator physics = requested_physics.begin();
         physics != requested_physics.end();
         physics++ )
      {
        this->add_physics( input, *physics, physics_list );
      }

    this->check_physics_consistency( physics_list );

    if( input( "screen-options/echo_physics", true ) )
      {
        std::cout << "==========================================================" << std::endl
                  << "List of Enabled Physics:" << std::endl;

        for( PhysicsListIter it = physics_list.begin();
             it != physics_list.end();
             it++ )
          {
            std::cout<< it->first << std::endl;
          }
        std::cout <<  "==========================================================" << std::endl;
      }

    return physics_list;
  }

void GRINS::PhysicsFactory::check_physics_consistency ( const GRINS::PhysicsList &  physics_list )

protectedvirtual

Make sure the requested GRINS::Physics classes are consistent.

This is the other method to override (in addition to add_physics) for extending physics capabilities. The strategy is to check on the physics you've added, then call the parent PhysicsFactory::check_physics_consistency.

Todo:

Need to move the internals of the loop to a separate function that we'll make virtual and make this function non-virtual

Definition at line 710 of file physics_factory.C.

References GRINS::axisymmetric_boussinesq_buoyancy, GRINS::axisymmetric_heat_transfer, GRINS::boussinesq_buoyancy, GRINS::boussinesq_buoyancy_adjoint_stab, GRINS::heat_transfer, GRINS::heat_transfer_adjoint_stab, GRINS::heat_transfer_source, GRINS::incompressible_navier_stokes, GRINS::incompressible_navier_stokes_adjoint_stab, GRINS::incompressible_navier_stokes_spgsm_stab, GRINS::low_mach_navier_stokes, physics_consistency_error(), and GRINS::reacting_low_mach_navier_stokes.

Referenced by build().

  {
    for( PhysicsListIter physics = physics_list.begin();
         physics != physics_list.end();
         physics++ )
      {
        // For IncompressibleNavierStokes*Stabilization, we'd better have IncompressibleNavierStokes
        if( (physics->first == incompressible_navier_stokes_adjoint_stab) ||
            (physics->first == incompressible_navier_stokes_spgsm_stab) )
          {
            if( physics_list.find(incompressible_navier_stokes) == physics_list.end() )
              {
                this->physics_consistency_error( physics->first, incompressible_navier_stokes  );
              }
          }

        // For HeatTransfer, we need IncompressibleNavierStokes
        if( physics->first == heat_transfer )
          {
            if( physics_list.find(incompressible_navier_stokes) == physics_list.end() )
              {
                this->physics_consistency_error( heat_transfer, incompressible_navier_stokes  );
              }
          }

        // For BoussinesqBuoyancy, we need both HeatTransfer and IncompressibleNavierStokes
        if( physics->first == boussinesq_buoyancy )
          {
            if( physics_list.find(incompressible_navier_stokes) == physics_list.end() )
              {
                this->physics_consistency_error( boussinesq_buoyancy, incompressible_navier_stokes  );
              }

            if( physics_list.find(heat_transfer) == physics_list.end() )
              {
                this->physics_consistency_error( boussinesq_buoyancy, heat_transfer  );
              }
          }

        /* For AxisymmetricBoussinesqBuoyancy, we need both AxisymmetricHeatTransfer
           and AxisymmetricIncompNavierStokes */
        if( physics->first == axisymmetric_boussinesq_buoyancy )
          {

            if( physics_list.find(axisymmetric_heat_transfer) == physics_list.end() )
              {
                this->physics_consistency_error( axisymmetric_boussinesq_buoyancy,
                                                 axisymmetric_heat_transfer  );
              }
          }

        /* For LowMachNavierStokes, there should be nothing else loaded, except
           for stabilization. */
        if( physics->first == low_mach_navier_stokes )
          {
            if( physics_list.size() > 2 )
              {
                std::cerr << "=======================================================" << std::endl
                          << "Error: For physics " << low_mach_navier_stokes << std::endl
                          << "only one stabilization physics is allowed. Detected the" << std::endl
                          << "following:" << std::endl;
                for( GRINS::PhysicsListIter iter = physics_list.begin();
                     iter != physics_list.end();
                     iter++ )
                  {
                    std::cerr << physics->first << std::endl;
                  }
                std::cerr << "=======================================================" << std::endl;
                libmesh_error();
              }
          }

        /* For HeatTransferSource, we'd better have HeatTransfer */
        if( physics->first == heat_transfer_source )
          {
            if( physics_list.find(heat_transfer) == physics_list.end() )
              {
                this->physics_consistency_error( physics->first, heat_transfer  );
              }
          }

        /* For HeatTransferAdjointStabilization, we'd better have HeatTransfer */
        if( physics->first == heat_transfer_adjoint_stab )
          {
            if( physics_list.find(heat_transfer) == physics_list.end() )
              {
                this->physics_consistency_error( physics->first, heat_transfer  );
              }
          }

        /* For BoussinesqBuoyancyAdjointStabilization, we'd better have IncompressibleNavierStokes */
        if( physics->first == boussinesq_buoyancy_adjoint_stab )
          {
            if( physics_list.find(incompressible_navier_stokes) == physics_list.end() )
              {
                this->physics_consistency_error( physics->first, incompressible_navier_stokes  );
              }
          }

        /* For ReactingLowMachNavierStokes, there should be nothing else loaded, except
           for stabilization. */
        if( physics->first == reacting_low_mach_navier_stokes )
          {
            if( physics_list.size() > 2 )
              {
                std::cerr << "=======================================================" << std::endl
                          << "Error: For physics " << reacting_low_mach_navier_stokes << std::endl
                          << "only one stabilization physics is allowed. Detected the" << std::endl
                          << "following:" << std::endl;
                for( GRINS::PhysicsListIter iter = physics_list.begin();
                     iter != physics_list.end();
                     iter++ )
                  {
                    std::cerr << physics->first << std::endl;
                  }
                std::cerr << "=======================================================" << std::endl;
                libmesh_error();
              }
          }
      }

    return;
  }

void GRINS::PhysicsFactory::physics_consistency_error ( const std::string  physics_checked, const std::string  physics_required  ) const

protected

Utility function.

Definition at line 836 of file physics_factory.C.

Referenced by check_physics_consistency().

  {
    std::cerr << "Error: " << physics_checked << " physics class requires using "
              << physics_required << " physics." << std::endl
              << physics_required << " not found in list of requested physics."
              << std::endl;

    libmesh_error();

    return;
  }

---

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

• src/physics/include/grins/physics_factory.h
• src/physics/src/physics_factory.C