diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua
index 6709730..b3f5624 100644
--- a/LuaLibs/BeamExec.lua
+++ b/LuaLibs/BeamExec.lua
@@ -26,6 +26,9 @@
 -- 2021/12/15 Corretta CompareFeature (risultato deve essere simmetrico scambiando le feature).
 -- 2021/12/20 Ulteriore correzione a CompareFeature (caso con entrambe senza geometria).
 -- 2022/05/04 Nell'ordinamento quando si confrontano i box delle feature aggiunta verifica preliminare della loro validità.
+-- 2022/05/31 Aggiunta gestione sovramateriale per sezioni alte e larghe e informazione di eventuale creazione nuova fase dalla AddFeatureMachining.
+-- 2022/06/10 Per sezioni alte e larghe modificata la gestione del sovramateriale per considerare la presenza di feature preesistenti e eventuale parametro Q05, che determinano la presenza o meno della finitura.
+--            Create le funzioni AnalyzeHeadFeatures e AnalyzeTailFeatures. Spostate più in alto le funzioni CollectFeatures, isHeadFeature e isTailFeature.
 
 -- Tabella per definizione modulo
 local BeamExec = {}
@@ -122,163 +125,6 @@ EgtOutLog( ' BeamExec started', 1)
 EgtMdbSetGeneralParam( MCH_GP.MAXDEPTHSAFE, BD.COLL_SIC)
 EgtMdbSave()
 
--------------------------------------------------------------------------------------------------------------
---    *** Inserimento delle travi nel grezzo ***
--------------------------------------------------------------------------------------------------------------
-function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroupOk)
-
-   -- Determinazione minimo grezzo scaricabile
-   BeamExec.CalcMinUnloadableRaw( dRawW, dRawH)
-
-   -- Creazione nuovo gruppo di lavoro
-   if not bMachGroupOk then
-      local sMgName = EgtGetMachGroupNewName( 'Mach_1')
-      local NewMgId = EgtAddMachGroup( sMgName)
-      if not NewMgId then
-         local sOut = 'Errore nella creazione del gruppo di lavoro ' .. sMgName
-         return false, sOut
-      end
-   end
-
-   -- Impostazione della tavola
-   EgtSetTable( 'Tab')
-
-   -- Area tavola
-   local b3Tab = EgtGetTableArea()
-   -- Calcolo posizione estremo TR/BR della tavola rispetto a sua origine in BL
-   BD.OriXR = Point3d( b3Tab:getDimX(), EgtIf( BD.RIGHT_LOAD, 0, b3Tab:getDimY()), 0)
-   BD.PosXR = EgtIf( BD.RIGHT_LOAD, MCH_CR.BR, MCH_CR.TR)
-   
-   -- Impostazione dell'attrezzaggio di default
-   EgtImportSetup()
-
-   -- Inserimento dei pezzi con il loro grezzo
-   local Cnt = 0
-   local Len = dRawL
-   local nPrevRaw, dPrevDelta
-   local DeltaS = dOvmHead
-   local DeltaE = BD.OVM_MID
-   for i = 1, #vBeam do
-      -- assegno identificativo pezzo
-      local Pz = vBeam[i].Id
-      -- dati del pezzo
-      local b3Part = EgtGetBBoxGlob( Pz or GDB_ID.NULL, GDB_BB.EXACT)
-      local b3Solid = vBeam[i].Box
-      if b3Part:isEmpty() or b3Solid:isEmpty() then break end
-      EgtOutLog( 'PartSez=' .. EgtNumToString( b3Part:getDimY(), 1) .. 'x' .. EgtNumToString( b3Part:getDimZ(), 1), 3)
-      -- se sezione compatibile e lunghezza disponibile sufficiente
-      local PartLen = b3Solid:getDimX()
-      local PartWidth = b3Solid:getDimY()
-      local PartHeight = b3Solid:getDimZ()
-      local NextLen = Len - DeltaS - PartLen - DeltaE
-      if (( abs( PartWidth - dRawW) < 10 * GEO.EPS_SMALL  and  abs( PartHeight - dRawH) < 10 * GEO.EPS_SMALL)  or
-          ( abs( PartHeight - dRawW) < 10 * GEO.EPS_SMALL  and  abs( PartWidth - dRawH) < 10 * GEO.EPS_SMALL))  and
-         NextLen + DeltaE >= 0 then
-         -- eventuale sovramateriale di testa
-         if vBeam[i].PosX then
-            DeltaS = max( vBeam[i].PosX - ( dRawL - Len), 0)
-         end
-         -- dimensioni del grezzo
-         local CrawLen = min( PartLen + DeltaS + DeltaE, Len)
-         local Delta = CrawLen - PartLen - DeltaS
-         -- creo e posiziono il grezzo
-         local nRaw = EgtAddRawPart( Point3d(0,0,0), CrawLen, dRawW, dRawH, BD.RAWCOL)
-         EgtMoveToCornerRawPart( nRaw, BD.OriXR, BD.PosXR)
-         EgtMoveRawPart( nRaw, Vector3d( Len - dRawL, 0, 0))
-         -- assegno ordine in lavorazione
-         Cnt = Cnt + 1
-         EgtSetInfo( nRaw, 'ORD', Cnt)
-         -- creo o pulisco gruppo geometrie aggiuntive
-         if not BL.CreateOrEmptyAddGroup( Pz) then
-            local sOut = 'Error creating Additional Group in Part ' .. tostring( Pz)
-            return false, sOut
-         end
-         -- aggiungo faccia per taglio iniziale al pezzo
-         BL.AddPartStartFace( Pz, b3Solid)
-         -- se sovramateriale di testa, lo notifico
-         if DeltaS > 0.09 then
-            EgtSetInfo( nRaw, 'HOVM', DeltaS)
-            if nPrevRaw then
-               EgtSetInfo( nPrevRaw, 'BDST', DeltaS + dPrevDelta)
-            end
-         end
-         -- aggiungo faccia per taglio finale al pezzo
-         BL.AddPartEndFace( Pz, b3Solid)
-         -- inserisco il pezzo nel grezzo
-         EgtDeselectPartObjs( Pz)
-         local ptPos = b3Part:getMin() - b3Solid:getMin() + Vector3d( Delta, ( dRawW - PartWidth) / 2, ( dRawH - PartHeight) / 2)
-         EgtAddPartToRawPart( Pz, ptPos, nRaw)
-         if abs( PartWidth - dRawW) > 10 * GEO.EPS_SMALL then
-            -- rotazione attorno a centro geometria complessiva del pezzo
-            EgtRotatePartInRawPart( Pz, X_AX(), 90)
-            -- correggo per eccentricità solido rispetto a geometria complessiva del pezzo
-            local vtEccOri = b3Solid:getCenter() - b3Part:getCenter()
-            local vtEccRot = Vector3d( vtEccOri)
-            vtEccRot:rotate( X_AX(), 90)
-            EgtMovePartInRawPart( Pz, ( vtEccOri - vtEccRot))
-         end
-         -- aggiorno la lunghezza residua della barra
-         Len = Len - CrawLen
-         -- aggiorno grezzo precedente
-         nPrevRaw = nRaw
-         dPrevDelta = Delta
-      else
-         local sOut = 'Error: part L(' .. EgtNumToString( PartLen, 1) .. ') too big for raw part L(' .. EgtNumToString( Len - 0.1, 1) .. ')'
-         return false, sOut
-      end
-      -- se rimasto troppo poco grezzo, esco
-      --if Len < BD.MinRaw then break end
-      DeltaS = 0
-   end
-   if nPrevRaw then
-      EgtSetInfo( nPrevRaw, 'BDST', 10000)
-   end
-
-   -- Se rimasto materiale aggiungo grezzo dell'avanzo
-   if Len > 10 then
-      local nRaw = EgtAddRawPart( Point3d(0,0,0), Len, dRawW, dRawH, BD.RAWCOL)
-      EgtMoveToCornerRawPart( nRaw, BD.OriXR, BD.PosXR)
-      EgtMoveRawPart( nRaw, Vector3d( Len - dRawL, 0, 0))
-      -- assegno ordine in lavorazione
-      Cnt = Cnt + 1
-      EgtSetInfo( nRaw, 'ORD', Cnt)
-   end
-
-   return true
-end
-
--------------------------------------------------------------------------------------------------------------
-function BeamExec.CalcMinUnloadableRaw( dRawW, dRawH)
-   if BD.GetMinUnloadableRaw then
-      BD.MinRaw = BD.GetMinUnloadableRaw( dRawW, dRawH)
-   else
-      local H_S = 200
-      local H_L = 400
-      -- Determinazione minimo grezzo scaricabile
-      if dRawH <= H_S then
-         BD.MinRaw = BD.MINRAW_S
-      elseif dRawH <= H_L then
-         local Coeff = ( dRawH - H_S) / ( H_L - H_S)
-         BD.MinRaw = ( 1 - Coeff) * BD.MINRAW_S + Coeff * BD.MINRAW_L
-      else
-         BD.MinRaw = BD.MINRAW_L
-      end
-   end
-end
-
--------------------------------------------------------------------------------------------------------------
---    *** Inserimento delle lavorazioni nelle travi ***
--------------------------------------------------------------------------------------------------------------
-local function Verify90DegRotation( nRawId)
-   if not nRawId then return false end
-   -- dimensioni sezione trave in posizione normale (rotazione 0°)
-   local dRawW = EgtGetRawPartBBox( nRawId):getDimY()
-   local dRawH = EgtGetRawPartBBox( nRawId):getDimZ()
-   -- verifica dell'altezza rispetto alla massima larghezza
-   return ( dRawH < BD.MAX_WIDTH + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT + 10 * GEO.EPS_SMALL) or
-          ( dRawH < BD.MAX_WIDTH2 + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL)
-end
-
 -------------------------------------------------------------------------------------------------------------
 local function IsHeadFeature( Proc, b3Raw, dCurrOvmH)
    -- feature sempre di testa o coda per il gruppo
