diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua
index 430878a..5985b98 100644
--- a/LuaLibs/BeamLib.lua
+++ b/LuaLibs/BeamLib.lua
@@ -1,4 +1,4 @@
--- BeamLib.lua by Egaltech s.r.l. 2021/08/03
+-- BeamLib.lua by Egaltech s.r.l. 2021/09/12
 -- Libreria globale per Travi
 -- 2020/07/28 Corretto calcolo attacchi e uscite di lame per non uscire dalla faccia sotto.
 -- 2020/08/18 Aggiunto a GetNearestParalOpposite e GetNearestOrthoOpposite parametro opzionale vtNorm.
@@ -15,6 +15,7 @@
 -- 2021/07/08 Modifiche in MakeOneFaceBySaw per gestione taglio con due segmenti.
 -- 2021/07/15 Aggiunta GetFaceElevationFromPointDir.
 -- 2021/08/03 In MakeOneFaceBySaw mgliorata gestione tagli con normale verso il basso e da sopra.
+-- 2021/09/12 Aggiustamenti in GetNearestParalOpposite e GetNearestOrthoOpposite.
 
 -- Tabella per definizione modulo
 local BeamLib = {}
@@ -269,11 +270,8 @@ function BeamLib.GetNearestParalOpposite( vtRef, vtNorm)
       vtMyRef = vtMyRef - ( vtMyRef * vtNorm) * vtNorm
       vtMyRef:normalize()
    end
-   -- devo confrontare la componente orizzontale con quella verticale
-   local dHorSq = vtMyRef:getX() * vtMyRef:getX() + vtMyRef:getY() * vtMyRef:getY()
-   local dVertSq =vtMyRef:getZ() * vtMyRef:getZ()
-   -- se prevalente la componente orizzontale
-   if dHorSq >= dVertSq then
+   -- se prevalente una componente orizzontale (con piccolo vantaggio)
+   if abs( vtMyRef:getX()) > 0.9 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.9 * abs( vtMyRef:getZ()) then
       if abs( vtMyRef:getX()) > abs( vtMyRef:getY()) - GEO.EPS_SMALL then
          if vtMyRef:getX() > -GEO.EPS_SMALL then
             return MCH_MILL_FU.PARAL_LEFT
@@ -306,11 +304,8 @@ function BeamLib.GetNearestOrthoOpposite( vtRef, vtNorm)
       vtMyRef = vtMyRef - ( vtMyRef * vtNorm) * vtNorm
       vtMyRef:normalize()
    end
-   -- devo confrontare la componente orizzontale con quella verticale
-   local dHorSq = vtMyRef:getX() * vtMyRef:getX() + vtMyRef:getY() * vtMyRef:getY()
-   local dVertSq = vtMyRef:getZ() * vtMyRef:getZ()
-   -- se prevalente la componente orizzontale (con piccolo vantaggio)
-   if dHorSq >= 0.9 * dVertSq then
+   -- se prevalente una componente orizzontale (con piccolo vantaggio)
+   if abs( vtMyRef:getX()) > 0.9 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.9 * abs( vtMyRef:getZ()) then
       -- se prevale la componente destra/sinistra (con piccolo vantaggio)
       if abs( vtMyRef:getX()) > 0.9 * abs( vtMyRef:getY()) then
          if vtMyRef:getX() > -GEO.EPS_SMALL then
diff --git a/LuaLibs/DiceCut.lua b/LuaLibs/DiceCut.lua
index ef3e4ea..82bd6a9 100644
--- a/LuaLibs/DiceCut.lua
+++ b/LuaLibs/DiceCut.lua
@@ -1,4 +1,4 @@
--- DiceCut.lua by Egaltech s.r.l. 2021/04/27
+-- DiceCut.lua by Egaltech s.r.l. 2021/09/10
 -- Gestione dei piano paralleli nei tagli lunghi: equidistanziamento dei piani paralleli
 
 -- Tabella per definizione modulo
