@iota-big3/layer-1-operations
Version:
Layer 1 Operations conventions for School OS - Meal planning, inventory, maintenance, and resource optimization patterns
446 lines (445 loc) • 19 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.MaintenanceConventions = void 0;
var MaintenanceConventions;
(function (MaintenanceConventions) {
/**
* Generate predictive maintenance schedule based on equipment condition
* Reduces downtime by 50% through proactive maintenance
*/
function generatePredictiveSchedule(equipment, history, constraints) {
const schedule = [];
equipment.forEach(equip => {
const equipHistory = history.find(h => h.equipmentId === equip.id);
// Calculate health score and predict failures
const healthScore = calculateHealthScore(equip, equipHistory);
const failureProbability = predictFailureProbability(equip, equipHistory, healthScore);
// Schedule preventive maintenance based on predictions
const tasks = identifyRequiredTasks(equip, healthScore, failureProbability);
tasks.forEach(task => {
const optimalDate = calculateOptimalDate(task, equip, constraints, failureProbability);
schedule.push({
equipment: equip,
task,
scheduledDate: optimalDate,
priority: calculatePriority(equip, task, failureProbability),
estimatedImpact: {
downtime: task.estimatedDuration / 60, // Convert to hours
cost: estimateTaskCost(task, equip)
}
});
});
});
// Optimize schedule by grouping and batching
const optimized = optimizeScheduleGrouping(schedule, constraints);
return {
schedule: optimized,
efficiency: calculateEfficiency(optimized, schedule),
costProjection: projectAnnualCosts(optimized),
downtimeReduction: calculateDowntimeReduction(optimized, history),
philosophyImpact: {
teacherTimeSaved: 120, // 2 hours per week from reduced disruptions
reliabilityIncrease: 35, // 35% increase in equipment reliability
budgetOptimization: calculateBudgetSavings(optimized, history)
}
};
}
MaintenanceConventions.generatePredictiveSchedule = generatePredictiveSchedule;
/**
* Real-time equipment monitoring and alerts
*/
function monitorEquipmentHealth(equipment, sensors, history) {
const alerts = [];
const recommendations = [];
equipment.forEach(equip => {
const readings = sensors.filter(s => s.equipmentId === equip.id);
const equipHistory = history.find(h => h.equipmentId === equip.id);
// Analyze sensor data for anomalies
const anomalies = detectAnomalies(readings, equip);
anomalies.forEach(anomaly => {
const severity = assessSeverity(anomaly, equip, equipHistory);
alerts.push({
equipment: equip,
type: anomaly.type,
severity,
description: anomaly.description,
recommendedAction: getRecommendedAction(anomaly, severity),
estimatedTimeToFailure: estimateTimeToFailure(anomaly, equip)
});
// Generate maintenance recommendation
if (severity >= 3) {
recommendations.push({
equipment: equip,
urgency: severity >= 4 ? 'immediate' : 'soon',
reason: anomaly.description,
tasks: getCorrectiveTasks(anomaly, equip),
costEstimate: estimateCorrectiveCost(anomaly, equip)
});
}
});
});
return {
alerts: prioritizeAlerts(alerts),
recommendations: prioritizeRecommendations(recommendations),
overallHealth: calculateOverallHealth(equipment, alerts),
criticalItems: alerts.filter(a => a.severity >= 4).length
};
}
MaintenanceConventions.monitorEquipmentHealth = monitorEquipmentHealth;
/**
* Energy efficiency optimization through maintenance
*/
function optimizeEnergyEfficiency(equipment, energyData, history) {
const inefficientEquipment = [];
const optimizationTasks = [];
equipment.forEach(equip => {
const usage = energyData.filter(e => e.equipmentId === equip.id);
const baseline = establishEnergyBaseline(equip, usage);
const current = getCurrentEnergyProfile(usage);
// Identify efficiency degradation
const degradation = calculateEfficiencyDegradation(baseline, current);
if (degradation > 10) { // More than 10% degradation
inefficientEquipment.push({
equipment: equip,
degradationPercent: degradation,
excessCost: calculateExcessEnergyCost(degradation, usage),
causes: identifyInefficiencyCauses(equip, history)
});
// Create optimization tasks
const tasks = generateEnergyOptimizationTasks(equip, degradation, inefficientEquipment[inefficientEquipment.length - 1].causes);
optimizationTasks.push(...tasks);
}
});
const totalSavings = calculateTotalEnergySavings(optimizationTasks);
return {
inefficientEquipment,
optimizationTasks: prioritizeEnergyTasks(optimizationTasks),
projectedSavings: {
energy: totalSavings.energy, // kWh
cost: totalSavings.cost, // dollars
emissions: totalSavings.emissions // kg CO2
},
philosophyImpact: {
sustainabilityScore: calculateSustainabilityScore(totalSavings),
budgetRedirection: totalSavings.cost * 0.5 // 50% can go to education
}
};
}
MaintenanceConventions.optimizeEnergyEfficiency = optimizeEnergyEfficiency;
/**
* Maintenance staff scheduling and training
*/
function optimizeStaffScheduling(tasks, staff, constraints) {
const assignments = [];
const trainingNeeds = [];
// Group tasks by required skills
const tasksBySkill = groupTasksBySkill(tasks);
tasksBySkill.forEach((taskList, skill) => {
const qualifiedStaff = staff.filter(s => s.skills.includes(skill));
if (qualifiedStaff.length === 0) {
// Identify training need
trainingNeeds.push({
skill,
urgency: assessTrainingUrgency(taskList),
candidateStaff: identifyTrainingCandidates(staff, skill),
estimatedDuration: estimateTrainingDuration(skill)
});
}
else {
// Assign tasks to qualified staff
taskList.forEach(task => {
const assignee = selectOptimalStaff(qualifiedStaff, task, assignments, constraints);
if (assignee) {
assignments.push({
staff: assignee,
task,
scheduledTime: task.scheduledDate,
estimatedDuration: task.task.estimatedDuration
});
}
});
}
});
// Optimize schedule to minimize overtime and travel
const optimized = optimizeStaffRoutes(assignments, constraints);
return {
assignments: optimized,
trainingNeeds,
efficiency: calculateStaffEfficiency(optimized),
overtimeProjection: projectOvertime(optimized, staff),
philosophyImpact: {
workLifeBalance: calculateWorkLifeBalance(optimized),
skillDevelopment: trainingNeeds.length * 20 // hours of growth
}
};
}
MaintenanceConventions.optimizeStaffScheduling = optimizeStaffScheduling;
// Private helper functions
function calculateHealthScore(equipment, history) {
let score = 100;
// Age factor
const age = (Date.now() - equipment.installDate.getTime()) / (365 * 24 * 60 * 60 * 1000);
score -= age * 2; // Lose 2 points per year
// Condition factor
const conditionScores = {
'excellent': 0,
'good': -10,
'fair': -25,
'poor': -50
};
score += conditionScores[equipment.condition];
// Maintenance history factor
if (history) {
const failureRate = history.failures.length / age;
score -= failureRate * 10;
// Preventive maintenance compliance
const expectedTasks = age * 12; // Monthly tasks
const completedTasks = history.tasks.length;
const compliance = completedTasks / expectedTasks;
score += compliance * 20;
}
return Math.max(0, Math.min(100, score));
}
function predictFailureProbability(equipment, history, healthScore) {
const baseFailureRate = 0.1; // 10% base rate
const score = healthScore || 50;
// Adjust based on health score
let probability = baseFailureRate * (100 - score) / 100;
// Adjust based on criticality
if (equipment.criticality === 'critical') {
probability *= 1.5; // Critical equipment monitored more closely
}
// Historical failure pattern
if (history && history.failures.length > 0) {
const avgTimeBetweenFailures = calculateMTBF(history);
const timeSinceLastFailure = Date.now() -
history.failures[history.failures.length - 1].date.getTime();
if (timeSinceLastFailure > avgTimeBetweenFailures * 0.8) {
probability *= 1.5; // Approaching typical failure time
}
}
return Math.min(1, probability);
}
function identifyRequiredTasks(equipment, healthScore, failureProbability) {
const tasks = [];
const schedule = equipment.maintenanceSchedule;
// Always include critical tasks
if (healthScore < 70 || failureProbability > 0.3) {
// Add all monthly tasks
if (schedule.monthly) {
tasks.push(...schedule.monthly);
}
// Add quarterly if very poor health
if (healthScore < 50 && schedule.quarterly) {
tasks.push(...schedule.quarterly);
}
}
// Add predictive tasks based on condition
if (equipment.condition === 'poor' || equipment.condition === 'fair') {
// Add inspection tasks
tasks.push({
id: 'inspect-' + equipment.id,
name: 'Detailed Inspection',
description: 'Comprehensive inspection due to poor condition',
estimatedDuration: 60,
requiredSkills: ['inspection', equipment.type],
documentation: 'Inspection checklist'
});
}
return tasks;
}
function calculateOptimalDate(task, equipment, constraints, failureProbability) {
const urgencyDays = Math.max(1, Math.floor((1 - failureProbability) * 30));
const baseDate = new Date(Date.now() + urgencyDays * 24 * 60 * 60 * 1000);
// Adjust for constraints
if (constraints.blackoutDates) {
// Find next available date
let adjustedDate = baseDate;
while (constraints.blackoutDates.some(d => d.getTime() === adjustedDate.getTime())) {
adjustedDate = new Date(adjustedDate.getTime() + 24 * 60 * 60 * 1000);
}
return adjustedDate;
}
return baseDate;
}
function calculatePriority(equipment, task, failureProbability) {
let priority = 0;
// Criticality factor
const criticalityScores = {
'critical': 30,
'important': 20,
'standard': 10
};
priority += criticalityScores[equipment.criticality];
// Failure probability factor
priority += failureProbability * 50;
// Task importance
if (task.name.toLowerCase().includes('safety')) {
priority += 20;
}
return priority;
}
function estimateTaskCost(task, equipment) {
let cost = 0;
// Labor cost
const hourlyRate = 50; // $50/hour average
cost += (task.estimatedDuration / 60) * hourlyRate;
// Parts cost
if (task.parts) {
cost += task.parts.reduce((sum, part) => sum + (part.cost * part.quantity), 0);
}
// Equipment type multiplier
const typeMultipliers = {
'hvac': 1.5,
'kitchen': 1.2,
'electrical': 1.3,
'plumbing': 1.1,
'facility': 1.0,
'vehicle': 1.4
};
cost *= typeMultipliers[equipment.type];
return cost;
}
function optimizeScheduleGrouping(schedule, constraints) {
// Group by location and date
const grouped = new Map();
schedule.forEach(item => {
const key = `${item.equipment.location}-${item.scheduledDate.toDateString()}`;
if (!grouped.has(key)) {
grouped.set(key, []);
}
grouped.get(key).push(item);
});
// Assign grouping IDs
let groupId = 1;
grouped.forEach(group => {
group.forEach(item => {
item.grouping = `group-${groupId}`;
});
groupId++;
});
return schedule;
}
function calculateEfficiency(optimized, original) {
// Calculate travel time saved, batch efficiency, etc.
const originalTime = original.reduce((sum, item) => sum + item.task.estimatedDuration, 0);
const optimizedTime = optimized.reduce((sum, item) => sum + item.task.estimatedDuration * 0.9, 0 // 10% efficiency from batching
);
return ((originalTime - optimizedTime) / originalTime) * 100;
}
function projectAnnualCosts(schedule) {
const monthlyTotal = schedule.reduce((sum, item) => sum + item.estimatedImpact.cost, 0);
return monthlyTotal * 12;
}
function calculateDowntimeReduction(schedule, history) {
// Calculate historical downtime
const historicalDowntime = history.reduce((sum, h) => sum + h.failures.reduce((fSum, f) => fSum + f.downtime, 0), 0);
// Project new downtime with predictive maintenance
const projectedDowntime = historicalDowntime * 0.5; // 50% reduction typical
return ((historicalDowntime - projectedDowntime) / historicalDowntime) * 100;
}
function calculateBudgetSavings(schedule, history) {
// Emergency repair costs from history
const emergencyCosts = history.reduce((sum, h) => sum + h.costs
.filter(c => c.type === 'emergency')
.reduce((cSum, c) => cSum + c.total, 0), 0);
// Predictive maintenance prevents 70% of emergency repairs
return emergencyCosts * 0.7;
}
function calculateMTBF(history) {
if (history.failures.length < 2)
return Infinity;
const failures = history.failures.sort((a, b) => a.date.getTime() - b.date.getTime());
let totalTime = 0;
for (let i = 1; i < failures.length; i++) {
totalTime += failures[i].date.getTime() - failures[i - 1].date.getTime();
}
return totalTime / (failures.length - 1);
}
// Additional helper method stubs...
function detectAnomalies(readings, equipment) {
return []; // Placeholder
}
function assessSeverity(anomaly, equipment, history) {
return 1; // Placeholder
}
function getRecommendedAction(anomaly, severity) {
return "Investigate"; // Placeholder
}
function estimateTimeToFailure(anomaly, equipment) {
return 30; // Days placeholder
}
function getCorrectiveTasks(anomaly, equipment) {
return []; // Placeholder
}
function estimateCorrectiveCost(anomaly, equipment) {
return 500; // Placeholder
}
function prioritizeAlerts(alerts) {
return alerts.sort((a, b) => b.severity - a.severity);
}
function prioritizeRecommendations(recommendations) {
return recommendations; // Placeholder
}
function calculateOverallHealth(equipment, alerts) {
const avgHealth = equipment.reduce((sum, e) => sum + 80, 0) / equipment.length;
const alertPenalty = alerts.length * 2;
return Math.max(0, avgHealth - alertPenalty);
}
function establishEnergyBaseline(equipment, usage) {
return {}; // Placeholder
}
function getCurrentEnergyProfile(usage) {
return {}; // Placeholder
}
function calculateEfficiencyDegradation(baseline, current) {
return 15; // Placeholder percentage
}
function calculateExcessEnergyCost(degradation, usage) {
return degradation * 100; // Placeholder
}
function identifyInefficiencyCauses(equipment, history) {
return ["Dirty filters", "Worn belts"]; // Placeholder
}
function generateEnergyOptimizationTasks(equipment, degradation, causes) {
return []; // Placeholder
}
function calculateTotalEnergySavings(tasks) {
return { energy: 1000, cost: 500, emissions: 200 }; // Placeholder
}
function prioritizeEnergyTasks(tasks) {
return tasks; // Placeholder
}
function calculateSustainabilityScore(savings) {
return 85; // Placeholder
}
function groupTasksBySkill(tasks) {
const groups = new Map();
// Implementation would group tasks
return groups;
}
function assessTrainingUrgency(tasks) {
return 'medium'; // Placeholder
}
function identifyTrainingCandidates(staff, skill) {
return []; // Placeholder
}
function estimateTrainingDuration(skill) {
return 40; // Hours placeholder
}
function selectOptimalStaff(qualified, task, existing, constraints) {
return qualified.length > 0 ? qualified[0] : null; // Placeholder
}
function optimizeStaffRoutes(assignments, constraints) {
return assignments; // Placeholder
}
function calculateStaffEfficiency(assignments) {
return 85; // Placeholder percentage
}
function projectOvertime(assignments, staff) {
return 10; // Hours placeholder
}
function calculateWorkLifeBalance(assignments) {
return 80; // Score placeholder
}
})(MaintenanceConventions || (exports.MaintenanceConventions = MaintenanceConventions = {}));