@@ -378,25 +224,6 @@ local function IsTailFeature( Proc, b3Raw, dCurrOvmH)
    return false
 end
 
--------------------------------------------------------------------------------------------------------------
-local function PrintFeatures( vProc, b3Raw)
-   EgtOutLog( ' RawBox=' .. tostring( b3Raw))
-   for i = 1, #vProc do
-      local Proc = vProc[i]
-      local sOut = string.format( ' Id=%3d Grp=%1d Prc=%3d TC=%2d/%d Flg=%2d Down=%s Side=%s Head=%s Tail=%s Fcse=%1d,%1d Diam=%.2f Fct=%2d Box=%s',
-                                  Proc.Id, Proc.Grp, Proc.Prc, Proc.TaskId, Proc.CutId,
-                                  Proc.Flg, EgtIf( Proc.Down, 'T', 'F'), EgtIf( Proc.Side, 'T', 'F'),
-                                  EgtIf( Proc.Head, 'T', 'F'), EgtIf( Proc.Tail, 'T', EgtIf( Proc.AdvTail, 'A', 'F')),
-                                  Proc.Fcs, Proc.Fce, Proc.Diam, Proc.Fct, tostring( Proc.Box))
-      -- info speciali per Block Haus Half Lap
-      if Proc.Prc == 37 then
-         local sSpec = string.format( ' N=%s Hd=%s', tostring( Proc.vtN or V_NULL()), EgtIf( Proc.HeadDir, 'T', 'F'))
-         sOut = sOut .. sSpec
-      end
-      EgtOutLog( sOut)
-   end
-end
-
 -------------------------------------------------------------------------------------------------------------
 local function CollectFeatures( PartId, b3Raw, dCurrOvmH)
    -- recupero le feature
@@ -484,6 +311,268 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH)
    return vProc
 end
 
