hemoCellFields.h

Go to the documentation of this file.

/*
This file is part of the HemoCell library
 
HemoCell is developed and maintained by the Computational Science Lab 
in the University of Amsterdam. Any questions or remarks regarding this library 
can be sent to: info@hemocell.eu
 
When using the HemoCell library in scientific work please cite the
corresponding paper: https://doi.org/10.3389/fphys.2017.00563
 
The HemoCell library is free software: you can redistribute it and/or
modify it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
 
The library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef HEMOCELLFIELDS_H
#define HEMOCELLFIELDS_H
namespace hemo {
class HemoCellFields;
}
#include "hemoCellParticleField.h"
#include "genericFunctions.h"
#include "hemoCellFunctional.h"
#include "hemoCellField.h"
#include "hemoCellParticle.h"
#include "config.h"
#include <unistd.h>
 
#include "latticeBoltzmann/advectionDiffusionLattices.hh"
#include "multiBlock/multiBlockLattice3D.hh"
#include "offLattice/triangularSurfaceMesh.hh"
#include "libraryInterfaces/TINYXML_xmlIO.hh"
#include "particles/multiParticleField3D.hh"
#include "parallelism/parallelBlockCommunicator3D.h"
 
namespace hemo {
class HemoCell;
 
class HemoCellFields
{
public:
  
  HemoCellFields(plb::MultiBlockLattice3D<T, DESCRIPTOR> & lattice_, unsigned int particleEnvelopeWidth,HemoCell &);
 
  /*
   * Create the particle field seperately, takes the arguments set in the constructor
   * Is called in the constructor as well
   */
  void createParticleField(plb::SparseBlockStructure3D* sbStructure_ = 0, plb::ThreadAttribution * tAttribution_ = 0);
  
  void createCEPACfield();
  
  void InitAfterLoadCheckpoint();
 
public:
  ~HemoCellFields();
  
  HemoCellField * addCellType(std::string name_, int constructType);
  
  HemoCellField * operator[](unsigned int index);
  
  HemoCellField * operator[](string name);
  
  unsigned int size();
  
  /*Checkpoint functions*/
private:
  void copyXMLreader2XMLwriter(plb::XMLreader const& reader, plb::XMLwriter & writer);
  void copyXMLreader2XMLwriter(plb::XMLreaderProxy readerProxy, plb::XMLwriter & writer);
public:
  void load(plb::XMLreader * documentXML, unsigned int & iter, Config * cfg = NULL);
  void save(plb::XMLreader * documentXML, unsigned int iter, Config * cfg = NULL);
    
  plb::MultiParticleField3D<HemoCellParticleField> & getParticleField3D();
  void readPositionsCellFields(std::string particlePosFile);
 
  //Class functionals
  void advanceParticles();
  
  // Find interior lattice points and set omega
  void findInternalParticleGridPoints();
  
  // Look for lattice nodes near the membrane and update those
  void internalGridPointsMembrane();
  
  void interpolateFluidVelocity();
  
  void spreadParticleForce();
  
  void separate_force_vectors();
  
  void unify_force_vectors();
  
  void applyRepulsionForce();
 
  void applyBoundaryRepulsionForce();
  
  void deleteIncompleteCells(bool verbose = true);
  
  void applyConstitutiveModel(bool forced = false);
  
  void syncEnvelopes();
 
  void getParticles(vector<HemoCellParticle*> & particles, plb::Box3D & domain);
  
  void addParticles(vector<HemoCellParticle> & particles);
 
  void populateBoundaryParticles();
 
  void populateBindingSites(plb::Box3D * box = 0);
  
  void deleteNonLocalParticles(int envelope);
  
  void solidifyCells();
  void prepareSolidification();
 
  void updateResidenceTime(unsigned int rtime);
  
  //Class Variables
  
  plb::MultiBlockLattice3D<T, DESCRIPTOR> * lattice;
  vector<int> desiredFluidOutputVariables;
  
  vector<int> desiredCEPACfieldOutputVariables;
  HemoCell & hemocell;
  vector<HemoCellField *> cellFields;
  pluint envelopeSize;
  plb::MultiParticleField3D<HemoCellParticleField> * immersedParticles = 0;
  plb::MultiParticleField3D<HemoCellParticleField> * preinlet_immersedParticles = 0, * domain_immersedParticles = 0;
 
  plb::MultiBlockLattice3D<T,CEPAC_DESCRIPTOR> * CEPACfield = 0; 
 
  T repulsionCutoff = 0.0;
  T repulsionConstant = 0.0;
  pluint repulsionTimescale = 1;
 
  T boundaryRepulsionCutoff = 0.0;
  T boundaryRepulsionConstant = 0.0;
  pluint boundaryRepulsionTimescale = 1;
  
  pluint particleVelocityUpdateTimescale = 1;
  
  pluint solidifyTimescale = 1;
  
  pluint interiorViscosityTimescale = 1;
  pluint interiorViscosityEntireGridTimescale = 1;
  
  int periodicity_limit[3] = {100};
  //Internal calculation of offset created by flattening limits
  int periodicity_limit_offset_y = 100;
  int periodicity_limit_offset_z = 10000;
  
