Guggenheim Helsinki

The building should be designed so as to fit into its surroundings. In cityscape and landscape impact, the design should be located so as to not obscure views from Tahitornin vuori park past and over the building

Aeriel View	Site View

//Vantage Point
Peak=Point.ByCoordinates(-552,-77,27.5);

//A list of the xyz coordinates of the points along the site boundary
portX = {-556,-530,-528,-516,-518,-481,-480,-462,-384,-385,-380,
-380,-385,-386,-358,-358,-277,-273,-257,-246,-6};
portY = {544,546,517,518,546,548,520,500,505,520,520,532,532,549,
550,553,557,458,447,464,302};
portZ = -10;
portVer = Point.ByCoordinates(portX,portY,portZ);
portEdg = PolyCurve.ByPoints(portVer,false);

0:0	1:0
	1:2

2KB

20160627-1.zip

archive

Open

GridDensity=2;

//Far Port Profile
PortVertices=[Imperative]
{
//Elevation, considering a level site
e2=-10;
//A list of the xyz coordinates of the points along the site boundary
Coordinates={-556,544,e2,-530,546,e2,-528,517,e2,-516,518,e2,-518,546,e2,-481,548,e2,-480,520,e2,-462,500,e2,-384,505,e2,-385,520,e2,-380,520,e2,-380,532,e2,-385,532,e2,-386,549,e2,-358,550,e2,-358,553,e2,-277,557,e2,-273,458,e2,-257,447,e2,-246,464,e2,-6,302,e2};
//Creating points from the list of xyz coordinates
Points={};
pi=0;
pc=0;
while (pc<List.Count(Coordinates))
{
Points[pi]=Point.ByCoordinates(Coordinates[pc],Coordinates[pc+1],Coordinates[pc+2]);
pi=pi+1;
pc=pc+3;
}
return=Points;
}
//Connecting points with lines
PortEdge=PolyCurve.ByPoints(PortVertices,false);

VolumetricMass=[Imperative]
{
//Elevation, considering a level site
e1=2.1;
//A list of the xyz coordinates of the points along the site boundary
Coordinates={-535,270,e1,-471,274,e1,-470,253,e1,-442,219,e1,-428,202,e1,-418,189,e1,-366,126,e1,-439,65,e1,-470,107,e1,-476,115,e1,-484,125,e1,-490,134,e1,-493,138,e1,-497,143,e1,-504,154,e1,-511,166,e1,-517,177,e1,-521,187,e1,-525,199,e1,-529,211,e1,-532,224,e1,-534,239,e1,-535,244,e1,-536,250,e1};
//Creating points from the list of xyz coordinates
Points={};
pi=0;
pc=0;
while (pc<List.Count(Coordinates))
{
Points[pi]=Point.ByCoordinates(Coordinates[pc],Coordinates[pc+1],Coordinates[pc+2]);
pi=pi+1;
pc=pc+3;
}

//Connecting points with lines
SiteBoundary=PolyCurve.ByPoints(Points,true);

//West Deduction Profile
//A list of the xyz coordinates of the points along the site boundary
WestDeductionCoordinates={-535,270,e1,-525,271,e1,-526,250,e1,-525,245,e1,-525,240,e1,-522,226,e1,-519,214,e1,-516,202,e1,-511,191,e1,-507,181,e1,-502,170,e1,-495,159,e1,-489,149,e1,-485,144,e1,-481,139,e1,-476,131,e1,-468,121,e1,-462,113,e1,-452,99,e1,-432,72,e1,-431,71,e1,-439,64,e1,-439,65,e1,-470,107,e1,-476,115,e1,-484,125,e1,-490,134,e1,-493,138,e1,-497,143,e1,-504,154,e1,-511,166,e1,-517,177,e1,-521,187,e1,-525,199,e1,-529,211,e1,-532,224,e1,-534,239,e1,-535,244,e1,-536,250,e1};
//Creating points from the list of xyz coordinates
WestDeductionPoints={};
pi=0;
pc=0;
while (pc<List.Count(WestDeductionCoordinates))
{
WestDeductionPoints[pi]=Point.ByCoordinates(WestDeductionCoordinates[pc],WestDeductionCoordinates[pc+1],WestDeductionCoordinates[pc+2]);
pi=pi+1;
pc=pc+3;
}
//Connecting points with lines
WestDeductionLines=PolyCurve.ByPoints(WestDeductionPoints,true);
WestDeduction=WestDeductionLines.ExtrudeAsSolid(Vector.ByCoordinates(0,0,1),5.5);

//East Deduction Profile
//A list of the xyz coordinates of the points along the East boundary
EastDeductionCoordinates={-485,274,e1,-470,274,e1,-469,253,e1,-441,219,e1,-433,209,e1,-427,202,e1,-417,189,e1,-377,141,e1,-397,140,e1,-429,180,e1,-440,192,e1,-446,200,e1,-454,209,e1,-485,247,e1};
//Creating points from the list of xyz coordinates
EastDeductionPoints={};
qi=0;
qc=0;
while (qc<List.Count(EastDeductionCoordinates))
{
EastDeductionPoints[qi]=Point.ByCoordinates(EastDeductionCoordinates[qc],EastDeductionCoordinates[qc+1],EastDeductionCoordinates[qc+2]);
qi=qi+1;
qc=qc+3;
}
//Connecting points with lines
EastDeductionLines=PolyCurve.ByPoints(EastDeductionPoints,true);
EastDeduction=EastDeductionLines.ExtrudeAsSolid(Vector.ByCoordinates(0,0,1),25);

//Volumetric Mass
SiteMass=SiteBoundary.ExtrudeAsSolid(-22);
Deductions={WestDeduction,EastDeduction};
Deduction=Deductions[0].UnionAll(Deductions);
SiteMass=SiteMass.Difference(Deduction);
return=SiteMass;
}