+-------------------------------------------------------------------------------------------------------------
+local function AnalyzeHeadFeatures( b3Solid, vProc, dRawW, dRawH)
+   local nReplacedFeatureId = nil
+   local bHeadFinishingNeeded = true
+   for i = 1, #vProc do
+      local Proc = vProc[i]
+      -- controllo se esiste già una feature taglio di testa
+      if not nReplacedFeatureId then
+         if ( Proc.Grp == 1 or Proc.Grp == 2) and Proc.Prc == 10 then
+            local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
+            if ptC and vtN and AreSameVectorApprox( vtN, X_AX())  and  abs( ptC:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL then
+               nReplacedFeatureId = Proc.Id
+            end
+         end
+      end
+      if Proc.Head and Proc.Id ~= nReplacedFeatureId and Proc.Prc ~= 340 then
+         -- controllo se la feature taglia l'intera sezione; in caso positivo la finitura non è necessaria
+         bHeadFinishingNeeded = not ((abs(Proc.Box:getDimY() - dRawW) < 10 * GEO.EPS_SMALL or Proc.Box:getDimY() > dRawW) and (abs(Proc.Box:getDimZ() - dRawH) < 10 * GEO.EPS_SMALL or Proc.Box:getDimZ() > dRawH))
+      end
+   end
+   return bHeadFinishingNeeded, nReplacedFeatureId
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function AnalyzeTailFeatures( b3Solid, vProc, dRawW, dRawH)
+   local nReplacedFeatureId = nil
+   local bTailFinishingNeeded = true
+   for i = 1, #vProc do
+      local Proc = vProc[i]
+      -- controllo se esistè già una feature taglio di coda
+      if not nReplacedFeatureId then
+         if ( Proc.Grp == 1 or Proc.Grp == 2) and Proc.Prc == 10 then
+            local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
+            if ptC and vtN and AreSameVectorApprox( vtN, -X_AX())  and  abs( ptC:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL then
+               nReplacedFeatureId = Proc.Id
+            end
+         end
+      end
+      if Proc.Tail and Proc.Id ~= nReplacedFeatureId and Proc.Prc ~= 350 then
+         -- controllo se la feature taglia l'intera sezione; in caso positivo la finitura non è necessaria
+         bTailFinishingNeeded = not ((abs(Proc.Box:getDimY() - dRawW) < 10 * GEO.EPS_SMALL or Proc.Box:getDimY() > dRawW) and (abs(Proc.Box:getDimZ() - dRawH) < 10 * GEO.EPS_SMALL or Proc.Box:getDimZ() > dRawH))
+      end
+   end
+   return bTailFinishingNeeded, nReplacedFeatureId
+end
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Inserimento delle travi nel grezzo ***
+-------------------------------------------------------------------------------------------------------------
+function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, vBeam, bMachGroupOk)
+
+   -- Determinazione minimo grezzo scaricabile
+   BeamExec.CalcMinUnloadableRaw( dRawW, dRawH)
+
+   -- Creazione nuovo gruppo di lavoro
+   if not bMachGroupOk then
+      local sMgName = EgtGetMachGroupNewName( 'Mach_1')
+      local NewMgId = EgtAddMachGroup( sMgName)
+      if not NewMgId then
+         local sOut = 'Errore nella creazione del gruppo di lavoro ' .. sMgName
+         return false, sOut
+      end
+   end
+
+   -- Impostazione della tavola
+   EgtSetTable( 'Tab')
+
+   -- Area tavola
+   local b3Tab = EgtGetTableArea()
+   -- Calcolo posizione estremo TR/BR della tavola rispetto a sua origine in BL
+   BD.OriXR = Point3d( b3Tab:getDimX(), EgtIf( BD.RIGHT_LOAD, 0, b3Tab:getDimY()), 0)
+   BD.PosXR = EgtIf( BD.RIGHT_LOAD, MCH_CR.BR, MCH_CR.TR)
+   
+   -- Impostazione dell'attrezzaggio di default
+   EgtImportSetup()
+
+   -- Inserimento dei pezzi con il loro grezzo
+   local Cnt = 0
+   local Len = dRawL
+   local nPrevRaw, dPrevDelta
+   local DeltaS = dOvmHead
+   local DeltaSMin = 0
+   local DeltaE = BD.OVM_MID
+   -- controllo sezione larga e alta per considerare taglio con sega
+   local bBigSectionCut = false
+   if BD.MAX_DIM_HTCUT and BD.CUT_EXTRA_MIN and ( dRawW > 2 * BD.MAX_DIM_HTCUT - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and ( dRawH > 2 * BD.MAX_DIM_HTCUT - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) then
+      bBigSectionCut = true
+   end
+   for i = 1, #vBeam do
+      -- assegno identificativo pezzo
+      local Pz = vBeam[i].Id
+      -- dati del pezzo
+      local b3Part = EgtGetBBoxGlob( Pz or GDB_ID.NULL, GDB_BB.EXACT)
+      local b3Solid = vBeam[i].Box
+      if b3Part:isEmpty() or b3Solid:isEmpty() then break end
+      if bBigSectionCut then
+         -- lascio in coda solo il materiale necessario; il resto verrà tolto nell'head cut successivo
+         local lastB3Solid = nil
+         local dOffset = dOvmHead
+         if i > 1 then
+            lastB3Solid = vBeam[i-1].Box
+            dOffset = vBeam[i].PosX - vBeam[i-1].PosX - lastB3Solid:getDimX()
+         end
+         -- analizzo le features per valutare l'esistenza di feature head/tail che renderebbero inutili le rispettive finiture o di tagli di testa/coda sostituiti da cui leggere il parametro Q05
+         local vProc = CollectFeatures( Pz, b3Solid, 0)
+         local bSFinishingNeeded, nReplacedHeadCutFeatureId = AnalyzeHeadFeatures( b3Solid, vProc, dRawW, dRawH)
+         local iSQ05Value = nil
+         if nReplacedHeadCutFeatureId then
+            iSQ05Value = EgtGetInfo( nReplacedHeadCutFeatureId, 'Q05', 'i')
+         end
+         if ( dOffset <= BD.OVM_CHAIN_HBEAM and iSQ05Value == 0) or not bSFinishingNeeded then
+            DeltaSMin = 0
+         else
+            DeltaSMin = BD.OVM_BLADE_HBEAM
+         end
+         local bEFinishingNeeded, nReplacedTailCutFeatureId = AnalyzeTailFeatures( b3Solid, vProc, dRawW, dRawH)
+         local iEQ05Value = nil
+         if nReplacedTailCutFeatureId then
+            iEQ05Value = EgtGetInfo( nReplacedTailCutFeatureId, 'Q05', 'i')
+         end
+         if iEQ05Value == 0 or not bEFinishingNeeded then
+            DeltaE = BD.OVM_CHAIN_HBEAM
+         else
+            DeltaE = BD.OVM_CHAIN_HBEAM + BD.OVM_BLADE_HBEAM
+         end
+      end
+      EgtOutLog( 'PartSez=' .. EgtNumToString( b3Part:getDimY(), 1) .. 'x' .. EgtNumToString( b3Part:getDimZ(), 1), 3)
+      -- se sezione compatibile e lunghezza disponibile sufficiente
+      local PartLen = b3Solid:getDimX()
+      local PartWidth = b3Solid:getDimY()
+      local PartHeight = b3Solid:getDimZ()
+      local NextLen = Len - DeltaS - PartLen - DeltaE
+      if (( abs( PartWidth - dRawW) < 10 * GEO.EPS_SMALL  and  abs( PartHeight - dRawH) < 10 * GEO.EPS_SMALL)  or
+          ( abs( PartHeight - dRawW) < 10 * GEO.EPS_SMALL  and  abs( PartWidth - dRawH) < 10 * GEO.EPS_SMALL))  and
+         NextLen + DeltaE >= 0 then
+         -- eventuale sovramateriale di testa
+         if i > 1 and vBeam[i].PosX then
+            DeltaS = max( vBeam[i].PosX - ( dRawL - Len), DeltaSMin)
+         end
+         -- dimensioni del grezzo
+         local CrawLen = min( PartLen + DeltaS + DeltaE, Len)
+         local Delta = CrawLen - PartLen - DeltaS
+         -- creo e posiziono il grezzo
+         local nRaw = EgtAddRawPart( Point3d(0,0,0), CrawLen, dRawW, dRawH, BD.RAWCOL)
+         EgtMoveToCornerRawPart( nRaw, BD.OriXR, BD.PosXR)
+         EgtMoveRawPart( nRaw, Vector3d( Len - dRawL, 0, 0))
+         -- assegno ordine in lavorazione
+         Cnt = Cnt + 1
+         EgtSetInfo( nRaw, 'ORD', Cnt)
+         -- creo o pulisco gruppo geometrie aggiuntive
+         if not BL.CreateOrEmptyAddGroup( Pz) then
+            local sOut = 'Error creating Additional Group in Part ' .. tostring( Pz)
+            return false, sOut
+         end
+         -- aggiungo faccia per taglio iniziale al pezzo
+         BL.AddPartStartFace( Pz, b3Solid)
+         -- se sovramateriale di testa, lo notifico
+         if DeltaS > 0.09 then
+            EgtSetInfo( nRaw, 'HOVM', DeltaS)
+            if nPrevRaw then
+               EgtSetInfo( nPrevRaw, 'BDST', DeltaS + dPrevDelta)
+            end
+         end
+         if DeltaE > 0.09 then
+            EgtSetInfo( nRaw, 'TOVM', DeltaE)
+         end
+         -- aggiungo faccia per taglio finale al pezzo
+         BL.AddPartEndFace( Pz, b3Solid)
+         -- inserisco il pezzo nel grezzo
+         EgtDeselectPartObjs( Pz)
+         local ptPos = b3Part:getMin() - b3Solid:getMin() + Vector3d( Delta, ( dRawW - PartWidth) / 2, ( dRawH - PartHeight) / 2)
+         EgtAddPartToRawPart( Pz, ptPos, nRaw)
+         if abs( PartWidth - dRawW) > 10 * GEO.EPS_SMALL then
+            -- rotazione attorno a centro geometria complessiva del pezzo
+            EgtRotatePartInRawPart( Pz, X_AX(), 90)
+            -- correggo per eccentricità solido rispetto a geometria complessiva del pezzo
+            local vtEccOri = b3Solid:getCenter() - b3Part:getCenter()
+            local vtEccRot = Vector3d( vtEccOri)
+            vtEccRot:rotate( X_AX(), 90)
+            EgtMovePartInRawPart( Pz, ( vtEccOri - vtEccRot))
+         end
+         -- aggiorno la lunghezza residua della barra
+         Len = Len - CrawLen
+         -- aggiorno grezzo precedente
+         nPrevRaw = nRaw
+         dPrevDelta = Delta
+      else
+         local sOut = 'Error: part L(' .. EgtNumToString( PartLen, 1) .. ') too big for raw part L(' .. EgtNumToString( Len - 0.1, 1) .. ')'
+         return false, sOut
+      end
+      -- se rimasto troppo poco grezzo, esco
+      --if Len < BD.MinRaw then break end
+      DeltaS = 0
+   end
+   if nPrevRaw then
+      EgtSetInfo( nPrevRaw, 'BDST', 10000)
+   end
+
+   -- Se rimasto materiale aggiungo grezzo dell'avanzo
+   if Len > 10 then
+      local nRaw = EgtAddRawPart( Point3d(0,0,0), Len, dRawW, dRawH, BD.RAWCOL)
+      EgtMoveToCornerRawPart( nRaw, BD.OriXR, BD.PosXR)
+      EgtMoveRawPart( nRaw, Vector3d( Len - dRawL, 0, 0))
+      -- assegno ordine in lavorazione
+      Cnt = Cnt + 1
+      EgtSetInfo( nRaw, 'ORD', Cnt)
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamExec.CalcMinUnloadableRaw( dRawW, dRawH)
+   if BD.GetMinUnloadableRaw then
+      BD.MinRaw = BD.GetMinUnloadableRaw( dRawW, dRawH)
+   else
+      local H_S = 200
+      local H_L = 400
+      -- Determinazione minimo grezzo scaricabile
+      if dRawH <= H_S then
+         BD.MinRaw = BD.MINRAW_S
+      elseif dRawH <= H_L then
+         local Coeff = ( dRawH - H_S) / ( H_L - H_S)
+         BD.MinRaw = ( 1 - Coeff) * BD.MINRAW_S + Coeff * BD.MINRAW_L
+      else
+         BD.MinRaw = BD.MINRAW_L
+      end
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Inserimento delle lavorazioni nelle travi ***
+-------------------------------------------------------------------------------------------------------------
+local function Verify90DegRotation( nRawId)
+   if not nRawId then return false end
+   -- dimensioni sezione trave in posizione normale (rotazione 0°)
+   local dRawW = EgtGetRawPartBBox( nRawId):getDimY()
+   local dRawH = EgtGetRawPartBBox( nRawId):getDimZ()
+   -- verifica dell'altezza rispetto alla massima larghezza
+   return ( dRawH < BD.MAX_WIDTH + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT + 10 * GEO.EPS_SMALL) or
+          ( dRawH < BD.MAX_WIDTH2 + 10 * GEO.EPS_SMALL and dRawW < BD.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL)
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function PrintFeatures( vProc, b3Raw)
+   EgtOutLog( ' RawBox=' .. tostring( b3Raw))
+   for i = 1, #vProc do
+      local Proc = vProc[i]
+      local sOut = string.format( ' Id=%3d Grp=%1d Prc=%3d TC=%2d/%d Flg=%2d Down=%s Side=%s Head=%s Tail=%s Fcse=%1d,%1d Diam=%.2f Fct=%2d Box=%s',
+                                  Proc.Id, Proc.Grp, Proc.Prc, Proc.TaskId, Proc.CutId,
+                                  Proc.Flg, EgtIf( Proc.Down, 'T', 'F'), EgtIf( Proc.Side, 'T', 'F'),
+                                  EgtIf( Proc.Head, 'T', 'F'), EgtIf( Proc.Tail, 'T', EgtIf( Proc.AdvTail, 'A', 'F')),
+                                  Proc.Fcs, Proc.Fce, Proc.Diam, Proc.Fct, tostring( Proc.Box))
+      -- info speciali per Block Haus Half Lap
+      if Proc.Prc == 37 then
+         local sSpec = string.format( ' N=%s Hd=%s', tostring( Proc.vtN or V_NULL()), EgtIf( Proc.HeadDir, 'T', 'F'))
+         sOut = sOut .. sSpec
+      end
+      EgtOutLog( sOut)
+   end
+end
+
 -------------------------------------------------------------------------------------------------------------
 local function OrderFeatures( vProc, b3Raw)
 
@@ -931,10 +1020,10 @@ local function ClassifyFeatures( vProc, b3Raw, Stats)
 end
 
 -------------------------------------------------------------------------------------------------------------
-local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bNeedHCut, b3Raw)
+local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bNeedHCut, b3Raw, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dCurrOvmT)
    local bOk = true
    local sErr = ''
-   local bNewPhase = false
+   local nNewPhase = -1
    EgtOutLog( ' * Process ' .. tostring( Proc.Id) .. ' *', 1)
    -- se intestatura ( 1-340-X )
    if Hcut.Identify( Proc) then
@@ -943,13 +1032,11 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
    -- se separazione ( 2-350-X )
    elseif Split.Identify( Proc) then
       -- esecuzione separazione o eliminazione grezzo residuo
-      bOk, sErr = Split.Make( Proc, nPhase, nRawId, nPartId)
-      -- richiedo il passaggio alla seconda fase di lavorazione di questa trave
-      bNewPhase = true
+      bOk, sErr, nNewPhase = Split.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dCurrOvmT)
    -- se taglio ( 1/2-010-X)
    elseif Cut.Identify( Proc) then
       -- esecuzione taglio
-      bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+      bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH, nil, nil, nil, nil, nil, dCurrOvmT)
    -- se doppio taglio ( 1/2-011-X)
    elseif DoubleCut.Identify( Proc) then
       -- esecuzione doppio taglio
@@ -970,7 +1057,7 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
    -- se taglio con lama ( 0/3/4-013-X)
    elseif SawCut.Identify( Proc) then
       -- esecuzione taglio
