Technical documentation

struct bendingOperator

Public Functions

inline bendingOperator()

Public Members

double cosTheta

double sinTheta

Vector3d axis

class Cartesian : public Region 

Subclassed by Triangle

Public Functions

Cartesian(Geometry*, double)

virtual SurfaceVector randomSurfaceVector() = 0

virtual void getTrajectoryCoordinates(SurfaceVector&, double&, vector<PointATedge>&, TrajectoryVector&) = 0

virtual void makeIntersectionList(Trajectory*)

virtual void translateVector(SurfaceVector&, const double)

virtual double intersectionAngle(Trajectory*, Trajectory*)

void getOrderParameters(OrderParameters&)

void getOrderParametersRawFlat(OrderParametersRaw&, vector<Vector3d>&, double)

void getOrderParametersRawCylinder(OrderParametersRaw&, double, double, double)

virtual void outputSnapshot(ostream&)

void outputSnapshotOffset(ostream&, double, double)

virtual void outputOrderHeatMap(ostream&, vector<double>&, vector<Vector3d>&)

template<class T, int AllocatorGranularity = 32> class CompactList

Public Functions

inline CompactList()

~CompactList()

inline T *ElementAddress(int idx)

inline void RemoveElement(int idx)

inline int size()

inline T &operator[](int idx)

inline T *create()

template<class Q> inline T *create(Q)

template<class Q, class R> inline T *create(Q, R)

template<class Q, class R, class S> inline T *create(Q, R, S)

Private Types

typedef boost::singleton_pool<PoolTag, sizeof(T), boost::default_user_allocator_new_delete, boost::details::pool::null_mutex, AllocatorGranularity> MemPool

Private Functions

inline T *InsertElement(T *newElement)

inline void remove(T*)

void removeAll()

Private Members

vector<T*> elements

template<class T> class CompactListItem

Public Functions

inline CompactListItem()

Public Members

int index

Protected Functions

inline virtual ~CompactListItem()

Friends

friend class CompactList

class DeterministicEvent

Public Functions

inline bool operator<(const DeterministicEvent &ev2) const

Public Members

double eventTimeDist

EventDescriptorIndex infoIdx

EventTrackingTag tag

GlobalEventType global_type

union DeterministicEvent

class DeterministicQueue

Public Functions

DeterministicQueue(System*, double (System::* dtFunc)(double), double (System::* tdFunc)(double))

inline double currentPos()

void advanceTime(double)

void storeTime(int)

inline double progression(int cachePos)

double firstEventTime()

DeterministicEvent pop()

inline bool empty()

void flush()

void pushGlobal(double, GlobalEventType)

EventTrackingTag pushDeterministic(double, EventDescriptorIndex)

Public Members

System *const system

Private Members

priority_queue<DeterministicEvent> queue

double currentBase

double valueCache[POSITION_CACHE_SIZE]

double (System::*const distanceTimeConversionFunction)(double)

double (System::*const timeDistanceConversionFunction)(double)

Friends

friend class System

template<class T> class DLBaseItem

Public Functions

inline T *next()

inline T *previous()

Protected Functions

inline virtual ~DLBaseItem()

Private Members

T *nextElement

T *previousElement

Friends

friend class DLList

template<class T> class DLContainerItem

Public Functions

inline DLContainerItem<T> *next()

inline DLContainerItem<T> *previous()

inline T *dataPtr()

inline DLContainerItem<T> *containerPtr(T *dPtr)

inline DLContainerItem()

template<class Q> inline DLContainerItem(Q par1)

template<class Q, class R> inline DLContainerItem(Q par1, R par2)

template<class Q, class R, class S> inline DLContainerItem(Q par1, R par2, S par3)

Public Members

T data

Protected Functions

inline virtual ~DLContainerItem()

Private Members

DLContainerItem<T> *nextElement

DLContainerItem<T> *previousElement

Friends

friend class DLList< DLContainerItem< T > >

template<class T, int AllocatorGranularity = 32> class DLList

Public Functions

inline DLList()

~DLList()

inline int size()

inline T *first()

inline T *last()

inline T *next(T *el)