//Sight Lines from Park to Far Port
ParkSightLines=[Imperative]
{
Peak=Point.ByCoordinates(-552,-77,27.5);

//Elevation, considering a level site
e2=-15;
//A list of the xyz coordinates of the points along the site boundary
Coordinates={-556,544,e2,-530,546,e2,-528,517,e2,-516,518,e2,-518,546,e2,-481,548,e2,-480,520,e2,-462,500,e2,-384,505,e2,-385,520,e2,-380,520,e2,-380,532,e2,-385,532,e2,-386,549,e2,-358,550,e2,-358,553,e2,-277,557,e2,-273,458,e2,-257,447,e2,-246,464,e2,-6,302,e2};
//Creating points from the list of xyz coordinates
Points={};
pi=0;
pc=0;
while (pc<List.Count(Coordinates))
{
Points[pi]=Point.ByCoordinates(Coordinates[pc],Coordinates[pc+1],Coordinates[pc+2]);
pi=pi+1;
pc=pc+3;
}

//Angles Connecting Peak to Port Edge
Angles={};
ai=0;
while (ai<List.Count(Points))
{
Angles[ai]=Math.Atan((Points[ai].X-Peak.X)/(Points[ai].Y-Peak.Y));
ai=ai+1;
}

//Lines Connecting Peak to Port Edge
EPoints={};
li=0;
lc=1;
EPoints[0]=Points[0];
while (li<(List.Count(Points)-1))
{
if (Angles[li+1]>(Angles[li]+0.5))
{
EPoints[lc]=Points[li+1];
li=li+1;
lc=lc+1;
}
else
{
li=li+1;
}
}
//Polycurves
PLines={};
PExt={};
di=0;
while (di<(List.Count(EPoints)-1))
{
PPoints={Peak,EPoints[di],EPoints[di+1]};
PLines[di]=PolyCurve.ByPoints(PPoints,true);
PExt[di]=PLines[di].ExtrudeAsSolid(Vector.ByCoordinates(0,0,1),25);
di=di+1;
}
CutMass=PExt[0].UnionAll(PExt);
CutSurface=Surface.ByPatch(PLines);
CutSurface=PolySurface.ByJoinedSurfaces(CutSurface);
return={CutMass,CutSurface};
}