-      bOk, sErr = SawCut.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+      bOk, sErr = SawCut.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH, dCurrOvmT)
    -- se mezzo-legno di testa ( 1/2-030-X)
    elseif RidgeLap.Identify( Proc) then
       -- esecuzione mezzo-legno di testa
@@ -992,11 +1079,11 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
    -- se giunzione francese ( 1/2-035-X)
    elseif FrenchRidgeLap.Identify( Proc) then
       -- esecuzione giunzione francese
-      bOk, sErr = FrenchRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+      bOk, sErr = FrenchRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH, dCurrOvmT)
    -- se block house front ( 3/4-038-X)
    elseif BlockHausFront.Identify( Proc) then
       -- esecuzione giunzione francese
-      bOk, sErr = BlockHausFront.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+      bOk, sErr = BlockHausFront.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH, dCurrOvmT)
    -- se tenone ( 1/2-050-X)
    elseif Tenon.Identify( Proc) then
       -- esecuzione tenone
@@ -1024,11 +1111,11 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
    -- se giunto Gerber ( 1/2-071-X)
    elseif ScarfJoint.Identify( Proc) then
       -- esecuzione giunto Gerber
-      bOk, sErr = ScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+      bOk, sErr = ScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH, dCurrOvmT)
    -- se giunto Gerber ( 1/2-070-X)
    elseif Scarf.Identify( Proc) then
       -- esecuzione giunto Gerber
-      bOk, sErr = Scarf.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+      bOk, sErr = Scarf.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH, dCurrOvmT)
    -- se giunto a gradino ( 1/2-080-X)
    elseif StepJoint.Identify( Proc) then
       -- esecuzione giunto a gradino
@@ -1063,10 +1150,10 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
       bOk, sErr = ProfHead.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
    -- se incastro tirolo ( 1/2/3/4-136-X)
    elseif TyroleanDovetail.Identify( Proc) then
-      bOk, sErr = TyroleanDovetail.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+      bOk, sErr = TyroleanDovetail.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH, dCurrOvmT)
    -- se giunto coda di rondine ( 1/2/3/4-138-X)
    elseif Dovetail.Identify( Proc) then
-      bOk, sErr = Dovetail.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
+      bOk, sErr = Dovetail.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH, dCurrOvmT)
    -- se contorno libero ( 0/3/4-250-X)
    elseif FreeContour.Identify( Proc) then
       -- esecuzione contorno
@@ -1081,7 +1168,7 @@ local function AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bN
       EgtOutLog( sErr)
       bOk = false
    end
-   return bOk, sErr, bNewPhase
+   return bOk, sErr, nNewPhase
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -1215,6 +1302,7 @@ function BeamExec.ProcessFeatures()
       -- ingombro del grezzo e sovramateriale di testa
       local b3Raw = EgtGetRawPartBBox( nRawId)
       local dCurrOvmH = EgtGetInfo( nRawId, 'HOVM', 'd') or 0
+      local dCurrOvmT = EgtGetInfo( nRawId, 'TOVM', 'd') or 0
       -- recupero le feature di lavorazione della trave
       local vProc = CollectFeatures( nPartId, b3Raw, dCurrOvmH)
       -- le ordino lungo X
@@ -1235,8 +1323,11 @@ function BeamExec.ProcessFeatures()
       SetCutsOnFrontMortises( vProc)
       -- eventuale spostamento fori sui tenoni
       MoveDrillsOnTenon( vProc)
+      -- identifico la condizione di lavorazione, in base a bSomeDown e bSomeSide
+      local sDownOrSideOrStd = 'standard'
       -- se richiesto ribaltamento (oppure rotazione)
       if ( bSomeDown or bSomeSide) and not BD.DOWN_HEAD and not BD.TURN then
+         sDownOrSideOrStd = 'down'
          -- ribalto le travi della fase corrente
          local nRId = nRawId
          while nRId do
@@ -1249,7 +1340,7 @@ function BeamExec.ProcessFeatures()
             -- creo la lavorazione
             local Proc = vProc[i]
             if Proc.Flg ~= 0 and Proc.Down then
-               local bOk, sMsg, bNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bNeedHCut, b3Raw)
+               local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, bNeedHCut, b3Raw, nOrd, sDownOrSideOrStd, nil, nil, dCurrOvmT)
                if not bOk then
                   nTotErr = nTotErr + 1
                   table.insert( Stats, {Err=1, Msg=sMsg, Rot=-2, CutId=Proc.CutId, TaskId=Proc.TaskId})
@@ -1258,8 +1349,10 @@ function BeamExec.ProcessFeatures()
                else
                   table.insert( Stats, {Err=0, Msg='', Rot=-2, CutId=Proc.CutId, TaskId=Proc.TaskId})
                end
-               -- se era taglio di separazione, aggiungo nuova fase
-               if bNewPhase then
+               -- se è taglio di separazione, verifico se ha già aggiunto una nuova fase oppure se è da creare
+               if nNewPhase > 0 then
+                  nPhase = nNewPhase
+               elseif nNewPhase == 0 then
                   BL.AddPhaseWithRawParts( nRawId, BD.OriXR, BD.PosXR, BD.RAW_OFFSET)
                   EgtRotateRawPart( nRawId, X_AX(), 180)
                   -- se grezzo successivo senza pezzi e finale, va tolto
@@ -1297,6 +1390,7 @@ function BeamExec.ProcessFeatures()
       end
       -- se richiesta rotazione
       if bSomeSide and not BD.DOWN_HEAD and not BD.TURN then
+         sDownOrSideOrStd = 'side'
          -- vettore movimento grezzi per rotazione di 90deg
          local dDeltaYZ = EgtGetRawPartBBox( nRawId):getDimY() - EgtGetRawPartBBox( nRawId):getDimZ()
          local vtMove = Vector3d( 0, dDeltaYZ / 2, dDeltaYZ / 2)
@@ -1316,7 +1410,7 @@ function BeamExec.ProcessFeatures()
             -- creo la lavorazione
             local Proc = vProc[i]
             if Proc.Flg ~= 0 and Proc.Side then
-               local bOk, sMsg, bNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw)
+               local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dCurrOvmT)
                if not bOk then
                   nTotErr = nTotErr + 1
                   table.insert( Stats, {Err=1, Msg=sMsg, Rot=-2, CutId=Proc.CutId, TaskId=Proc.TaskId})
@@ -1327,7 +1421,9 @@ function BeamExec.ProcessFeatures()
                end
                if bOk then nSideMchOk = nSideMchOk + 1 end
                -- se era taglio di separazione, aggiungo nuova fase
-               if bNewPhase then
+               if nNewPhase > 0 then
+                  nPhase = nNewPhase
+               elseif nNewPhase == 0 then
                   BL.AddPhaseWithRawParts( nRawId, BD.OriXR, BD.PosXR, BD.RAW_OFFSET)
                   if bPreMove then EgtMoveRawPart( nRawId, vtMove) end
                   EgtRotateRawPart( nRawId, X_AX(), EgtIf( BD.RIGHT_LOAD, -90, 90))
@@ -1366,12 +1462,13 @@ function BeamExec.ProcessFeatures()
          EgtSetInfo( nDispId, 'TYPE', EgtIf( not bSplitRot, 'MID', 'END2'))
          EgtSetInfo( nDispId, 'ORD', nOrd)
       end
+      sDownOrSideOrStd = 'standard'
       -- inserisco le lavorazioni non ribaltate della trave
       for i = 1, #vProc do
          -- creo la lavorazione
          local Proc = vProc[i]
          if Proc.Flg ~= 0 and ( not ( Proc.Down or Proc.Side) or BD.DOWN_HEAD or BD.TURN) then
