MSE Full Height en Revit 2026:
distribución y ajuste de paneles con Dynamo y Python

dist = [float(x.strip()) for x in IN[0].split(",")]
alt  = [float(x.strip()) for x in IN[1].split(",")]
OUT  = [dist, alt]

import math
L = IN[0];  junta = IN[1]
ref = "Inicio" if IN[2] else "Final"
ANCHO = IN[3];  AMIN = 0.50;  STEP = 0.05
modulo = ANCHO + junta
N_std  = int(math.floor((L + junta) / modulo))
if N_std < 1: N_std = 1
ocupado = N_std * ANCHO + (N_std - 1) * junta
residuo  = L - ocupado
if abs(residuo) < 0.001:
    anchos   = [ANCHO] * N_std
    es_ajuste = [False] * N_std
elif residuo > 0:
    ancho_especial = residuo - junta
    if ancho_especial > ANCHO:
        N_std += 1
        ocupado = N_std * ANCHO + (N_std - 1) * junta
        residuo = L - ocupado
        ancho_especial = residuo - junta
    if ancho_especial >= AMIN and ancho_especial <= ANCHO:
        if ref == "Final":
            anchos    = [ANCHO] * N_std + [ancho_especial]
            es_ajuste = [False] * N_std + [True]
        else:
            anchos    = [ancho_especial] + [ANCHO] * N_std
            es_ajuste = [True] + [False] * N_std
    elif ancho_especial > 0.001:
        N_std -= 1
        espacio = L - N_std * ANCHO - N_std * junta
        p1 = round(round(espacio / 2.0 / STEP) * STEP, 4)
        p2 = round(espacio - p1 - junta, 4)
        if p1 < AMIN: p1 = AMIN; p2 = round(espacio - p1 - junta, 4)
        if p2 < AMIN: p2 = AMIN; p1 = round(espacio - p2 - junta, 4)
        if p1 >= AMIN and p2 >= AMIN and p1 <= ANCHO and p2 <= ANCHO:
            if ref == "Final":
                anchos    = [ANCHO] * N_std + [p1, p2]
                es_ajuste = [False] * N_std + [True, True]
            else:
                anchos    = [p1, p2] + [ANCHO] * N_std
                es_ajuste = [True, True] + [False] * N_std
        else:
            anchos = [ANCHO] * (N_std + 1); es_ajuste = [False] * (N_std + 1)
    else:
        anchos = [ANCHO] * N_std; es_ajuste = [False] * N_std
else:
    anchos = [ANCHO] * N_std; es_ajuste = [False] * N_std
N_total = len(anchos)
OUT = [anchos, N_total, es_ajuste]

import math
anchos = IN[0];  junta = IN[1]
dist_infl = list(IN[2]);  alt_infl = list(IN[3])
L = IN[4];  alt_default = IN[5]
HMIN = 0.10;  STEP = 0.05
dist_infl[-1] = L
if len(dist_infl) == 2 and abs(alt_infl[0] - alt_infl[1]) < 0.001:
    alturas = [round(round(alt_default / STEP) * STEP, 4)] * len(anchos)
else:
    centros = [];  acum = 0.0
    for a in anchos:
        centros.append(acum + a / 2.0)
        acum = acum + a + junta
    alturas_obj = []
    for centro in centros:
        if   centro <= dist_infl[0]:  h = alt_infl[0]
        elif centro >= dist_infl[-1]: h = alt_infl[-1]
        else:
            for j in range(len(dist_infl) - 1):
                if dist_infl[j] <= centro <= dist_infl[j+1]:
                    t = (centro - dist_infl[j]) / (dist_infl[j+1] - dist_infl[j])
                    h = alt_infl[j] + t * (alt_infl[j+1] - alt_infl[j])
                    break
        h_round = round(h / STEP) * STEP
        if h_round < HMIN: h_round = HMIN
        alturas_obj.append(round(h_round, 4))
    alturas = [alturas_obj[0]]
    for i in range(1, len(alturas_obj)):
        h_prev = alturas[i-1];  h_obj = alturas_obj[i]
        diff = h_obj - h_prev
        if   abs(diff) <= STEP + 0.001: alturas.append(h_obj)
        elif diff > 0: alturas.append(round(h_prev + STEP, 4))
        else:
            nueva = round(h_prev - STEP, 4)
            if nueva < HMIN: nueva = HMIN
            alturas.append(nueva)