//Bernhardinkatu
BernhardinkatuSlope=Vector.ByTwoPoints(Point.ByCoordinates(-609,113,12.8),Point.ByCoordinates(-486,120,(3.5+5.5)));
BernhardinkatuPoints={Point.ByCoordinates(-610,128,12.25),Point.ByCoordinates(-609,113,12.25),Point.ByCoordinates(-609,113,22.5),Point.ByCoordinates(-610,128,22.5)};
BernhardinkatuLine=PolyCurve.ByPoints(BernhardinkatuPoints,true);
BernhardinkatuMass=BernhardinkatuLine.ExtrudeAsSolid(BernhardinkatuSlope,250);

RampSlope=Vector.ByTwoPoints(Point.ByCoordinates(-609,113,18.25),Point.ByCoordinates(-486,120,10));
RampCutPoints={Point.ByCoordinates(-610,128,17.25),Point.ByCoordinates(-609,113,17.25),Point.ByCoordinates(-609,113,25),Point.ByCoordinates(-610,128,25)};
RampLine=PolyCurve.ByPoints(RampCutPoints,true);
RampCuttingMass=RampLine.ExtrudeAsSolid(RampSlope,250);

BuildingMass1=VolumetricMass.Difference(ParkSightLines[0]);
BuildingMass=BuildingMass1.Difference(BernhardinkatuMass);
BuildingMass=BuildingMass.Difference(RampCuttingMass);

//Entry/Exit Triangle
EnTriPnts={Point.ByCoordinates(-465.411644,222.985474,2.1),Point.ByCoordinates(-462.375319,233.504172,2.1),Point.ByCoordinates(-422.323500,171.657816,2.1),Point.ByCoordinates(-430.082047,156.780317,2.1)};
EntTriBou=PolyCurve.ByPoints(EnTriPnts,true);
EntTriSur=Surface.ByPatch(EntTriBou);
EntTriSol1=EntTriSur.Thicken(-15,false);
EntTriSol=EntTriSol1.Difference(ParkSightLines[0]);
BuildingMassEnt=BuildingMass.Union(EntTriSol);

//Extracting Top Surface
BuildingPolySurface=PolySurface.BySolid(BuildingMass);
BuildingSurfaces=BuildingPolySurface.Surfaces();
RampTopSurf=Flatten(BuildingSurfaces<1>.Intersect(RampCuttingMass));
RampTopSurf=RemoveIfNot(RampTopSurf,"Surface");
RampTopSurf=RampTopSurf[0];
//RampTopSurf=RampTopSurf.FlipNormalDirection();
TopSurf=BuildingSurfaces<1>.Intersect(ParkSightLines[0]);
TopSurf=Flatten(TopSurf);
TopSurf=RemoveIfNot(TopSurf,"Surface");
TopSurface=Flatten({TopSurf,RampTopSurf});

def remPnt(Li:var[])
{
LiF=RemoveIfNot(Li,"Line");
return=LiF;
}

//Function: Creating a Uniform Grid
def SurfaceGrid(surf,UnitDivision,Mass)
{
DivisionU=UnitDivision/(surf.PointAtParameter(0,0).DistanceTo(surf.PointAtParameter(1,0)));
DivisionV=UnitDivision/(surf.PointAtParameter(0,0).DistanceTo(surf.PointAtParameter(0,1)));
SurfPoints=Flatten(surf.PointAtParameter((0..1..~DivisionU)<1>,(0..1..~DivisionV)<2>));
SurfNormals=Flatten(surf.NormalAtParameter((0..1..~DivisionU)<1>,(0..1..~DivisionV)<2>));
SurfLines=Line.ByStartPointDirectionLength(SurfPoints,SurfNormals,20);
SurfInPoints=Flatten(SurfLines.DoesIntersect(surf));
SurfInLines=List.FilterByBoolMask(SurfLines,SurfInPoints)["in"];

//BuildingMass Intersects
Intersects=Flatten(Mass.Intersect(SurfInLines));
Intersects=remPnt(Intersects);

//Filter by Base Level
BaseLevelFilter1=Intersects.EndPoint.Z==2.1&&Intersects.EndPoint.Z<7.61?true:false;
BaseLevel1=Flatten(List.FilterByBoolMask(Intersects,BaseLevelFilter1)["in"]);
BaseLevelFilter2=Intersects.EndPoint.Z==7.6?true:false;
BaseLevel2=Flatten(List.FilterByBoolMask(Intersects,BaseLevelFilter2)["in"]);

//Returns BasePoint(2.1), RoofPoint(2.1),
return={BaseLevel1.EndPoint,BaseLevel1.StartPoint,BaseLevel2.EndPoint,BaseLevel2.StartPoint};
}