-            local bOk, sMsg, bNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw)
+            local bOk, sMsg, nNewPhase = AddFeatureMachining( Proc, nPhase, nRawId, nPartId, dCurrOvmH, false, b3Raw, nOrd, sDownOrSideOrStd, nil, nil, dCurrOvmT)
             if not bOk then
                nTotErr = nTotErr + 1
                table.insert( Stats, {Err=1, Msg=sMsg, Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
@@ -1381,7 +1478,9 @@ function BeamExec.ProcessFeatures()
                table.insert( Stats, {Err=0, Msg='', Rot=0, CutId=Proc.CutId, TaskId=Proc.TaskId})
             end
             -- se era taglio di separazione, aggiungo nuova fase
-            if bNewPhase then
+            if nNewPhase > 0 then
+               nPhase = nNewPhase
+            elseif nNewPhase == 0 then
                BL.AddPhaseWithRawParts( nRawId, BD.OriXR, BD.PosXR, BD.RAW_OFFSET)
                -- se grezzo successivo senza pezzi e finale, va tolto
                local nNextRawId = EgtGetNextRawPart( nRawId)
diff --git a/LuaLibs/ProcessBlockHausFront.lua b/LuaLibs/ProcessBlockHausFront.lua
index 75887e4..1a1cc32 100644
--- a/LuaLibs/ProcessBlockHausFront.lua
+++ b/LuaLibs/ProcessBlockHausFront.lua
@@ -1,5 +1,6 @@
 -- ProcessBlockHausFront.lua by Egaltech s.r.l. 2020/08/03
 -- Gestione calcolo giunzione block house in testa
+-- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 
 -- Tabella per definizione modulo
 local ProcessBlockHausFront = {}
@@ -43,7 +44,10 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessBlockHausFront.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+function ProcessBlockHausFront.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTail)
+   if not dOvmTail then
+      dOvmTail = BD.OVM_MID
+   end
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ingombro del pezzo
@@ -141,7 +145,7 @@ function ProcessBlockHausFront.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
          bCut = false
       end
       -- se di coda e coincide con taglio di separazione, non va fatto
-      if not bHead and AreSameVectorApprox( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+      if not bHead and AreSameVectorApprox( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
          bCut = false
       end
       -- se va fatto, inserisco la lavorazione
@@ -232,7 +236,7 @@ function ProcessBlockHausFront.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
             bCut = false
          end
          -- se di coda e coincide con taglio di separazione, non va fatto
-         if not bHead and AreSameVectorApprox( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+         if not bHead and AreSameVectorApprox( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
             bCut = false
          end
          -- se va fatto, inserisco la lavorazione
diff --git a/LuaLibs/ProcessCut.lua b/LuaLibs/ProcessCut.lua
index 5cf8ac5..863e335 100644
--- a/LuaLibs/ProcessCut.lua
+++ b/LuaLibs/ProcessCut.lua
@@ -8,7 +8,8 @@
 -- 2022/01/26 Taglio da sotto orizzontale deve avere direzione di riferimento ortogonale -Z.
 -- 2022/02/02 Modifiche per tagli di coda spostati prima come lavorazione su pezzi a caduta.
 -- 2022/02/06 Correzioni per tagli di coda spostati prima.
-
+-- 2022/05/31 Alcune modifiche per utilizzare la ProcessCut.Make in ProcessSplit e ProcessHeadCut, per le sezioni alte e larghe.
+-- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 -- Tabella per definizione modulo
 local ProcessCut = {}
 
@@ -221,9 +222,11 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione con testa da sopra
-local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut)
-   -- ingombro del grezzo
-   local b3Raw = EgtGetRawPartBBox( nRawId)
+local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes)
+   if not b3Raw then
+      -- ingombro del grezzo
+      b3Raw = EgtGetRawPartBBox( nRawId)
+   end
    -- ingombro del pezzo
    local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
    -- dati geometrici del taglio
@@ -329,7 +332,11 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
          vtExtra = X_AX()
          bAutoCalcSurf = false
       end
-      vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
+      if bForced then 
+         vCuts = DC.GetDice( nAddGrpId, b3Raw, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
+      else
+         vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA)
+      end
       -- se taglio sborda in coda e non è stato inserito nessun taglio a cubetti, lo rilancio con le dimensioni customizzate
       if ( bFillTail or bCustDiceCut) and #vCuts == 0 then
          vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC, vtN, bAutoCalcSurf, ptExtra, vtExtra, dMaxVertDepth - BD.CUT_EXTRA, Proc.Box:getDimY())
@@ -435,7 +442,7 @@ local function MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, b
                end
                local dVzLimDwnUp = dNzLimDwnUp
                if not BD.C_SIMM and vtN:getZ() > 0.707 then dVzLimDwnUp = -0.708 end
-               local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
+               local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, dVzLimDwnUp, dExtraCut, BD.CUT_SIC, 0, 0, 0, sNotes, b3Raw)
                if not bOk then return bOk, sErr end
             end
          end
@@ -664,10 +671,14 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bUpdateIng)
-   -- ingombro del grezzo
-   local b3Raw = EgtGetRawPartBBox( nRawId)
-   -- ingombro del pezzo
+function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes, dOvmTail, bUpdateIng)
+   if not dOvmTail then
+      dOvmTail = BD.OVM_MID
+   end
+   if not b3Raw then
+      -- ingombro del grezzo
+      b3Raw = EgtGetRawPartBBox( nRawId)
+   end
    local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
    if not b3Solid then
       local sErr = 'Error : part box not found'
@@ -677,21 +688,23 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
    -- dati geometrici del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- se taglio di testa
-   if Proc.Head then
-      -- se coincide con il taglio di separazione precedente, non va fatto
-      if AreSameVectorApprox( vtN, X_AX())  and  abs( ptC:getX() - b3Raw:getMax():getX() + dOvmHead) < 10 * GEO.EPS_SMALL then
+   if not bForced then
+      if Proc.Head then
+         -- se coincide con il taglio di separazione precedente, non va fatto
+         if AreSameVectorApprox( vtN, X_AX())  and  abs( ptC:getX() - b3Raw:getMax():getX() + dOvmHead) < 10 * GEO.EPS_SMALL then
+            return true
+         end
+      -- altrimenti taglio di coda
+      else
+         -- se coincide con taglio di separazione, non va fatto
+         if AreSameVectorApprox( vtN, - X_AX())  and  abs( ptC:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
+            return true
+         end
+      end
+      -- se coincide con un taglio frontale non va fatto
+      if Proc.CutFront then
          return true
       end
-   -- altrimenti taglio di coda
-   else
-      -- se coincide con taglio di separazione, non va fatto
-      if AreSameVectorApprox( vtN, - X_AX())  and  abs( ptC:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
-         return true
-      end
-   end
-   -- se coincide con un taglio frontale non va fatto
-   if Proc.CutFront then
-      return true
    end
    -- abilitazione lavorazione da sotto (testa da sotto e direzione normale sotto -20deg e sbandato oltre 1deg oppure sezione larga o pezzo corto)
    local bDownHead = ( BD.DOWN_HEAD and vtN:getZ() < -0.341 and
@@ -709,7 +722,7 @@ function ProcessCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom,
    end
    -- se taglio con testa da sopra
    if not bDownHead and not bDownTurn then
-      local bOk, sErr = MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut)
+      local bOk, sErr = MakeFromTop( sCutting, Proc, nPhase, nRawId, nPartId, dOvmHead, bFromBottom, bCustDiceCut, bForced, b3Raw, sNotes)
       if not bOk then return false, sErr end
    -- altrimenti taglio con testa da sotto
    else
diff --git a/LuaLibs/ProcessDoubleCut.lua b/LuaLibs/ProcessDoubleCut.lua
index 910a5ff..ee182d0 100644
--- a/LuaLibs/ProcessDoubleCut.lua
+++ b/LuaLibs/ProcessDoubleCut.lua
@@ -176,7 +176,7 @@ end
 -- Applicazione della lavorazione
 function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- se singola faccia, passo a quella lavorazione
-   if Proc.Fct == 1 then return Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, true) end
+   if Proc.Fct == 1 then return Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, bForced, b3Raw, sNotes, dOvmTail, true) end
    -- ingombro del grezzo
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ingombro del pezzo
@@ -237,7 +237,7 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
          -- applico lavorazione
          local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Add, Fct = 1, Flg = Proc.Flg,
                            Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
-         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, true)
+         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, bForced, b3Raw, sNotes, dOvmTail, true)
          if not bOk then return bOk, sErr end
       end
       -- creo piano di taglio coincidente con la seconda faccia e lo lavoro
@@ -249,7 +249,7 @@ function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
          -- applico lavorazione
          local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Add, Fct = 1, Flg = Proc.Flg,
                            Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
-         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, true)
+         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, nil, nil, bForced, b3Raw, sNotes, dOvmTail, true)
          if not bOk then return bOk, sErr end
       end
    -- altrimenti concavo
diff --git a/LuaLibs/ProcessDovetail.lua b/LuaLibs/ProcessDovetail.lua
index c62abe9..0089713 100644
--- a/LuaLibs/ProcessDovetail.lua
+++ b/LuaLibs/ProcessDovetail.lua
@@ -1,5 +1,6 @@
 -- ProcessDovetail.lua by Egaltech s.r.l. 2021/02/04
 -- Gestione calcolo giunzione coda di rondine
+-- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 
 -- Tabella per definizione modulo
 local ProcessDovetail = {}
@@ -1380,7 +1381,7 @@ local function Make2Faces( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Sol
 end
 
 ---------------------------------------------------------------------
-local function MakeAuxCut( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid)
+local function MakeAuxCut( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, dOvmTail)
 
    -- recupero la geometria ausiliaria
    local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
@@ -1427,7 +1428,7 @@ local function MakeAuxCut( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Sol
       return true
    end
    -- verifico se coincide con taglio di coda
-   if not bHead and AreSameVectorApprox( vtN, - X_AX())  and  abs( ptC:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+   if not bHead and AreSameVectorApprox( vtN, - X_AX())  and  abs( ptC:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
       return true
    end
    -- inserisco la lavorazione
@@ -1710,7 +1711,10 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessDovetail.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+function ProcessDovetail.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTail)
+   if not dOvmTail then
+      dOvmTail = BD.OVM_MID
+   end
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- in base al tipo di feature attribuisco il significato dei parametri Q
@@ -1735,7 +1739,7 @@ function ProcessDovetail.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- se ha due facce ( allora è di testa o coda)
    if Proc.Fct == 2 then
       -- eventuale taglio di testa o coda
-      local bAuxOk, sAuxErr = MakeAuxCut( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid)
+      local bAuxOk, sAuxErr = MakeAuxCut( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, dOvmTail)
       if not bAuxOk then return bAuxOk, sAuxErr end
       -- lavorazione della feature
       local bOk, sErr = Make2Faces( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, bForceUseRough)
@@ -1743,7 +1747,7 @@ function ProcessDovetail.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- se ha 3 facce ed è di testa o coda
    elseif Proc.Fct == 3 and ( Proc.Head or Proc.Tail) then
       -- eventuale taglio di testa o coda
-      local bAuxOk, sAuxErr = MakeAuxCut( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid)
+      local bAuxOk, sAuxErr = MakeAuxCut( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, dOvmTail)
       if not bAuxOk then return bAuxOk, sAuxErr end
       -- lavorazione della feature
       if bForceUseRough then
diff --git a/LuaLibs/ProcessFrenchRidgeLap.lua b/LuaLibs/ProcessFrenchRidgeLap.lua
index 67ad4dd..160ca5a 100644
--- a/LuaLibs/ProcessFrenchRidgeLap.lua
+++ b/LuaLibs/ProcessFrenchRidgeLap.lua
@@ -1,5 +1,6 @@
 -- ProcessFrenchRidgeLap.lua by Egaltech s.r.l. 2020/02/11
 -- Gestione calcolo giunzione francese
+-- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 
 -- Tabella per definizione modulo
 local ProcessFrenchRidgeLap = {}
@@ -38,7 +39,10 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessFrenchRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+function ProcessFrenchRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTail)
+   if not dOvmTail then
+      dOvmTail = BD.OVM_MID
+   end
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ingombro del pezzo
@@ -191,7 +195,7 @@ function ProcessFrenchRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
             bCut = false
          end
          -- se di coda e coincide con taglio di separazione, non va fatto
-         if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX())  and  abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+         if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX())  and  abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
             bCut = false
          end
          -- se va fatto, inserisco la lavorazione