OUT = alturas

import math
anchos = IN[0];  junta = IN[1];  curva = IN[2]
puntos = [];  distancias = [];  angulos = []
acum = 0.0;  L = curva.Length
for i in range(len(anchos)):
    a = anchos[i]
    centro = max(acum + a / 2.0, 0.001)
    centro = min(centro, L - 0.001)
    distancias.append(centro)
    try:    pt = curva.PointAtSegmentLength(centro); puntos.append(pt)
    except: puntos.append(curva.StartPoint)
    try:
        t = curva.TangentAtSegmentLength(centro)
        angulos.append(math.degrees(math.atan2(t.Y, t.X)))
    except:
        s0 = max(acum, L * 0.001);  s1 = min(acum + a, L * 0.999)
        try:
            p0 = curva.PointAtSegmentLength(s0)
            p1 = curva.PointAtSegmentLength(s1)
            angulos.append(math.degrees(math.atan2(p1.Y - p0.Y, p1.X - p0.X)))
        except: angulos.append(0.0)
    acum += a
    if i < len(anchos) - 1: acum += junta
OUT = [puntos, distancias, angulos]

import clr
clr.AddReference('RevitAPI'); clr.AddReference('RevitServices')
from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Structure import StructuralType
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
fam_type = UnwrapElement(IN[0])
puntos   = IN[1] if isinstance(IN[1], list) else [IN[1]]
FT = 3.28083989501312
levels = FilteredElementCollector(doc).OfClass(Level).ToElements()
level  = sorted(levels, key=lambda lv: lv.Elevation)[0]
z = level.Elevation
TransactionManager.Instance.EnsureInTransaction(doc)
instancias = []
for pt in puntos:
    if pt is None: instancias.append(None); continue
    try:
        xyz  = XYZ(pt.X * FT, pt.Y * FT, z)
        inst = doc.Create.NewFamilyInstance(xyz, fam_type, level, StructuralType.NonStructural)
        instancias.append(inst)
    except: instancias.append(None)
TransactionManager.Instance.TransactionTaskDone()
clr.AddReference('RevitNodes')
import Revit; clr.ImportExtensions(Revit.Elements)
OUT = [inst.ToDSType(True) if inst is not None else None for inst in instancias]

import clr
clr.AddReference('RevitAPI'); clr.AddReference('RevitServices')
from Autodesk.Revit.DB import *
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc   = DocumentManager.Instance.CurrentDBDocument
elems = UnwrapElement(IN[0]);  curva = IN[1]
if not isinstance(elems, list): elems = [elems]
TransactionManager.Instance.EnsureInTransaction(doc)
for elem in elems:
    loc = elem.Location
    if loc is None: continue
    pt = loc.Point
    x_param = elem.LookupParameter("Coord_X")
    y_param = elem.LookupParameter("Coord_Y")
    r_param = elem.LookupParameter("Radio_Curva")
    if x_param: x_param.Set(pt.X)
    if y_param: y_param.Set(pt.Y)
    if r_param:
        try:    r_param.Set(1.0 / curva.CurvatureAtParameter(0.5))
        except: r_param.Set(0.0)
TransactionManager.Instance.TransactionTaskDone()
OUT = IN[0]