//Top and Bottom Grid (1-Base Lower Points,2-Top for Lower, 3-Base Upper, 4-Top for Upper

TopBottomGrid=SurfaceGrid(TopSurface,GridDensity,BuildingMass);

//Separate the Grids based on Levels
TopBottomGrid=List.Transpose(TopBottomGrid);
//LowerLevelFloorPoints
LLFP=TopBottomGrid[0];
//LowerLevelRoofPoints
LLRP=TopBottomGrid[1];
//UpperLevelFloorPoints
ULFP=TopBottomGrid[2];
//UpperLevelRoofPoints
ULRP=TopBottomGrid[3];

//Height Range1
h1={0,1.5,2.45,3.15,4.05,5.05,6.75,8.35,9.5,11.45,12.05,13.6,14.05,15.7,16.05,17.75,18};
//Height Range2
h2={1.45,2.4,3.1,4,5.00,6.7,8.15,9.5,11.45,12,13.55,14,15.65,16,17.75,18,20};

def HeightGroup(RoofPoints:var[],FloorPoints:var[],Height1,Height2)
{
R0=(RoofPoints.Z)>(Height1+2.1)&&(RoofPoints.Z)<(Height2+2.1)?true:false;
R0FilterIn=List.FilterByBoolMask(RoofPoints<1>,R0<2>)["in"];
F0FilterIn=List.FilterByBoolMask(FloorPoints<1>,R0<2>)["in"];
return={R0FilterIn,F0FilterIn};
}

//Lower Level Points Grouped by Height
LLPH=List.Transpose(HeightGroup(LLRP<1>,LLFP<1>,h1<2>,h2<2>)<2>);

//Upper Level Points Grouped by Height
ULPH=List.Transpose(HeightGroup(ULRP<1>,ULFP<1>,h1<2>,h2<2>)<2>);

//Function - Boundary Points in Cluster
def BoundaryPoints(PointsGrid:var[],GroupKey)
{
//Group Points with same X
GridX=GroupByKey(PointsGrid<1>,GroupKey)<2>;
GridMin=List.FirstItem(GridX<1>);
GridMax=List.LastItem(GridX<1>);

SingleItemFilter=GridMin==GridMax?true:false;
PeripheryMinX=List.FilterByBoolMask(GridMin<1>,SingleItemFilter<2>)["in"];

PeripheryMaxX=List.Reverse(List.FilterByBoolMask(GridMax<1>,SingleItemFilter<2>)["in"]);

PeripheryPoint=Flatten({PeripheryMinX,
PeripheryMaxX});
return=PeripheryPoint;
}

//Boundary Points
LLBPn=List.Transpose(BoundaryPoints(LLPH,GroupKeyX));
ULBPn=List.Transpose(BoundaryPoints(ULPH,GroupKeyX));

//Lower Level Boundary Curves
LLBP=Point.PruneDuplicates(LLBPn<1>,GridDensity+0.05);
LLBP[0][1][8]=List.RemoveItemAtIndex(LLBP[0][1][8],18);
LLBN=NurbsCurve.ByControlPoints(LLBP<1>,3,1);

//Lower Level Extrusions
LLBN=List.Transpose(LLBN);
LLBN=List.Transpose(LLBN<1>);
LLS=Solid.ByLoft(LLBN);
LLS=RemoveIfNot(Flatten(LLS),"Solid");

//Upper Level Boundary Curves
ULBP=Point.PruneDuplicates(ULBPn<1>,GridDensity+0.05);
ULBN=NurbsCurve.ByControlPoints(ULBP<1>,3,1);

//Upper Level Extrusions
ULBN=List.Transpose(ULBN);
ULBN=List.Transpose(ULBN<1>);
ULS=Solid.ByLoft(ULBN);
ULS=RemoveIfNot(Flatten(ULS),"Solid");