inline T *previous(T *el)

inline T *create(): The following functions create a new element from the heap and insert it into the linked list.

template<class Q> inline T *create(Q)

template<class Q, class R> inline T *create(Q, R)

template<class Q, class R, class S> inline T *create(Q, R, S)

inline void remove(T*)

void removeAll()

inline void import(DLList<T, AllocatorGranularity>&, T*)

inline void importSet(DLList<T, AllocatorGranularity>&, T*, T*)

Private Types

typedef boost::singleton_pool<PoolTag, sizeof(T), boost::default_user_allocator_new_delete, boost::details::pool::null_mutex, AllocatorGranularity> MemPool

Private Functions

inline void unlinkElement(T*)

inline T *linkElement(T*)

Private Members

int numElements

T *firstElement

T *lastElement

class Edge

Public Functions

inline Edge()

Public Members

int excludePoint

double pCat

double edgAngNorm

double xyRotationAngle

double edgAngle

double edgBendAngle

Vector2d midPoint

Vector2d b

Matrix2d A

vector<int> dir

Vector2d dir2D

vector<int> orientation

map<int, int> orientationMap

map<int, int> excludePointMap

class edgeOfficer

Public Functions

inline edgeOfficer(int c)

Public Members

int cur

double meanEdgAngle

vector<int> elements

vector<int> edgeSpStore

vector<vector<int>> edgefaceStore

struct edgeRecord

Public Members

vector<int> key

int cell_id

int edge_index

edgeRecord *next

class elementList

Public Functions

inline elementList()

Public Members

int midPoint

double length

vector<int> nodes

vector<int> sharedElement

vector<int> sharedEdge

double edge3DAngle

Vector3d intersectionByPlane

class EventDescriptor

Public Functions

EventDescriptor(Microtubule*, DeterministicQueue*, double)

~EventDescriptor()

void reinitialize(DeterministicQueue*, double)

void pushOnQueue(double, DeterministicEventType)

void clear()

Public Members

EventDescriptorIndex index

Microtubule *const mt

DeterministicEventType type

EventTrackingTag tag

double distanceScaleFactor

DeterministicQueue *queue

class Geometry

Subclassed by TriMeshGeometry

Public Functions

inline Geometry(System *s, double a)

inline virtual ~Geometry()

bool integrityCheck()

double opticalLength()

int trajectoryCount()

void callTranslator(SurfaceVector&, int, int)

virtual void getOrderParameters(OrderParameters&) = 0

virtual void outputSnapshot(ostream&) = 0

virtual void outputOrderHeatMap(ostream&, vector<double>&, vector<Vector3d>&) = 0

SurfaceVector randomSurfaceVector()

TrajectoryVector createTrajectory(const SurfaceVector&)

TrajectoryVector createAndLinkTrajectory(const SurfaceVector&, Trajectory*, Direction, double, double)

Public Members

double area

double areainMesh

System *const system

vector<elementList> ppbEdgeList

vector<Vertics> globalVertex

double areaPPB

vector<Vertics> ppb

double patchArea[3]

vector<int> RegionsIndex[3]

int elementMax

Vector3d objectCM

Vector3d objectPA

Vector3d nucleousPosition

vector<Region*> regions

Private Functions

virtual TrajectoryVector extendTrajectory(Trajectory*, Direction) = 0

Friends

friend class System

friend TrajectoryVector nextTrajectory(Direction)

class Intersection

Public Members

int occupancy

Trajectory *otherTrajectory

IntersectionItr mirror

OccupiedIntersection *occupiedListPtr

class Measurement

Public Members

double time

double lengthDensity

double opticalDensity

double averageLength

int numberOfMTs

double segmentsPerMT

OrderParameters order

int growingNumber

int shrinkingNumber

int segments

int trajectories

int zipperCount

int crossoverCount

int inducedCatastropheCount

int validDEventCount

int invalidDEventCount

int sEventCount

int lengthSeveringCount

int intersectionSeveringCount

int occupiedIntersectionCount

double G_effAdjust

class Microtubule : public DLBaseItem<Microtubule>

Public Functions