private:
  vector<vector<NoInitChar>> sendBuffers, recvBuffers;
public:
  
   int number_of_cells = 0;
   inline int base_cell_id(int wrapped) {
     return ((wrapped%number_of_cells)+number_of_cells)%number_of_cells;
   }
   unsigned int max_neighbours = 0;
   
   plb::CommunicationStructure3D * large_communicator = 0;
   plb::ParallelBlockCommunicator3D envelope_communicator;
   
   void calculateCommunicationStructure();
   
   /*
   * Functionals needed for access of the cellfields
   */
  class HemoSeperateForceVectors: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoSeperateForceVectors * clone() const;
  };
  class HemoUnifyForceVectors: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoUnifyForceVectors * clone() const;
  };
  class HemoSpreadParticleForce: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoSpreadParticleForce * clone() const;
  }; 
  class HemoFindInternalParticleGridPoints: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoFindInternalParticleGridPoints * clone() const;
  };
  
  class HemoInternalGridPointsMembrane: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoInternalGridPointsMembrane * clone() const;
  };
  
  
  class HemoInterpolateFluidVelocity: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoInterpolateFluidVelocity * clone() const;
  };
  class HemoAdvanceParticles: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoAdvanceParticles * clone() const;
  };
  class HemoApplyConstitutiveModel: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoApplyConstitutiveModel * clone() const;
  public:
   bool forced = false;
  };
  class HemoRepulsionForce: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoRepulsionForce * clone() const;
  };
  class HemoBoundaryRepulsionForce: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoBoundaryRepulsionForce * clone() const;
  };
  class HemoDeleteIncompleteCells: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoDeleteIncompleteCells * clone() const;
  public:
    bool verbose;
  };
  class HemoSyncEnvelopes: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoSyncEnvelopes * clone() const;
   void getTypeOfModification(std::vector<plb::modif::ModifT>& modified) const;
  };
  class HemoGetParticles: public HemoCellFunctional {
    vector<HemoCellParticle *> & particles;
    void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
    HemoGetParticles * clone() const;
  public:
    HemoGetParticles(vector<HemoCellParticle *> & particles_) : particles(particles_) {}
  };
  class HemoSetParticles: public HemoCellFunctional {
    vector<HemoCellParticle> & particles;
    void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
    HemoSetParticles * clone() const;
  public:
    HemoSetParticles(vector<HemoCellParticle> & particles_) : particles(particles_) {}
  };
  class HemoPopulateBoundaryParticles: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoPopulateBoundaryParticles * clone() const;
  };
  class HemoPopulateBindingSites: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoPopulateBindingSites * clone() const;
  };
  class HemoDeleteNonLocalParticles: public HemoCellFunctional {
   void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
   HemoDeleteNonLocalParticles * clone() const;
   public:
    int envelopeSize;
    HemoDeleteNonLocalParticles(int envelope_) : envelopeSize(envelope_) {}
  };
  class HemoSolidifyCells: public HemoCellFunctional {
    void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
    HemoSolidifyCells * clone() const;
  };
  class HemoPrepareSolidification: public HemoCellFunctional {
    void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
    HemoPrepareSolidification * clone() const;
  };
  class HemoupdateResidenceTime: public HemoCellFunctional {
    void processGenericBlocks(plb::Box3D, std::vector<plb::AtomicBlock3D*>);
    HemoupdateResidenceTime * clone() const;
  public:
    unsigned int rtime;
  };
};
}
#endif