//InteriorBlocks=Solid.UnionAll(Flatten({LLS,ULS}));
InteriorBlocks=Flatten({LLS,ULS});
InteriorBlocks1=List.RemoveItemAtIndex(InteriorBlocks,{40,23,24});
ParkSightLines1=ParkSightLines[0].Translate(Vector.ByCoordinates(0,0,-1),0.1);
BuildingSkinMass=BuildingMass.Difference(ParkSightLines1);
BuildingSkinPunctured=BuildingMassEnt.Difference(InteriorBlocks1[0].UnionAll(InteriorBlocks1));

//Bridge
BrMsPts={Point.ByCoordinates(-471.821220,135.860936,2.1),Point.ByCoordinates(-470.797753,120.865169,2.1),Point.ByCoordinates(-533.930443,117.272251,2.1),Point.ByCoordinates(-544.177164,131.746015,2.1)};
BrMsBou=PolyCurve.ByPoints(BrMsPts);
BrMsSol1=BrMsBou.ExtrudeAsSolid(Vector.ByCoordinates(0,0,1),10);
BrMsSol=BrMsSol1.Difference(RampCuttingMass);
BrFlInt=BrMsSol.Intersect(RampCuttingMass);
BrFlInt=PolyCurve.ByJoinedCurves(BrFlInt);
BrFlInt=BrFlInt.Offset(0.5);
BrFlSur=Surface.ByPatch(BrFlInt);
BrFlSol1=BrFlSur.Thicken(1,false);
BrFlSol2=BrFlSur.Thicken(-5.5,false);
BrFlSol=BrFlSol1.Union(BrFlSol2);
BrFlSol=BrFlSol.Difference(ParkSightLines[0]);
BrFlSol=BrFlSol.Difference(RampCuttingMass);
BuildingSkinPunctured=BuildingSkinPunctured.Difference(BrFlSol);

//Volumetric Mass Bottom Surfaces
VMassSurfaces=PolySurface.BySolid(VolumetricMass);
VMassSurfaces=VMassSurfaces.Surfaces();
VMassBottomSurfaces=Flatten({VMassSurfaces[26],VMassSurfaces[17]});
VMassBottomSurface=PolySurface.ByJoinedSurfaces(VMassBottomSurfaces);

//Interior Blocks  Floor Area and Average Height
IntBlksBottomSurface=Flatten(InteriorBlocks.Intersect(VMassBottomSurface));
IntBlksBottomFlrArea=IntBlksBottomSurface.Area;
IntBlksBottomVol=InteriorBlocks.Volume;
IntBlksAvHeight=IntBlksBottomVol/IntBlksBottomFlrArea;

//Interior Blocks Surfaces
IntBlkSurfaces1=PolySurface.BySolid(InteriorBlocks);
IntBlkSurfaces1=IntBlkSurfaces1.Surfaces();
IntBlkSurfaces=List.Transpose(IntBlkSurfaces1);
IntBlkFlSurf=IntBlkSurfaces[0];
IntBlkRfSurf=IntBlkSurfaces[1];
IntBlkWlSurf=IntBlkSurfaces[2];

//Center of Plane Rotation
IntBlkBotCen=IntBlkFlSurf.PointAtParameter(0.5,0.5);
IntBlkU=(IntBlkFlSurf.PointAtParameter(0,0)).DistanceTo(IntBlkFlSurf.PointAtParameter(1,0));
IntBlkV=(IntBlkFlSurf.PointAtParameter(0,0)).DistanceTo(IntBlkFlSurf.PointAtParameter(0,1));
IntBlkCenShift=IntBlkU/2;
IntBlkBotCen=IntBlkBotCen.Translate(Vector.ByCoordinates(0,0,-1),IntBlkCenShift);
IntBlkCutPlane=Plane.ByOriginNormal(IntBlkBotCen,Vector.ByCoordinates(0,0,1));

DivAngle=Math.Round(IntBlkU/1.5);
RotAngle=0..180..#DivAngle;