Microtubule(System*, TrajectoryVector, bool = true)

~Microtubule()

bool integrityCheck()

inline double length()

inline void updateLength(bool forceUpdate = false)

void setDisappearEvent()

void handleEvent(const EventDescriptor*)

void catastrophe()

void rescue()

void harakiri()

void wall()

void collision()

void zipper(Direction dir)

void crossover()

void backtrack(MTTip*)

void endOfSegment(MTTip*)

void sever(Segment*, double)

void severAtCross(IntersectionItr is, Segment *cutSeg)

void splitSegmentAtTrajPos(double cutPos, Segment *cutSeg)

void translatePositionMT2Segment(double &cutPos, Segment *&cutSeg)

Public Members

System *const system

MTTip plus

MTTip minus

EventDescriptor disappearEvent

MTType type

double nucleationTime

int previousUpdateTag

DLList<Segment> segments

Private Functions

Microtubule(const Microtubule&)

Microtubule &operator=(const Microtubule&)

class MTRand

Public Types

Values:

enumerator N

Values:

enumerator SAVE

typedef unsigned long uint32

Public Functions

inline MTRand(const uint32 &oneSeed)

inline MTRand(uint32 *const bigSeed, uint32 const seedLength = N)

inline MTRand()

inline double rand()

inline double rand(const double &n)

inline double randExc()

inline double randExc(const double &n)

inline double randDblExc()

inline double randDblExc(const double &n)

inline uint32 randInt()

inline uint32 randInt(const uint32 &n)

inline double operator()()

inline double rand53()

inline double randNorm(const double &mean = 0.0, const double &variance = 0.0)

inline void seed(const uint32 oneSeed)

inline void seed(uint32 *const bigSeed, const uint32 seedLength = N)

inline void seed()

inline void save(uint32 *saveArray) const

inline void load(uint32 *const loadArray)

Protected Types

Values:

enumerator M

Protected Functions

inline void initialize(const uint32 oneSeed)

inline void reload()

inline uint32 hiBit(const uint32 &u) const

inline uint32 loBit(const uint32 &u) const

inline uint32 loBits(const uint32 &u) const

inline uint32 mixBits(const uint32 &u, const uint32 &v) const

inline uint32 twist(const uint32 &m, const uint32 &s0, const uint32 &s1) const

Protected Attributes

uint32 state[N]

uint32 *pNext

int left

Protected Static Functions

static inline uint32 hash(time_t t, clock_t c)

Friends

friend std::ostream &operator<<(std::ostream &os, const MTRand &mtrand)

friend std::istream &operator>>(std::istream &is, MTRand &mtrand)

class MTTip

Public Functions

MTTip(Microtubule*, TrajectoryVector, double, DeterministicQueue*, double)

~MTTip()

TipType type()

double position()

double otherPosition()

Segment &segment()

void initialize()

void unlinkFromTrajectory()

void switchTrajectory(Trajectory*, Direction, IntersectionItr, bool = true)

void locateIntersection()

void advanceIntersection()

void determineEvent()

void notifyInsert(IntersectionItr&)

void notifyRemove(IntersectionItr&)

Public Members

Microtubule *mt

Trajectory *trajectory

Direction dir

double velocity

EventDescriptor event

IntersectionItr nextCollision

TrjMTTipTag notificationTag

RegionMTTipTag regionTag

double nextEventPos

Private Functions

MTTip(const MTTip&)

MTTip &operator=(const MTTip&)

class OccupiedIntersection : public CompactListItem<OccupiedIntersection>

Public Functions

inline OccupiedIntersection(IntersectionItr is)

Public Members

IntersectionItr intersectionToCut

struct OrderParameters

Public Members

double R

double C

double Rdirector[3]

vector<double> localOrder

vector<Vector3d> Sv

class OrderParametersRaw

Public Functions

inline OrderParametersRaw(void)

inline double extractR(double director[3], string geometry)

Public Members

double localL

double localLOpt

double Qxx

double Qxy

double Qxz

double Qyy

double Qyz

double Qzz

double localOrder

Vector3d Sv

class Parameters

Public Functions