import clr, math
clr.AddReference('RevitAPI'); clr.AddReference('RevitServices')
from Autodesk.Revit.DB import *
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc     = DocumentManager.Instance.CurrentDBDocument
elems   = UnwrapElement(IN[0]);  angulos = IN[1]
if not isinstance(elems,   list): elems   = [elems]
if not isinstance(angulos, list): angulos = [angulos]
resultados = []
TransactionManager.Instance.EnsureInTransaction(doc)
doc.Regenerate()
for i in range(len(elems)):
    elem = elems[i]
    if elem is None: resultados.append(None); continue
    if i >= len(angulos): resultados.append(elem); continue
    ang_deseado = angulos[i]
    try:
        loc = elem.Location
        if loc is None: resultados.append(elem); continue
        pt   = loc.Point
        axis = Line.CreateBound(XYZ(pt.X, pt.Y, pt.Z), XYZ(pt.X, pt.Y, pt.Z + 1.0))
        ang_actual = loc.Rotation
        ang_diff   = math.radians(ang_deseado) - ang_actual
        while ang_diff >  math.pi: ang_diff -= 2 * math.pi
        while ang_diff < -math.pi: ang_diff += 2 * math.pi
        if abs(ang_diff) > 0.001:
            ElementTransformUtils.RotateElement(doc, elem.Id, axis, ang_diff)
        resultados.append(elem)
    except: resultados.append(elem)
TransactionManager.Instance.TransactionTaskDone()
OUT = resultados

import clr, math
clr.AddReference('RevitAPI')
clr.AddReference('RevitServices')
clr.AddReference('RevitNodes')
from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Structure import StructuralType
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
import Revit
clr.ImportExtensions(Revit.Elements)
doc            = DocumentManager.Instance.CurrentDBDocument
paneles_dy     = IN[0] if isinstance(IN[0], list) else [IN[0]]
curva_elem     = UnwrapElement(IN[1])
largo_obj_m    = float(IN[2])
ajuste_inicio  = bool(IN[3])
panel_prev_dy  = IN[4]
panel_next_dy  = IN[5]
FT       = 3.28083989501312
MI       = 1.0 / FT
STEP_M   = 0.05
AMIN_M   = 0.50
JUNTA_MIN_M = 0.020
JUNTA_MAX_M = 0.025
def snap(v):
    return round(round(v / STEP_M) * STEP_M, 4)
def copy_params(src, dst):
    for pname in ['Largo','Altura','ID_Tramo','Total_Paneles',
                   'EsPanelAjuste','Angulo_Rotacion','Bloqueado','Viga Corona']:
        try:
            ps = src.LookupParameter(pname)
            pd = dst.LookupParameter(pname)
            if ps and pd and not pd.IsReadOnly:
                st = ps.StorageType
                if   st == StorageType.Double:  pd.Set(ps.AsDouble())
                elif st == StorageType.Integer: pd.Set(ps.AsInteger())
                elif st == StorageType.String:  pd.Set(ps.AsString() or '')
        except:
            pass
panel_prev  = UnwrapElement(panel_prev_dy) if panel_prev_dy else None
panel_next  = UnwrapElement(panel_next_dy) if panel_next_dy else None
def get_altura_m(elem):
    p = elem.LookupParameter('Altura')
    return (p.AsDouble() * MI) if p else None
paneles_rv   = [UnwrapElement(p) for p in paneles_dy if p is not None]
revit_curve  = curva_elem.GeometryCurve
L_ft_tot     = revit_curve.Length
p0_raw  = revit_curve.GetEndParameter(0)
p1_raw  = revit_curve.GetEndParameter(1)
p_range = p1_raw - p0_raw
def to_norm(p_raw):
    return max(0.0, min(1.0, (p_raw - p0_raw) / p_range))
def eval_norm(t):
    return revit_curve.Evaluate(max(0.00001, min(0.99999, t)), True)
def panel_t(elem):
    try:
        return to_norm(revit_curve.Project(elem.Location.Point).Parameter)
    except:
        return 0.0
def get_largo_ft(elem):
    p = elem.LookupParameter('Largo')
    return p.AsDouble() if p else largo_obj_m * FT
