681 lines
24 KiB
JavaScript
681 lines
24 KiB
JavaScript
/**
|
|
* LiXX Cell Pack Matcher - Matching Algorithms
|
|
*
|
|
* Implements optimized algorithms for lithium cell matching:
|
|
* - Genetic Algorithm (default, fast)
|
|
* - Simulated Annealing
|
|
* - Exhaustive search (for small configurations)
|
|
*
|
|
* Based on research:
|
|
* - Shi et al., 2013: "Internal resistance matching for parallel-connected
|
|
* lithium-ion cells and impacts on battery pack cycle life"
|
|
* DOI: 10.1016/j.jpowsour.2013.11.064
|
|
*/
|
|
|
|
// =============================================================================
|
|
// Utility Functions
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Calculate the coefficient of variation (CV) as a percentage.
|
|
* CV = (standard deviation / mean) * 100
|
|
* @param {number[]} values - Array of numeric values
|
|
* @returns {number} CV as percentage, or 0 if invalid
|
|
*/
|
|
function coefficientOfVariation(values) {
|
|
if (!values || values.length === 0) return 0;
|
|
const mean = values.reduce((a, b) => a + b, 0) / values.length;
|
|
if (mean === 0) return 0;
|
|
const variance = values.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / values.length;
|
|
return (Math.sqrt(variance) / mean) * 100;
|
|
}
|
|
|
|
/**
|
|
* Shuffle array in place using Fisher-Yates algorithm.
|
|
* @param {Array} array - Array to shuffle
|
|
* @returns {Array} The same array, shuffled
|
|
*/
|
|
function shuffleArray(array) {
|
|
for (let i = array.length - 1; i > 0; i--) {
|
|
const j = Math.floor(Math.random() * (i + 1));
|
|
[array[i], array[j]] = [array[j], array[i]];
|
|
}
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* Deep clone an array of arrays.
|
|
* @param {Array[]} arr - Array to clone
|
|
* @returns {Array[]} Cloned array
|
|
*/
|
|
function cloneConfiguration(arr) {
|
|
return arr.map(group => [...group]);
|
|
}
|
|
|
|
// =============================================================================
|
|
// Scoring Functions
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Calculate the match score for a pack configuration.
|
|
* Lower score = better match.
|
|
*
|
|
* The score combines:
|
|
* - Capacity variance between parallel groups (weighted by capacityWeight)
|
|
* - Internal resistance variance within parallel groups (weighted by irWeight)
|
|
*
|
|
* @param {Object[][]} configuration - Array of parallel groups, each containing cell objects
|
|
* @param {number} capacityWeight - Weight for capacity matching (0-1)
|
|
* @param {number} irWeight - Weight for IR matching (0-1)
|
|
* @returns {Object} Score breakdown
|
|
*/
|
|
function calculateScore(configuration, capacityWeight = 0.7, irWeight = 0.3) {
|
|
// Calculate total capacity for each parallel group
|
|
const groupCapacities = configuration.map(group =>
|
|
group.reduce((sum, cell) => sum + cell.capacity, 0)
|
|
);
|
|
|
|
// Calculate average IR for each parallel group
|
|
const groupIRs = configuration.map(group => {
|
|
const irsWithValues = group.filter(cell => cell.ir !== null && cell.ir !== undefined);
|
|
if (irsWithValues.length === 0) return null;
|
|
return irsWithValues.reduce((sum, cell) => sum + cell.ir, 0) / irsWithValues.length;
|
|
}).filter(ir => ir !== null);
|
|
|
|
// Calculate IR variance within each parallel group (important for parallel cells)
|
|
const withinGroupIRVariances = configuration.map(group => {
|
|
const irsWithValues = group.filter(cell => cell.ir !== null && cell.ir !== undefined);
|
|
if (irsWithValues.length < 2) return 0;
|
|
const irs = irsWithValues.map(cell => cell.ir);
|
|
return coefficientOfVariation(irs);
|
|
});
|
|
|
|
// Capacity CV between groups (should be low for balanced pack)
|
|
const capacityCV = coefficientOfVariation(groupCapacities);
|
|
|
|
// Average IR CV within groups (should be low for parallel cells)
|
|
const avgWithinGroupIRCV = withinGroupIRVariances.length > 0
|
|
? withinGroupIRVariances.reduce((a, b) => a + b, 0) / withinGroupIRVariances.length
|
|
: 0;
|
|
|
|
// Combined score (lower is better)
|
|
const score = (capacityWeight * capacityCV) + (irWeight * avgWithinGroupIRCV);
|
|
|
|
return {
|
|
score,
|
|
capacityCV,
|
|
irCV: avgWithinGroupIRCV,
|
|
groupCapacities,
|
|
groupIRs,
|
|
withinGroupIRVariances
|
|
};
|
|
}
|
|
|
|
// =============================================================================
|
|
// Genetic Algorithm
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Genetic Algorithm for cell matching.
|
|
* Fast and effective for most configurations.
|
|
*/
|
|
class GeneticAlgorithm {
|
|
/**
|
|
* @param {Object[]} cells - Array of cell objects {label, capacity, ir}
|
|
* @param {number} serial - Number of series groups
|
|
* @param {number} parallel - Number of cells in parallel per group
|
|
* @param {Object} options - Algorithm options
|
|
*/
|
|
constructor(cells, serial, parallel, options = {}) {
|
|
this.cells = cells;
|
|
this.serial = serial;
|
|
this.parallel = parallel;
|
|
this.totalCellsNeeded = serial * parallel;
|
|
|
|
// Options with defaults
|
|
this.populationSize = options.populationSize || 50;
|
|
this.maxIterations = options.maxIterations || 5000;
|
|
this.mutationRate = options.mutationRate || 0.15;
|
|
this.eliteCount = options.eliteCount || 5;
|
|
this.capacityWeight = options.capacityWeight ?? 0.7;
|
|
this.irWeight = options.irWeight ?? 0.3;
|
|
this.onProgress = options.onProgress || (() => { });
|
|
|
|
this.stopped = false;
|
|
this.bestSolution = null;
|
|
this.bestScore = Infinity;
|
|
}
|
|
|
|
/**
|
|
* Stop the algorithm.
|
|
*/
|
|
stop() {
|
|
this.stopped = true;
|
|
}
|
|
|
|
/**
|
|
* Create a random individual (configuration).
|
|
* @param {Object[]} cellPool - Cells to choose from
|
|
* @returns {Object[][]} Configuration
|
|
*/
|
|
createIndividual(cellPool) {
|
|
const shuffled = shuffleArray([...cellPool]).slice(0, this.totalCellsNeeded);
|
|
const configuration = [];
|
|
|
|
for (let i = 0; i < this.serial; i++) {
|
|
const group = [];
|
|
for (let j = 0; j < this.parallel; j++) {
|
|
group.push(shuffled[i * this.parallel + j]);
|
|
}
|
|
configuration.push(group);
|
|
}
|
|
|
|
return configuration;
|
|
}
|
|
|
|
/**
|
|
* Convert configuration to flat array of cell indices for crossover.
|
|
* @param {Object[][]} config - Configuration
|
|
* @returns {number[]} Flat array of cell indices
|
|
*/
|
|
configToIndices(config) {
|
|
const flat = config.flat();
|
|
return flat.map(cell => this.cells.findIndex(c => c.label === cell.label));
|
|
}
|
|
|
|
/**
|
|
* Convert indices back to configuration.
|
|
* @param {number[]} indices - Array of cell indices
|
|
* @returns {Object[][]} Configuration
|
|
*/
|
|
indicesToConfig(indices) {
|
|
const configuration = [];
|
|
for (let i = 0; i < this.serial; i++) {
|
|
const group = [];
|
|
for (let j = 0; j < this.parallel; j++) {
|
|
const idx = indices[i * this.parallel + j];
|
|
group.push(this.cells[idx]);
|
|
}
|
|
configuration.push(group);
|
|
}
|
|
return configuration;
|
|
}
|
|
|
|
/**
|
|
* Perform crossover between two parents using Order Crossover (OX).
|
|
* @param {number[]} parent1 - First parent indices
|
|
* @param {number[]} parent2 - Second parent indices
|
|
* @returns {number[]} Child indices
|
|
*/
|
|
crossover(parent1, parent2) {
|
|
const length = parent1.length;
|
|
const start = Math.floor(Math.random() * length);
|
|
const end = start + Math.floor(Math.random() * (length - start));
|
|
|
|
const child = new Array(length).fill(-1);
|
|
const usedIndices = new Set();
|
|
|
|
// Copy segment from parent1
|
|
for (let i = start; i <= end; i++) {
|
|
child[i] = parent1[i];
|
|
usedIndices.add(parent1[i]);
|
|
}
|
|
|
|
// Fill remaining from parent2
|
|
let childIdx = (end + 1) % length;
|
|
for (let i = 0; i < length; i++) {
|
|
const parent2Idx = (end + 1 + i) % length;
|
|
if (!usedIndices.has(parent2[parent2Idx])) {
|
|
while (child[childIdx] !== -1) {
|
|
childIdx = (childIdx + 1) % length;
|
|
}
|
|
child[childIdx] = parent2[parent2Idx];
|
|
usedIndices.add(parent2[parent2Idx]);
|
|
childIdx = (childIdx + 1) % length;
|
|
}
|
|
}
|
|
|
|
return child;
|
|
}
|
|
|
|
/**
|
|
* Mutate an individual by swapping cells.
|
|
* @param {number[]} indices - Individual indices
|
|
* @param {Object[]} unusedCells - Cells not in this configuration
|
|
* @returns {number[]} Mutated indices
|
|
*/
|
|
mutate(indices, unusedCells) {
|
|
const mutated = [...indices];
|
|
|
|
if (Math.random() < this.mutationRate) {
|
|
if (unusedCells.length > 0 && Math.random() < 0.3) {
|
|
// Replace a cell with an unused one
|
|
const replaceIdx = Math.floor(Math.random() * mutated.length);
|
|
const unusedCell = unusedCells[Math.floor(Math.random() * unusedCells.length)];
|
|
const unusedIdx = this.cells.findIndex(c => c.label === unusedCell.label);
|
|
mutated[replaceIdx] = unusedIdx;
|
|
} else {
|
|
// Swap two cells within the configuration
|
|
const i = Math.floor(Math.random() * mutated.length);
|
|
const j = Math.floor(Math.random() * mutated.length);
|
|
[mutated[i], mutated[j]] = [mutated[j], mutated[i]];
|
|
}
|
|
}
|
|
|
|
return mutated;
|
|
}
|
|
|
|
/**
|
|
* Run the genetic algorithm.
|
|
* @returns {Promise<Object>} Best solution found
|
|
*/
|
|
async run() {
|
|
const startTime = Date.now();
|
|
|
|
// Initialize population
|
|
let population = [];
|
|
for (let i = 0; i < this.populationSize; i++) {
|
|
population.push(this.createIndividual(this.cells));
|
|
}
|
|
|
|
// Evaluate initial population
|
|
let evaluated = population.map(config => ({
|
|
config,
|
|
indices: this.configToIndices(config),
|
|
...calculateScore(config, this.capacityWeight, this.irWeight)
|
|
}));
|
|
|
|
// Sort by score
|
|
evaluated.sort((a, b) => a.score - b.score);
|
|
|
|
if (evaluated[0].score < this.bestScore) {
|
|
this.bestScore = evaluated[0].score;
|
|
this.bestSolution = evaluated[0];
|
|
}
|
|
|
|
// Main evolution loop
|
|
for (let iteration = 0; iteration < this.maxIterations && !this.stopped; iteration++) {
|
|
// Selection (tournament selection)
|
|
const newPopulation = [];
|
|
|
|
// Keep elite individuals
|
|
for (let i = 0; i < this.eliteCount && i < evaluated.length; i++) {
|
|
newPopulation.push(evaluated[i].indices);
|
|
}
|
|
|
|
// Generate rest through crossover and mutation
|
|
while (newPopulation.length < this.populationSize) {
|
|
// Tournament selection
|
|
const tournament1 = evaluated.slice(0, Math.ceil(evaluated.length / 2));
|
|
const tournament2 = evaluated.slice(0, Math.ceil(evaluated.length / 2));
|
|
const parent1 = tournament1[Math.floor(Math.random() * tournament1.length)];
|
|
const parent2 = tournament2[Math.floor(Math.random() * tournament2.length)];
|
|
|
|
// Crossover
|
|
let child = this.crossover(parent1.indices, parent2.indices);
|
|
|
|
// Determine unused cells
|
|
const usedLabels = new Set(child.map(idx => this.cells[idx].label));
|
|
const unusedCells = this.cells.filter(c => !usedLabels.has(c.label));
|
|
|
|
// Mutation
|
|
child = this.mutate(child, unusedCells);
|
|
|
|
newPopulation.push(child);
|
|
}
|
|
|
|
// Evaluate new population
|
|
evaluated = newPopulation.map(indices => {
|
|
const config = this.indicesToConfig(indices);
|
|
return {
|
|
config,
|
|
indices,
|
|
...calculateScore(config, this.capacityWeight, this.irWeight)
|
|
};
|
|
});
|
|
|
|
// Sort by score
|
|
evaluated.sort((a, b) => a.score - b.score);
|
|
|
|
// Update best solution
|
|
if (evaluated[0].score < this.bestScore) {
|
|
this.bestScore = evaluated[0].score;
|
|
this.bestSolution = evaluated[0];
|
|
}
|
|
|
|
// Progress callback
|
|
if (iteration % 50 === 0 || iteration === this.maxIterations - 1) {
|
|
this.onProgress({
|
|
iteration,
|
|
maxIterations: this.maxIterations,
|
|
bestScore: this.bestScore,
|
|
currentBest: this.bestSolution,
|
|
elapsedTime: Date.now() - startTime
|
|
});
|
|
|
|
// Allow UI to update
|
|
await new Promise(resolve => setTimeout(resolve, 0));
|
|
}
|
|
}
|
|
|
|
// Determine excluded cells
|
|
const usedLabels = new Set(this.bestSolution.config.flat().map(c => c.label));
|
|
const excludedCells = this.cells.filter(c => !usedLabels.has(c.label));
|
|
|
|
return {
|
|
configuration: this.bestSolution.config,
|
|
score: this.bestScore,
|
|
capacityCV: this.bestSolution.capacityCV,
|
|
irCV: this.bestSolution.irCV,
|
|
groupCapacities: this.bestSolution.groupCapacities,
|
|
excludedCells,
|
|
iterations: this.maxIterations,
|
|
elapsedTime: Date.now() - startTime
|
|
};
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Simulated Annealing
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Simulated Annealing algorithm for cell matching.
|
|
* Good for escaping local minima.
|
|
*/
|
|
class SimulatedAnnealing {
|
|
/**
|
|
* @param {Object[]} cells - Array of cell objects
|
|
* @param {number} serial - Number of series groups
|
|
* @param {number} parallel - Number of cells in parallel per group
|
|
* @param {Object} options - Algorithm options
|
|
*/
|
|
constructor(cells, serial, parallel, options = {}) {
|
|
this.cells = cells;
|
|
this.serial = serial;
|
|
this.parallel = parallel;
|
|
this.totalCellsNeeded = serial * parallel;
|
|
|
|
this.maxIterations = options.maxIterations || 5000;
|
|
this.initialTemp = options.initialTemp || 100;
|
|
this.coolingRate = options.coolingRate || 0.995;
|
|
this.capacityWeight = options.capacityWeight ?? 0.7;
|
|
this.irWeight = options.irWeight ?? 0.3;
|
|
this.onProgress = options.onProgress || (() => { });
|
|
|
|
this.stopped = false;
|
|
this.bestSolution = null;
|
|
this.bestScore = Infinity;
|
|
}
|
|
|
|
stop() {
|
|
this.stopped = true;
|
|
}
|
|
|
|
/**
|
|
* Create initial configuration.
|
|
*/
|
|
createInitialConfig() {
|
|
const shuffled = shuffleArray([...this.cells]).slice(0, this.totalCellsNeeded);
|
|
const configuration = [];
|
|
|
|
for (let i = 0; i < this.serial; i++) {
|
|
const group = [];
|
|
for (let j = 0; j < this.parallel; j++) {
|
|
group.push(shuffled[i * this.parallel + j]);
|
|
}
|
|
configuration.push(group);
|
|
}
|
|
|
|
return configuration;
|
|
}
|
|
|
|
/**
|
|
* Generate a neighbor solution by making a small change.
|
|
*/
|
|
getNeighbor(config) {
|
|
const newConfig = cloneConfiguration(config);
|
|
const usedLabels = new Set(config.flat().map(c => c.label));
|
|
const unusedCells = this.cells.filter(c => !usedLabels.has(c.label));
|
|
|
|
const moveType = Math.random();
|
|
|
|
if (unusedCells.length > 0 && moveType < 0.3) {
|
|
// Replace a cell with an unused one
|
|
const groupIdx = Math.floor(Math.random() * this.serial);
|
|
const cellIdx = Math.floor(Math.random() * this.parallel);
|
|
const unusedCell = unusedCells[Math.floor(Math.random() * unusedCells.length)];
|
|
newConfig[groupIdx][cellIdx] = unusedCell;
|
|
} else if (moveType < 0.65) {
|
|
// Swap cells between different groups
|
|
const group1 = Math.floor(Math.random() * this.serial);
|
|
let group2 = Math.floor(Math.random() * this.serial);
|
|
while (group2 === group1 && this.serial > 1) {
|
|
group2 = Math.floor(Math.random() * this.serial);
|
|
}
|
|
const cell1 = Math.floor(Math.random() * this.parallel);
|
|
const cell2 = Math.floor(Math.random() * this.parallel);
|
|
|
|
const temp = newConfig[group1][cell1];
|
|
newConfig[group1][cell1] = newConfig[group2][cell2];
|
|
newConfig[group2][cell2] = temp;
|
|
} else {
|
|
// Swap cells within the same group
|
|
const groupIdx = Math.floor(Math.random() * this.serial);
|
|
if (this.parallel >= 2) {
|
|
const cell1 = Math.floor(Math.random() * this.parallel);
|
|
let cell2 = Math.floor(Math.random() * this.parallel);
|
|
while (cell2 === cell1) {
|
|
cell2 = Math.floor(Math.random() * this.parallel);
|
|
}
|
|
const temp = newConfig[groupIdx][cell1];
|
|
newConfig[groupIdx][cell1] = newConfig[groupIdx][cell2];
|
|
newConfig[groupIdx][cell2] = temp;
|
|
}
|
|
}
|
|
|
|
return newConfig;
|
|
}
|
|
|
|
/**
|
|
* Run simulated annealing.
|
|
*/
|
|
async run() {
|
|
const startTime = Date.now();
|
|
|
|
let current = this.createInitialConfig();
|
|
let currentScore = calculateScore(current, this.capacityWeight, this.irWeight);
|
|
|
|
this.bestSolution = { config: cloneConfiguration(current), ...currentScore };
|
|
this.bestScore = currentScore.score;
|
|
|
|
let temperature = this.initialTemp;
|
|
|
|
for (let iteration = 0; iteration < this.maxIterations && !this.stopped; iteration++) {
|
|
const neighbor = this.getNeighbor(current);
|
|
const neighborScore = calculateScore(neighbor, this.capacityWeight, this.irWeight);
|
|
|
|
const delta = neighborScore.score - currentScore.score;
|
|
|
|
// Accept if better, or with probability based on temperature
|
|
if (delta < 0 || Math.random() < Math.exp(-delta / temperature)) {
|
|
current = neighbor;
|
|
currentScore = neighborScore;
|
|
|
|
if (currentScore.score < this.bestScore) {
|
|
this.bestScore = currentScore.score;
|
|
this.bestSolution = { config: cloneConfiguration(current), ...currentScore };
|
|
}
|
|
}
|
|
|
|
// Cool down
|
|
temperature *= this.coolingRate;
|
|
|
|
// Progress callback
|
|
if (iteration % 100 === 0 || iteration === this.maxIterations - 1) {
|
|
this.onProgress({
|
|
iteration,
|
|
maxIterations: this.maxIterations,
|
|
bestScore: this.bestScore,
|
|
currentBest: this.bestSolution,
|
|
temperature,
|
|
elapsedTime: Date.now() - startTime
|
|
});
|
|
|
|
await new Promise(resolve => setTimeout(resolve, 0));
|
|
}
|
|
}
|
|
|
|
const usedLabels = new Set(this.bestSolution.config.flat().map(c => c.label));
|
|
const excludedCells = this.cells.filter(c => !usedLabels.has(c.label));
|
|
|
|
return {
|
|
configuration: this.bestSolution.config,
|
|
score: this.bestScore,
|
|
capacityCV: this.bestSolution.capacityCV,
|
|
irCV: this.bestSolution.irCV,
|
|
groupCapacities: this.bestSolution.groupCapacities,
|
|
excludedCells,
|
|
iterations: this.maxIterations,
|
|
elapsedTime: Date.now() - startTime
|
|
};
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Exhaustive Search (for small configurations)
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Exhaustive search - finds the globally optimal solution.
|
|
* Only practical for small configurations due to factorial complexity.
|
|
*/
|
|
class ExhaustiveSearch {
|
|
constructor(cells, serial, parallel, options = {}) {
|
|
this.cells = cells;
|
|
this.serial = serial;
|
|
this.parallel = parallel;
|
|
this.totalCellsNeeded = serial * parallel;
|
|
|
|
this.capacityWeight = options.capacityWeight ?? 0.7;
|
|
this.irWeight = options.irWeight ?? 0.3;
|
|
this.onProgress = options.onProgress || (() => { });
|
|
this.maxIterations = options.maxIterations || 100000;
|
|
|
|
this.stopped = false;
|
|
this.bestSolution = null;
|
|
this.bestScore = Infinity;
|
|
}
|
|
|
|
stop() {
|
|
this.stopped = true;
|
|
}
|
|
|
|
/**
|
|
* Generate all combinations of k elements from array.
|
|
*/
|
|
*combinations(array, k) {
|
|
if (k === 0) {
|
|
yield [];
|
|
return;
|
|
}
|
|
if (array.length < k) return;
|
|
|
|
const [first, ...rest] = array;
|
|
for (const combo of this.combinations(rest, k - 1)) {
|
|
yield [first, ...combo];
|
|
}
|
|
yield* this.combinations(rest, k);
|
|
}
|
|
|
|
/**
|
|
* Generate all partitions of cells into groups.
|
|
*/
|
|
*generatePartitions(cells, groupSize, numGroups) {
|
|
if (numGroups === 0) {
|
|
yield [];
|
|
return;
|
|
}
|
|
|
|
if (cells.length < groupSize * numGroups) return;
|
|
|
|
for (const group of this.combinations(cells, groupSize)) {
|
|
const remaining = cells.filter(c => !group.includes(c));
|
|
for (const rest of this.generatePartitions(remaining, groupSize, numGroups - 1)) {
|
|
yield [group, ...rest];
|
|
}
|
|
}
|
|
}
|
|
|
|
async run() {
|
|
const startTime = Date.now();
|
|
let iteration = 0;
|
|
|
|
// Select best subset if we have more cells than needed
|
|
const cellCombos = this.cells.length > this.totalCellsNeeded
|
|
? this.combinations(this.cells, this.totalCellsNeeded)
|
|
: [[...this.cells]];
|
|
|
|
for (const cellSubset of cellCombos) {
|
|
if (this.stopped) break;
|
|
|
|
for (const partition of this.generatePartitions(cellSubset, this.parallel, this.serial)) {
|
|
if (this.stopped) break;
|
|
|
|
const scoreResult = calculateScore(partition, this.capacityWeight, this.irWeight);
|
|
|
|
if (scoreResult.score < this.bestScore) {
|
|
this.bestScore = scoreResult.score;
|
|
this.bestSolution = { config: partition, ...scoreResult };
|
|
}
|
|
|
|
iteration++;
|
|
|
|
if (iteration % 1000 === 0) {
|
|
this.onProgress({
|
|
iteration,
|
|
maxIterations: this.maxIterations,
|
|
bestScore: this.bestScore,
|
|
currentBest: this.bestSolution,
|
|
elapsedTime: Date.now() - startTime
|
|
});
|
|
|
|
await new Promise(resolve => setTimeout(resolve, 0));
|
|
}
|
|
|
|
if (iteration >= this.maxIterations) {
|
|
this.stopped = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const usedLabels = new Set(this.bestSolution.config.flat().map(c => c.label));
|
|
const excludedCells = this.cells.filter(c => !usedLabels.has(c.label));
|
|
|
|
return {
|
|
configuration: this.bestSolution.config,
|
|
score: this.bestScore,
|
|
capacityCV: this.bestSolution.capacityCV,
|
|
irCV: this.bestSolution.irCV,
|
|
groupCapacities: this.bestSolution.groupCapacities,
|
|
excludedCells,
|
|
iterations: iteration,
|
|
elapsedTime: Date.now() - startTime
|
|
};
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Export
|
|
// =============================================================================
|
|
|
|
// Make available globally for the main app
|
|
window.CellMatchingAlgorithms = {
|
|
GeneticAlgorithm,
|
|
SimulatedAnnealing,
|
|
ExhaustiveSearch,
|
|
calculateScore,
|
|
coefficientOfVariation
|
|
};
|