Guggenheim Helsinki

//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);

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);