@@ -211,7 +215,7 @@ function ProcessFrenchRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
             bCut = false
          end
          -- se di coda e coincide con taglio di separazione, non va fatto
-         if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX())  and  abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+         if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX())  and  abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
             bCut = false
          end
          -- se va fatto, inserisco la lavorazione
diff --git a/LuaLibs/ProcessHeadCut.lua b/LuaLibs/ProcessHeadCut.lua
index 81be523..4fd7316 100644
--- a/LuaLibs/ProcessHeadCut.lua
+++ b/LuaLibs/ProcessHeadCut.lua
@@ -1,5 +1,7 @@
 -- ProcessSplit.lua by Egaltech s.r.l. 2022/06/07
 -- Gestione calcolo tagli di testa per Travi
+-- 2022/05/31 Aggiunta gestione sezioni alte e larghe con taglio di tipo diceCut.
+-- 2022/06/10 Per sezioni alte e larghe aggiunta gestione finitura in base a sovramateriale e a parametro Q05 dell' eventuale lavorazione sostituita.
 
 -- Tabella per definizione modulo
 local ProcessHeadCut = {}
@@ -8,6 +10,8 @@ local ProcessHeadCut = {}
 require( 'EgtBase')
 local BL = require( 'BeamLib')
 local Fbs = require( 'FacesBySaw')
+local Cut = require( 'ProcessCut')
+local Pocket = require( 'FaceByPocket')
 
 EgtOutLog( ' ProcessHeadCut started', 1)
 
@@ -170,10 +174,11 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    end
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
    -- caratteristiche taglio
-   local bHorizCut = (( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA)
    local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, BD.MAX_DIM_HTCUT_HBEAM)
-   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
-   local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL)
+   local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and ( b3Raw:getDimZ() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA)
+   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL)
    -- dati geometrici del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- se non obbligatorio e coincide con inizio grezzo, non va fatto
@@ -183,8 +188,33 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut
    -- determino se più tagli con offset
    local nCuts = max( ceil( dOvmHead / ( BD.MAX_LEN_SCRAP_START or BD.MAX_LEN_SCRAP)), 1)
    local dOffsL = dOvmHead / nCuts
+   -- se taglio per sezioni alte e larghe
+   if bBigSectionCut then
+      if dOvmHead > 0 then
+         -- se finitura con lama
+         if not nOriId or EgtGetInfo( nOriId, 'Q05', 'i') == 1 or EgtGetInfo( nOriId, 'Q05', 'i') == 0 then
+            local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT)
+            if not bOk then return bOk, sErr end
+         -- se finitura con truciolatore
+         elseif EgtGetInfo( nOriId, 'Q05', 'i') == 2 then
+            local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+            if not b3Solid then
+               local sErr = 'Error : part box not found'
+               EgtOutLog( sErr)
+               return false, sErr
+            end
+            local sPocketing = ML.FindPocketing( 'OpenPocket', nil, 0)
+            if not sPocketing then
+               local sErr = 'Error : pocketing not found in library'
+               EgtOutLog( sErr)
+               return false, sErr
+            end
+            local bOk, sErr = Pocket.Make( Proc, Proc.Id, 0, sPocketing, nPartId, b3Solid)
+            if not bOk then return bOk, sErr end
+         end
+      end
    -- se tagli standard
-   if not bDoubleHorizCut then
+   elseif not bDoubleHorizCut then
       -- flag di lavorazione faccia
       local nOrthoOpposite = EgtIf( bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_FRONT)
       -- calcolo extra taglio ed accorciamento
diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua
index d2ecaf2..42fba8e 100644
--- a/LuaLibs/ProcessLapJoint.lua
+++ b/LuaLibs/ProcessLapJoint.lua
@@ -42,6 +42,7 @@
 -- 2022/04/28 Lavorazione BH forzata sempre OneWay.
 -- 2022/05/04 Corretta classificazione due facce sotto. Modificati criteri assegnazione due facce alla coda.
 -- 2022/05/24 Miglioramenti vari per BH, compreso controlli per lavorazione da sotto.
+-- 2022/05/31 Rese globali le funzioni GetChainSawBlockedAxis e GetChainSawInitAngs per essere richiamate dalla ProcessSplit per taglio sega a catena in sezioni alte e larghe.
 -- 2022/06/13 Modifiche per feature lunga con due facce non equivalenti a taglio long. doppio o singolo con faccia terminale.
 -- 2022/06/15 Correzione calcolo normale alla faccia per sega catena di fianco.
 
@@ -257,7 +258,7 @@ local function TestElleShape4( Proc)
 end
 
 ---------------------------------------------------------------------
-local function GetChainSawBlockedAxis( nInd)
+function ProcessLapJoint.GetChainSawBlockedAxis( nInd)
    if BD.GetChainSawBlockedAxis then
       return BD.GetChainSawBlockedAxis( nInd)
    else
@@ -270,7 +271,7 @@ local function GetChainSawBlockedAxis( nInd)
 end
 
 ---------------------------------------------------------------------
-local function GetChainSawInitAngs( vtN, vtO, nInd)
+function ProcessLapJoint.GetChainSawInitAngs( vtN, vtO, nInd)
    if BD.GetChainSawInitAngs then
       return BD.GetChainSawInitAngs( vtN, vtO, nInd)
    else
@@ -3052,8 +3053,8 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                EgtSetMachiningParam( MCH_MP.ENDADDLEN, EgtIf( bOpenEnd, 0, - dSawWidth / 2))
             end
             -- imposto angolo 3° asse rot e eventuale angolo suggerito per inizio
-            EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, GetChainSawBlockedAxis( 1))
-            EgtSetMachiningParam( MCH_MP.INITANGS, GetChainSawInitAngs( vtN, rfFac:getVersZ(), 1))
+            EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, ProcessLapJoint.GetChainSawBlockedAxis( 1))
+            EgtSetMachiningParam( MCH_MP.INITANGS, ProcessLapJoint.GetChainSawInitAngs( vtN, rfFac:getVersZ(), 1))
             -- imposto offset radiale
             local dOffs = ( i - 1) * dStep
             EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
@@ -3075,8 +3076,8 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                   return false, sErr
                end
                -- impostazione alternativa angolo 3° asse rot
-               EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, GetChainSawBlockedAxis( 2))
-               EgtSetMachiningParam( MCH_MP.INITANGS, GetChainSawInitAngs( vtN, rfFac:getVersZ(), 2))
+               EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, ProcessLapJoint.GetChainSawBlockedAxis( 2))
+               EgtSetMachiningParam( MCH_MP.INITANGS, ProcessLapJoint.GetChainSawInitAngs( vtN, rfFac:getVersZ(), 2))
                if not ML.ApplyMachining( true, false) then
                   local _, sErr = EgtGetLastMachMgrError()
                   EgtSetOperationMode( nMchFId, false)
@@ -3120,8 +3121,8 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                -- imposto uso del lato faccia
                EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
                -- imposto angolo 3° asse rot
-               EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, GetChainSawBlockedAxis( 1))
-               EgtSetMachiningParam( MCH_MP.INITANGS, GetChainSawInitAngs( vtNL, vtOrtho, 1))
+               EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, ProcessLapJoint.GetChainSawBlockedAxis( 1))
+               EgtSetMachiningParam( MCH_MP.INITANGS, ProcessLapJoint.GetChainSawInitAngs( vtNL, vtOrtho, 1))
                -- imposto offset radiale
                local dOffs = ( i - 1) * dStep
                EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
@@ -3151,8 +3152,8 @@ local function MakeByChainOrSaw( Proc, nPhase, nRawId, nPartId, nFacInd,
                      return false, sErr
                   end
                   -- impostazione alternativa angolo 3° asse rot
-                  EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, GetChainSawBlockedAxis( 2))
-                  EgtSetMachiningParam( MCH_MP.INITANGS, GetChainSawInitAngs( vtNL, vtOrtho, 2))
+                  EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, ProcessLapJoint.GetChainSawBlockedAxis( 2))
+                  EgtSetMachiningParam( MCH_MP.INITANGS, ProcessLapJoint.GetChainSawInitAngs( vtNL, vtOrtho, 2))
                   if not ML.ApplyMachining( true, false) then
                      local _, sErr = EgtGetLastMachMgrError()
                      EgtSetOperationMode( nMchFId, false)