Parameters(System*)

void initialize(const char*)

bool reinitialize(const char*)

bool readFromFile(const char*, bool)

bool writeToFile()

void verifyParameters()

bool calcTheoryParameters()

Public Members

System *system

double vPlus

double vMin

double vTM

double kSev

double kCross

double kCat

double kRes

double kNuc

double PPBformingTime

double poolDensity

int treadmillingEnabled

int severingEnabled

int crossSeveringEnabled

int crossSeveringTop

double crossSeveringStartAngle

int PPB

int restrictedPool

int edgeCatastropheEnabled

int edgeCatastropheSmooth

double pCatSpecialEdgeMax

double pCatRegularEdgeMax

int edgNumber

int faceNumber

map<string, double> edgCatMap

map<string, double> faceCatMap

vector<double> RegionKcatMultiplier

NucleationType nucleationType

int zipperingEnabled

int catastrophesEnabled

int proportionalCatastrophes

double inducedCatastropheFraction

double zipFraction

double PPBkNucFraction

double catStartAngle

double magicAngle

InteractionType interactionType

BundleType bundleType

string geomParam

unsigned long seed

double stopTime

double measurementInterval

double wallClockLimit

double memoryLimit

string inputDir

string outputDir

string movieDir

int createSubdir

double newParameterReadInterval

string newParameterFile

int movieEnabled

int showOutput

int showMesh

string geometry

double movieFrameInterval

double geometryScaleFactor

double c0calc

double x0calc

double z0calc

class PointATedge

Public Functions

inline PointATedge(double x1, double y1, double z1, int n1)

Public Members

double x

double y

double z

int nextElement

struct PoolTag

struct PoolTag

class Region

Subclassed by Cartesian

Public Functions

RegionMTTipTag registerOnRegion(MTTip*, TipType, MTType)

void unregisterFromRegion(RegionMTTipTag, TipType, MTType)

inline void updateRegionLength(bool forceUpdate = false)

inline Region(Geometry *g, double a)

inline virtual ~Region()

double opticalLength()

virtual void translateVector(SurfaceVector&, const double) = 0

virtual void getTrajectoryCoordinates(SurfaceVector&, double&, vector<PointATedge>&, TrajectoryVector&) = 0

virtual double intersectionAngle(Trajectory*, Trajectory*) = 0

virtual void outputSnapshot(ostream&) = 0

virtual void outputOrderHeatMap(ostream&, vector<double>&, vector<Vector3d>&) = 0

Public Members

Geometry *const geometry

double area

double totalLength

int previousUpdateTag

int regionId

double zOffset

double rotAngle

double periMeter

Vector2d midPoint

vector<Edge> side

map<int, int> sideMap

map<int, int> sideRevMap

Quaternion<double> Q

vector<Vector2d> Vertics

vector<Vector3d> orientation

int faceTag

int polyIntersectMark

vector<int> intersectEdg

DLList<Trajectory, TRAJECTORY_GRANULARITY> trajectories

list<MTTip*> growingPlusTipList

list<MTTip*> shrinkingPlusTipList

list<MTTip*> minusTipList

Protected Functions

TrajectoryVector insertTrajectory(const SurfaceVector&)

void removeTrajectory(Trajectory*)

virtual void makeIntersectionList(Trajectory*) = 0

virtual SurfaceVector randomSurfaceVector() = 0

Private Functions

Region(const Region&)

Region &operator=(const Region&)

Friends

friend class Geometry

friend class Trajectory

class Segment : public DLBaseItem<Segment>

Public Functions

Segment(Microtubule*, TrajectoryVector&)

~Segment()

inline double length()

bool isLastInMT()

bool isFirstInMT()

bool crossesIntersection(IntersectionItr &is)

Public Members

Microtubule *mt

Trajectory *const trajectory

TrjSegmentTag trajectoryTag

double nucleationTime

Direction dir

double start

double end

IntersectionItr startItr

IntersectionItr endItr

struct SurfaceVector

Public Functions

inline SurfaceVector()

Public Members

double x

double y

double z

double angle

double tvPos

Region *region

class System

Public Functions

