advectiondiffusionboundaries.hh

open lattice boltzmann project www.openlb.org

        LatticeStatistics<T>& statistics )
{
   assert(false);
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int xNormal, int yNormal>
T AdvectionDiffusionCornerDynamics2D<T,Lattice,Dynamics,xNormal,yNormal>::getOmega() const 
{
    return boundaryDynamics.getOmega();
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int xNormal, int yNormal>
void AdvectionDiffusionCornerDynamics2D<T,Lattice,Dynamics,xNormal,yNormal>::setOmega(T omega_)
{
    boundaryDynamics.setOmega(omega_);
}



//=================================================================
// For 3D Corners with regularized Dynamic ==============================================
//=================================================================
template<typename T, template<typename U> class Lattice, typename Dynamics, int xNormal, int yNormal, int zNormal>
AdvectionDiffusionCornerDynamics3D<T,Lattice,Dynamics,xNormal,yNormal,zNormal>::AdvectionDiffusionCornerDynamics3D(
        T omega_, Momenta<T,Lattice>& momenta_)
    : BasicDynamics<T,Lattice>(momenta_),
      boundaryDynamics(omega_, momenta_)
{
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int xNormal, int yNormal, int zNormal>
AdvectionDiffusionCornerDynamics3D<T,Lattice,Dynamics,xNormal,yNormal, zNormal>* AdvectionDiffusionCornerDynamics3D<T,Lattice, Dynamics, xNormal,yNormal,zNormal>::clone() const
{
    return new AdvectionDiffusionCornerDynamics3D<T,Lattice,Dynamics,xNormal,yNormal,zNormal>(*this);
}

template<typename T, template<typename U> class Lattice, typename Dynamics,  int xNormal, int yNormal, int zNormal>
T AdvectionDiffusionCornerDynamics3D<T,Lattice,Dynamics,xNormal,yNormal,zNormal>::computeEquilibrium(int iPop, T rho, const T u[Lattice<T>::d], T uSqr) const
{ 
     return advectionDiffusionLbHelpers<T,Lattice>::equilibrium(iPop, rho, u);
}


template<typename T, template<typename U> class Lattice, typename Dynamics,  int xNormal, int yNormal, int zNormal>
void AdvectionDiffusionCornerDynamics3D<T,Lattice,Dynamics,xNormal,yNormal,zNormal>::collide(Cell<T,Lattice>& cell,LatticeStatistics<T>& statistics)
{
    typedef Lattice<T> L;
    typedef advectionDiffusionLbHelpers<T,Lattice> lbH;
    
    T temperature = this->momenta.computeRho(cell);
    T* u = cell.getExternal(Lattice<T>::ExternalField::velocityBeginsAt);
    // I need to get Missing information on the corners !!!!
    std::vector<int> unknownIndexes = utilAdvDiff::subIndexOutgoing3DonCorners<L,xNormal,yNormal,zNormal>();
   // here I know all missing and non missing f_i
    
    
    // The collision procedure for D2Q5 and D3Q7 lattice is the same ...
    // Given the rule f_i_neq = -f_opposite(i)_neq
    // I have the right number of equations for the number of unknowns using these lattices 
    
    for (unsigned iPop = 0; iPop < unknownIndexes.size(); ++iPop)
    {
        cell[unknownIndexes[iPop]] = lbH::equilibrium(unknownIndexes[iPop], temperature, u) 
                                    -(cell[util::opposite<L>(unknownIndexes[iPop])]
                                    - lbH::equilibrium(util::opposite<L>(unknownIndexes[iPop]), temperature, u) ) ;
    }
    
    // Once all the f_i are known, I can call the collision for the Regularized Model.
    boundaryDynamics.collide(cell, statistics);
    
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int xNormal, int yNormal, int zNormal>
void AdvectionDiffusionCornerDynamics3D<T,Lattice,Dynamics,xNormal,yNormal,zNormal>::staticCollide (
        Cell<T,Lattice>& cell,
        const T u[Lattice<T>::d],
        LatticeStatistics<T>& statistics )
{
   assert(false);
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int xNormal, int yNormal, int zNormal>
T AdvectionDiffusionCornerDynamics3D<T,Lattice,Dynamics,xNormal,yNormal,zNormal>::getOmega() const 
{
    return boundaryDynamics.getOmega();
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int xNormal, int yNormal, int zNormal>
void AdvectionDiffusionCornerDynamics3D<T,Lattice,Dynamics,xNormal,yNormal,zNormal>::setOmega(T omega_)
{
    boundaryDynamics.setOmega(omega_);
}

//=================================================================
// For 3D Edges with regularized Dynamic ==============================================
//=================================================================
template<typename T, template<typename U> class Lattice, typename Dynamics, int plane, int normal1, int normal2>
AdvectionDiffusionEdgesDynamics<T,Lattice,Dynamics,plane,normal1, normal2>::AdvectionDiffusionEdgesDynamics(
        T omega_, Momenta<T,Lattice>& momenta_)
    : BasicDynamics<T,Lattice>(momenta_),
      boundaryDynamics(omega_, momenta_)
{
}

template<typename T, template<typename U> class Lattice, typename Dynamics,  int plane, int normal1, int normal2>
AdvectionDiffusionEdgesDynamics<T,Lattice,Dynamics,plane,normal1, normal2>* AdvectionDiffusionEdgesDynamics<T,Lattice, Dynamics,plane,normal1, normal2>::clone() const
{
    return new AdvectionDiffusionEdgesDynamics<T,Lattice,Dynamics,plane,normal1, normal2>(*this);
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int plane, int normal1, int normal2>
T AdvectionDiffusionEdgesDynamics<T,Lattice,Dynamics,plane,normal1, normal2>::computeEquilibrium(int iPop, T rho, const T u[Lattice<T>::d], T uSqr) const
{ 
     return advectionDiffusionLbHelpers<T,Lattice>::equilibrium(iPop, rho, u);
}


template<typename T, template<typename U> class Lattice, typename Dynamics,  int plane, int normal1, int normal2>
void AdvectionDiffusionEdgesDynamics<T,Lattice,Dynamics,plane,normal1, normal2>::collide(Cell<T,Lattice>& cell,LatticeStatistics<T>& statistics)
{
    typedef Lattice<T> L;
    typedef advectionDiffusionLbHelpers<T,Lattice> lbH;
    
    T temperature = this->momenta.computeRho(cell);
    T* u = cell.getExternal(Lattice<T>::ExternalField::velocityBeginsAt);
    // I need to get Missing information on the corners !!!!
    std::vector<int> unknownIndexes = utilAdvDiff::subIndexOutgoing3DonEdges<L,plane,normal1, normal2>();
   // here I know all missing and non missing f_i
    
    
    // The collision procedure for D2Q5 and D3Q7 lattice is the same ...
    // Given the rule f_i_neq = -f_opposite(i)_neq
    // I have the right number of equations for the number of unknowns using these lattices 
    
    for (unsigned iPop = 0; iPop < unknownIndexes.size(); ++iPop)
    {
        cell[unknownIndexes[iPop]] = lbH::equilibrium(unknownIndexes[iPop], temperature, u) 
                                    -(cell[util::opposite<L>(unknownIndexes[iPop])]
                                    - lbH::equilibrium(util::opposite<L>(unknownIndexes[iPop]), temperature, u) ) ;
    }
    
    // Once all the f_i are known, I can call the collision for the Regularized Model.
    boundaryDynamics.collide(cell, statistics);
    
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int plane, int normal1, int normal2>
void AdvectionDiffusionEdgesDynamics<T,Lattice,Dynamics,plane,normal1, normal2>::staticCollide (
        Cell<T,Lattice>& cell,
        const T u[Lattice<T>::d],
        LatticeStatistics<T>& statistics )
{
   assert(false);
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int plane, int normal1, int normal2>
T AdvectionDiffusionEdgesDynamics<T,Lattice,Dynamics,plane,normal1, normal2>::getOmega() const 
{
    return boundaryDynamics.getOmega();
}

template<typename T, template<typename U> class Lattice, typename Dynamics, int plane, int normal1, int normal2>
void AdvectionDiffusionEdgesDynamics<T,Lattice,Dynamics,plane,normal1, normal2>::setOmega(T omega_)
{
    boundaryDynamics.setOmega(omega_);
}




}  // namespace olb




#endif