@@ -4477,8 +4478,8 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                end
                local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nLundIdFace, GDB_ID.ROOT)
                -- imposto angolo 3° asse rot
-               EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, GetChainSawBlockedAxis( 1))
-               EgtSetMachiningParam( MCH_MP.INITANGS, GetChainSawInitAngs( vtN, vtOrtho, 1))
+               EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, ProcessLapJoint.GetChainSawBlockedAxis( 1))
+               EgtSetMachiningParam( MCH_MP.INITANGS, ProcessLapJoint.GetChainSawInitAngs( vtN, vtOrtho, 1))
                -- imposto offset radiale
                local dOffs = ( i - 1) * dStep
                EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
@@ -4498,8 +4499,8 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa
                      EgtSetOperationMode( nMchFId, false)
                      return false, sErr
                   end
-                  EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, GetChainSawBlockedAxis( 2))
-                  EgtSetMachiningParam( MCH_MP.INITANGS, GetChainSawInitAngs( vtN, vtOrtho, 2))
+                  EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, ProcessLapJoint.GetChainSawBlockedAxis( 2))
+                  EgtSetMachiningParam( MCH_MP.INITANGS, ProcessLapJoint.GetChainSawInitAngs( vtN, vtOrtho, 2))
                   if not ML.ApplyMachining( true, false) then
                      local _, sErr = EgtGetLastMachMgrError()
                      EgtSetOperationMode( nMchFId, false)
diff --git a/LuaLibs/ProcessSawCut.lua b/LuaLibs/ProcessSawCut.lua
index 8e800d5..37793e4 100644
--- a/LuaLibs/ProcessSawCut.lua
+++ b/LuaLibs/ProcessSawCut.lua
@@ -1,5 +1,6 @@
 -- ProcessSawCut.lua by Egaltech s.r.l. 2022/03/07
 -- Gestione calcolo taglio di lama per Travi
+-- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 
 -- Tabella per definizione modulo
 local ProcessSawCut = {}
@@ -36,7 +37,10 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessSawCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+function ProcessSawCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTail)
+   if not dOvmTail then
+      dOvmTail = BD.OVM_MID
+   end
    -- ingombro del grezzo
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ingombro del pezzo
@@ -71,7 +75,7 @@ function ProcessSawCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    -- altrimenti taglio di coda
    else
       -- se coincide con taglio di separazione, non va fatto
-      if AreSameVectorApprox( vtN, - X_AX())  and  abs( ptC:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+      if AreSameVectorApprox( vtN, - X_AX())  and  abs( ptC:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
          return true
       end
    end
diff --git a/LuaLibs/ProcessScarfJoint.lua b/LuaLibs/ProcessScarfJoint.lua
index 0f67f60..22b7a28 100644
--- a/LuaLibs/ProcessScarfJoint.lua
+++ b/LuaLibs/ProcessScarfJoint.lua
@@ -1,6 +1,7 @@
 -- ProcessScarfJoint.lua by Egaltech s.r.l. 2021/06/28
 -- Gestione calcolo giunto Gerber per Travi
 -- 2021/06/28 Aggiunto extra-taglio alle lamate orizzontali.
+-- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 
 -- Tabella per definizione modulo
 local ProcessScarfJoint = {}
@@ -198,7 +199,10 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTail)
+   if not dOvmTail then
+      dOvmTail = BD.OVM_MID
+   end
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ingombro del pezzo
@@ -401,7 +405,7 @@ function ProcessScarfJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
          bCut = false
       end
       -- se di coda e coincide con taglio di separazione, non va fatto
-      if not bHead and AreSameVectorApprox( vtN[vFaceOrd[5]], - X_AX())  and  abs( ptC[vFaceOrd[5]]:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+      if not bHead and AreSameVectorApprox( vtN[vFaceOrd[5]], - X_AX())  and  abs( ptC[vFaceOrd[5]]:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
          bCut = false
       end
       -- se va fatto, inserisco la lavorazione
diff --git a/LuaLibs/ProcessSimpleScarf.lua b/LuaLibs/ProcessSimpleScarf.lua
index 67da1d5..e25baf4 100644
--- a/LuaLibs/ProcessSimpleScarf.lua
+++ b/LuaLibs/ProcessSimpleScarf.lua
@@ -1,5 +1,6 @@
 -- ProcessSimpleScarf.lua by Egaltech s.r.l. 2020/06/04
 -- Gestione calcolo giunto Gerber per Travi
+-- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 
 -- Tabella per definizione modulo
 local ProcessSimpleScarf = {}
@@ -124,7 +125,10 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTail)
+   if not dOvmTail then
+      dOvmTail = BD.OVM_MID
+   end
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- ingombro del pezzo
@@ -208,7 +212,7 @@ function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
          bCut = false
       end
       -- se di coda e coincide con taglio di separazione, non va fatto
-      if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX())  and  abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+      if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX())  and  abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
          bCut = false
       end
       -- se va fatto, inserisco la lavorazione
diff --git a/LuaLibs/ProcessSplit.lua b/LuaLibs/ProcessSplit.lua
index 2416ee7..2153567 100644
--- a/LuaLibs/ProcessSplit.lua
+++ b/LuaLibs/ProcessSplit.lua
@@ -1,5 +1,7 @@
 -- ProcessSplit.lua by Egaltech s.r.l. 2022/06/07
 -- Gestione calcolo tagli di separazione per Travi
+-- 2022/05/31 Aggiunta gestione sezioni alte e larghe con taglio con sega a catena seguito da rifinitura con lama (aggiunta funzione MakeSplitByChainSaw); gestione eventuale creazione nuova fase dall'interno della Make.
+-- 2022/06/10 Per sezioni alte e larghe aggiunta gestione finitura in base a sovramateriale e a parametro Q05 dell' eventuale lavorazione sostituita.
 
 -- Tabella per definizione modulo
 local ProcessSplit = {}
@@ -8,6 +10,9 @@ local ProcessSplit = {}
 require( 'EgtBase')
 local BL = require( 'BeamLib')
 local Fbs = require( 'FacesBySaw')
+local LapJoint = require( 'ProcessLapJoint')
+local Cut = require( 'ProcessCut')
+local Pocket = require( 'FaceByPocket')
 
 EgtOutLog( ' ProcessSplit started', 1)
 
@@ -140,9 +145,94 @@ local function MakeChamfer( nOriId, Proc, nPhase, nRawId, nPartId, dOvmHead)
    return true, nil
 end
 
+---------------------------------------------------------------------
+-- lavorazione con sega a catena per sezioni alte e larghe
+local function MakeSplitByChainSaw( nSurfId, nFaceUse, dDepth, sNotes, dOffs)
+   -- Recupero i dati dell'utensile
+   local sSawing = ML.FindSawing('Sawing')
+   local dMaxMat = 0
+   local dSawCornerRad = 0
+   local dSawThick = 0
+   -- se non trova una lavorazione di sawing esco
+   if not sSawing then
+      local sErr = 'Error : Sawing not found in library'
+      EgtOutLog( sErr)
+      return false, sErr, 'MNF'
+   else
+      -- recupero i dati dell'utensile
+      if EgtMdbSetCurrMachining( sSawing) then
+         local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
+         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
+            dMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dMaxMat
+            dSawThick = EgtTdbGetCurrToolParam( MCH_TP.THICK) or dSawThick
+            dSawCornerRad = EgtTdbGetCurrToolParam( MCH_TP.CORNRAD) or dSawCornerRad
+         end
+      end
+   end
+   -- inserisco la lavorazione di sawing
+   local sName = 'Csaw_' .. ( EgtGetName( nSurfId) or tostring( nSurfId)) .. '_1'
+   local nMchFId = EgtAddMachining( sName, sSawing)
+   if not nMchFId then
+      local sErr = 'Error adding machining ' .. sName .. '-' .. sSawing
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   sName = EgtGetOperationName( nMchFId)
+   -- aggiungo geometria
+   EgtSetMachiningGeometry( {{ nSurfId, 0}})
+   -- imposto uso del lato faccia
+   EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
+   -- imposto angolo 3° asse rot
+   EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, LapJoint.GetChainSawBlockedAxis( 2))
+   local _, vtN = EgtSurfTmFacetCenter( nSurfId, 0, GDB_ID.ROOT)
+   vtOrthO = BL.GetVersRef( nFaceUse)
+   EgtSetMachiningParam( MCH_MP.INITANGS, LapJoint.GetChainSawInitAngs( vtN, vtOrtho, 2))
+   -- imposto offset radiale per mantenere il materiale in coda per la finitura
+   EgtSetMachiningParam( MCH_MP.OFFSR, dOffs)
+   -- imposto allungamento percorso iniziale e finale a zero
+   EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0)
+   EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
+   -- faccio in modo che l'attacco della lama sia dal lato opposto rispetto al corpo macchina
+   EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
+   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
+   if dMaxMat >= dDepth then
+      EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
+   -- se massimo affondamento utensile inferiore fessura, setto affondamento ed emetto warning
+   else
+      EgtSetMachiningParam( MCH_MP.DEPTH, dMaxMat)
+      sWarn = 'Warning : elevation bigger than max tool depth'
+      EgtOutLog( sWarn)
+   end
+   -- eventuali note
+   if sNotes and #sNotes > 0 then EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) end
+   -- eseguo
+   if not ML.ApplyMachining( true, false) then
+      if EgtGetOutstrokeInfo() then
+         local _, sErr = EgtGetLastMachMgrError()
+         EgtSetOperationMode( nMchFId, false)
+         return false, sErr
+      end
+      -- impostazione alternativa angolo 3° asse rot
+      EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, LapJoint.GetChainSawBlockedAxis( 1))
+      EgtSetMachiningParam( MCH_MP.INITANGS, LapJoint.GetChainSawInitAngs( vtN, vtOrtho, 1))
+      if not ML.ApplyMachining( true, false) then
+         local _, sErr = EgtGetLastMachMgrError()
+         EgtSetOperationMode( nMchFId, false)
+         return false, sErr
+      end
+   end
+   if EgtIsMachiningEmpty() then
+      _, sWarn = EgtGetMachMgrWarning( 0)
+      EgtSetOperationMode( nMchFId, false)
+      return false, sWarn
+   end
+   --end
+   return true, sName, nMchFId
+end
+
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId)
+function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrStd, bPreMove, vtMove, dOvmTail)
    -- ingombro del grezzo
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- inserimento smussi
@@ -170,10 +260,11 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId)
    end
    local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
    -- caratteristiche taglio