int estimateMemoryFootprint()

inline double identity(double i)

double vPlusToTime(double)

double timeToVPlus(double)

EventDescriptorIndex registerEventDescriptor(EventDescriptor*)

void unregisterEventDescriptor(EventDescriptorIndex)

EventDescriptor *getEventDescriptor(EventDescriptorIndex)

inline EventTrackingTag getEventTag()

System(char*)

~System()

bool integrityCheck()

void flushAndReload(bool = true)

void advanceTime(double nextTime)

void updateAll(bool forceUpdate = false)

void emergencyBreak()

void run(double, string&, string&)

void nextEvent(void)

void handleGlobalEvent(DeterministicEvent&)

void determineStochasticEvent()

inline void handleNucleationEvent()

inline void handleSeveringEvent()

void handleSeveringAtCrossEvent()

inline void handleRescueEvent()

inline void handleCatastropheEvent()

void randomPositionOnMicrotubule(double &cutLength, Segment *&cutSeg)

inline CollisionType collisionResult(double, int, int)

inline void collisionProbabilities(double, double&, double&)

void makeBinomialTable(void)

inline double multiPcross(int Npar, int Ncoll, double xSingle, double zSingle)

inline double multiPzip(int Npar, int Ncoll, double xSingle, double zSingle)

void initializeOutput()

void performMeasurement()

void writeMeasurementsToFile(int = 0)

void closeFiles()

void removeOccupiedIntersection(Intersection &is)

void addOccupiedIntersection(IntersectionItr is)

Public Members

Geometry *geometry

DLList<Microtubule, MICROTUBULE_GRANULARITY> growing_mts

DLList<Microtubule, MICROTUBULE_GRANULARITY> shrinking_mts

CompactList<OccupiedIntersection, OCCUPIED_INTERSECTION_GRANULARITY> OccupiedIntersectionList

vector<int> growingTipsReg

Parameters p

MTRand randomGen

double systemTime

double systemTimeOffset

int currentTimeTag

double totalLength

int memUsage

bool stopSignal

time_t wallClockStartTime

int totalSEventCount

int totalValidDEventCount

int totalInvalidDEventCount

int totalLengthSeveringCount

int totalIntersectionSeveringCount

int boundaryCrossingCount

int totalZipperCount

int totalCrossoverCount

int totalInducedCatastropheCount

int countSegments

int countTrajectories

int countIntersections

double nextStochasticEventTime

StochasticEventType nextStochasticEventType

DeterministicQueue timeQueue

DeterministicQueue vPlusQueue

double nextStatusEventTime

double nextSnapshotEventTime

double nextParameterEventTime

double nextPPBEventTime

EventDescriptorIndex EventDescriptorID

map<EventDescriptorIndex, EventDescriptor*> EventDescriptorMap

EventTrackingTag eventID

double binomialTable[MAXBINOM][MAXBINOM]

ofstream parameterFile

ofstream movieFile

ofstream heatMapFile

ofstream measurementFile

ofstream orderDirectorFile

deque<Measurement> measurementHistory

bool dataSaved

Private Functions

System(const System&)

System &operator=(const System&)

class Trajectory : public DLBaseItem<Trajectory>

Public Functions

inline IntersectionItr wallEnd()

inline IntersectionItr wallBegin()

explicit Trajectory(SurfaceVector, vector<PointATedge>, double)

~Trajectory()

bool integrityCheck()

TrajectoryVector nextTrajectory(Direction)

inline void conditionalRemove()

TrjSegmentTag insertSegment(Segment*)

void removeSegment(TrjSegmentTag)

TrjMTTipTag registerForNotifications(MTTip*)

void unregisterForNotifications(TrjMTTipTag)

inline void invalidateIntersection(IntersectionItr&)

void newIntersection(IntersectionItr&)

int differenceSign(IntersectionItr itr1, double pos1, IntersectionItr itr2, double pos2)

double coveredLength()

double segmentLength()

Public Members

const SurfaceVector base

const double length

vector<PointATedge> endPoint

TrajectoryVector thisTr

TrajectoryVector prevTr