@@ -378,8 +378,9 @@ end
 --   vtNBond*: il versore normale della superfice limitante (se non esistono altre superfici può essere omesso)
 --   dOrthoMaxDim : massima profondità taglio se faccia singola perpendicolare facce laterali trave
 --   dCustMaxDimDice: dimensione massima customizzata, sostituisce il parametro BD.MAX_DIM_DICE
+--   bDownHead : taglio con testa da sotto
 ----------------------------------------------------------------------------------------------------------------------------------------------------
-function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPlanes, ptCBond, vtNBond, dOrthoMaxDim, dCustMaxDimDice)
+function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPlanes, ptCBond, vtNBond, dOrthoMaxDim, dCustMaxDimDice, bDownHead)
 
    local dMaxDimDice = EgtIf( dCustMaxDimDice and dCustMaxDimDice < BD.MAX_DIM_DICE, dCustMaxDimDice, BD.MAX_DIM_DICE)
    local dTolerance = 0                      -- distanza di sicurezza per i tagli ortogonali
@@ -491,6 +492,10 @@ function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPl
          if vtO:getZ() > 0.939 and abs( vtNInner:getY()) > 0.5 then
             vtO:rotate( vtNInner, 90)
          end
+         -- se taglio con testa da sotto
+         if bDownHead and vtO:getZ() > 0.05 then
+            vtO = -vtO
+         end
          -- calcolo le dimensioni dell'offset e dove posizionare la prima faccia:
          --   CopyPlane: 0 => crea la prima faccia direttamente sul punto passato
          --   CopyPlane: 1 => crea la prima faccia e tutte le altre con l'offset passato
diff --git a/LuaLibs/ProcessCut.lua b/LuaLibs/ProcessCut.lua
index df66dc9..da70554 100644
--- a/LuaLibs/ProcessCut.lua
+++ b/LuaLibs/ProcessCut.lua
@@ -1,4 +1,4 @@
--- ProcessCut.lua by Egaltech s.r.l. 2021/07/14
+-- ProcessCut.lua by Egaltech s.r.l. 2021/09/10
 -- Gestione calcolo singoli tagli di lama per Travi
 -- 2021/05/18 I due tagli con testa da sotto di un cubetto sono fatti di seguito.
 -- 2021/06/06 Correzioni per tagli con testa da sotto.
@@ -523,11 +523,11 @@ local function MakeFromDown( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead)
       local bAutoCalcSurf = true
       if bFillAreaPiece or bFillTail then
          local ptMiddle = ( b3Solid:getMin() + b3Solid:getMax()) / 2
-         ptExtra = Point3d( b3Solid:getMin():getX() + 5*GEO.EPS_SMALL, ptMiddle:getY(), ptMiddle:getZ())
+         ptExtra = Point3d( b3Solid:getMin():getX() + 5 * GEO.EPS_SMALL, ptMiddle:getY(), ptMiddle:getZ())
          vtExtra = X_AX()
          bAutoCalcSurf = false
       end
