FlowFrapconJacobian.h

Go to the documentation of this file.

 
#ifndef included_AMP_FlowFrapconJacobian
#define included_AMP_FlowFrapconJacobian
 
#include "AMP/operators/Operator.h"
#include "AMP/operators/subchannel/FlowFrapconJacobianParameters.h"
 
// Libmesh files
DISABLE_WARNINGS
#include "libmesh/fe_base.h"
#include "libmesh/fe_type.h"
#include "libmesh/quadrature.h"
ENABLE_WARNINGS
 
namespace AMP::Operator {
 
class FlowFrapconJacobian : public Operator
{
public:
    explicit FlowFrapconJacobian( std::shared_ptr<const OperatorParameters> params );
 
    virtual ~FlowFrapconJacobian() {}
 
    std::string type() const override { return "FlowFrapconJacobian"; }
 
    void apply( AMP::LinearAlgebra::Vector::const_shared_ptr u,
                AMP::LinearAlgebra::Vector::shared_ptr r ) 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 );
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> createOutputVariable( const std::string &name,
                                                                        int varId = -1 );
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> getInputVariable() const override;
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> getOutputVariable() const override;
 
    void setInputVariableName( const std::string &name, int varId = -1 );
 
    void setOutputVariableName( const std::string &name, int varId = -1 );
 
    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; }
 
    const auto &getZLocations() { return zPoints; }
 
    double getCp() { return Cp; }
 
    double getdCp() { return dCp; }
 
    void setVector( AMP::LinearAlgebra::Vector::shared_ptr frozenVec ) { d_cladVec = frozenVec; }
 
    void setFrozenVector( AMP::LinearAlgebra::Vector::shared_ptr frozenVec )
    {
        d_frozenVec = frozenVec;
    }
 
    double getHeatCapacity( double T_b )
    {
        double cp = 0.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;
    }
 
    double getHeatCapacityGradient( double T_b )
    {
        double dcp = 0.0;
        if ( T_b >= 544 ) {
            dcp = 2.4e5 * ( 2.9e-3 * 1.8 * T_b );
        }
        return dcp;
    }
 
    /*
       std::shared_ptr< std::vector<double>  > getFlowSolution() {
       return flowSolutionVector;
       }
       */
 
 
public: // Data members (this should be private)
    AMP::LinearAlgebra::Vector::shared_ptr d_cladVec;
    AMP::LinearAlgebra::Vector::shared_ptr d_frozenVec;
 
    AMP::LinearAlgebra::Vector::shared_ptr d_localCladVec;
    AMP::LinearAlgebra::Vector::shared_ptr d_localFrozenVec;
 
    int d_numpoints = 0; 
    std::vector<unsigned int> d_dofIds;
    std::vector<double> zPoints; 
 
    double d_De  = 0; 
    double Cp    = 0; 
    double dCp   = 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;    
    std::shared_ptr<AMP::LinearAlgebra::Variable> d_SimpleVariable; 
 
    AMP::LinearAlgebra::Vector::shared_ptr flowInput;
    AMP::LinearAlgebra::Vector::shared_ptr flowOutput;
 
protected:
private:
};
} // namespace AMP::Operator
 
#endif