Egalware/databeamnew
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Migliorato calcolo tempo per rating strategia/soluzione

Browse Source 
- 'dTimeToMachine' ora obbligatorio nei Result (da sistemare tutte le strategie)
- Piccola modifica ai nomi delle variabili, qualità e completamento diventano double e non più interi
- Riduzione numero scelte in parametri generici
This commit is contained in:
andrea.villa
2025-10-10 11:56:51 +02:00
parent f7462a47f4
commit 911113e853
25 changed files with 245 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files
BatchProcessNew.lua
+1 -1
View File
@@ -692,7 +692,7 @@ if bToProcess then
nWarnCnt = nWarnCnt + 1
sOutput = sOutput .. string.format( '[%d,%d] %s\n', RESULT[i].idCut, RESULT[i].idTask, sMsg)
BEAM.ERR = -19
BEAM.MSG = 'Incomplete : Completion index ' .. RESULT[i].ChosenStrategy.nCompletionIndex .. '/5\n' .. sMsg
BEAM.MSG = 'Incomplete : Completion index ' .. RESULT[i].ChosenStrategy.dCompletionIndex .. '/5\n' .. sMsg
BEAM.ROT = -( RESULT[i].nRotation or 1) + 1
BEAM.CUTID = RESULT[i].idCut
BEAM.TASKID = RESULT[i].idTask
LuaLibs/BeamExec.lua
+40 -31
View File
@@ -673,6 +673,7 @@ local function CollectFeatures( Part, dRotIndex)
end
-- se ci sono strategie disponibili, aggiungo a lista delle feature da lavorare
if Proc.AvailableStrategies and #Proc.AvailableStrategies > 0 then
Proc.AvailableStrategies.dAllStrategiesTotalTime = 0
nProcCount = nProcCount + 1
Proc.nIndexInVProc = nProcCount
table.insert( vProc, Proc)
@@ -891,22 +892,11 @@ local function GetIndexBestStrategyFromComparison( AvailableStrategies, Part, nI
-- se le due strategie hanno stesso stato e sono entrambe applicabili (quindi entrambe complete o entrambe non-complete)
if AvailableStrategies[nIndex1].Result.sStatus ~= 'Not-Applicable' and AvailableStrategies[nIndex2].Result.sStatus ~= 'Not-Applicable' and
AvailableStrategies[nIndex1].Result.sStatus == AvailableStrategies[nIndex2].Result.sStatus then
local dCompositeRatingStrategy1 = AvailableStrategies[nIndex1].Result.dCompositeRating
local dCompositeRatingStrategy2 = AvailableStrategies[nIndex2].Result.dCompositeRating
if Part.GeneralParameters.GEN_sMachiningStrategy == 'BALANCED' then
dCompositeRatingStrategy1 = dCompositeRatingStrategy1 * ( 1 / AvailableStrategies[nIndex1].Result.dTimeToMachine)
dCompositeRatingStrategy2 = dCompositeRatingStrategy2 * ( 1 / AvailableStrategies[nIndex2].Result.dTimeToMachine)
elseif Part.GeneralParameters.GEN_sMachiningStrategy == 'FASTEST' then
dCompositeRatingStrategy1 = ( dCompositeRatingStrategy1 * 0.25) * ( 1 / ( AvailableStrategies[nIndex1].Result.dTimeToMachine * 0.75))
dCompositeRatingStrategy2 = ( dCompositeRatingStrategy2 * 0.25) * ( 1 / ( AvailableStrategies[nIndex2].Result.dTimeToMachine * 0.75))
elseif Part.GeneralParameters.GEN_sMachiningStrategy == 'HIGH_QUALITY' then
dCompositeRatingStrategy1 = ( dCompositeRatingStrategy1 * 0.75) * ( 1 / ( AvailableStrategies[nIndex1].Result.dTimeToMachine * 0.25))
dCompositeRatingStrategy2 = ( dCompositeRatingStrategy2 * 0.75) * ( 1 / ( AvailableStrategies[nIndex2].Result.dTimeToMachine * 0.25))
end
-- si predilige strategia con rating composito più alto
if dCompositeRatingStrategy1 > dCompositeRatingStrategy2 then
if AvailableStrategies[nIndex1].Result.dCompositeRating > AvailableStrategies[nIndex2].Result.dCompositeRating then
dChosenIndex = nIndex1
elseif dCompositeRatingStrategy2 > dCompositeRatingStrategy1 then
elseif AvailableStrategies[nIndex2].Result.dCompositeRating > AvailableStrategies[nIndex1].Result.dCompositeRating then
dChosenIndex = nIndex2
-- altrimenti si prende la strategia con indice più basso
else
@@ -978,7 +968,13 @@ local function CalculateStrategies( vProcSingleRot, Part)
-- eseguo la strategia solo come calcolo fattibilità e voto. Non si applicano le lavorazioni. Si passa la Proc e i parametri personalizzati
_, Proc.AvailableStrategies[nIndexCurrentStrategy].Result = CurrentStrategy.Script.Make( false, Proc, Part, Proc.AvailableStrategies[nIndexCurrentStrategy])
Proc.AvailableStrategies[nIndexCurrentStrategy].Result = FeatureLib.CalculateCompositeRating( Proc.AvailableStrategies[nIndexCurrentStrategy].Result)
-- TODO da capire se dare un tempo molto alto oppure se dare errore perchè non deve mai capitare. Per ora si setta tempo alto
-- se tempo non calcolato, si setta un tempo molto alto, 99 minuti
if not Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine then
Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine = 99
end
Proc.AvailableStrategies.dAllStrategiesTotalTime = Proc.AvailableStrategies.dAllStrategiesTotalTime + Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine
-- se scelta strategia in modalità base o standard, esco subito alla prima che trovo completa
if Part.GeneralParameters.GEN_sMachiningStrategy == 'FIRST_IN_LIST' and Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus == 'Complete' then
break
@@ -991,6 +987,8 @@ local function CalculateStrategies( vProcSingleRot, Part)
Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus = 'Not-Applicable'
end
end
-- si calcola il composite rating delle strategie
Proc.AvailableStrategies = FeatureLib.CalculateStrategiesCompositeRating( Proc.AvailableStrategies, Part.GeneralParameters.GEN_sMachiningStrategy)
end
end
end
@@ -1076,7 +1074,7 @@ end
local function AddFeatureResultToGlobalList( Proc, OptionalParameters)
local sStrategyId
local sStatus
local nCompletionIndex
local dCompletionIndex
local dCompositeRating
local sInfo
@@ -1090,14 +1088,14 @@ local function AddFeatureResultToGlobalList( Proc, OptionalParameters)
if ChosenStrategyTable then
sStrategyId = ChosenStrategyTable.sStrategyId
sStatus = ChosenStrategyTable.Result.sStatus
nCompletionIndex = ChosenStrategyTable.Result.nCompletionIndex
dCompletionIndex = ChosenStrategyTable.Result.dCompletionIndex
dCompositeRating = ChosenStrategyTable.Result.dCompositeRating
sInfo = ChosenStrategyTable.Result.sInfo
end
elseif Proc.ChosenStrategy then
sStrategyId = Proc.ChosenStrategy.sStrategyId
sStatus = Proc.ChosenStrategy.Result.sStatus
nCompletionIndex = Proc.ChosenStrategy.Result.nCompletionIndex
dCompletionIndex = Proc.ChosenStrategy.Result.dCompletionIndex
dCompositeRating = Proc.ChosenStrategy.Result.dCompositeRating
sInfo = Proc.ChosenStrategy.Result.sInfo
end
@@ -1114,7 +1112,7 @@ local function AddFeatureResultToGlobalList( Proc, OptionalParameters)
ChosenStrategy = {
sStrategyName = sStrategyId,
sStatus = sStatus,
nCompletionIndex = nCompletionIndex,
dCompletionIndex = dCompletionIndex,
dCompositeRating = dCompositeRating,
sInfo = sInfo
}
@@ -1323,7 +1321,7 @@ local function GetBestCombination( ListToCompare, Part)
end
end
end
-- GEN_sPieceRotation = 'MODERATE_IMPACT' oppure 'NO_CONSTRAINT'
-- GEN_sPieceRotation = 'NO_CONSTRAINT'
else
-- si sceglie soluzione con più feature complete
if ListToCompare[ListIndex].nComplete > ListToCompare[nIndexBestCombination].nComplete then
@@ -1331,12 +1329,6 @@ local function GetBestCombination( ListToCompare, Part)
elseif ListToCompare[ListIndex].nComplete == ListToCompare[nIndexBestCombination].nComplete then
local dBestTotalRating = ListToCompare[nIndexBestCombination].dTotalRating
local dOtherTotalRating = ListToCompare[ListIndex].dTotalRating
-- se la rotazione ha un moderato impatto, si calcola che ogni rotazione aumenta il dTotalRating del 10%
if Part.GeneralParameters.GEN_sPieceRotation == 'MODERATE_IMPACT' then
-- TODO IMPROVEMENT: si potrebbe avere un tempo di rotazione e aggiungere quello alla somma dei tempi delle lavorazioni delle feature
dBestTotalRating = dBestTotalRating * ( 1 + ( ListToCompare[nIndexBestCombination].nRotations / 10))
dOtherTotalRating = dOtherTotalRating * ( 1 + ( ListToCompare[ListIndex].nRotations / 10))
end
-- scelgo soluzione con voto più alto
if dBestTotalRating < dOtherTotalRating then
@@ -1414,10 +1406,12 @@ local function GetProcBestMachRotationFromList( ListToCompare, Part)
-- se ci sono almeno 2 possibili soluzioni, scelgo la posizione migliore di lavorazione
if #ListToCompare > 1 then
-- formatto lista strategie disponibili come se le aspetta la funzione di compare
local AvailableStrategiesInRot = {}
local AvailableStrategiesInRot = { dAllStrategiesTotalTime = 0}
for i = 1, #ListToCompare do
table.insert( AvailableStrategiesInRot, ListToCompare[i][1].ChosenStrategy)
AvailableStrategiesInRot.dAllStrategiesTotalTime = AvailableStrategiesInRot.dAllStrategiesTotalTime + ListToCompare[i][1].ChosenStrategy.Result.dTimeToMachine
end
AvailableStrategiesInRot = FeatureLib.CalculateStrategiesCompositeRating( AvailableStrategiesInRot, Part.GeneralParameters.GEN_sMachiningStrategy)
for nIndexCurrentStrategy = 1, #AvailableStrategiesInRot do
-- la scelta tra le differenti strategie tra le rotazioni utilizza gli stessi criteri della scelta strategie all'interno della feature stessa
nIndexChosenProcInRot = GetIndexBestStrategyFromComparison( AvailableStrategiesInRot, Part, nIndexCurrentStrategy, nIndexChosenProcInRot)
@@ -1429,7 +1423,9 @@ local function GetProcBestMachRotationFromList( ListToCompare, Part)
Proc = ListToCompare[nIndexChosenProcInRot][1]
Data.nIndexRotation = ListToCompare[nIndexChosenProcInRot].nRotation
Data.dCompositeRating = ListToCompare[nIndexChosenProcInRot][1].ChosenStrategy.Result.dCompositeRating
Data.dTimeToMachine = ListToCompare[nIndexChosenProcInRot][1].ChosenStrategy.Result.dTimeToMachine
Data.dQuality = ListToCompare[nIndexChosenProcInRot][1].ChosenStrategy.Result.dQuality
Data.dCompletionIndex = ListToCompare[nIndexChosenProcInRot][1].ChosenStrategy.Result.dCompletionIndex
Data.bComplete = ListToCompare[nIndexChosenProcInRot][1].ChosenStrategy.Result.sStatus == 'Completed'
Data.bNotComplete = ListToCompare[nIndexChosenProcInRot][1].ChosenStrategy.Result.sStatus == 'Not-Completed'
Data.bNotApplicable = ListToCompare[nIndexChosenProcInRot][1].ChosenStrategy.Result.sStatus == 'Not-Applicable'
@@ -1440,7 +1436,7 @@ end
-- funzione che calcola le combinazioni di rotazione per lavorare la trave e sceglie la migliore
local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo)
local BestCombination = {}
local CombinationsList = {}
local CombinationsList = { dAllCombinationsTotalTime = 0}
--
-- scrittura nel log della matrice delle rotazioni
@@ -1454,7 +1450,9 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo)
local SingleCombination = {}
local nUnloadPos = PartInfo.CombinationList[i].nUnloadPos
SingleCombination.nRotations = 0
SingleCombination.dTotalRating = 0
SingleCombination.dTotalTimeToMachine = 0
SingleCombination.dTotalQuality = 0
SingleCombination.dTotalCompletionIndex = 0
SingleCombination.nComplete = 0
SingleCombination.nNotComplete = 0
SingleCombination.nNotExecute = 0
@@ -1514,7 +1512,9 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo)
bRot180 = true
end
SingleCombination.dTotalRating = SingleCombination.dTotalRating + Data.dCompositeRating
SingleCombination.dTotalTimeToMachine = SingleCombination.dTotalTimeToMachine + Data.dTimeToMachine
SingleCombination.dTotalQuality = SingleCombination.dTotalQuality + Data.dQuality
SingleCombination.dTotalCompletionIndex = SingleCombination.dTotalCompletionIndex + Data.dCompletionIndex
SingleCombination.nComplete = SingleCombination.nComplete + EgtIf( Data.bComplete, 1, 0)
SingleCombination.nNotComplete = SingleCombination.nNotComplete + EgtIf( Data.bNotComplete, 1, 0)
SingleCombination.nNotExecute = SingleCombination.nNotExecute + EgtIf( Data.bNotApplicable, 1, 0)
@@ -1537,10 +1537,19 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo)
end
-- aggiungo rotazioni
SingleCombination.nRotations = EgtIf( bRot90, 1, 0) + EgtIf( bRot180, 1, 0)
-- aggiungo tempo totale considerando le rotazioni -- TODO per il momento la rotazione impiega 1 minuto. Serve configurare?
SingleCombination.dTotalTimeToMachine = SingleCombination.dTotalTimeToMachine + ( SingleCombination.nRotations * 1)
-- aggiungo la combinazione all'elenco delle combinazioni disponibili
table.insert( CombinationsList, SingleCombination)
-- aggiorno tempo totale di tutte le combinazioni
CombinationsList.dAllCombinationsTotalTime = CombinationsList.dAllCombinationsTotalTime + SingleCombination.dTotalTimeToMachine
end
-- si calsola il total rating
CombinationsList = FeatureLib.CalculateCombinationsCompositeRating( CombinationsList, PartInfo.GeneralParameters.GEN_sMachiningStrategy)
return CombinationsList
end
LuaLibs/FeatureLib.lua
+96 -37
View File
@@ -553,31 +553,31 @@ end
-- funzione che restituisce indice di completamento in base alla percentuale di volume lavorato
function FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
-- indice di completamento
local nCompletionIndex = 0
local dCompletionIndex = 0
-- nullo
if dCompletionPercentage < 5 then
nCompletionIndex = 0
dCompletionIndex = 0
-- Low
elseif dCompletionPercentage < 50 then
nCompletionIndex = 1
dCompletionIndex = 1
-- Medium
elseif dCompletionPercentage < 80 then
nCompletionIndex = 2
dCompletionIndex = 2
-- High
elseif dCompletionPercentage < 95 then
nCompletionIndex = 4
dCompletionIndex = 4
-- High / Complete
else
nCompletionIndex = 5
dCompletionIndex = 5
end
return nCompletionIndex
return dCompletionIndex
end
-------------------------------------------------------------------------------------------------------------
function FeatureLib.GetStrategyQuality( Parameter)
local nQuality = 0
local dQuality = 0
-- se viene passata una tabella, si calcola media pesata di tutte le lavorazioni
if type( Parameter) == "table" then
@@ -592,43 +592,43 @@ function FeatureLib.GetStrategyQuality( Parameter)
dQualityDenominator = dQualityDenominator + Machining.dLengthToMachine
end
end
nQuality = dQualityNumerator / dQualityDenominator
dQuality = dQualityNumerator / dQualityDenominator
-- se viene passato un tag, si ritorna direttamente il voto
elseif type( Parameter) == "string" then
local sMachiningTag = Parameter
-- #### STATI DI LAVORAZIONE AGGREGATI #### --
-- BEST = lavorazione eccellente, la migliore qualità che si possa ottenere
if sMachiningTag == 'BEST' then
nQuality = 5
dQuality = 5
-- FINE = lavorazione ottima, non dovrebbero esscerci scheggiature
elseif sMachiningTag == 'FINE' then
nQuality = 4
dQuality = 4
-- STD = lavorazione accettabile, potrebbe avere scheggiature minime
elseif sMachiningTag == 'STD' then
nQuality = 3
dQuality = 3
-- SEMI = lavorazione accettabile, potrebbe avere scheggiature minime, mancano piccoli dettagli alla lavorazione (es. se vengono lasciati i raggi fresa sugli spigoli)
elseif sMachiningTag == 'SEMI' then
nQuality = 2.5
dQuality = 2.5
-- ROUGH = Lavorazione scadente, scheggiatura molto probabile, potrebbe non essere precisa
elseif sMachiningTag == 'ROUGH' then
nQuality = 1
dQuality = 1
-- #### UTENSILI DI LAVORAZIONE UTILIZZATI #### --
elseif sMachiningTag == 'SAWBLADE' then
nQuality = 5
dQuality = 5
elseif sMachiningTag == 'DRILLBIT' then
nQuality = 4
dQuality = 4
elseif sMachiningTag == 'MILL' then
nQuality = 3
dQuality = 3
elseif sMachiningTag == 'MORTISE' then
nQuality = 1
dQuality = 1
else
nQuality = 0
dQuality = 0
end
else
nQuality = 0
dQuality = 0
end
return nQuality
return dQuality
end
-------------------------------------------------------------------------------------------------------------
@@ -656,30 +656,89 @@ function FeatureLib.GetStrategyResultNotApplicable( sInfo)
Result.dMRR = 0
Result.dCompletionPercentage = 0
Result.sStatus = 'Not-Applicable'
Result.nCompletionIndex = 0
Result.nQuality = 0
Result.dCompletionIndex = 0
Result.dQuality = 0
Result.sInfo = sInfo
return Result
end
-------------------------------------------------------------------------------------------------------------
-- TODO rivedere affidabilità del calcolo del composite rating
-- funzione che calcola il 'CompositeRating' di ogni strategia
function FeatureLib.CalculateCompositeRating( StrategyResult)
-- se ho tutti i dati che mi servono calcolo il rating della strategia applicato alla feature
if StrategyResult and StrategyResult.nQuality and StrategyResult.nCompletionIndex and StrategyResult.dMRR then
-- TODO serve funzione generale?
-- indice bonta lavorazione feature in rotazione è opzionale, se non settato viene messo a 3
if not StrategyResult.nFeatureRotationIndex then
StrategyResult.nFeatureRotationIndex = 3
end
StrategyResult.dCompositeRating = ceil( StrategyResult.nQuality * StrategyResult.nCompletionIndex * ( 1 + ( StrategyResult.nFeatureRotationIndex / 10)))
else
StrategyResult.dCompositeRating = 0
local function GetMachiningStrategyCoefficients( sMachiningStrategy)
local dCoeffQuality, dCoeffCompletion, dCoeffTime
-- queste sono tutte le opzioni possibili. Da configurazione si può settare solo: AUTO, FASTEST, HIGH_QUALITY
if sMachiningStrategy == 'FASTEST' then
dCoeffQuality, dCoeffCompletion, dCoeffTime = 0.75, 0.75, 1.5
elseif sMachiningStrategy == 'HIGH_QUALITY' then
dCoeffQuality, dCoeffCompletion, dCoeffTime = 1.5, 0.75, 0.75
elseif sMachiningStrategy == 'COMPLETEST' then
dCoeffQuality, dCoeffCompletion, dCoeffTime = 0.75, 1.5, 0.75
elseif sMachiningStrategy == 'IGNORE_TIME' then
dCoeffQuality, dCoeffCompletion, dCoeffTime = 1.25, 1.25, 0.5
elseif sMachiningStrategy == 'IGNORE_QUALITY' then
dCoeffQuality, dCoeffCompletion, dCoeffTime = 0.5, 1.25, 1.25
elseif sMachiningStrategy == 'IGNORE_COMPLETION' then
dCoeffQuality, dCoeffCompletion, dCoeffTime = 1.25, 0.5, 1.25
else -- sMachiningStrategy == 'FIRST_IN_LIST' or sMachiningStrategy == 'AUTO' (oppure non settato, ma dovrebbe essere sempre settato!)
dCoeffQuality, dCoeffCompletion, dCoeffTime = 1, 1, 1
end
return StrategyResult
return dCoeffQuality, dCoeffCompletion, dCoeffTime
end
-------------------------------------------------------------------------------------------------------------
-- TODO rivedere affidabilità del calcolo del composite rating
-- funzione che calcola il 'CompositeRating' di ogni strategia
function FeatureLib.CalculateStrategiesCompositeRating( AvailableStrategies, sMachiningStrategy)
for n = 1, #AvailableStrategies do
-- se ho tutti i dati che mi servono calcolo il rating della strategia applicato alla feature
if AvailableStrategies[n].Result and AvailableStrategies[n].Result.dQuality and AvailableStrategies[n].Result.dCompletionIndex and AvailableStrategies[n].Result.dTimeToMachine then
-- il tempo è pesato sul totale delle strategie, e riportato nell'intervallo 1-5, dove 5 è il tempo migliore (il più basso)
local dIndexWeightTimeToMachine = 5 - ( 4 * ( EgtClamp( AvailableStrategies[n].Result.dTimeToMachine / AvailableStrategies.dAllStrategiesTotalTime, 0, 1)))
-- si calcolano gli indici pesati in base alla configurazione utente. Possibili parametri di configurazione:
local dQuality, dCompletion, dTime, dCoeffQuality, dCoeffCompletion, dCoeffTime
dCoeffQuality, dCoeffCompletion, dCoeffTime = GetMachiningStrategyCoefficients( sMachiningStrategy)
dQuality = AvailableStrategies[n].Result.dQuality * dCoeffQuality
dCompletion = AvailableStrategies[n].Result.dCompletionIndex * dCoeffCompletion
dTime = dIndexWeightTimeToMachine * dCoeffTime
AvailableStrategies[n].Result.dCompositeRating = dQuality + dCompletion + dTime -- TODO da verificare se meglio sommare o moltiplicare gli indici
else
AvailableStrategies[n].Result.dCompositeRating = 0
end
end
return AvailableStrategies
end
-------------------------------------------------------------------------------------------------------------
-- TODO rivedere affidabilità del calcolo del composite rating
-- funzione che calcola il 'CompositeRating' di ogni combinazione
function FeatureLib.CalculateCombinationsCompositeRating( CombinationsList, sMachiningStrategy)
for n = 1, #CombinationsList do
-- se ho tutti i dati che mi servono calcolo il rating della strategia applicato alla feature
if CombinationsList[n].dTotalQuality and CombinationsList[n].dTotalCompletionIndex and CombinationsList[n].dTotalTimeToMachine then
-- il tempo è pesato sul totale delle strategie, e riportato nell'intervallo 1-5, dove 5 è il tempo migliore (il più basso)
local dIndexWeightTimeToMachine = 5 - ( 4 * ( EgtClamp( CombinationsList[n].dTotalTimeToMachine / CombinationsList.dAllCombinationsTotalTime, 0, 1)))
-- si calcolano gli indici pesati in base alla configurazione utente. Possibili parametri di configurazione:
local dQuality, dCompletion, dTime, dCoeffQuality, dCoeffCompletion, dCoeffTime
dCoeffQuality, dCoeffCompletion, dCoeffTime = GetMachiningStrategyCoefficients( sMachiningStrategy)
dQuality = CombinationsList[n].dTotalQuality * dCoeffQuality
dCompletion = CombinationsList[n].dTotalCompletionIndex * dCoeffCompletion
dTime = dIndexWeightTimeToMachine * dCoeffTime
CombinationsList[n].dTotalRating = dQuality + dCompletion + dTime -- TODO da verificare se meglio sommare o moltiplicare gli indici
else
CombinationsList[n].dTotalRating = 0
end
end
return CombinationsList
end
-------------------------------------------------------------------------------------------------------------
Process.lua
+1 -1
View File
@@ -336,7 +336,7 @@ local function MyProcessFeatures()
-- feature incompleta e altro
elseif RESULT[i].sType == 'Feature' and RESULT[i].ChosenStrategy.sStatus == 'Not-Completed' then
nWarnCnt = nWarnCnt + 1
sMsg = 'Incomplete : Completion index ' .. RESULT[i].ChosenStrategy.nCompletionIndex .. '/5\n' .. sMsg
sMsg = 'Incomplete : Completion index ' .. RESULT[i].ChosenStrategy.dCompletionIndex .. '/5\n' .. sMsg
sOutput = sOutput .. string.format( '[%d,%d] %s\n', RESULT[i].idCut, RESULT[i].idTask, sMsg)
end
Strategies/GeneralParameters.json
+5 -17
View File
@@ -4,7 +4,7 @@
"nGroup": "1",
"sName": "GEN_sPiecesLoadingPosition",
"sNameNge": "GEN_PIECES_LOADING",
"sValue": "BTL_POSITION",
"sValue": "BEST_POSITION",
"sDescriptionShort": "Part loading position",
"sDescriptionLong": "",
"sType": "combo",
@@ -52,12 +52,6 @@
"sDescriptionLong": "",
"sMessageId": ""
},
{
"sValue": "MODERATE_IMPACT",
"sDescriptionShort": "Rotation acceptable with moderate impact",
"sDescriptionLong": "",
"sMessageId": ""
},
{
"sValue": "NO_CONSTRAINT",
"sDescriptionShort": "Rotation easily acceptable / no constraint",
@@ -70,21 +64,15 @@
"nGroup": "1",
"sName": "GEN_sMachiningStrategy",
"sNameNge": "GEN_MACHINING_STRATEGY",
"sValue": "BALANCED",
"sValue": "AUTO",
"sDescriptionShort": "Machining Strategy",
"sDescriptionLong": "",
"sType": "combo",
"sMinUserLevel": "1",
"Choices": [
{
"sValue": "FIRST_IN_LIST",
"sDescriptionShort": "Prefer first strategy in list",
"sDescriptionLong": "",
"sMessageId": ""
},
{
"sValue": "BALANCED",
"sDescriptionShort": "Balanced",
"sValue": "AUTO",
"sDescriptionShort": "Quality and time equally prioritized",
"sDescriptionLong": "",
"sMessageId": ""
},
@@ -97,7 +85,7 @@
{
"sValue": "HIGH_QUALITY",
"sDescriptionShort": "High quality",
"sDescriptionLong": "Prefer strategies with an high-quality",
"sDescriptionLong": "Prefer high-quality strategies",
"sMessageId": ""
}
]
Strategies/Standard/HEADCUT/HEADCUT.lua
+2 -2
View File
@@ -47,10 +47,10 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
end
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.dMRR = 1
-- TODO di quale utensile si deve impostare la qualità qui?
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
-- se devo applicare le lavorazioni
Strategies/Standard/STR0001/STR0001.lua
+5 -5
View File
@@ -266,12 +266,12 @@ local function GetTenonMachiningResult( Proc, Result)
-- lavorazione completa
if Strategy.Machining.Milling.bIsApplicable and Strategy.Machining.Cutting.bIsApplicable then
TotalResult.sStatus = Result.Milling.sStatus
TotalResult.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
TotalResult.dMRR = ( Result.Milling.dMRR + Result.Cutting.dMRR) / 2
if Strategy.Machining.nMillingPathsNeeded > Strategy.Parameters.nMaxMillingPaths then
TotalResult.nQuality = FeatureLib.GetStrategyQuality( 'STD')
TotalResult.dQuality = FeatureLib.GetStrategyQuality( 'STD')
else
TotalResult.nQuality = FeatureLib.GetStrategyQuality( 'FINE')
TotalResult.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
end
TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
TotalResult.dTimeToMachine = Result.Milling.dTimeToMachine + Result.Cutting.dTimeToMachine
@@ -279,9 +279,9 @@ local function GetTenonMachiningResult( Proc, Result)
-- lavorazione incompleta
elseif Strategy.Machining.Cutting.bIsApplicable then
TotalResult.sStatus = 'Not-Completed'
TotalResult.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 50)
TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 50)
TotalResult.dMRR = Result.Cutting.dMRR
TotalResult.nQuality = FeatureLib.GetStrategyQuality( 'FINE')
TotalResult.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
TotalResult.sInfo = 'Tenon not completed'
TotalResult.dTimeToMachine = Result.Cutting.dTimeToMachine
-- strategia non applicabile, manca il taglio di lama sulla lunghezza del tenone
Strategies/Standard/STR0002/STR0002.lua
+11 -11
View File
@@ -108,7 +108,7 @@ local function GetBestPocketingStrategy( Proc)
local ToolSearchParameters = {}
ToolSearchParameters.sMillShape = 'STANDARD'
Machining.sTypeMachining = 'None' -- Bottom-Side1-Side2\ Bottom-Side1\ Bottom-Side2\ Side1-Side2\ Bottom\ Side1 \ Side2 \ None
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'STD')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'STD')
-- caso speciale Tunnel che non ha faccia bottom
if Proc.Topology.sName == 'Tunnel-4-Through' then
@@ -283,7 +283,7 @@ local function GetBestPocketingStrategy( Proc)
if Machining[1].bIsApplicable and Machining[1].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
Machining.sTypeMachining = 'Bottom'
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dMRR = Machining[1].dMRR
Machining[1].ToolInfo.dResidualDepth = 0
Machining[3].bIsApplicable = false
@@ -294,7 +294,7 @@ local function GetBestPocketingStrategy( Proc)
Machining.sTypeMachining = 'Bottom2'
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dMRR = Machining[2].dMRR
Machining[2].ToolInfo.dResidualDepth = 0
else
@@ -306,7 +306,7 @@ local function GetBestPocketingStrategy( Proc)
and Machining[2].bIsApplicable and Machining[2].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
Machining.sTypeMachining = 'Bottom2'
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dMRR = Machining[2].dMRR
Machining[2].ToolInfo.dResidualDepth = 0
Machining[1].bIsApplicable = false
@@ -322,8 +322,8 @@ local function GetBestPocketingStrategy( Proc)
else
Strategy.Result.sStatus = 'Completed'
end
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'SEMI')
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'SEMI')
Strategy.Result.dMRR = Machining[3].dMRR
if Proc.MainFaces.TunnelAddedFaces then
Machining[3].ToolInfo.dResidualDepth = -( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP)
@@ -343,8 +343,8 @@ local function GetBestPocketingStrategy( Proc)
else
Strategy.Result.sStatus = 'Completed'
end
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'SEMI')
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'SEMI')
Strategy.Result.dMRR = Machining[4].dMRR
if Proc.MainFaces.TunnelAddedFaces then
Machining[4].ToolInfo.dResidualDepth = -( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP)
@@ -369,8 +369,8 @@ local function GetBestPocketingStrategy( Proc)
local dExtraMachDepth = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2 - Machining[3].ToolInfo.dResidualDepth - Machining[4].ToolInfo.dResidualDepth - BeamData.MILL_OVERLAP) / 2
Machining[3].ToolInfo.dResidualDepth = Machining[3].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + dExtraMachDepth
Machining[4].ToolInfo.dResidualDepth = Machining[4].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + dExtraMachDepth
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'SEMI')
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'SEMI')
Strategy.Result.dMRR = ( Machining[3].dMRR + Machining[4].dMRR) / 2
Machining[1].bIsApplicable = false
Machining[2].bIsApplicable = false
@@ -403,7 +403,7 @@ local function GetBestPocketingStrategy( Proc)
end
local dMachinedPrercentage = CalcMachinedPercentage( Proc, Machining)
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.sInfo = 'Machining not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
-- se non ho trovato neanche una lavorazione
Strategies/Standard/STR0003/STR0003.lua
+4 -4
View File
@@ -321,9 +321,9 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
end
-- calcolo risultati
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( Blade.Result.Sorted)
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( Blade.Result.Sorted)
Strategy.Result.dCompletionPercentage = dAreaToMachineBlade / LongFace.dArea * 100
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
Strategy.Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Blade.Result.Sorted)
Strategy.Result.dMRR = ( dFeatureVolume / Strategy.Result.dTimeToMachine) / pow( 10, 6)
if #Blade.Result.Sorted > 0 then
@@ -666,14 +666,14 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
-- calcolo risultati
Strategy.Result.dCompletionPercentage = max( dAreaToMachineBlade, dAreaToMachineChainsaw) / LongFace.dArea * 100
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
if #Result > 0 then
if Strategy.Result.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
Strategy.Result.sStatus = 'Completed'
else
Strategy.Result.sStatus = 'Not-Completed'
end
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( Result)
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( Result)
Strategy.Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Result)
Strategy.Result.dMRR = ( dFeatureVolume / Strategy.Result.dTimeToMachine) / pow( 10, 6)
else
Strategies/Standard/STR0004/STR0004.lua
+2 -2
View File
@@ -305,14 +305,14 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
-- calcolo risultati
Strategy.Result.dCompletionPercentage = dTotalAreaToMachine / LongFace.dArea * 100
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
if #Chainsaw.Result.Sorted > 0 then
if Mortising.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
Strategy.Result.sStatus = 'Completed'
else
Strategy.Result.sStatus = 'Not-Completed'
end
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( Chainsaw.Result.Sorted)
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( Chainsaw.Result.Sorted)
Strategy.Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Chainsaw.Result.Sorted)
Strategy.Result.dMRR = ( dFeatureVolume / Strategy.Result.dTimeToMachine) / pow( 10, 6)
else
Strategies/Standard/STR0005/STR0005.lua
+9 -9
View File
@@ -59,10 +59,10 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
local dTimeToMachine = 0
local dMRRBlade = 0
local dCompletionPercentage = 0
local nQuality = 0
local dQuality = 0
local dMRRBladeAddedFace = 0
local dCompletionPercentageAddedFace = 0
local nQualityAddedFace = 0
local dQualityAddedFace = 0
-- più di 3 facce non supportate
if Proc.nFct > 3 then
@@ -115,7 +115,7 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
dTimeToMachine = BladeKeepWasteResult.dTimeToMachine
dMRRBlade = BladeKeepWasteResult.dMRR
dCompletionPercentage = BladeKeepWasteResult.dCompletionPercentage
nQuality = BladeKeepWasteResult.nQuality
dQuality = BladeKeepWasteResult.dQuality
end
-- lavorazione a cubetti / taglio singolo
@@ -147,7 +147,7 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
dTimeToMachine = BladeToWasteResult.dTimeToMachine
dMRRBlade = BladeToWasteResult.dMRR
dCompletionPercentage = BladeToWasteResult.dCompletionPercentage
nQuality = BladeToWasteResult.nQuality
dQuality = BladeToWasteResult.dQuality
end
-- se arrivati qui non è stata ancora applicata alcuna lavorazione, si prova la lavorazione con codolo
@@ -160,7 +160,7 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
dTimeToMachine = BladeKeepWasteResult.dTimeToMachine
dMRRBlade = BladeKeepWasteResult.dMRR
dCompletionPercentage = BladeKeepWasteResult.dCompletionPercentage
nQuality = BladeKeepWasteResult.nQuality
dQuality = BladeKeepWasteResult.dQuality
end
-- lavorazione eventuale terza faccia tipo RidgeLap
@@ -188,13 +188,13 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
-- TODO calcolo risultati da aggiornare con funzioni nuove
dMRRBladeAddedFace = BladeToWasteResult.dMRR
dCompletionPercentageAddedFace = BladeToWasteResult.dCompletionPercentage
nQualityAddedFace = BladeToWasteResult.nQuality
dQualityAddedFace = BladeToWasteResult.dQuality
dTimeToMachine = dTimeToMachine + BladeToWasteResult.dTimeToMachine
-- la faccia aggiuntiva conta per 1/3
dMRRBlade = 2/3 * dMRRBlade + 1/3 * dMRRBladeAddedFace
dCompletionPercentage = 2/3 * dCompletionPercentage + 1/3 * dCompletionPercentageAddedFace
nQuality = 2/3 * nQuality + 1/3 * nQualityAddedFace
dQuality = 2/3 * dQuality + 1/3 * dQualityAddedFace
end
-- aggiunta lavorazioni
@@ -223,8 +223,8 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
else
Strategy.Result.sStatus = 'Not-Applicable'
end
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Strategy.Result.nQuality = nQuality
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Strategy.Result.dQuality = dQuality
Strategy.Result.dTimeToMachine = dTimeToMachine
Strategy.Result.dMRR = dMRRBlade
Strategies/Standard/STR0006/STR0006.lua
+4 -4
View File
@@ -225,18 +225,18 @@ local function GetTenonMachiningResult( Proc, Result)
-- lavorazione completa
if Strategy.Machining.Milling.bIsApplicable and Strategy.Machining.Cutting.bIsApplicable then
TotalResult.sStatus = Result.Milling.sStatus
TotalResult.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
TotalResult.dMRR = ( Result.Milling.dMRR + Result.Cutting.dMRR) / 2
TotalResult.nQuality = FeatureLib.GetStrategyQuality( EgtIf( Strategy.Machining.bCuttingWithMill, 'STD', 'FINE'))
TotalResult.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Strategy.Machining.bCuttingWithMill, 'STD', 'FINE'))
TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
TotalResult.dTimeToMachine = Result.Milling.dTimeToMachine + Result.Cutting.dTimeToMachine
TotalResult.sInfo = ''
-- lavorazione incompleta
elseif Strategy.Machining.Cutting.bIsApplicable then
TotalResult.sStatus = 'Not-Completed'
TotalResult.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 50)
TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 50)
TotalResult.dMRR = Result.Cutting.dMRR
TotalResult.nQuality = FeatureLib.GetStrategyQuality( EgtIf( Strategy.Machining.bCuttingWithMill, 'MILL', 'SAWBLADE'))
TotalResult.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Strategy.Machining.bCuttingWithMill, 'MILL', 'SAWBLADE'))
TotalResult.sInfo = 'Tenon not completed'
TotalResult.dTimeToMachine = Result.Cutting.dTimeToMachine
-- strategia non applicabile, manca il taglio di lama sulla lunghezza del tenone
Strategies/Standard/STR0007/STR0007.lua
+6 -6
View File
@@ -158,7 +158,7 @@ function GetMortiseMachiningResult( Proc, Result)
-- lavorazione mortasa frontale completa
if Strategy.Machining.Milling.bIsApplicable and Strategy.Machining.Cutting.bIsApplicable and Proc.FeatureInfo.bIsFrontMortise then
TotalResult.sStatus = Result.Milling.sStatus
TotalResult.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
TotalResult.dMRR = ( Result.Milling.dMRR + Result.Cutting.dMRR) / 2
local sQuality
if not Strategy.Machining.bCuttingWithMill and Strategy.Machining.bAntiSplint then
@@ -168,24 +168,24 @@ function GetMortiseMachiningResult( Proc, Result)
else
sQuality = 'STD'
end
TotalResult.nQuality = FeatureLib.GetStrategyQuality( sQuality)
TotalResult.dQuality = FeatureLib.GetStrategyQuality( sQuality)
TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
TotalResult.sInfo = ''
-- lavorazione mortasa completa
elseif Strategy.Machining.Milling.bIsApplicable and not( Proc.FeatureInfo.bIsFrontMortise) then
TotalResult.sStatus = Result.Milling.sStatus
TotalResult.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
TotalResult.dMRR = Result.Milling.dMRR
local sQuality = EgtIf( Strategy.Parameters.bAntiSplint, 'BEST', 'STD')
TotalResult.nQuality = FeatureLib.GetStrategyQuality( sQuality)
TotalResult.dQuality = FeatureLib.GetStrategyQuality( sQuality)
TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
TotalResult.sInfo = ''
-- lavorazione incompleta
elseif Strategy.Machining.Cutting.bIsApplicable then
TotalResult.sStatus = 'Not-Completed'
TotalResult.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 50)
TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 50)
TotalResult.dMRR = Result.Cutting.dMRR
TotalResult.nQuality = FeatureLib.GetStrategyQuality( EgtIf( Strategy.Machining.bCuttingWithMill, 'MILL', 'SAWBLADE'))
TotalResult.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Strategy.Machining.bCuttingWithMill, 'MILL', 'SAWBLADE'))
TotalResult.sInfo = 'Mortise not completed'
-- strategia non applicabile, manca il taglio di lama sulla lunghezza del Mortise
else
Strategies/Standard/STR0008/STR0008.lua
+6 -6
View File
@@ -36,7 +36,7 @@ local function GetBestPocketingStrategy( Proc, Part)
local ToolSearchParameters = {}
Machining.sTypeMachining = 'None' -- Bottom\ Side1\ Side2\ Side1-Side2\ None
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'MILL')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'MILL')
-- in caso sia una mortasa frontale, bisogna lavorare il taglio
if Proc.FeatureInfo.bIsFrontMortise then
@@ -97,9 +97,9 @@ local function GetBestPocketingStrategy( Proc, Part)
-- alterimenti esco subito
else
Strategy.Result.sStatus = 'Not-Applicable'
Strategy.Result.nCompletionIndex = 0
Strategy.Result.dCompletionIndex = 0
Strategy.Result.dMRR = 0
Strategy.Result.nQuality = 0
Strategy.Result.dQuality = 0
Strategy.Result.sInfo = 'Mill not found'
return Machining
end
@@ -203,9 +203,9 @@ local function GetBestPocketingStrategy( Proc, Part)
else
-- TODO per feature frontale, ha senso voler applicare solo il taglio e non la lavorazione della mortasatura? Adesso non fa nulla
Strategy.Result.sStatus = 'Not-Applicable'
Strategy.Result.nCompletionIndex = 0
Strategy.Result.dCompletionIndex = 0
Strategy.Result.dMRR = 0
Strategy.Result.nQuality = 0
Strategy.Result.dQuality = 0
Strategy.Result.sInfo = 'Mill not found'
return Machining
end
@@ -219,7 +219,7 @@ local function GetBestPocketingStrategy( Proc, Part)
Strategy.Result.sInfo = 'Mortise not complete, left ' .. ceil( Machining.dResidual) .. 'mm'
Strategy.Result.dCompletionPercentage = ( 1 - Machining.dResidual / Proc.FeatureInfo.dMortiseDepth) * 100
end
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
return Machining
end
Strategies/Standard/STR0009/STR0009.lua
+2 -2
View File
@@ -154,9 +154,9 @@ local function GetArcStrategy( Proc, Part)
-- TODO VOTO DA FARE!!!!
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo or Machining[2].ToolInfo)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'MILL')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'MILL')
Strategy.Result.sInfo = ''
return Machining
Strategies/Standard/STR0010/STR0010.lua
+2 -2
View File
@@ -234,12 +234,12 @@ function STR0010.Make( bAddMachining, Proc, Part, CustomParameters)
-- calcolo completamento, serve la lista di lavorazioni che comprende le non applicabili
Strategy.Result.dCompletionPercentage = GetStrategyCompletionPercentage( Strategy.Machinings)
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Strategy.Result.dCompletionPercentage)
Strategy.Machinings = MachiningLib.GetSplitMachinings( Strategy.Machinings, FeatureSplittingPoints, Part)
table.sort( Strategy.Machinings, SortMachiningsBySegment)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( Strategy.Machinings)
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( Strategy.Machinings)
Strategy.Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Strategy.Machinings)
Strategy.Result.dMRR = ( dFeatureVolume / Strategy.Result.dTimeToMachine) / pow( 10, 6)
if Strategy.Result.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
Strategies/Standard/STR0011/STR0011.lua
+17 -17
View File
@@ -64,23 +64,23 @@ local function GetDrillingStrategy( Proc, Part)
-- voto
if Drilling.ToolInfo.dResidualDepth < 0 or ( Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP) / 2 > Drilling.ToolInfo.dResidualDepth then
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo or Machining[2].ToolInfo)
if bDouble or not Proc.FeatureInfo.bIsDrillOpen then
sQuality = 'FINE'
else
sQuality = 'ROUGH'
end
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( sQuality)
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( sQuality)
Strategy.Result.sInfo = ''
else
Strategy.Result.sStatus = 'Not-Completed'
local dMachinedLen = EgtIf( bDouble, Machining[1].sDepth * 2, Proc.FeatureInfo.dDrillLen)
local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo or Machining[2].ToolInfo)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'FINE') -- se non completo, anche se fosse foro singolo, comunque non esce dall'altra parte, quindi non scheggia
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE') -- se non completo, anche se fosse foro singolo, comunque non esce dall'altra parte, quindi non scheggia
end
end
-- se lavorazione verticale
@@ -128,10 +128,10 @@ local function GetDrillingStrategy( Proc, Part)
-- voto
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.sInfo = ''
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'FINE')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
-- se utensile 1 esegue completamente
elseif Drilling.ToolInfo.nToolIndex and Drilling.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL and
@@ -143,9 +143,9 @@ local function GetDrillingStrategy( Proc, Part)
table.insert( Machining, Drilling)
-- voto
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
Strategy.Result.sInfo = ''
-- se utensile 2 esegue completamente
elseif Drilling2.ToolInfo.nToolIndex and Drilling2.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL and
@@ -158,9 +158,9 @@ local function GetDrillingStrategy( Proc, Part)
table.insert( Machining, Drilling2)
-- voto
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
Strategy.Result.sInfo = ''
-- se possono lavorare entrambi
elseif Drilling.ToolInfo.nToolIndex and Drilling2.ToolInfo.nToolIndex then
@@ -180,16 +180,16 @@ local function GetDrillingStrategy( Proc, Part)
Strategy.Result.sStatus = 'Not-Completed'
local dMachinedLen = Machining[1].sDepth + Machining[2].sDepth
local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
else
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.sInfo = ''
end
-- voto
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'FINE')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
-- se utensile 1 non completo
elseif Drilling.ToolInfo.nToolIndex and ( Strategy.Parameters.sDrillingMode ~= 'FORCE_TWO' or Proc.FeatureInfo.bIsDrillOpen) then
Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth
@@ -202,10 +202,10 @@ local function GetDrillingStrategy( Proc, Part)
Strategy.Result.sStatus = 'Not-Completed'
local dMachinedLen = Machining[1].sDepth
local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'FINE')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
-- se utensile 2 non completo
elseif Drilling2.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode ~= 'FORCE_TWO' then
Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth
@@ -219,10 +219,10 @@ local function GetDrillingStrategy( Proc, Part)
Strategy.Result.sStatus = 'Not-Completed'
local dMachinedLen = Machining[1].sDepth
local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'FINE')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
else
local sMessage
-- se non sono state trovate punte
Strategies/Standard/STR0012/STR0012.lua
+7 -7
View File
@@ -37,10 +37,10 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
local dTimeToMachine = 0
local dMRRBlade = 0
local dCompletionPercentage = 0
local nQuality = 0
local dQuality = 0
local dMRRBladeAddedFace = 0
local dCompletionPercentageAddedFace = 0
local nQualityAddedFace = 0
local dQualityAddedFace = 0
-- gestito solo RidgeLap 3 facce
if Proc.nFct ~= 3 then
@@ -109,7 +109,7 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
dTimeToMachine = BladeToWasteResult.dTimeToMachine
dMRRBlade = BladeToWasteResult.dMRR
dCompletionPercentage = BladeToWasteResult.dCompletionPercentage
nQuality = BladeToWasteResult.nQuality
dQuality = BladeToWasteResult.dQuality
-- lavorazione terza faccia
-- TODO da completare
@@ -137,13 +137,13 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
-- TODO calcolo risultati da aggiornare con funzioni nuove
dMRRBladeAddedFace = BladeToWasteResult.dMRR
dCompletionPercentageAddedFace = BladeToWasteResult.dCompletionPercentage
nQualityAddedFace = BladeToWasteResult.nQuality
dQualityAddedFace = BladeToWasteResult.dQuality
dTimeToMachine = dTimeToMachine + BladeToWasteResult.dTimeToMachine
-- la faccia aggiuntiva conta per 1/3
dMRRBlade = 2/3 * dMRRBlade + 1/3 * dMRRBladeAddedFace
dCompletionPercentage = 2/3 * dCompletionPercentage + 1/3 * dCompletionPercentageAddedFace
nQuality = 2/3 * nQuality + 1/3 * nQualityAddedFace
dQuality = 2/3 * dQuality + 1/3 * dQualityAddedFace
end
-- lavorazioni in lista unica
@@ -177,8 +177,8 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
else
Strategy.Result.sStatus = 'Not-Completed'
end
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Strategy.Result.nQuality = nQuality
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Strategy.Result.dQuality = dQuality
Strategy.Result.dTimeToMachine = dTimeToMachine
Strategy.Result.dMRR = dMRRBlade
else
Strategies/Standard/STR0013/STR0013.lua
+4 -4
View File
@@ -129,15 +129,15 @@ local function GetDrillingWithMillStrategy( Proc, Part)
if #Machining > 0 then
if dResidual < 0 then
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.sInfo = ''
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'MILL')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'MILL')
else
Strategy.Result.sStatus = 'Not-Completed'
local dResidualPrercentage = 100 * ( dResidual / Proc.FeatureInfo.dDrillLen)
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100 - dResidualPrercentage)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100 - dResidualPrercentage)
Strategy.Result.sInfo = 'Machining not complete, left ' .. tostring( ceil( dResidualPrercentage)) .. '%'
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'MILL')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'MILL')
end
-- se son state trovate frese compatibili
else
Strategies/Standard/STR0014/STR0014.lua
+2 -2
View File
@@ -74,10 +74,10 @@ function STR0014.Make( bAddMachining, Proc, Part, CustomParameters)
if Strategy.Machining.ToolInfo.nToolIndex then
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
local Parameters = { nToolIndex = Strategy.Machining.ToolInfo.nToolIndex}
Strategy.Result.dMRR = MachiningLib.GetToolMRR( Parameters)
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'MILL')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'MILL')
else
Strategy.Result = FeatureLib.GetStrategyResultNotApplicable()
end
Strategies/Standard/STR0015/STR0015.lua
+3 -3
View File
@@ -672,13 +672,13 @@ local function GetFeatureResult( Proc)
local dPercentageLeft = ceil( 100 - Result.dCompletionPercentage)
Result.sInfo = Result.sInfo .. '- Not Complete : left ' .. tostring( dPercentageLeft) .. '%\n'
end
Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Result.dCompletionPercentage)
Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Result.dCompletionPercentage)
Result.dMRR = 1
-- se tutte le lavorazioni sono state eseguite, è la massima qualità che si possa ottenere, altrimenti qualità più bassa
if Result.sInfo == '' then
Result.nQuality = FeatureLib.GetStrategyQuality( 'BEST')
Result.dQuality = FeatureLib.GetStrategyQuality( 'BEST')
else
Result.nQuality = FeatureLib.GetStrategyQuality( 'MILL')
Result.dQuality = FeatureLib.GetStrategyQuality( 'MILL')
end
return Result
Strategies/Standard/TAILCUT/TAILCUT.lua
+2 -2
View File
@@ -52,10 +52,10 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
-- se non faccio tagli PRECUT, imposto tabella Result direttamente. Non serve verificare che riesca a rimuovere il materiale extra
else
Strategy.Result.sStatus = 'Completed'
Strategy.Result.nCompletionIndex = 5
Strategy.Result.dCompletionIndex = 5
Strategy.Result.dMRR = 1
-- TODO di quale utensile si deve impostare la qualità qui?
Strategy.Result.nQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Strategy.Result.sInfo = 'Split not possible'
end
end
StrategyLibs/BLADEKEEPWASTE.lua
+2 -2
View File
@@ -255,7 +255,7 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
-- calcolo completamento, serve la lista di lavorazioni che comprende le non applicabili
Result.dCompletionPercentage = GetStrategyCompletionPercentage( CalculatedMachinings)
Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Result.dCompletionPercentage)
Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Result.dCompletionPercentage)
-- aggiunta eventuali lavorazioni splittate
if bIsSplitFeature then
@@ -267,7 +267,7 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
-- calcolo risultati
if Cutting1.bIsApplicable or Cutting2.bIsApplicable then
Result.nQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Machinings)
Result.dMRR = ( dFeatureVolume / Result.dTimeToMachine) / pow( 10, 6)
if Result.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
StrategyLibs/BLADETOWASTE.lua
+7 -7
View File
@@ -637,8 +637,8 @@ local function CutWholeWaste( Proc, Part, OptionalParameters)
Result.sStatus = 'Not-Completed'
end
Result.dCompletionPercentage = dCompletionPercentage
Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Result.nQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Result.dQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Machinings)
Result.dMRR = ( FeatureInfo.dFeatureVolume / Result.dTimeToMachine) / pow( 10, 6)
else
@@ -890,7 +890,7 @@ local function CutWithDicing( Proc, Part, OptionalParameters)
if bIsDicingOk then
Result.sStatus = 'Completed'
Result.dCompletionPercentage = 100
Result.nQuality = TOOLS[nToolIndex].nQuality
Result.dQuality = FeatureLib.GetStrategyQuality( TOOLS[nToolIndex].sFamily)
Result.dTimeToMachineOriginal = FeatureLib.GetStrategyTimeToMachine( Machinings)
Result.dTimeToMachine = Result.dTimeToMachineOriginal * 1.3
Result.dMRR = ( FeatureInfo.dFeatureVolume / Result.dTimeToMachine) / pow( 10, 6)
@@ -1045,9 +1045,9 @@ function BLADETOWASTE.Make( ProcOrId, Part, OptionalParameters)
end
-- calcolo risultati
Result.nQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dCompletionPercentage = dAreaToMachineTotal / ( EgtSurfArea( idFace1) + EgtSurfArea( idFace2)) * 100
Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Result.dCompletionPercentage)
Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Result.dCompletionPercentage)
Result.dTimeToMachine = Result1.dTimeToMachine + Result2.dTimeToMachine
Result.dMRR = ( FeatureInfo.dFeatureVolume / Result.dTimeToMachine) / pow( 10, 6)
if Result1.sStatus == 'Completed' and Result2.sStatus == 'Completed' then
@@ -1126,8 +1126,8 @@ function BLADETOWASTE.Make( ProcOrId, Part, OptionalParameters)
end
Result.dCompletionPercentage = dCompletionPercentage
Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Result.nQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Result.dQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Machinings)
Result.dMRR = ( FeatureInfo.dFeatureVolume / Result.dTimeToMachine) / pow( 10, 6)
else
StrategyLibs/SPLITCUT.lua
+5 -5
View File
@@ -79,7 +79,7 @@ function SPLITCUT.GetStrategy( Proc, Part, OptionalParameters)
-- setto valori di default. Impossibile che taglio di separazione sia incompleto
Result.sStatus = 'Completed'
Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
Result.dMRR = 1
-- correzioni sul massimo materiale lama, considerando ingombri vari
@@ -125,7 +125,7 @@ function SPLITCUT.GetStrategy( Proc, Part, OptionalParameters)
-- TODO considerare di tagliare con il massimo materiale possibile per non salire troppo in Z (macchine tipo PF), oppure non scendere troppo (tipo Kairos)
-- BladeSideSingle (taglio di lama singolo di fianco)
if Machining[1].bIsApplicable and ( dMaxMatBladeSideSingle - BeamData.CUT_EXTRA) > Part.dWidth + 10 * GEO.EPS_SMALL then
Result.nQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Result.dQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Machining.sTypeMachining = 'BladeSideSingle'
Machining[2].bIsApplicable = false
Machining[3].bIsApplicable = false
@@ -134,7 +134,7 @@ function SPLITCUT.GetStrategy( Proc, Part, OptionalParameters)
-- TODO considerare di tagliare con il massimo materiale possibile per non salire troppo in Z (macchine tipo PF), oppure non scendere troppo (tipo Kairos)
-- BladeSideDouble (taglio di lama doppio di fianco)
elseif Machining[1].bIsApplicable and ( dMaxMatBladeSideDouble - BeamData.CUT_EXTRA) > Part.dWidth + 10 * GEO.EPS_SMALL then
Result.nQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Result.dQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Result.dMRR = Result.dMRR/2
Machining.sTypeMachining = 'BladeSideDouble'
Machining[2].bIsApplicable = false
@@ -143,7 +143,7 @@ function SPLITCUT.GetStrategy( Proc, Part, OptionalParameters)
return Machining, Result
-- BladeHorizontalSingle (taglio di lama singolo orizzontale)
elseif Machining[1].bIsApplicable and ( dMaxMatBladeHorizontalSingle - BeamData.CUT_EXTRA) > Part.dHeight + 10 * GEO.EPS_SMALL then
Result.nQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Result.dQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Machining.sTypeMachining = 'BladeHorizontalSingle'
Machining[2].bIsApplicable = false
Machining[3].bIsApplicable = false
@@ -152,7 +152,7 @@ function SPLITCUT.GetStrategy( Proc, Part, OptionalParameters)
-- BladeHorizontalDouble (taglio di lama doppio orizzontale)
elseif Machining[1].bIsApplicable and Machining[2].bIsApplicable and
( dMaxMatBladeHorizontalSingle + dMaxMatBladeHorizontalDouble - BeamData.CUT_EXTRA) > Part.dHeight + 10 * GEO.EPS_SMALL then
Result.nQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Result.dQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
Result.dMRR = Result.dMRR/2
Machining.sTypeMachining = 'BladeHorizontalDouble'
Machining[1].ToolInfo.dMaxMatBladeFromTop = dMaxMatBladeHorizontalSingle