def CutPlanes(Pl,ang:var[])
{
p=Pl<2>.Rotate(Pl.Origin<2>,Pl.YAxis<2>,ang<1>);
return=p;
}
IntBlkCutPlanes=CutPlanes(IntBlkCutPlane<1>,RotAngle<1>);
IntBlkCutPlanes=Flatten(IntBlkCutPlanes<1>);

//Center of Plane Rotation
IntBlkBotCen=IntBlkFlSurf.PointAtParameter(0.5,0.5);
IntBlkU=(IntBlkFlSurf.PointAtParameter(0,0)).DistanceTo(IntBlkFlSurf.PointAtParameter(1,0));
IntBlkV=(IntBlkFlSurf.PointAtParameter(0,0)).DistanceTo(IntBlkFlSurf.PointAtParameter(0,1));
IntBlkCenShift=IntBlkU/2;
IntBlkBotCen=IntBlkBotCen.Translate(Vector.ByCoordinates(0,0,-1),IntBlkCenShift);
IntBlkCutPlane=Plane.ByOriginNormal(IntBlkBotCen,Vector.ByCoordinates(0,0,1));

DivAngle=Math.Round(IntBlkU/1.5);
RotAngle=0..180..#DivAngle;

def CutPlanes(Pl,ang:var[])
{
p=Pl<2>.Rotate(Pl.Origin<2>,Pl.YAxis<2>,ang<1>);
return=p;
}
IntBlkCutPlanes=CutPlanes(IntBlkCutPlane<1>,RotAngle<1>);
IntBlkCutPlanes=Flatten(IntBlkCutPlanes<1>);