TrajectoryVector nextTr

double prevTrCosAngle

double nextTrCosAngle

double prevTrpCat

double nextTrpCat

multimap<double, Intersection, std::less<double>, boost::fast_pool_allocator<std::pair<double, Intersection>>> intersections

list<Segment*> segments

list<MTTip*> notificationList

Private Functions

Trajectory(const Trajectory&)

Trajectory &operator=(const Trajectory&)

Friends

friend class Region

class TrajectoryVector

Public Functions

inline TrajectoryVector(double p, Direction d, Trajectory *t)

inline TrajectoryVector()

inline TrajectoryVector flipped()

Public Members

double pos

Direction dir

Direction Cdir

Trajectory *trajectory

class Triangle : public Cartesian 

Public Functions

Triangle(double, Geometry*)

virtual SurfaceVector randomSurfaceVector()

virtual void getTrajectoryCoordinates(SurfaceVector&, double&, vector<PointATedge>&, TrajectoryVector&)

class Triangle3D

Public Functions

inline Triangle3D()

Public Members

int elementId

int edgeTag

int faceTag

int polyIntersectMark

int periodicTag

double area

double periMeter

double edgAngNorm

double pcatEdgeWeight

Vector3d midPoint

Vector3d givenNormal

vector<Edge> side

vector<int> vertexIds

vector<int> intersectEdg

vector<Vector3d> Vertex

map<int, int> sideMap

map<int, int> sideRevMap

map<int, int> vertexIdsMap

map<int, int> sideToEdge

class TriMeshGeometry : public Geometry 

Public Functions

TriMeshGeometry(System*)

virtual TrajectoryVector extendTrajectory(Trajectory*, Direction)

virtual void getOrderParameters(OrderParameters&)

virtual void outputSnapshot(ostream&)

virtual void outputOrderHeatMap(ostream&, vector<double>&, vector<Vector3d>&)

class Vertics

Public Functions

inline Vertics(double x1, double y1, double z1)

Public Members

double x

double y

double z

namespace Eigen

namespace std

file CompactList.h: #include <boost/pool/singleton_pool.hpp>

#include <new>

#include <iostream>

file corticalSimReal.h

#include <vector>

#include <list>

#include <map>

#include <queue>

#include <boost/pool/pool_alloc.hpp>

#include <boost/lexical_cast.hpp>

#include <boost/filesystem.hpp>

#include <string>

#include <cstring>

#include <cmath>

#include <iomanip>

#include <fstream>

#include <Eigen/Dense>

#include “MersenneTwister.h”

#include “eig3.h”

#include “DLList.h”

#include <float.h>

#include “CompactList.h”

#include <sys/stat.h>

#include “../src/inline.cpp”

Defines

PROGRAM_VERSION

CROSS_SEV

Typedefs

typedef multimap<double, Intersection, std::less<double>, boost::fast_pool_allocator<std::pair<double, Intersection>>>::iterator IntersectionItr

typedef int EventDescriptorIndex

typedef int EventTrackingTag

typedef list<Segment*>::iterator TrjSegmentTag

typedef list<MTTip*>::iterator TrjMTTipTag

typedef list<MTTip*>::iterator RegionMTTipTag

Enums

enum Direction

Values:

enumerator forward

enumerator backward

enum DeterministicEventType

Values:

enumerator ev_none

enumerator ev_wall

enumerator ev_collision

enumerator ev_backtrack

enumerator ev_end_of_segment

enumerator ev_disappear

enum GlobalEventType

Values:

enumerator measure

enumerator snapshot

enumerator stop

enumerator status

enumerator parameter_change

enumerator signalPPB

enum StochasticEventType

Values:

enumerator catastrophe

enumerator rescue

enumerator katanin

enumerator severingAtCross

enumerator nucleation

enum CollisionType

Values:

enumerator ct_zipper

enumerator ct_crossover

enumerator ct_inducedCatastrophe

enum NucleationType

Values:

enumerator nuc_isotropic

enumerator nuc_COUNT_LAST

enum InteractionType

Values:

enumerator int_zipFirst

enumerator int_catFirst