def get_z(elem):
    try:
        return elem.Location.Point.Z
    except:
        return 0.0
N_FULL   = 1000
ts_full  = [k / float(N_FULL) for k in range(N_FULL + 1)]
pts_full = [eval_norm(t) for t in ts_full]
arc_full = [0.0]
for k in range(1, N_FULL + 1):
    dx = pts_full[k].X - pts_full[k-1].X
    dy = pts_full[k].Y - pts_full[k-1].Y
    arc_full.append(arc_full[-1] + math.sqrt(dx*dx + dy*dy))
L_curve_ft = arc_full[-1]
JUNTA_M  = JUNTA_MIN_M
JUNTA_FT = JUNTA_M * FT
def t_to_arc(t_val):
    t_val = max(0.0, min(1.0, t_val))
    lo, hi = 0, N_FULL
    while lo < hi - 1:
        mid = (lo + hi) // 2
        if ts_full[mid] <= t_val: lo = mid
        else: hi = mid
    if ts_full[hi] == ts_full[lo]: return arc_full[lo]
    frac = (t_val - ts_full[lo]) / (ts_full[hi] - ts_full[lo])
    return arc_full[lo] + frac * (arc_full[hi] - arc_full[lo])
def arc_to_t(s_ft):
    s_ft = max(0.0, min(L_curve_ft, s_ft))
    lo, hi = 0, N_FULL
    while lo < hi - 1:
        mid = (lo + hi) // 2
        if arc_full[mid] <= s_ft: lo = mid
        else: hi = mid
    if arc_full[hi] == arc_full[lo]: return ts_full[lo]
    frac = (s_ft - arc_full[lo]) / (arc_full[hi] - arc_full[lo])
    return ts_full[lo] + frac * (ts_full[hi] - ts_full[lo])
def rv_at_arc(s_ft):
    return eval_norm(arc_to_t(s_ft))
def panel_arc(elem):
    return t_to_arc(panel_t(elem))
paneles_rv.sort(key=panel_arc)
N_exist  = len(paneles_rv)
template = paneles_rv[0]
z_nivel  = get_z(template)
s_c0 = panel_arc(paneles_rv[0])
s_cN = panel_arc(paneles_rv[-1])
s_seg_ini = s_c0 - get_largo_ft(paneles_rv[0])  / 2.0
s_seg_fin = s_cN + get_largo_ft(paneles_rv[-1]) / 2.0
if s_seg_fin - s_seg_ini < largo_obj_m * FT * 0.5:
    OUT = ['ERROR: segmento demasiado pequeno (' + str(round((s_seg_fin-s_seg_ini)*MI,3)) + 'm). Verifica la seleccion de paneles y el trazado.']
