optimization_application.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   license: OptimizationApplication/license.txt
//
//  Main authors:    Reza Najian Asl, https://github.com/RezaNajian
//                   Suneth Warnakulasuriya
 
#pragma once
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "includes/kratos_application.h"
 
/* ELEMENTS */
#include "custom_elements/helmholtz_surf_shape_element.h"
#include "custom_elements/helmholtz_surf_thickness_element.h"
#include "custom_elements/helmholtz_bulk_shape_element.h"
#include "custom_elements/helmholtz_bulk_element.h"
#include "custom_elements/helmholtz_element.h"
 
/* ELEMENT DATA CONTAINERS*/
#include "custom_elements/data_containers/helmholtz_surface_data_container.h"
#include "custom_elements/data_containers/helmholtz_solid_data_container.h"
#include "custom_elements/data_containers/helmholtz_solid_shape_data_container.h"
 
/* ADJOINT ELEMENTS */
#include "custom_elements/adjoint_small_displacement_element.h"
 
/* CONDITIONS */
#include "custom_conditions/helmholtz_surf_shape_condition.h"
#include "custom_conditions/helmholtz_surface_shape_condition.h"
 
/* CONSTITUTIVE LAWS */
#include "custom_constitutive/helmholtz_jacobian_stiffened_3d.h"
 
namespace Kratos
{
 
 
    class KRATOS_API(OPTIMIZATION_APPLICATION) KratosOptimizationApplication : public KratosApplication
    {
    public:
 
        KRATOS_CLASS_POINTER_DEFINITION(KratosOptimizationApplication);
 
 
        KratosOptimizationApplication();
 
        ~KratosOptimizationApplication() override {}
 
        KratosOptimizationApplication& operator=(KratosOptimizationApplication const& rOther) = delete;
 
        KratosOptimizationApplication(KratosOptimizationApplication const& rOther) = delete;
 
 
        void Register() override;
 
 
        std::string Info() const override
        {
            return "KratosOptimizationApplication";
        }
 
        void PrintInfo(std::ostream& rOStream) const override
        {
            rOStream << Info();
            PrintData(rOStream);
        }
 
        void PrintData(std::ostream& rOStream) const override
        {
            KRATOS_WATCH("in my application");
            KRATOS_WATCH(KratosComponents<VariableData>::GetComponents().size() );
            rOStream << "Variables:" << std::endl;
            KratosComponents<VariableData>().PrintData(rOStream);
            rOStream << std::endl;
            rOStream << "Elements:" << std::endl;
            KratosComponents<Element>().PrintData(rOStream);
            rOStream << std::endl;
            rOStream << "Conditions:" << std::endl;
            KratosComponents<Condition>().PrintData(rOStream);
        }
 
 
    private:
 
        /* ELEMENTS */
 
        const HelmholtzSurfShapeElement mHelmholtzSurfShape3D3N;
        const HelmholtzSurfThicknessElement mHelmholtzSurfThickness3D3N;
        const HelmholtzBulkShapeElement mHelmholtzBulkShape3D4N;
        const HelmholtzBulkElement mHelmholtzBulkTopology3D4N;
 
        /* ADJ ELEMENTS */
        const AdjointSmallDisplacementElement mAdjointSmallDisplacementElement3D4N;
 
        // Helmholtz elements
        const HelmholtzElement<HelmholtzSurfaceDataContainer<3, 3, 1>> mHelmholtzSurfaceElement3D3N;
        const HelmholtzElement<HelmholtzSurfaceDataContainer<3, 4, 1>> mHelmholtzSurfaceElement3D4N;
        const HelmholtzElement<HelmholtzSurfaceDataContainer<3, 3, 3>> mHelmholtzVectorSurfaceElement3D3N;
        const HelmholtzElement<HelmholtzSurfaceDataContainer<3, 4, 3>> mHelmholtzVectorSurfaceElement3D4N;
 
        const HelmholtzElement<HelmholtzSolidDataContainer<3, 4, 1>> mHelmholtzSolidElement3D4N;
        const HelmholtzElement<HelmholtzSolidDataContainer<3, 8, 1>> mHelmholtzSolidElement3D8N;
        const HelmholtzElement<HelmholtzSolidDataContainer<3, 4, 3>> mHelmholtzVectorSolidElement3D4N;
        const HelmholtzElement<HelmholtzSolidDataContainer<3, 8, 3>> mHelmholtzVectorSolidElement3D8N;
 
        const HelmholtzElement<HelmholtzSolidShapeDataContainer<3, 4>> mHelmholtzSolidShapeElement3D4N;
        const HelmholtzElement<HelmholtzSolidShapeDataContainer<3, 8>> mHelmholtzSolidShapeElement3D8N;
 
        /* CONDITIONS*/
        // Surface conditions
        const HelmholtzSurfShapeCondition mHelmholtzSurfShapeCondition3D3N;
        const HelmholtzSurfaceShapeCondition mHelmholtzSurfaceShapeCondition3D3N;
        const HelmholtzSurfaceShapeCondition mHelmholtzSurfaceShapeCondition3D4N;
 
        /* CONSTITUTIVE LAWS */
        const HelmholtzJacobianStiffened3D mHelmholtzJacobianStiffened3D;
 
 
    }; // Class KratosOptimizationApplication
 
 
}  // namespace Kratos.