Plataforma de Cálculo Estructural
:root {
--primary-color: #2563eb;
--secondary-color: #64748b;
--success-color: #10b981;
--danger-color: #ef4444;
}
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
line-height: 1.6;
color: #1e293b;
}
.container {
max-width: 1400px;
margin: 0 auto;
padding: 2rem;
}
.calculator-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
gap: 2rem;
margin-top: 2rem;
}
.card {
background: white;
border-radius: 12px;
padding: 2rem;
box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
transition: transform 0.2s, box-shadow 0.2s;
}
.card:hover {
transform: translateY(-4px);
box-shadow: 0 8px 12px rgba(0, 0, 0, 0.15);
}
.btn {
padding: 0.75rem 1.5rem;
border: none;
border-radius: 8px;
font-weight: 600;
cursor: pointer;
transition: all 0.2s;
}
.btn-primary {
background: var(--primary-color);
color: white;
}
.btn-primary:hover {
background: #1d4ed8;
}
.btn-save {
background: var(--success-color);
color: white;
}
.btn-open {
background: var(--secondary-color);
color: white;
}
// Motor principal de cálculo estructural
class StructuralEngine {
constructor() {
this.projects = new Map();
this.currentProject = null;
this.standards = {
NCh432: new WindLoadStandard(),
NCh2745: new SeismicLoadStandard(),
ACI318: new ConcreteStandard(),
AISC: new SteelStandard()
};
}
// Crear nuevo proyecto
createProject(name, type) {
const project = {
id: this.generateId(),
name,
type,
createdAt: new Date(),
elements: [],
loads: [],
results: {}
};
this.projects.set(project.id, project);
this.currentProject = project;
return project;
}
// Calcular elemento estructural
async calculateElement(element) {
const calculator = this.getCalculator(element.type);
const results = await calculator.compute(element);
// Guardar resultados
this.currentProject.results[element.id] = results;
return results;
}
// Exportar proyecto a archivo .dat
exportProject(projectId) {
const project = this.projects.get(projectId);
const data = JSON.stringify(project, null, 2);
// Crear blob y descargar
const blob = new Blob([data], { type: 'application/json' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = `${project.name}.dat`;
a.click();
URL.revokeObjectURL(url);
}
// Importar proyecto desde archivo .dat
importProject(file) {
return new Promise((resolve, reject) => {
const reader = new FileReader();
reader.onload = (e) => {
try {
const project = JSON.parse(e.target.result);
this.projects.set(project.id, project);
resolve(project);
} catch (error) {
reject(error);
}
};
reader.onerror = reject;
reader.readAsText(file);
});
}
generateId() {
return 'proj_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
}
getCalculator(type) {
// Factory pattern para obtener calculadora específica
const calculators = {
'beam': new BeamCalculator(),
'column': new ColumnCalculator(),
'slab': new SlabCalculator(),
'foundation': new FoundationCalculator()
};
return calculators[type];
}
}
// Clase base para calculadoras
class BaseCalculator {
async compute(element) {
throw new Error('Method must be implemented');
}
}
// Calculadora de vigas
class BeamCalculator extends BaseCalculator {
async compute(beam) {
const { length, load, support_type, material } = beam;
// Cálculos estructurales
const maxMoment = this.calculateMaxMoment(load, length, support_type);
const maxShear = this.calculateMaxShear(load, length, support_type);
const maxDeflection = this.calculateMaxDeflection(load, length, material);
// Verificación
const checks = {
moment: maxMoment <= material.fy * material.W,
shear: maxShear <= material.fy * material.Av,
deflection: maxDeflection <= length / 360
};
return {
maxMoment,
maxShear,
maxDeflection,
checks,
passed: Object.values(checks).every(v => v)
};
}
calculateMaxMoment(load, length, supportType) {
if (supportType === 'simply_supported') {
return (load * length ** 2) / 8;
}
// Otros tipos de apoyo
return 0;
}
calculateMaxShear(load, length, supportType) {
if (supportType === 'simply_supported') {
return (load * length) / 2;
}
return 0;
}
calculateMaxDeflection(load, length, material) {
const E = material.E;
const I = material.I;
return (5 * load * length ** 4) / (384 * E * I);
}
}
// Exportar para uso global
window.StructuralEngine = StructuralEngine;
Comentarios
Publicar un comentario