QCAD_PoissonSource.hpp

Go to the documentation of this file.

//*****************************************************************//
//    Albany 2.0:  Copyright 2012 Sandia Corporation               //
//    This Software is released under the BSD license detailed     //
//    in the file "license.txt" in the top-level Albany directory  //
//*****************************************************************//

#ifndef QCAD_POISSONSOURCE_HPP
#define QCAD_POISSONSOURCE_HPP

#include "Phalanx_ConfigDefs.hpp"
#include "Phalanx_Evaluator_WithBaseImpl.hpp"
#include "Phalanx_Evaluator_Derived.hpp"
#include "Phalanx_MDField.hpp"

#include "Teuchos_ParameterList.hpp"
#include "Epetra_Vector.h"
#include "Sacado_ParameterAccessor.hpp"
#include "Stokhos_KL_ExponentialRandomField.hpp"
#include "Teuchos_Array.hpp"

#include "Albany_Layouts.hpp"

#include "QCAD_MaterialDatabase.hpp"
#include "QCAD_MeshRegion.hpp"
#include "QCAD_EvaluatorTools.hpp"

namespace QCAD {
  template<typename EvalT, typename Traits>
  class PoissonSource : 
  public PHX::EvaluatorWithBaseImpl<Traits>,
  public PHX::EvaluatorDerived<EvalT, Traits>,
  public Sacado::ParameterAccessor<EvalT, SPL_Traits>,
  public EvaluatorTools<EvalT, Traits>
  {
  public:
    typedef typename EvalT::ScalarT ScalarT;
    typedef typename EvalT::MeshScalarT MeshScalarT;

    PoissonSource(Teuchos::ParameterList& p,
                 const Teuchos::RCP<Albany::Layouts>& dl);
  
    void postRegistrationSetup(typename Traits::SetupData d,
         PHX::FieldManager<Traits>& vm);
  
    void evaluateFields(typename Traits::EvalData d);
  
    ScalarT& getValue(const std::string &n);

    /***** define universal constants as double constants *****/
    static const double kbBoltz; // Boltzmann constant in [eV/K]
    static const double eps0; // vacuum permittivity in [C/(V.cm)]
    static const double eleQ; // electron elemental charge in [C]
    static const double m0;   // vacuum electron mass in [kg]
    static const double hbar; // reduced planck constant in [J.s]
    static const double pi;   // pi constant (unitless)
    static const double MAX_EXPONENT;  // max. exponent in an exponential function [1]

  private:

    Teuchos::RCP<const Teuchos::ParameterList>
        getValidPoissonSourceParameters() const;

    void evaluateFields_elementblocks(typename Traits::EvalData workset);
    void evaluateFields_default(typename Traits::EvalData workset);
    void evaluateFields_moscap1d(typename Traits::EvalData workset);


    struct PoissonSourceSetupInfo;
    PoissonSourceSetupInfo source_setup(const std::string& sourceName, const std::string& mtrlCategory,
          const typename Traits::EvalData workset);
    void source_semiclassical(const typename Traits::EvalData workset, std::size_t cell, std::size_t qp,
            const ScalarT& scaleFactor, const PoissonSourceSetupInfo& setup_info);
    void source_none         (const typename Traits::EvalData workset, std::size_t cell, std::size_t qp,
            const ScalarT& scaleFactor, const PoissonSourceSetupInfo& setup_info);
    void source_quantum      (const typename Traits::EvalData workset, std::size_t cell, std::size_t qp,
            const ScalarT& scaleFactor, const PoissonSourceSetupInfo& setup_info);
    void source_coulomb      (const typename Traits::EvalData workset, std::size_t cell, std::size_t qp,
            const ScalarT& scaleFactor, const PoissonSourceSetupInfo& setup_info);
    void source_testcoulomb  (const typename Traits::EvalData workset, std::size_t cell, std::size_t qp,
            const ScalarT& scaleFactor, const PoissonSourceSetupInfo& setup_info);



    inline ScalarT computeMBStat(const ScalarT x);
        
    inline ScalarT computeFDIntOneHalf(const ScalarT x);
        
    inline ScalarT computeZeroKFDInt(const ScalarT x);

    inline ScalarT computeZeroStat(const ScalarT x);


        
    inline ScalarT fullDopants(const std::string dopType, const ScalarT &x);
        
    ScalarT ionizedDopants(const std::string dopType, const ScalarT &x);


    
    ScalarT eDensityForPoissonSchrodinger(typename Traits::EvalData workset, std::size_t cell, 
        std::size_t qp, const ScalarT prevPhi, const bool bUsePredCorr, const double Ef, const double fixedOcc);

    ScalarT eDensityForPoissonCI(typename Traits::EvalData workset, std::size_t cell,
        std::size_t qp, const ScalarT prevPhi, const bool bUsePredCorr, const double Ef, const double fixedOcc);



    void source_pointcharges(typename Traits::EvalData workset);

    bool pointIsInTetrahedron(const MeshScalarT* cellVertices, const MeshScalarT* position, int nVertices);

    bool pointIsInHexahedron(const MeshScalarT* cellVertices, const MeshScalarT* position, int nVertices);

    bool pointIsInPolygon(const MeshScalarT* cellVertices, const MeshScalarT* position, int nVertices);

    MeshScalarT determinant(const MeshScalarT** mx, int N);

    bool sameSideOfPlane(const MeshScalarT* plane0, const MeshScalarT* plane1, const MeshScalarT* plane2, 
       const MeshScalarT* ptA, const MeshScalarT* ptB);



    ScalarT computeFDIntMinusOneHalf(const ScalarT x);
    
    ScalarT computeVxcLDA(const double& relPerm, const double& effMass, 
        const ScalarT& eDensity); 

    ScalarT getCellScaleFactor(std::size_t cell, const std::vector<bool>& bEBInRegion, ScalarT init_factor);

    ScalarT getReferencePotential(typename Traits::EvalData workset);




    
    std::size_t numQPs;
    std::size_t numDims;
    std::size_t numNodes;
    PHX::MDField<MeshScalarT,Cell,QuadPoint,Dim> coordVec;
    PHX::MDField<MeshScalarT,Cell,Vertex,Dim> coordVecAtVertices;
    PHX::MDField<MeshScalarT,Cell,QuadPoint> weights;
    PHX::MDField<ScalarT,Cell,QuadPoint> potential; // scaled potential (no unit)
    PHX::MDField<ScalarT,Dim> temperatureField; // lattice temperature [K]
    
    PHX::MDField<ScalarT,Cell,QuadPoint> poissonSource; // scaled RHS (unitless)
    PHX::MDField<ScalarT,Cell,QuadPoint> chargeDensity; // space charge density in [cm-3]
    PHX::MDField<ScalarT,Cell,QuadPoint> electronDensity; // electron density in [cm-3]
    PHX::MDField<ScalarT,Cell,QuadPoint> artCBDensity; // artificial conduction band density [cm-3]
    PHX::MDField<ScalarT,Cell,QuadPoint> holeDensity;   // electron density in [cm-3]
    PHX::MDField<ScalarT,Cell,QuadPoint> electricPotential; // phi in [V]
    PHX::MDField<ScalarT,Cell,QuadPoint> ionizedDopant;    // ionized dopants in [cm-3]
    PHX::MDField<ScalarT,Cell,QuadPoint> conductionBand; // conduction band in [eV]
    PHX::MDField<ScalarT,Cell,QuadPoint> valenceBand;   // valence band in [eV]
    PHX::MDField<ScalarT,Cell,QuadPoint> approxQuanEDen;   // approximate quantum electron density [cm-3]

    ScalarT factor;
    
    ScalarT temperatureName; //name of temperature field
    
    std::string device;

    std::string nonQuantumRegionSource;
    std::string quantumRegionSource;
    ScalarT sourceEvecInds[2], prevDensityMixingFactor;
    bool imagPartOfCoulombSrc; // if true, use the imaginary as opposed to real part of coulomb source
    
    std::string carrierStatistics;
    std::string incompIonization;
        
    double dopingDonor;   // in [cm-3]
    double dopingAcceptor;
        
    double donorActE;     // (Ec-Ed) where Ed = donor energy level
    double acceptorActE;  // (Ea-Ev) where Ea = acceptor energy level
        
    double length_unit_in_m;  // length unit for input and output mesh
    double energy_unit_in_eV; // energy unit for solution, conduction band, etc, but NOT boundary conditions
    //ScalarT C0;  // scaling for conc. [cm^-3]
    //ScalarT Lambda2;  // derived scaling factor (unitless) that appears in the scaled Poisson equation

    std::vector< Teuchos::RCP<MeshRegion<EvalT, Traits> > > meshRegionList;
    std::vector< ScalarT > meshRegionFactors;

    struct PointCharge { MeshScalarT position[3]; double charge; int iWorkset, iCell; };
    std::vector< PointCharge > pointCharges;
    std::size_t numWorksetsScannedForPtCharges;
    
    bool bUsePredictorCorrector;
    bool bIncludeVxc; 
    bool bRealEigenvectors;
    int  nEigenvectors;
    double fixedQuantumOcc;
    std::vector< PHX::MDField<ScalarT,Cell,QuadPoint> > eigenvector_Re;
    std::vector< PHX::MDField<ScalarT,Cell,QuadPoint> > eigenvector_Im;
    
    Teuchos::RCP<QCAD::MaterialDatabase> materialDB;

    std::map<std::string, ScalarT > materialParams;
    
    double oxideWidth;
    double siliconWidth; 
    
    std::map<std::string, double> mapDBCValue_eb; 
    std::map<std::string, double> mapDBCValue_ns; 


    struct PoissonSourceSetupInfo
    {
      ScalarT qPhiRef; // energy reference for heterogeneous structures, in [eV]
      ScalarT Lambda2; // derived scaling factor
      ScalarT V0;      // kb*T in desired energy unit ( or kb*T/q in desired voltage unit), [myV]
      ScalarT kbT;     // in [eV]
      double Chi;      // Electron affinity (in semiconductors & insulators) or Work function (in metals) in [eV]
      
      //Semiconductors
      double fermiE; // Fermi energy, [myV]
      ScalarT eArgOffset, hArgOffset;  
      
      
      ScalarT Nc;  // conduction band effective DOS in [cm-3]
      ScalarT Nv;  // valence band effective DOS in [cm-3]
      ScalarT Eg;  // band gap at T [K] in [eV]
      
      std::string fixedChargeType;
      ScalarT dopingConc, fixedChargeConc;  // [cm-3]
      ScalarT inArg;
      
      //for predictor corrector
      Albany::MDArray prevPhiArray;

      //for damping/mixing
      double prevDensityFactor;
      Albany::MDArray prevDensityArray;
      
      //for coulomb
      int sourceEvec1, sourceEvec2;
      ScalarT coulombPrefactor;
      
      // for exchange-correlation
      double averagedEffMass;
      double relPerm;
      
      ScalarT (QCAD::PoissonSource<EvalT,Traits>::*carrStat) (const ScalarT);
      
      ScalarT (QCAD::PoissonSource<EvalT,Traits>::*ionDopant) (const std::string, const ScalarT&); 
      
      ScalarT (QCAD::PoissonSource<EvalT,Traits>::*quantum_edensity_fn) 
      (typename Traits::EvalData, std::size_t, std::size_t, const ScalarT, const bool, const double, const double);
    };

  };

}

#endif