---

DragParticle.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  ' \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
//
// This software is copyright (C) by the Lawrence Berkeley
// National Laboratory.  Permission is granted to reproduce
// this software for non-commercial purposes provided that
// this notice is left intact.
//
// It is acknowledged that the U.S. Government has rights to
// this software under Contract DE-AC03-765F00098 between
// the U.S.  Department of Energy and the University of
// California.
//
// This software is provided as a professional and academic
// contribution for joint exchange. Thus it is experimental,
// is provided ``as is'', with no warranties of any kind
// whatsoever, no support, no promise of updates, or printed
// documentation. By using this software, you acknowledge
// that the Lawrence Berkeley National Laboratory and
// Regents of the University of California shall have no
// liability with respect to the infringement of other
// copyrights by any part of this software.
//

#ifndef _DRAGPARTICLE_H_
#define _DRAGPARTICLE_H_

#include "BinItem.H"
#include "DiscreteDeltaFn.H"
#include "PolynomialDelta.H"
#include "SPMD.H"


class DragParticle: public BinItem
{
  
public:

  DragParticle();


  DragParticle(const RealVect& a_position);

  DragParticle(const RealVect& a_position,
               const RealVect& a_velocity,
               const DiscreteDeltaFn* a_deltaFnPtr);


  DragParticle(const DragParticle&);

  virtual ~DragParticle();

  virtual void define(const RealVect& a_position);

  virtual void define(const RealVect& a_position,
                      const RealVect& a_velocity, 
                      const DiscreteDeltaFn* a_deltaFnPtr);

  virtual void setVel(const RealVect& a_vel);
  
  virtual void setFluidVel(const RealVect& a_vel);

  virtual void setFluidVel(Real a_vel, int a_comp);

  virtual void setDragForce(const RealVect& a_force);


  virtual void setBodyForce(const RealVect& a_force);


  virtual RealVect velocity() const {return m_velocity;};
  
  virtual RealVect fluidVel() const {return m_fluidVel;};

  virtual RealVect totalForce() const {return m_dragForce + m_bodyForce;};

  virtual RealVect dragForce() const {return m_dragForce;};

  virtual RealVect bodyForce() const {return m_bodyForce;}

  virtual void setDragCoeff(const Real a_dragCoeff);

  virtual Real dragCoeff() const {return m_dragCoeff;};

  virtual Real mass() const {return m_mass;}

  virtual void setMass(Real a_mass);

  virtual bool boundaryMarker() const {return m_boundaryMarker;}

  virtual void setBoundaryMarker(bool a_marker);


  virtual DragParticle* clone() const;


  virtual void computeDragForce(const RealVect& a_flowVelocity);

  virtual void computeDragForce();


  virtual Real computeK(const RealVect& a_x, int a_idir, int a_jdir) const;


  virtual Real computeProjForce(const RealVect& a_x, int a_idir) const;


  virtual void computeProjForce(FArrayBox& a_force, 
                                const Box& a_box,
                                Real a_dx,
                                RealVect& a_origin) const;


  virtual void computeProjForce(FArrayBox& a_force, 
                                const Box& a_box,
                                int a_idir,
                                int a_destComp,
                                Real a_dx,
                                RealVect& a_origin) const;



  // Linearization functions
  

  virtual int size() const;


  
  virtual int linearSize() const;


  virtual void linearOut(void* a_buf) const;


  virtual void linearIn(const void* const a_buf);

  int preAllocatable() {return 0;}


  DragParticle& operator= (const DragParticle& a_src);


protected:
  RealVect m_velocity;


  RealVect m_fluidVel;

  RealVect m_dragForce;

  RealVect m_bodyForce;

  Real m_dragCoeff;

  Real m_mass;

  bool m_boundaryMarker;

  //DiscreteDeltaFn* m_deltaFnPtr;
  PolynomialDelta m_deltaFn;
  
  void setDefaultValues();

};


// Specializations for SPMD
//Vector<DragParticle>  specialization
template < > 
int linearSize(const Vector<DragParticle>& a_input); 
template < > 
void linearIn(Vector<DragParticle>& a_outputT, const void* const inBuf); 
template < > 
void linearOut(void* const a_outBuf, const Vector<DragParticle>& a_inputT); 



#endif

---