enumerator int_COUNT_LAST

enum BundleType

Values:

enumerator bdl_simple

enumerator bdl_sticky

enumerator bdl_noZip

enumerator bdl_multiCollision

enumerator bdl_Ncollision

enumerator bdl_COUNT_LAST

enum TipType

Values:

enumerator t_minus

enumerator t_plus

enum MTType

Values:

enumerator mt_growing

enumerator mt_shrinking

Functions

ostream &operator<<(ostream&, const Measurement)

void writeMeasurementDescriptors(ostream&)

Variables

const double PI = 3.141592653589793

const double ZERO_CUTOFF = 1000000 * numeric_limits<double>::epsilon()

const double VERY_LARGE = 10E100

const int MAXBINOM = 100

const int MICROTUBULE_GRANULARITY = 256

const int SEGMENT_GRANULARITY = 1024

const int TRAJECTORY_GRANULARITY = 512

const int INTERSECTION_GRANULARITY = 4096

const int EVENT_GRANULARITY = 1024

const int OCCUPIED_INTERSECTION_GRANULARITY = 256

const int MAX_HISTORY_SIZE = 256

const int MIN_HISTORY_SIZE = 64

const int POSITION_CACHE_SIZE = 32768

const int CLOCK_POLLING_INTERVAL = 10000

const int MEMORY_POLLING_INTERVAL = 200

const int QUEUE_FLUSH_INTERVAL = 1000000

const int NUCLEATION_DISCRETIZATION_STEPS = 512

string DirectionTypeText[]

string NucleationTypeText[]

string InteractionTypeText[]

string BundleTypeText[]

file DLList.h: #include <boost/pool/singleton_pool.hpp>

#include <new>

file eig3.h

Functions

void eigen_decomposition(double A[3][3], double V[3][3], double d[3])

file MersenneTwister.h

#include <iostream>

#include <limits.h>

#include <stdio.h>

#include <time.h>

#include <math.h>

Functions

inline std::ostream &operator<<(std::ostream &os, const MTRand &mtrand)

inline std::istream &operator>>(std::istream &is, MTRand &mtrand)

file meshImport.h

#include “corticalSimReal.h”

Functions

vector<string> split(string, char)

double findNorm(VectorXd&)

bool checkEular(int, int, int)

void pickup_shape(Geometry*)

bool checkSurfaceOrientation(vector<Triangle3D*>&)

void Image3dTo2D(vector<Region*>&, vector<Triangle3D*>&, double[])

void orientSurface(vector<Vertics*>&, vector<Triangle3D*>&, vector<Triangle3D*>&)

void connectWithGlobe(vector<Vertics*>&, vector<Triangle3D*>&)

void makeGraph(int, vector<elementList*>&, vector<Triangle3D*>&)

void edgeDescriptors(vector<Vertics*>&, vector<elementList*>&, vector<Triangle3D*>&)

void establishPBC(vector<Vertics*>&, vector<Triangle3D*>&, vector<Triangle3D*>&, vector<elementList*>&, double): PBC for 2D-plane and disc.

void rigidBodyProperties(vector<Vertics*>&, vector<Triangle3D*>&, Vector3d&, Vector3d&, Vector3d&, Vector3d&)

void viewGraph(vector<Vertics*>&, vector<Triangle3D*>&, Vector3d&, string)

bool linePlaneIntersect(Vector3d, Vector3d, Vector3d, Vector3d, Vector3d&)

double areaPolygon3D(vector<Vertics>&, Vector3d)

double intersectingPolygon(vector<Vertics>&, vector<Vertics>&, vector<Region*>&, vector<elementList>&, Vector3d, Vector3d, string)

file eig3.cpp

#include <cmath>

Defines

MAX(a, b)

n

Functions

static double hypot2(double x, double y)

static void tred2(double V[n][n], double d[n], double e[n])

static void tql2(double V[n][n], double d[n], double e[n])

void eigen_decomposition(double A[n][n], double V[n][n], double d[n])

file geometry-generic.cpp: #include “corticalSimReal.h”

file geometry-special.cpp: #include “corticalSimReal.h”

