FlowFrapconOperator.h

Go to the documentation of this file.

 
#ifndef included_AMP_FlowFrapconOperator
#define included_AMP_FlowFrapconOperator
 
#include "AMP/operators/Operator.h"
 
 
namespace AMP::Operator {
 
class FlowFrapconOperator : public Operator
{
public:
    explicit FlowFrapconOperator( std::shared_ptr<const OperatorParameters> params );
 
    virtual ~FlowFrapconOperator() {}
 
    std::string type() const override { return "FlowFrapconOperator"; }
 
    void apply( AMP::LinearAlgebra::Vector::const_shared_ptr u,
                AMP::LinearAlgebra::Vector::shared_ptr f ) override;
 
    void reset( std::shared_ptr<const OperatorParameters> params ) override;
 
    /*
          static bool sort_nodes_in_z ( const libMesh::Node *one , const libMesh::Node *two ) {
            return (*one)(2) < (*two)(2);
          }
    */
    std::shared_ptr<AMP::LinearAlgebra::Variable> createInputVariable( const std::string &name,
                                                                       int varId = -1 )
    {
        (void) varId;
        return d_inpVariable->clone( name );
    }
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> createOutputVariable( const std::string &name,
                                                                        int varId = -1 )
    {
        (void) varId;
        return d_outVariable->clone( name );
    }
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> getInputVariable() const override
    {
        return d_inpVariable;
    }
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> getOutputVariable() const override
    {
        return d_outVariable;
    }
 
    std::shared_ptr<AMP::LinearAlgebra::VectorSelector> selectOutputVector() const override;
 
    std::shared_ptr<AMP::LinearAlgebra::VectorSelector> selectInputVector() const override;
 
    void setZLocations( const std::vector<double> &zloc ) { zPoints = zloc; }
 
    void setVector( AMP::LinearAlgebra::Vector::shared_ptr frozenVec ) { d_cladVec = frozenVec; }
 
    AMP::LinearAlgebra::Vector::shared_ptr getVector() { return d_cladVec; }
 
    const auto &getZLocations() { return zPoints; }
 
    double getHeatCapacity( double T_b )
    {
        double cp = 0;
 
        if ( T_b < 544 ) {
 
            cp = 2.4e5;
        } else if ( 544 <= T_b && T_b < 588 ) {
 
            cp = 2.4e5 * ( 1.0 + 2.9e-3 * ( 1.8 * T_b - 1031.0 ) );
        } else {
 
            cp = 2.4e5 * ( 1.0 + 2.9e-3 * ( 1.8 * T_b - 979.4 ) );
        }
 
        return cp;
    }
 
public: // Data members (should be private)
    int d_boundaryId = 0;
    int d_numpoints  = 0; 
    std::vector<unsigned int> d_dofIds;
    std::vector<double> zPoints; 
    AMP::LinearAlgebra::Vector::shared_ptr d_cladVec;
    double d_De  = 0; 
    double Cp    = 0; 
    double d_G   = 0; 
    double d_Tin = 0; 
    double d_K   = 0; 
    double d_Re  = 0; 
    double d_Pr  = 0; 
    std::shared_ptr<AMP::LinearAlgebra::Variable> d_inpVariable;
    std::shared_ptr<AMP::LinearAlgebra::Variable> d_outVariable;
 
protected:
    std::shared_ptr<OperatorParameters>
    getJacobianParameters( AMP::LinearAlgebra::Vector::const_shared_ptr u ) override;
 
private:
};
} // namespace AMP::Operator
 
#endif