hemocell.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 HEMOCELL_H
#define HEMOCELL_H
 
//Load Constants
#include "constant_defaults.h"
#include "config.h"
 
/* CORE libs */
#include "hemoCellFields.h"
 
/* IO */
#include "loadBalancer.h"
#include "profiler.h"
 
/* MECHANICS */
#include "cellMechanics.h"
#include "constantConversion.h"
 
/* Helpers */
#include "preInlet.h"
// #include "leesEdwardsBC.h"
 
/* Always used palabos functions in case files*/
#ifndef COMPILING_HEMOCELL_LIBRARY
#include "voxelizeDomain.h"
#include "palabos3D.h"
#include "palabos3D.hh"
using namespace hemo;
using namespace plb;
#endif
 
namespace hemo { 
 
class HemoCell {
  public:
  enum class MPIHandle {Internal, External};
 
  HemoCell(char * configFileName, int argc, char* argv[]) : HemoCell{ configFileName, argc, argv, HemoCell::MPIHandle::Internal } {};
 
  HemoCell(char * configFileName, int argc, char* argv[], HemoCell::MPIHandle mpi_handle);
 
  /*
   * Clean up hemocell
   */
  ~HemoCell();
  
  void latticeEquilibrium(T rho, hemo::Array<T, 3> vel);
 
  void initializeCellfield();
 
  template<class Mechanics>
  void addCellType(string name, int constructType) {
    HemoCellField * cellfield = cellfields->addCellType(name,constructType);
    Mechanics * mechanics = new Mechanics(*cellfield->materialCfg, *cellfield);
    cellfield->mechanics = mechanics;
    cellfield->statistics();
  }
 
  void setOutputs(string name, vector<int> outputs);
  
  //Sets the repulsion constant and cutoff distance, also enables repulsion
  bool repulsionEnabled = false;
  bool boundaryRepulsionEnabled = false;
  void setRepulsion(T repulsionConstant, T repulsionCutoff);
 
  // Lees-Edwards boundary condition
  bool leesEdwardsBC = false;
  double * LEcurrentDisplacement;
 
  //Set the timescale separation of the particles of a particle type
  void setMaterialTimeScaleSeparation(string name, unsigned int separation);
  
  //Enable solidify mechanics of a celltype
  void enableSolidifyMechanics(string name) {
    hlog << "(HemoCell) Enabling Solidify Mechanics for " << name << " mechanical model" << endl;
    (*cellfields)[name]->doSolidifyMechanics = true;
  }
  
  //Set the separation of when velocity is interpolated to the particle
  void setParticleVelocityUpdateTimeScaleSeparation(unsigned int separation);
 
  //Set the timescale separation of the repulsion force for all particles
  void setRepulsionTimeScaleSeperation(unsigned int separation);
 
  void setSolidifyTimeScaleSeperation(unsigned int separation);
 
  //Set the timescale separation of the interior viscosity, in between update and raytracing (expensive) update
  void setInteriorViscosityTimeScaleSeperation(unsigned int separation, unsigned int separation_entire_grid);
  
  //Enable Boundary particles and set the boundary particle constants
  void enableBoundaryParticles(T boundaryRepulsionConstant, T boundaryRepulsionCutoff, unsigned int timestep = 1);
  
  //Set the minimum distance of the particles of a type to the solid, must be called BEFORE loadparticles
  void setInitialMinimumDistanceFromSolid(string name, T distance);
  
  //Set the output of the fluid field
  void setFluidOutputs(vector<int> outputs);
  
  //Set the output of the CEPAC field
  void setCEPACOutputs(vector<int> outputs);
  
  //Explicitly set the periodicity of the domain along the different axes
  void setSystemPeriodicity(unsigned int axis, bool bePeriodic);
 
  //Set the number or times a particle should be able to wrap around in a certain direction (both negative and positive (default: 100)
  void setSystemPeriodicityLimit(unsigned int axis, int limit);
  
  //Load the particles
private:
  bool loadParticlesIsCalled = false;
public:
  void loadParticles();
 
  void loadCheckPoint();
  
  void saveCheckPoint();
 
  bool outputInSiUnits = true;
  
  void writeOutput();
  
  void iterate();
 
  void checkExitSignals();
 
  //Load balancing library functions
  T calculateFractionalLoadImbalance();
  
  void doLoadBalance();
  
  void doRestructure(bool checkpoint_avail = true);
  
  void initializeLattice(MultiBlockManagement3D const & management);
 
  PreInlet * preInlet = 0;
  
  bool partOfpreInlet = false;
  
  map<plint,plint> BlockToMpi;
  
  LoadBalancer * loadBalancer = 0;
  MultiBlockLattice3D<T, DESCRIPTOR> * lattice = 0, *preinlet_lattice = 0, * domain_lattice = 0;
  
  MultiBlockManagement3D * preinlet_lattice_management = 0, * domain_lattice_management = 0;
  
  Config * cfg = 0;
  HemoCellFields * cellfields = 0;
  unsigned int iter = 0;
  
  XMLreader * documentXML = 0; //Needed for legacy checkpoint reading TODO fix
  private:
  unsigned int lastOutputAt = 0;
  std::chrono::high_resolution_clock::duration lastOutput = std::chrono::high_resolution_clock::duration::zero();
  
  void sanityCheck();
  bool sanityCheckDone = false;
};
}
#endif // HEMOCELL_H