#include “meshImport.h”

file inline.cpp: #include <cstddef>

file IO-analysis.cpp

#include “corticalSimReal.h”

Functions

ostream &operator<<(ostream &o, const Measurement m)

void writeMeasurementDescriptors(ostream &o)

file main.cpp

#include <csignal>

#include “corticalSimReal.h”

Functions

int main(int argc, char *argv[])

Variables

System *s1

System *s2

file meshImport.cpp

#include “meshImport.h”

Functions

void iniEdgeRecord(struct edgeRecord *head, vector<int> &v, int cid, int fid)

void addEdgeRecord(struct edgeRecord *head, vector<int> &v, int cid, int fid)

void deleteFirst(struct edgeRecord **head)

void display(struct edgeRecord *head)

void edge_sort(edgeRecord **EList, int nodeMax)

void find_connectivity(edgeRecord **FList, vector<elementList*> &eList)

void pickup_shape(Geometry *g)

void makeGraph(int Gvertex, vector<elementList*> &eList, vector<Triangle3D*> &element3D)

void orientSurface(vector<Vertics*> &Gvertex, vector<Triangle3D*> &element3D, vector<Triangle3D*> &viewTriangle)

void correctOrientation(vector<Vertics*> &Gvertex, Triangle3D *&nextTriangle, Triangle3D *&neighTriangle, int n1, int n2, int &flip)

bool checkSurfaceOrientation(vector<Triangle3D*> &element3D)

bool checkEular(int F, int V, int E)

void rigidBodyProperties(vector<Vertics*> &Gvertex, vector<Triangle3D*> &element3D, Vector3d &cm, Vector3d &pax, Vector3d &pbx, Vector3d &pcx)

void edgeDescriptors(vector<Vertics*> &Gvertex, vector<elementList*> &eList, vector<Triangle3D*> &element3D)

void connectWithGlobe(vector<Vertics*> &Gvertex, vector<Triangle3D*> &element3D)

void Image3dTo2D(vector<Region*> &regions, vector<Triangle3D*> &element3D, double pCatCurvList[])

void viewGraph(vector<Vertics*> &Gvertex, vector<Triangle3D*> &element3D, Vector3d &centroid, string outputDir)

bool linePlaneIntersect(Vector3d n, Vector3d p, Vector3d a, Vector3d b, Vector3d &I)

double areaPolygon3D(vector<Vertics> &V, Vector3d N)

double intersectingPolygon(vector<Vertics> &polygon, vector<Vertics> &Gvertex, vector<Region*> &regions, vector<elementList> &eList, Vector3d np, Vector3d cp, string shapeType)

vector<string> split(string str, char delimiter)

void establishPBC(vector<Vertics*> &vertices, vector<Triangle3D*> &triangles, vector<Triangle3D*> &viewTriangles, vector<elementList*> &eList, double sizeFactor): PBC for 2D-plane and disc.

file microtubule.cpp: #include “corticalSimReal.h”

file parameters.cpp

#include “corticalSimReal.h”

Functions

template<class T> inline void loadParam(bool &recognized, ifstream &file, string &id, const char *tag, T &target)

template<class T> inline void loadParamMaps(bool &recognized, ifstream &file, string &id, const char *tag, T &target, map<string, T> &edgCatMap)

template<class T> inline void loadParamRandom(bool &recognized, ifstream &file, string &id, const char *tag, T &target)

template<class T> inline void loadParamEnumText(bool &recognized, ifstream &file, string &id, const char *tag, T &target, string *compareList, T compareCount)

Variables

string DirectionTypeText[] = {"forward", "backward"}

string GeometryTypeText[] = {"cell"}

string InteractionTypeText[] = {"zipFirst", "catFirst", "minimalFourier"}

string NucleationTypeText[] = {"isotropic", "biased", "ellipse"}

string BundleTypeText[] = {"simple", "sticky", "noZip", "multiCollision", "Ncollision"}

file queue.cpp: #include “corticalSimReal.h”

file system.cpp

#include “corticalSimReal.h”

#include “meshImport.h”

Functions

inline double LambertW(double x)

dir include

dir src