else:
    L_seg_ft = s_seg_fin - s_seg_ini
    L_seg_m  = L_seg_ft * MI
    try:
        tang_ini = eval_norm(arc_to_t(s_seg_ini + 0.001))
        tang_mid = eval_norm(arc_to_t(s_seg_ini + L_seg_ft * 0.5))
        tang_fin = eval_norm(arc_to_t(s_seg_fin - 0.001))
        pt_ini   = rv_at_arc(s_seg_ini)
        pt_fin   = rv_at_arc(s_seg_fin)
        dx1 = tang_mid.X - tang_ini.X; dy1 = tang_mid.Y - tang_ini.Y
        dx2 = tang_fin.X - tang_mid.X; dy2 = tang_fin.Y - tang_mid.Y
        ang1 = math.degrees(math.atan2(dy1, dx1))
        ang2 = math.degrees(math.atan2(dy2, dx2))
        n_est = max(1, L_seg_m / (largo_obj_m + JUNTA_MIN_M))
        delta_ang_total = abs(ang2 - ang1)
        delta_ang_per_panel = delta_ang_total / n_est
        factor = min(1.0, delta_ang_per_panel / 10.0)
        JUNTA_M  = JUNTA_MIN_M + factor * (JUNTA_MAX_M - JUNTA_MIN_M)
        JUNTA_FT = JUNTA_M * FT
    except:
        JUNTA_M  = JUNTA_MIN_M
        JUNTA_FT = JUNTA_M * FT
    def rv_at_local(s_local_ft):
        return rv_at_arc(s_seg_ini + max(0.0, min(L_seg_ft, s_local_ft)))
    modulo = largo_obj_m + JUNTA_M
    N_std  = int(math.floor((L_seg_m + JUNTA_M) / modulo))
    if N_std < 1: N_std = 1
    ocupado = N_std * largo_obj_m + (N_std - 1) * JUNTA_M
    residuo = L_seg_m - ocupado
    ancho_ult = residuo - JUNTA_M
    if abs(residuo) < 0.001:
        anchos    = [largo_obj_m] * N_std
        es_ajuste = [False] * N_std
    elif ancho_ult >= AMIN_M and ancho_ult <= largo_obj_m:
        if ajuste_inicio:
            anchos    = [snap(ancho_ult)] + [largo_obj_m] * N_std
            es_ajuste = [True] + [False] * N_std
        else:
            anchos    = [largo_obj_m] * N_std + [snap(ancho_ult)]
            es_ajuste = [False] * N_std + [True]
    elif ancho_ult > 0.001:
        N2  = N_std - 1
        esp = L_seg_m - N2 * largo_obj_m - N2 * JUNTA_M
        p1v = snap(esp / 2.0)
        p2v = snap(esp - p1v - JUNTA_M)
        if p1v >= AMIN_M and p2v >= AMIN_M:
            if ajuste_inicio:
                anchos    = [p1v, p2v] + [largo_obj_m] * N2
                es_ajuste = [True, True] + [False] * N2
            else:
                anchos    = [largo_obj_m] * N2 + [p1v, p2v]
                es_ajuste = [False] * N2 + [True, True]
        else:
            anchos    = [largo_obj_m] * N_std
            es_ajuste = [False] * N_std
    else:
        anchos    = [largo_obj_m] * N_std
        es_ajuste = [False] * N_std
    N_nuevo = len(anchos)
    nuevos_creados = 0
    eliminados     = 0
    fam_type = template.Symbol
    TransactionManager.Instance.EnsureInTransaction(doc)
    doc.Regenerate()
    if N_nuevo > N_exist:
        levels = FilteredElementCollector(doc).OfClass(Level).ToElements()
        level  = sorted(levels, key=lambda lv: lv.Elevation)[0]
        pt_mid = rv_at_arc(s_seg_ini + L_seg_ft / 2.0)
        pt_tmp = XYZ(pt_mid.X, pt_mid.Y, z_nivel)
        for _ in range(N_nuevo - N_exist):
            inst = doc.Create.NewFamilyInstance(pt_tmp, fam_type, level, StructuralType.NonStructural)
            copy_params(template, inst)
            paneles_rv.append(inst)
            nuevos_creados += 1
    elif N_nuevo < N_exist:
        sobrantes  = paneles_rv[N_nuevo:]
        eliminados = len(sobrantes)
        for e in sobrantes:
            doc.Delete(e.Id)
        paneles_rv = paneles_rv[:N_nuevo]
    doc.Regenerate()
    h_ini = get_altura_m(panel_prev) if panel_prev else get_altura_m(paneles_rv[0])
    h_fin = get_altura_m(panel_next) if panel_next else get_altura_m(paneles_rv[-1])
    if h_ini is None: h_ini = get_altura_m(paneles_rv[0])
    if h_fin is None: h_fin = get_altura_m(paneles_rv[-1])
    if h_ini is None: h_ini = 2.4
    if h_fin is None: h_fin = h_ini
    HSTEP = 0.05
    def snap_h(v):
        return round(round(v / HSTEP) * HSTEP, 4)
    N = N_nuevo
    alturas_obj = []
    for idx in range(N):
        t_h = idx / max(1, N - 1)
        h   = h_ini + t_h * (h_fin - h_ini)
        alturas_obj.append(snap_h(h))
    alturas_final = [alturas_obj[0]]
    for idx in range(1, N):
        diff = alturas_obj[idx] - alturas_final[-1]
        if abs(diff) <= HSTEP + 0.001:
            alturas_final.append(alturas_obj[idx])
        elif diff > 0:
            alturas_final.append(round(alturas_final[-1] + HSTEP, 4))
        else:
            alturas_final.append(round(alturas_final[-1] - HSTEP, 4))
    resultados = []
    acum_ft    = 0.0
    acum_check_ft = sum(a * FT + JUNTA_FT for a in anchos) - JUNTA_FT
    last_exact_ft = L_seg_ft - (acum_check_ft - anchos[-1] * FT)
    for i, elem in enumerate(paneles_rv):
        if i == len(paneles_rv) - 1:
            a_ft = max(AMIN_M * FT, last_exact_ft)
        else:
            a_ft = anchos[i] * FT
        ri = rv_at_local(acum_ft)
        rf = rv_at_local(acum_ft + a_ft)
        cx = (ri.X + rf.X) / 2.0
        cy = (ri.Y + rf.Y) / 2.0
        dx_m    = (rf.X - ri.X) * MI
        dy_m    = (rf.Y - ri.Y) * MI
        cuerda_m = math.sqrt(dx_m*dx_m + dy_m*dy_m)
        ang_deg  = math.degrees(math.atan2(dy_m, dx_m))
        try:
            loc = elem.Location
            pt  = loc.Point
            delta = XYZ(cx - pt.X, cy - pt.Y, z_nivel - pt.Z)
            if delta.GetLength() > 0.00001:
                ElementTransformUtils.MoveElement(doc, elem.Id, delta)
            lp = elem.LookupParameter('Largo')
            if lp:
                largo_set = cuerda_m if i == len(paneles_rv)-1 else snap(cuerda_m)
                lp.Set(largo_set * FT)
            lpa = elem.LookupParameter('EsPanelAjuste')
            if lpa and not lpa.IsReadOnly: lpa.Set(1 if es_ajuste[i] else 0)
            lh = elem.LookupParameter('Altura')
            if lh and not lh.IsReadOnly and i < len(alturas_final):
                lh.Set(alturas_final[i] * FT)
            doc.Regenerate()
            loc2 = elem.Location
            pt2  = loc2.Point
            axis = Line.CreateBound(pt2, XYZ(pt2.X, pt2.Y, pt2.Z + 1.0))
            ang_diff = math.radians(ang_deg) - loc2.Rotation
            while ang_diff >  math.pi: ang_diff -= 2 * math.pi
            while ang_diff < -math.pi: ang_diff += 2 * math.pi
            if abs(ang_diff) > 0.0005:
                ElementTransformUtils.RotateElement(doc, elem.Id, axis, ang_diff)
            tag   = ' [AJUSTE]' if es_ajuste[i] else ''
            h_str = str(alturas_final[i]) + 'm' if i < len(alturas_final) else ''
            resultados.append('P' + str(i) + tag + ': ' + str(snap(cuerda_m)) + 'm ' + str(round(ang_deg,1)) + 'deg h=' + h_str)
        except Exception as ex:
            resultados.append('P' + str(i) + ' ERROR: ' + str(ex)[:80])
        acum_ft += a_ft + JUNTA_FT
    TransactionManager.Instance.TransactionTaskDone()
    resumen = ('Seg: ' + str(round(L_seg_m,3)) + 'm | '
               + str(N_nuevo) + ' paneles (+' + str(nuevos_creados)
               + ' nuevos, -' + str(eliminados) + ' elim) | '
               + str(largo_obj_m) + 'm | Ajuste al '
               + ('Inicio' if ajuste_inicio else 'Final'))
    OUT = [resumen] + resultados