INMOST A toolkit for distributed mathematical modeling
Todo List
Class INMOST::AbstractEntry
1. Is there a need for layout on how matrices are returned?
2. Is there a need for layout on how unknowns and equations are arranged?
3. Function for update of variables.
4. Function for synchronization of variables.
Member INMOST::AbstractMatrix< Var >::MPT (INMOST_DATA_ENUM_TYPE *Perm, INMOST_DATA_REAL_TYPE *SL=NULL, INMOST_DATA_REAL_TYPE *SR=NULL) const
1. Test rescaling.
2. Test on non-square matrices.
Member INMOST::AbstractMatrixReadOnly< Var >::Invert (int *ierr=NULL) const
(test) Activate and test implementation with Solve.
Member INMOST::AbstractMatrixReadOnly< Var >::Solve (const AbstractMatrixReadOnly< typeB > &B, int *ierr=NULL) const
1. Test implementation.
2. Maximum product transversal + block pivoting instead of pivoting by maximum element.
Member INMOST::AbstractMatrixReadOnly< Var >::SVD (AbstractMatrix< Var > &U, AbstractMatrix< Var > &Sigma, AbstractMatrix< Var > &V, bool order_singular_values=true, bool nonnegative=true) const
Test implementation for auto-differentiation.
Class INMOST::AbstractOperator
1. Different types of operators: time-stepping, local point-wise (curl,grad on element), global integrators (div,curl on domain), interpolators, inter-mesh interpolators. Each has its own functions. Implementation should be flexible enough to prevent limitation.
2. Ultimately operators should stack together: for staggered incompressible navier-stokes: Time(nU) + Projection(Divergence(ConvectionDiffusion(nU,\mu,Reconstruction(nU)))) - Grad(P) = f Divergence(nU) = 0
Class INMOST::Automatizator
1. (test) UnRegisterTag.
2. (test) Copy constructor.
3. Rename
Member INMOST::Cell::CheckEdgeOrder () const
1. Use in topology check algorithms.
Member INMOST::Cell::FixEdgeOrder () const
1. Use in topology check algorithms.
Member INMOST::Cell::getEdges () const
One should thoroughly check three scenarios of function execution in shared parallel environment for different types of cells (simple tet/hex cells as well as complex polyhedral cells) and draw a conclusion on the best scenario for each condition. One of the development versions contains all the algorithms, ask for the files.
1. Use of markers (current variant).
2. Put all elements into array with duplications, then run std::sort and std::unique.
3. Put all elements into array, check for duplication by running through array.
Member INMOST::Cell::Inside (const real *point) const
1. Should be checked or extended for 2d cells. (done, testing)
Member INMOST::Cell::SplitCell (Cell cell, const ElementArray< Face > &faces, MarkerType del_protect)
1. The algorithm inside is minimizing the size of the adjacency graph for each new cell. The correct behavior is to calculate volume of the cell for each adjacency graph and choose the graph with minimal volume. This requires calculation of volume for non-convex cells. For correct calculation of volume on non-convex cells one should find one face for which normal orientation can be clearly determined and then orient all edges of the cell with respect to the orientation of edges of this face and establish normals for all faces. Once the algorithm is implemented here it should be implemented in geometrical services or vice verse.
2. Probably the algorithm should minimize the volume and adjacency graph size altogether. Between the cells with smallest volume within some tolerance select those that have smallest adjacency graph.
Member INMOST::Cell::Volume () const
1. Geometric services should correctly resolve volume for non-convex cells.
Member INMOST::Element::Connect (const HandleType *adjacent, INMOST_DATA_ENUM_TYPE num) const
1. Asserts in this function should be replaced by Topography checks.
2. This function should be used for construction of elements instead of current implementation.
3. Should correctly account for order of edges (may be implemented through CheckEdgeOrder, FixEdgeOrder).
Member INMOST::Element::Hide () const
Probably have to check normal orientation after hiding a back cell for a face.
Member INMOST::Element::Show () const
Probably have to check normal orientation after recovering a back cell for a face.
Member INMOST::ElementSet::AddElements (const HandleType *handles, enumerator num) const
Recheck usage of markers.
Member INMOST::ElementSet::SortSet (ComparatorType comp) const
!TODO 52 - check radix sort on big endian computer
Member INMOST::ElementSet::Subtract (const ElementSet &other) const
If other and current sets are sorted in same way, may perform narrowing traversal by retrieving mutual lower_bound/higher_bound O(log(n)) operations for detecting common subsets in sorted sets. May work good when deleting handles by small chunks, ApplyModification may greatly benefit.
Class INMOST::Matrix< Var, storage_type >
:
1. expression templates for operations (???) how to for multiplication? efficient multiplication would require all the matrix elements to be precomputed. consider number 5 instead.
2. (ok) template matrix type for AD variables
3. (ok,test) template container type for data storage.
4. (ok,test) option for wrapper container around provided data storage. (to perform matrix operations with existing data)
5. consider multi-threaded stack to get space for matrices for local operations and returns.
7. Uniform implementation of algorithms for Matrix and Submatrix. to achieve: make abdstract class with abstract element access operator, make matrix and submatrix ancestors of that class
Member INMOST::Matrix< Var, storage_type >::Matrix (const storage_type &pspace)
Do we need reference for pspace or just pspace?
Member INMOST::Matrix< Var, storage_type >::Matrix (const storage_type &pspace, enumerator pn, enumerator pm)
Do we need reference for pspace or just pspace?
Member INMOST::Matrix< Var, storage_type >::RemoveColumns (enumerator first, enumerator last)
check
Member INMOST::Matrix< Var, storage_type >::RemoveRows (enumerator first, enumerator last)
check
Member INMOST::Mesh::ApplyModification ()
1. maybe instead of forming set of deleted elements and subtracting set from other sets it is better to remove each modified element (done, check and compare)
2. parent/child elements in set would not be replaced or reconnected, this may lead to wrong behavior (done, check and compare)
1. invoking function before loading mesh will not renew global identificators after load but would not unset have_global_id either. There are probably too many places when global ids may become invalid but no flag will be set. It may be benefitial to set such flags along with updating geometrical data which seems to be maintained fairly well during mesh modification
Member INMOST::Mesh::BeginTopologyCheck (ElementType etype, const HandleType *adj, enumerator num)
list checks performed inside in description
Member INMOST::Mesh::EndTopologyCheck (HandleType e, TopologyCheck begin_check)
list checks performed inside in description.
Member INMOST::Mesh::ExchangeData (const Tag &tag, ElementType mask, MarkerType select=0)
see TODO in Mesh::ReduceData
Member INMOST::Mesh::ExchangeMarked (enum Action action=AGhost)
1. test halo exchange algorithm (if used then change collective point-2-point to collective)
2. see TODO 2 in Mesh::Redistribute
1. When loading mesh with the same tag name but different type or size, load will fail.
Member INMOST::Mesh::Redistribute ()
1. introduce "TEMPORARY_KEEP_GHOSTED" tag that will store processors on which copy of element should be kept, internally just merge it with "TEMPORARY_NEW_PROCESSORS" tag this will allow user to control ghosting of certain elements and not to invoke ExchangeMarked every time after Redistribute. This is probably already done using Mesh::SendtoTag, because function fills it without clearing and ExchangeMarked performs initial action based on SendtoTag, it is due to check that SendtoTag is properly merged with "TEMPORARY_NEW_PROCESSORS" before call to ExchangeMarked and received elements are not deleted by accident.
2. let user provide any integer tag as input without involving RedistributeTag
Member INMOST::Mesh::ReduceData (const Tag &tag, ElementType mask, MarkerType select, ReduceOperation op)
1. Exchanging DATA_REFERENCE,DATA_REMOTE_REFERENCE tags not implemented, this is due to the absence of any conclusion
• on how it should behave: either only search within elements owned by the other processor and establish references and set InvalidHandle() to elements that are not found (fairly easy, will involve search operations to check against owned elements for similar entry, efficient implementation will require bounding search trees (see TODO 49);
• or: send all the referenced elements through PackElementsData and establish all the links within elements reproduced by UnpackElementsData (UnpackElementsData calls UnpackTagData with set of unpacked elements using which it will be very comfortable to establish references on remote processor). Drawback is that exchanging laplacian operator in such a manner should result in the whole grid being shared among all the processors.
Member INMOST::Mesh::RemoveGhostElements (const HandleType *ghost, enumerator num)
1. Currently request for deletion of elements of lower level then cell will be simply ignored, ensure in future that algorithm will properly rise deletion data from lower to upper adjacencies to delete all the upper adjacencies that depend on deleted lower adjacencies
Member INMOST::Mesh::Save (std::string File)
1. Markers are not saved in internal format due to possible conflict during load.
Member INMOST::Mesh::SortByGlobalID (HandleType *h, enumerator num)
TODO 53 check that putting global ids to array will be faster
Class INMOST::MultiEntry
1. Check it works
2. Check if it crashes with different combinations of entries on different element types or different masks.
Class INMOST::Residual
1. Extend for hessian calculation.
Class INMOST::StatusBlockEntry
1. Check it works
Class INMOST::stencil_block_variable
coefficients could be matrices here, introduce another class?
Member INMOST::SymmetricMatrix< Var, storage_type >::SymmetricMatrix (const storage_type &pspace)
Do we need reference for pspace or just pspace?
Member INMOST::SymmetricMatrix< Var, storage_type >::SymmetricMatrix (const storage_type &pspace, enumerator pn)
Do we need reference for pspace or just pspace?