//Function - Create Interior Block Components
def IntBlComponents(IntBlks,IntsPlns:var[])
{
IntBlkDivs=Flatten(IntBlks<1>.Intersect(IntsPlns<2>));

//Filter out Small Surfaces
IntBlkDivsAr=IntBlkDivs.Area;
IntBlkDivsPr=IntBlkDivs.Perimeter;
IntBlkPerArRat=IntBlkDivsPr/IntBlkDivsAr;

IntBlkDivFil=IntBlkPerArRat>3?true:false;
IntBlkDivf=List.FilterByBoolMask(IntBlkDivs<0>,IntBlkDivFil<0>)["out"];
IntBlkFrmCl1=IntBlkDivf.PerimeterCurves();
IntBlkFrmCl=PolyCurve.ByJoinedCurves(IntBlkFrmCl1);

//Interior Blocks Frame
IntBlkSurfaces0=PolySurface.BySolid(IntBlks);
IntBlkSurfaces1=IntBlkSurfaces0.Surfaces();
IntBlkSurfaces=List.Transpose(IntBlkSurfaces1);
IntBlkFlSurf=IntBlkSurfaces[0];
IntBlkRfSurf=IntBlkSurfaces[1];
IntBlkWlSurf=IntBlkSurfaces[2];
IntBlkBotCen=IntBlkFlSurf.PointAtParameter(0.5,0.5);
IntBlkV=(IntBlkFlSurf.PointAtParameter(0,0)).DistanceTo(IntBlkFlSurf.PointAtParameter(0,1));

//GluLam Span to Depth ratio is 21;
IntBlkFrmDep=((IntBlkV/21)/2)<0.6?0.6:((IntBlkV/21)/3);
IntBlkFrmThk=IntBlkFrmDep<=0.6?0.25:0.45;
IntBlkFrmOuterEdges=IntBlkFrmCl.Offset(IntBlkFrmDep,0);
IntBlkFrmInnerEdges=IntBlkFrmCl.Offset(-1*IntBlkFrmDep,0);
IntBlkFrmOuterPatch0=Surface.ByPatch(IntBlkFrmOuterEdges);
IntBlkFrmOuterPatchFil=IntBlkFrmOuterPatch0==Surface?false:true;
IntBlkFrmOuterPatch=RemoveIfNot(IntBlkFrmOuterPatch0,"Surface");
IntBlkFrmOuterSol=IntBlkFrmOuterPatch.Thicken(IntBlkFrmThk,true);
IntBlkFrmInnerEdges=List.FilterByBoolMask(IntBlkFrmInnerEdges,IntBlkFrmOuterPatchFil)["in"];
IntBlkFrmInnerPatch=Surface.ByPatch(IntBlkFrmInnerEdges);
IntBlkFrmInnerSol=IntBlkFrmInnerPatch.Thicken(IntBlkFrmThk,true);
IntBlkFrmSol1=IntBlkFrmOuterSol.Difference(IntBlkFrmInnerSol);
IntBlkFrmSol2=IntBlkFrmInnerSol.Difference(IntBlkFrmOuterSol);
IntBlkFrmSol3=IntBlkFrmSol1.Union(IntBlkFrmSol2);
IntBlkFrmSol4=RemoveIfNot(IntBlkFrmSol3,"Solid");
IntBlkFrmSol=List.Count(IntBlkFrmSol4)>0?IntBlkFrmSol4[0].UnionAll(IntBlkFrmSol4):IntBlkFrmSol4;

//Interior Blocks Walls;
IntBlkWlThk=0.1;
IntBlkWlSol1=IntBlkWlSurf.Thicken(IntBlkWlThk,1);
IntBlkWlSol=IntBlkWlSol1.Difference(IntBlkFrmSol);

//Interior Block Floors
IntBlkFlOfp=1*((IntBlkFrmDep)+0.2);
IntBlkFlOfn=-1*((IntBlkFrmDep)+0.2);
//IntBlkFlTk=((IntBlkFrmDep)+0.5);
IntBlkFlTk=0.15;
FlBoun1=IntBlkFlSurf.PerimeterCurves();
FlBoun1per=FlBoun1.Length;
FlBounP=FlBoun1.Offset(IntBlkFlOfp);
FlBounPper=FlBounP.Length;
FlBounN=FlBoun1.Offset(IntBlkFlOfn);
FlBounNper=FlBounN.Length;
FlBoun2=FlBounPper>FlBoun1per?FlBounP:FlBounN;
FlBoun3=FlBoun2.DivideEqually(10);
FlBoun=PolyCurve.ByJoinedCurves(FlBoun3);
IntBlkFlSurfa=Surface.ByPatch(FlBoun);
IntBlkFlSol=IntBlkFlSurfa.Thicken(IntBlkFlTk,true);

//Interior Block Roofs
SkLtWd=0.5;
IntBlkRfOfp=1*((IntBlkWlThk/2)+SkLtWd);
IntBlkRfOfn=-1*((IntBlkWlThk/2)+SkLtWd);
IntBlkRfTk=((IntBlkFrmDep*2)+0.3);
RfBoun1=IntBlkRfSurf.PerimeterCurves();
RfBoun1per=RfBoun1.Length;
RfBounP=RfBoun1.Offset(IntBlkRfOfp);
RfBounPper=RfBounP.Length;
RfBounN=RfBoun1.Offset(IntBlkRfOfn);
RfBounNper=RfBounN.Length;
RfBoun2=RfBounPper<RfBoun1per?RfBounP:RfBounN;
//RfBoun3=RfBoun2.DivideEqually(10);
//RfBoun=PolyCurve.ByJoinedCurves(RfBoun3);
IntBlkRfSurfa=Surface.ByPatch(RfBoun2);
IntBlkRfSol=IntBlkRfSurfa.Thicken(IntBlkRfTk,true);

//Interior Block Sky Lights
IntBlkSkOf=0.15;
IntBlkSkOfp=1*(IntBlkSkOf);
IntBlkSkOfn=-1*(IntBlkSkOf);
IntBlkSkTk=0.15;
SkBounP=RfBoun1.Offset(IntBlkSkOfp);
SkBounPper=SkBounP.Length;
SkBounN=RfBoun1.Offset(IntBlkSkOfn);
SkBounNper=SkBounN.Length;
SkBounN=RfBoun1.Offset(IntBlkSkOfn);
SkBounNper=SkBounN.Length;
SkBoun=SkBounPper>RfBoun1per?SkBounP:SkBounN;
IntBlkSkSurfa=Surface.ByPatch(SkBoun);
IntBlkSkSol1=IntBlkSkSurfa.Thicken(IntBlkSkTk,true);
IntBlkSkSol2=IntBlkSkSol1.Difference(IntBlkRfSol);
IntBlkSkSol=IntBlkSkSol2.Difference(IntBlkFrmSol);

return={IntBlkFrmSol,IntBlkWlSol,IntBlkFlSol,IntBlkRfSol,IntBlkSkSol};

}

