File size: 7,405 Bytes
5a600cf | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 | /*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2016-2026 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM 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 General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::binaryTree
Description
Data storage of the chemistryOnLineLibrary according to a binary
tree structure.
0 (root node)
/ \
0 0
/ \ / \
L R L 0
/ \
L R
L: leafLeft_
R: leafRight_
\*---------------------------------------------------------------------------*/
#ifndef binaryTree_H
#define binaryTree_H
#include "binaryNode.H"
#include "chemPointISAT.H"
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class binaryTree Declaration
\*---------------------------------------------------------------------------*/
class binaryTree
{
// Private Data
//- Reference to the ISAT table
chemistryTabulationMethods::ISAT& table_;
//- Root node of the binary tree
binaryNode *root_;
//- Maximum number of elements in the binary tree
label maxNLeafs_;
//- Size of the BST (= number of chemPoint stored)
label size_;
//- Secondary retrieve search variables
label n2ndSearch_;
//- Secondary retrieve search variables
label max2ndSearch_;
label maxNumNewDim_;
Switch printProportion_;
// Private Member Functions
//- Insert new node at the position of phi0. phi0 should be already
// attached to another node or the pointer to it will be lost.
inline void insertNode(chemPointISAT*& phi0, binaryNode*& newNode);
//- Perform a search in the subtree starting from the subtree node y.
// This search continues to use the hyperplane to walk the tree.
// If covering EOA is found return true and x points to the chemPoint.
bool inSubTree
(
const scalarField& phiq,
binaryNode* y,
chemPointISAT* x
);
inline void deleteSubTree(binaryNode* subTreeRoot);
inline void deleteSubTree();
//- Replace the binaryNode u with v
inline void transplant(binaryNode* u, binaryNode* v);
inline chemPointISAT* chemPSibling(binaryNode* y);
inline chemPointISAT* chemPSibling(chemPointISAT* x);
inline binaryNode* nodeSibling(binaryNode* y);
inline binaryNode* nodeSibling(chemPointISAT* x);
inline void deleteAllNode(binaryNode* subTreeRoot);
public:
//- Constructors
//- Construct from dictionary and chemistryOnLineLibrary
binaryTree
(
chemistryTabulationMethods::ISAT& table,
const dictionary& coeffDict
);
//- Member functions
inline label size() const;
//- Computes iteratively the depth of the subTree
inline label depth(binaryNode* subTreeRoot) const;
inline label depth() const;
inline binaryNode* root();
inline label maxNLeafs() const;
// Insert a new leaf starting from the parent node of phi0
// Parameters: phi0 the leaf to replace by a node
// phiq the new composition to store
// Rphiq the mapping of the new composition point
// A the mapping gradient matrix
// B the matrix used to initialise the EOA
// nCols the size of the matrix
// Returns: void
// Description :
//1) Create a new leaf with the data to initialise the EOA and to
// retrieve the mapping by linear interpolation (the EOA is
// initialise in the chemPoint constructor)
//2) Get the parent node of phi0 and connect a new node in place of the
// leaf of phi0. This new node is constructed with phi0 on the left
// and phiq on the right (the hyperplane is computed inside the
// binaryNode constructor)
void insertNewLeaf
(
const scalarField& phiq,
const scalarField& Rphiq,
const scalarSquareMatrix& A,
const scalarField& scaleFactor,
const scalar& epsTol,
const label nCols,
const label nActive,
chemPointISAT*& phi0
);
// Search the binaryTree until the nearest leaf of a specified
// leaf is found.
void binaryTreeSearch
(
const scalarField& phiq,
binaryNode* node,
chemPointISAT*& nearest
);
// Perform a secondary binary tree search starting from a failed
// chemPoint x, with a depth-first search algorithm
// If another candidate is found return true and x points to the chemP
bool secondaryBTSearch(const scalarField& phiq, chemPointISAT*& x);
//- Delete a leaf from the binary tree and reshape the binary tree for
// the following binary tree search
// Return the index in the nodeList of the removed node
// (-1 when no node)
void deleteLeaf(chemPointISAT*& phi0);
//- Cheap balance function
// This function just roughly separate the space in two parts
// with a hyperplane which separate the two extreme chemPoint in the
// direction of the maximum the variance
// Then, it repopulate the tree with this hyperplane stored at the root
// and by inserting the chemPoint in increasing order of value in that
// direction
void balance();
inline void deleteAllNode()
{
deleteAllNode(root_);
}
inline chemPointISAT* treeMin(binaryNode* subTreeRoot);
inline chemPointISAT* treeMin()
{
return treeMin(root_);
}
chemPointISAT* treeSuccessor(chemPointISAT* x);
//- Removes every entries of the tree and delete the associated objects
inline void clear();
//- ListFull
inline bool isFull();
inline void resetNumRetrieve();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "binaryTreeI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
|