-   local bHorizCut = (( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA)
    local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, BD.MAX_DIM_HTCUT_HBEAM)
-   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
-   local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA  + 10 * GEO.EPS_SMALL)
+   local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and ( b3Raw:getDimZ() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and ( b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA))
+   local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL)
+   local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA  + 10 * GEO.EPS_SMALL)
    -- dati geometrici del taglio
    local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
    -- flag di lavorazione faccia
@@ -195,8 +286,84 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId)
          b3Raw:Add( b3NextRaw)
       end
    end
+   -- se taglio per pezzi alti e larghi
+   local nNewPhase = 0
+   if bBigSectionCut then
+      local bFinishingNeeded = false
+      if bSplit then
+         --taglio sega a catena
+         local cutDepth = 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN
+         local sNotesSplit = 'Presplit;'
+         local dOffs = 0
+         if dOvmTail > BD.OVM_CHAIN_HBEAM then
+            dOffs = dOvmTail - BD.OVM_CHAIN_HBEAM
+            bFinishingNeeded = true
+         end
+         local bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_BACK, cutDepth, sNotesSplit, dOffs)
+         if not bOk then return bOk, sErr, nNewPhase end
+         sNotesSplit = 'Split;'
+         bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_FRONT, cutDepth, sNotesSplit, dOffs)
+         if not bOk then return bOk, sErr, nNewPhase end
+         -- creo nuova fase per successiva finitura
+         BL.AddPhaseWithRawParts( nRawId, BD.OriXR, BD.PosXR, BD.RAW_OFFSET)
+         nNewPhase = EgtGetCurrPhase()
+         nDispId = EgtGetPhaseDisposition( nNewPhase)
+         if sDownOrSideOrStd == 'down' then
+            EgtRotateRawPart( nRawId, X_AX(), 180)
+            EgtSetInfo( nDispId, 'TYPE', 'MID2')
+            EgtSetInfo( nDispId, 'ROT', -2)
+         elseif sDownOrSideOrStd == 'side' then
+            if bPreMove then EgtMoveRawPart( nRawId, vtMove) end
+            EgtRotateRawPart( nRawId, X_AX(), EgtIf( BD.RIGHT_LOAD, -90, 90))
+            if not bPreMove then EgtMoveRawPart( nRawId, vtMove) end
+            EgtSetInfo( nDispId, 'TYPE', 'MID2')
+            EgtSetInfo( nDispId, 'ROT', -1)
+         else
+            EgtSetInfo( nDispId, 'TYPE', 'END')
+         end
+         EgtSetInfo( nDispId, 'ORD', nOrd)
+         -- se grezzo successivo senza pezzi e finale, va tolto
+         local nNextRawId = EgtGetNextRawPart( nRawId)
+         if nNextRawId  and  EgtGetPartInRawPartCount( nNextRawId) == 0  and  EgtGetRawPartBBox( nNextRawId):getDimX() < BD.MinRaw then
+            EgtRemoveRawPartFromCurrPhase( nNextRawId)
+         end   
+         -- fine creazione nuova fase
+      end
+      -- se è necessaria la finitura
+      if bFinishingNeeded or not bSplit then
+         local sNotes, sNotesFinal
+         -- se non c'è separazione va aggiunta la nota Cut per l'ultimo taglio e Precut per i tagli precedenti
+         if not bSplit then
+            sNotes = 'Precut;'
+            sNotesFinal = 'Cut;'
+         end
+         -- se finitura con lama
+         if not nOriId or EgtGetInfo( nOriId, 'Q05', 'i') == 1 or EgtGetInfo( nOriId, 'Q05', 'i') == 0 or not bSplit then
+            local bOk, sErr = Cut.Make( Proc, nNewPhase, nRawId, nPartId, dLenEndRaw, nil, false, true, b3Raw, sNotes, dCurrOvmT)
+            if not bOk then return bOk, sErr, nNewPhase end
+         -- se finitura con truciolatore
+         elseif EgtGetInfo( nOriId, 'Q05', 'i') == 2 then
+            local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+            if not b3Solid then
+               local sErr = 'Error : part box not found'
+               EgtOutLog( sErr)
+               return false, sErr
+            end
+            local sPocketing = ML.FindPocketing( 'OpenPocket', nil, 0)
+            if not sPocketing then
+               local sErr = 'Error : pocketing not found in library'
+               EgtOutLog( sErr)
+               return false, sErr
+            end
+            local bOk, sErr = Pocket.Make( Proc, Proc.Id, 0, sPocketing, nPartId, b3Solid)
+            if not bOk then return bOk, sErr, nNewPhase end
+         end
+         if sNotesFinal then
+            EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesFinal)
+         end
+      end
    -- se tagli standard
-   if not bDoubleHorizCut then
+   elseif not bDoubleHorizCut then
       -- calcolo extra taglio ed accorciamento
       local dCutExtra = 0
       local dAccStart = 0
@@ -285,7 +452,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId)
          if not bOk then return false, sErr end
       end
    end
-   return true
+   return true, nil, nNewPhase
 end   
 
 ---------------------------------------------------------------------
diff --git a/LuaLibs/ProcessTyroleanDovetail.lua b/LuaLibs/ProcessTyroleanDovetail.lua
index 6f41a8e..6bd9cc1 100644
--- a/LuaLibs/ProcessTyroleanDovetail.lua
+++ b/LuaLibs/ProcessTyroleanDovetail.lua
@@ -1,5 +1,6 @@
 -- ProcessTyroleanDovetail.lua by Egaltech s.r.l. 2022/03/21
 -- Gestione calcolo giunzione tirolese
+-- 2022/06/10 Aggiunto il parametro dOvmTail per gestire sovramateriali in coda diversi da OVM_MID (sezioni alte e larghe)
 
 -- Tabella per definizione modulo
 local ProcessTyroleanDovetail = {}
@@ -141,7 +142,7 @@ local function EvaluateQParam( Proc, sDephtCham)
 end
 
 ---------------------------------------------------------------------
-local function MakeMachByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, nFacetCnt)
+local function MakeMachByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, nFacetCnt, dOvmTail)
 
    -- dati delle facce
    local ptC = {}
@@ -224,7 +225,7 @@ local function MakeMachByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw,
          bCut = false
       end
       -- se di coda e coincide con taglio di separazione, non va fatto
-      if not bHead and AreSameVectorApprox( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+      if not bHead and AreSameVectorApprox( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
          bCut = false
       end
       -- se va fatto, inserisco la lavorazione
@@ -322,7 +323,7 @@ local function MakeMachByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw,
             bCut = false
          end
          -- se di coda e coincide con taglio di separazione, non va fatto
-         if not bHead and AreSameVectorApprox( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < BD.OVM_MID + 10 * GEO.EPS_SMALL then
+         if not bHead and AreSameVectorApprox( vtNAux, - X_AX())  and  abs( ptCAux:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then
             bCut = false
          end
          -- se va fatto, inserisco la lavorazione
@@ -671,7 +672,10 @@ end
 
 ---------------------------------------------------------------------
 -- Applicazione della lavorazione
-function ProcessTyroleanDovetail.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
+function ProcessTyroleanDovetail.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmTail)
+   if not dOvmTail then
+      dOvmTail = BD.OVM_MID
+   end
    -- recupero l'ingombro del grezzo di appartenenza
    local b3Raw = EgtGetRawPartBBox( nRawId)
    -- in base al tipo di feature attribuisco il significato dei parametri Q
@@ -693,7 +697,7 @@ function ProcessTyroleanDovetail.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
    end
    -- se ho due facce allora è di testa
    if nFacetCnt == 2 then
-      local bOk, sErr = MakeMachByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, nFacetCnt)
+      local bOk, sErr = MakeMachByBlade( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, nFacetCnt, dOvmTail)
       if not bOk then return bOk, sErr end
    else
       local bOk, sErr = MakeMachByMill( Proc, nPhase, nRawId, nPartId, dOvmHead, b3Raw, b3Solid, nFacetCnt)