-      vCuts = DC.GetDice( EgtGetParent( Proc.Id), b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
+      vCuts = DC.GetDice( EgtGetParent( Proc.Id), b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, nil ,true)
    end
    --DC.PrintOrderCut( vCuts)
    if #vCuts > 0 then
diff --git a/LuaLibs/ProcessLongCut.lua b/LuaLibs/ProcessLongCut.lua
index 310c0d6..4ba3997 100644
--- a/LuaLibs/ProcessLongCut.lua
+++ b/LuaLibs/ProcessLongCut.lua
@@ -736,7 +736,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
             local bAddOpposite = true
             local dAddExtraPerp = 0
             -- se faccia da sotto e angolo inferiore ai 12° o faccia di fianco e angolo inferiore a 15° (al di sotto di questo angolo
-            -- l'attacco lama si comporta in modo diverso) allora calcolo il valore perpendicolare perpendicolare con la funzione CalcLeadInOutPerpGeom
+            -- l'attacco lama si comporta in modo diverso) allora calcolo il valore perpendicolare con la funzione CalcLeadInOutPerpGeom
             if ( nSide == -1 and abs(vtN:getY()) >= 0.2079) or ( abs(nSide) == 2 and abs(vtN:getZ()) >= 0.2588) then
                bAddOpposite = false
             end
@@ -757,7 +757,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus
                end
                dLioPerp = dLioPerp + dAddExtraPerp
                -------------------------------------------------------------------------------------------------------
-               -- disabilito questo calcolo dell'attacco perpendiclare perchè in alcune condizioni genera extra corsa 
+               -- disabilito questo calcolo dell'attacco perpendicolare perchè in alcune condizioni genera extra corsa 
                -------------------------------------------------------------------------------------------------------
                --[[
                -- parametri di attacco/uscita
diff --git a/LuaLibs/ProcessRidgeLap.lua b/LuaLibs/ProcessRidgeLap.lua
index 9b1b945..9940ce8 100644
--- a/LuaLibs/ProcessRidgeLap.lua
+++ b/LuaLibs/ProcessRidgeLap.lua
@@ -1,4 +1,4 @@
--- ProcessRidgeLap.lua by Egaltech s.r.l. 2021/06/15
+-- ProcessRidgeLap.lua by Egaltech s.r.l. 2021/09/10
 -- Gestione calcolo mezzolegno di testa per Travi
 
 -- Tabella per definizione modulo
@@ -25,6 +25,10 @@ end
 ---------------------------------------------------------------------
 -- Classificazione della feature
 function ProcessRidgeLap.Classify( Proc, b3Raw)
+   -- se PF con testa da sotto, ammessa qualunque orientazione
+   if BD.C_SIMM and BD.DOWN_HEAD then
+      return true, false
+   end
    -- Se più corta del limite si può fare anche da sotto
    if Proc.Box:getDimX() <= BD.GetMaxLenRidgeLapFromBottom( b3Raw:getDimZ()) then
       return true, false
@@ -89,8 +93,10 @@ function ProcessRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    end
    -- determino se di testa o di coda
    local bHead = ( vtN[vFaceOrd[2]]:getX() > 0)
+   -- determino se da lavorare con testa da sotto
+   local bDownHead = ( BD.DOWN_HEAD and vtN[vFaceOrd[3]]:getZ() < -0.1)
    -- recupero la lavorazione
-   local sCutting = ML.FindCutting( 'HeadSide')
+   local sCutting = ML.FindCutting( 'HeadSide' .. EgtIf( bDownHead, '_H2', ''))
    if not sCutting then
       local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' cutting not found in library'
       EgtOutLog( sErr)
@@ -107,6 +113,7 @@ function ProcessRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
       end
    end
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
+   local dVzLimDwnUp = EgtIf( bDownHead, -2, nil)
    -- taglio sulla faccia esterna
    if vFaceOrd[1] ~= 0 then
       -- recupero gruppo per geometria addizionale
@@ -163,7 +170,7 @@ function ProcessRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
          end
          -- lavoro la faccia
          for j = 1, #vCuts[i] do
-            local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, nOrthoOpposite, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+            local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, nOrthoOpposite, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
             if not bOk then
                return bOk, sErr
             end
@@ -174,14 +181,14 @@ function ProcessRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
       if vFaceOrd[2] ~= 0 then
          -- inserisco la lavorazione
          local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtN[vFaceOrd[3]])
-         local bOk, sErr = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+         local bOk, sErr = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
          if not bOk then return bOk, sErr end
       end
       -- taglio sulla faccia intermedia
       if vFaceOrd[3] ~= 0 then
          -- inserisco la lavorazione
          local nOrthoOpposite = BL.GetNearestOrthoOpposite( EgtIf( bHead, X_AX(), -X_AX()))
-         local bOk, sErr = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, nOrthoOpposite, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+         local bOk, sErr = BL.MakeOneFaceBySaw( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, nOrthoOpposite, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
          if not bOk then return bOk, sErr end
       end
    end