IntBlkComponents=IntBlComponents(InteriorBlocks,IntBlkCutPlanes);
IntBlkComponentsT=List.Transpose(IntBlkComponents);

//Interior Block Frames
IntBlkFrs=IntBlkComponentsT[0];
IntBlkFrs=RemoveIfNot(IntBlkFrs,"Solid");
IntBlkFrs=IntBlkFrs[0].UnionAll(IntBlkFrs);

//Interior Block Walls
IntBlkWls=IntBlkComponentsT[1];
IntBlkWls=RemoveIfNot(IntBlkWls,"Solid");
IntBlkWls=IntBlkWls[0].UnionAll(IntBlkWls);

//Interior Block Floors
IntBlkFls=IntBlkComponentsT[2];
IntBlkFls=Flatten(IntBlkFls);
IntBlkFls=RemoveIfNot(IntBlkFls,"Solid");
IntBlkFls=IntBlkFls[0].UnionAll(IntBlkFls);

//Interior Block Roofs
IntBlkRfs=IntBlkComponentsT[3];
IntBlkRfs=Flatten(IntBlkRfs);
IntBlkRfs=RemoveIfNot(IntBlkRfs,"Solid");
IntBlkRfs=IntBlkRfs[0].UnionAll(IntBlkRfs);

//Interior Block SkyLights
IntBlkSks=IntBlkComponentsT[4];
IntBlkSks=Flatten(IntBlkSks);
IntBlkSks=RemoveIfNot(IntBlkSks,"Solid");
IntBlkSks=IntBlkSks[0].UnionAll(IntBlkSks);

//Building Mass Punctured
BuildingSkinPunctured=BuildingSkinPunctured.Difference(IntBlkFrs);

//Interior Block Roof Covering;
IntBlkRfs1=IntBlkComponentsT[3];
IntBlkRfs1=Flatten(IntBlkRfs1);
IntBlkRfs1=RemoveIfNot(IntBlkRfs1,"Solid");

def Roofing(RoofSol)
{
RThkn=0.05;
RoofPol=PolySurface.BySolid(RoofSol);
RoofSur=RoofPol.Surfaces();
RoofTop=RoofSur[0];
RoofTopCen=RoofSur[0].PointAtParameter(0.5,0.5);
RoofTopSc=RoofSur[0].PointAtParameter(0.5,1);
RoofTopSc1=RoofSur[0].PointAtParameter(0.5,1.025);
RTConcen1=RoofTop.Scale(RoofTopCen,RoofTopSc,RoofTopSc1);
RTConcen1=RTConcen1.Thicken(RThkn*1);
RoofTopSc2=RoofSur[0].PointAtParameter(0.5,0.9);
RTConcen2=RoofTop.Scale(RoofTopCen,RoofTopSc,RoofTopSc2);
RTConcen2=RTConcen2.Thicken(RThkn*2);
RoofTopSc3=RoofSur[0].PointAtParameter(0.5,0.8);
RTConcen3=RoofTop.Scale(RoofTopCen,RoofTopSc,RoofTopSc3);
RTConcen3=RTConcen3.Thicken(RThkn*3);
RoofTopSc4=RoofSur[0].PointAtParameter(0.5,0.7);
RTConcen4=RoofTop.Scale(RoofTopCen,RoofTopSc,RoofTopSc4);
RTConcen4=RTConcen4.Thicken(RThkn*4);
RoofTopSc5=RoofSur[0].PointAtParameter(0.5,0.6);
RTConcen5=RoofTop.Scale(RoofTopCen,RoofTopSc,RoofTopSc5);
RTConcen5=RTConcen5.Thicken(RThkn*5);
RTConcen={RTConcen1,RTConcen2,RTConcen3,RTConcen4,RTConcen5};
RTpRfng=RTConcen[0].UnionAll(RTConcen);
return=RTpRfng;
}
IntBlkRfCvs=Roofing(IntBlkRfs1);