Nell'aggiornamento più recente del generatore di combinazioni di carico, abbiamo semplificato il funzionamento interno del modulo e aggiunto le seguenti funzionalità:

• La generazione della combinazione di carico è definita da un singolo file .json (Schema) per ogni norma.
• È possibile creare gruppi e combinazioni di carico senza dover prima assegnare i carichi nello spazio di modellazione S3D.
• Modelli, che si basano sul vecchio “Espandi Carichi del vento” casella di controllo, ora funziona con qualsiasi caso di carico.

Nomenclatura

Nell'ultima versione del generatore di combinazioni di carico, il nome del caso di carico utilizzato per molte cose:

• Agire come un ID univoco.
• Distinguere tra carico caso eccezionale e caso di carico, e richiedono sempre un valore in ciascuno (portando a quelli bizzarri come Morto: morto).
• Resta leggibile dall'uomo, pur rimanendo abbastanza piccolo per i menu a discesa contraendo le parole (Vivere: Q-dist-pavimento-tetto).

Nell'aggiornamento più recente, abbiamo diviso i nomi dei casi di carico simboli, che sono compatti e utilizzati quando lo spazio è limitato (quando si denominano le combinazioni di carico, ad esempio: 1.25D1 + 1.5Il + 1.5Ld + 0.5Sl + 0.5T), e etichette, che sarà descrittivo (utilizzato ad esempio nei menu a discesa). Tutti e due simboli e etichette dovrà essere unico all'interno di un dato standard. Lo consentiremo anche casi di carico avere lo stesso nome del carico caso eccezionale, solitamente per il caso di carico predefinito (più comunemente usato). I due esempi usati sopra verrebbero divisi in questo modo:

{"D": "Morto"}
{“Ldr”: "Vivere - Concentrato, Tetti, Pavimento"}

La simbolo deve essere composto almeno da una lettera maiuscola, che definisce il supercaso. La caso eccezionale è un concetto nuovo, utilizzato per raggruppare casi di carico simili che solitamente agiscono insieme. La caso eccezionale l'etichetta viene fornita all'inizio dell'etichetta del caso di carico (prima del trattino). Nell'esempio sopra (Eurocodice) il caso di carico Ldr farebbe parte del supercaso L (chiamato Live nell'etichetta), insieme ad altri casi di carico come Ldd e Ldo. Dietro le quinte, il caso eccezionale viene utilizzato principalmente per applicare le regole di filtraggio, ovvero determinare quali righe dello schema devono essere mantenute e quali devono essere rimosse.

La prima parte dell'etichetta (prima del trattino) è il nome del caso eccezionale. La seconda parte è una descrizione, utilizzare le virgole per separare le categorie dalle sottocategorie. La seconda parte è facoltativa, ma solo un caso di carico può assumere il valore predefinito caso eccezionale macchiare.

Righe di schemi standard

Ogni standard ha a schema che definisce completamente tutte le possibili combinazioni di carico per questa norma. La Schema.json il file è abbastanza semplice, ma può diventare piuttosto lungo, soprattutto negli standard (come l'Eurocodice) che richiedono una moltitudine di permutazioni. Per fare un semplice esempio, prendi il seguente requisito di esempio.

1.2*D + 1.5*L + (0.5*S o 0,5*W o 0,5*T)

Per convertire questo nel nostro schema, dobbiamo scomporlo in ogni possibile permutazione:

1.2*D + 1.5*L
1.2*D + 1.5*L + 0.5*S
1.2*D + 1.5*L + 0.5*W
1.2*D + 1.5*L + 0.5*T
1.2*D + 1.5*L + 0.5*S + 0.5*W
1.2*D + 1.5*L + 0.5*W + 0.5*T
1.2*D + 1.5*L + 0.5*T + 0.5*S
1.2*D + 1.5*L + 0.5*S + 0.5*W + 0.5*T

Una volta che ogni combinazione di carico viene elencata in questo modo, è possibile creare lo schema seguendo questi passaggi:

1. Utilizzare ciascuna chiave e coefficiente del caso di carico per creare un oggetto riga dello schema.
2. Assegna un nome a ciascuna riga con un identificatore univoco (poiché questo sarà un oggetto). La convenzione prevede l'uso dei trattini per separare i diversi elementi del nome.
3. Un livello in più, raggruppare le righe in criteri (forza, manutenibilità, accidentale, ecc.)

Il risultato finale dovrebbe assomigliare a questo:

"righe": {
  "forza":{
    "A-1-u": {"D": 1.40},
    "A-2a-u":{"D": 1.25, "L": 1.50, "Ls": 1.50},
    "A-2b-u":{"D": 1.25, "L": 1.50, "Ls": 1.50, "S": 1.00},
    "A-2c-u":{"D": 1.25, "S": 1.50, "W": 0.40},
    "A-3a-u":{"D": 1.25, "S": 1.50}
  }
}

Algoritmo di generazione della combinazione di carico

L'algoritmo esegue diversi passaggi per generare l'oggetto della combinazione di carico finale:

• La schema come sopra definito è necessario. Verrà passato alla funzione di generazione della combinazione di carico principale.
• Viene creato un oggetto per raggruppare il numero di casi di carico di modello. Per esempio, esaminiamo una richiesta per i casi di carico di seguito:

2 Caso di carico permanente, con un modello di unione
4 Casi di carico del vento, con un modello individuale
1 Casi di carico da neve, con un modello individuale
2 Casi di carico permanente, con un modello di unione

Raggruppando il modelli di caso di carico darà il seguente oggetto, che verrà passato alla funzione di generazione della combinazione di carico principale.

input_by_case = 
  {
    "D": {"unire": [2, 2], "individuale": []},
    "W": {"unire": [], "individuale": [4]},
    "S": {"unire": [], "individuale": [1]}
  }

• Gli ultimi due argomenti filtrano gli oggetti, che consentono il filtraggio in base a criteri o tramite chiave schema.
• Una volta che ha tutti gli argomenti richiesti, viene richiamata la funzione di generazione della combinazione di carico principale. Questa funzione passa attraverso più cicli nidificati per generare ogni combinazione richiesta, che sono spiegati nei seguenti punti elenco, ed illustrato nella figura successiva.
  • Al massimo livello, scorre attraverso le righe dello schema. Ogni riga viene controllata per vedere se deve essere mantenuta o saltata in questo passaggio, utilizzando gli oggetti di filtro e la logica specifica descritti nella sezione seguente.
  • Annidato nel primo ciclo ce n'è un secondo, che scorre attraverso ogni richiesta caso di carico nella riga dello schema. Se richiesto caso di carico esiste anche la riga dello schema (le richieste sono riepilogate nell'oggetto input_by_case), quindi procediamo al livello successivo.
  • Annidato nel secondo ciclo ce n'è un terzo, che scorre attraverso ogni possibile modello per vedere se ci sono gruppi di carico da generare al loro interno, ed esegue la funzione per nominarli e generarli quando lo fanno.
  • Una volta che tutti i casi di carico nella riga dello schema sono stati generati e denominati, sono ricombinati (insieme ai loro coefficienti) in una o più combinazioni di carico.

• Questo processo viene ripetuto per ogni riga dello schema, spingendo tutte le combinazioni di carico generate nell'oggetto della combinazione di carico finale.

Non vale nulla che tutta la logica relativa ai modelli avvenga all'interno di una singola riga dello schema. Sapere questo è importante per comprendere il comportamento dei modelli. Il modello di fusione, per esempio, non consente di unire nulla di diverso dal caso di carico a cui è assegnato. Ciò significa che non puoi:

• Unisci insieme diversi casi di carico, come provare a unire i gruppi di carico D1 e L1.
• Unisci casi di carico identici su righe diverse della tabella di input. Per esempio, nell'esempio riportato al punto #2 sopra, ci viene chiesto di generare 2 carichi morti utilizzando il modello di unione su due righe separate. Le combinazioni del risultato finale assomiglierebbero quindi a qualcosa di simile:

1.2*D1 + 1.2*D2 + 1.5*L
1.2*D3 + 1.2*D4 + 1.5*L
1.2*D1 + 1.2*D2 + 1.5*L + 0.5*S
1.2*D3 + 1.2*D4 + 1.5*L + 0.5*S
1.2*D1 + 1.2*D2 + 1.5*L + 0.5*W
1.2*D3 + 1.2*D4 + 1.5*L + 0.5*T

Filtraggio automatico delle combinazioni di carico non necessarie

Mentre l'algoritmo di cui sopra è funzionale senza alcun filtro, può portare a combinazioni di carico ridondanti, il che porta a tempi di elaborazione aggiuntivi e risultati ridondanti. Prendi le seguenti combinazioni di carico:

1.2*D + 1.5*L
1.2*D + 1.5*L + 0.5*S
1.2*D + 1.5*L + 0.5*W
1.2*D + 1.5*L + 0.5*T

Se abbiamo un singolo caso di carico morto, queste quattro combinazioni di carico daranno come risultato combinazioni di carico identiche:

1.2*D
1.2*D
1.2*D
1.2*D

Per evitare questa situazione, vengono utilizzate quattro regole che contengono ciascuna alcune lievi eccezioni. Primo, diamo un'occhiata alle regole. Lo stato predefinito prevede che la combinazione venga mantenuta e le regole vengono utilizzate per determinare quale escludere.

Filtraggio per criteri

Questo caso è abbastanza auto-esplicativo. Se la criteri non è richiesto, tutte le righe dello schema ad esso associate criteri vengono scartati.

Filtraggio in base ai caratteri nella chiave dello schema

Le chiavi dello schema sono generalmente puntatori separati da virgole al riferimento originale. Per esempio, nell'esempio NBCC riportato di seguito, la chiave ha tre componenti:

• A: Il primo termine è solitamente il riferimento principale, fare riferimento alla tabella in cui viene presa questa parte dei carichi.
• 2b: Il secondo termine è solitamente un identificatore univoco per la combinazione di carico all'interno della tabella.
• u: Il terzo termine è solitamente riservato per indicare quando un gran numero di combinazioni di carico vengono permutate con una leggera modifica. Per esempio, può indicare se i carichi permanenti nella combinazione di carico sono favorevoli ( f ) o sfavorevole ( u ).

{
  "forza":{
    "A-2b-u":{"D": 1.25, "L": 1.50, "Ls": 1.50, "S": 1.00},
  }
}

È possibile filtrare la chiave dello schema per uno qualsiasi di questi termini. Per esempio, se vogliamo filtrare in base al terzo termine, possiamo aggiungere il seguente filtro, che creerà un menu a discesa di filtro per questo termine:

"nome_filtri": {
  "Forza": {
    "Carico morto": {
      "posizione": 2,
      "descrizione comando": "",
      "elementi": {
        "Favorevole": "f",
        "Sfavorevole": "u"
      },
      "valori predefiniti": ["Favorevole", "Sfavorevole"]
    }
  }
}

Tutti i possibili nomi a discesa e i termini associati devono essere elencati in "elementi". Verranno mantenute solo le righe dello schema con i simboli corrispondenti. Se è necessario mantenere una riga dello schema indipendentemente da ciò che viene inserito nel filtro, il termine può essere lasciato vuoto. Qualsiasi chiave dello schema che non contenga tutti i termini del menu a discesa corrispondenti verrà scartata.

Combinazioni ridondanti

Se una riga dello schema non viene filtrata dai primi due passaggi, si passa al passaggio numero tre. In questo passaggio, viene risolto il problema della ridondanza dell'esempio precedente. Per fare questo, dobbiamo guardare due oggetti contemporaneamente, riga dello schema e l'oggetto input_by_case ordinato (vedere la descrizione sopra), che descrive quali casi di carico sono stati richiesti. Se la riga dello schema contiene un super caso che l'oggetto input_by_case non contiene, la combinazione di carico viene rimossa. Prendere, per esempio, la seguente riga dello schema:

"A-2a-u":{"D": 1.25, "L": 1.50, "S": 1.50}

e il seguente oggetto input_by_case:

input_by_case = 
{
  "D": {"unire": [], "individuale": [1]},
  "L": {"unire": [], "individuale": [4]}
}

In questo esempio, la riga dello schema contiene a caso eccezionale S che non è stato richiesto. Mantenere questa riga porterebbe a una combinazione di carico identica alla combinazione di carico associata alla riga dello schema seguente, quindi viene rimosso.

"A-1a-u":{"D": 1.25, "L": 1.50}

Eccezioni

Mentre questo comportamento è solitamente desiderabile, ci sono casi in cui NON eliminare una riga quando il caso di carico è assente porta a uno schema molto più semplice. Per esempio, se abbiamo carichi di terra orizzontali che dovrebbero essere aggiunti a ogni combinazione di schema, ma non sono sempre presenti, potremmo copiare e incollare tutte le combinazioni di carico e modificare la chiave dello schema per le nuove righe con un suffisso come "h" per i carichi di terra orizzontali. In alternativa, possiamo semplicemente aggiungere il carico di terra orizzontale a tutti i casi e aggiungere un'eccezione di mantenimento al caso di carico nei metadati. In questo modo, se il caso di carico non è richiesto, non verrà visualizzato, ma la riga verrà comunque mantenuta. Il risultato assomiglia a questo nella meta proprietà dello schema:

"H": {
  "etichetta": "Terra laterale - Sfavorevole",
  "rango": 1,
  "eccezioni": ["Mantenere"],
  "vecchie_etichette": []
},

Combinazioni superflue

Se una riga dello schema non viene filtrata dai primi tre passaggi, si passa al passaggio numero quattro. In questo passaggio, il problema della corrispondenza di casi di carico specifici tra lo schema e quanto richiesto. Se una riga dello schema e una richiesta hanno super casi corrispondenti, ma il caso di carico specifico richiesto non è nello schema, la riga non verrà mantenuta. Prendere, per esempio, la seguente riga dello schema:

"A-2a-u":{"D": 1.25, "Sl": 1.50}

e il seguente input_by_case:

input_by_case = 
{
  "D": {"unire": [], "individuale": [1]},
  "Sh": {"unire": [], "individuale": [1]}
}

In questo esempio, sia la riga dello schema che la richiesta hanno super casi corrispondenti. Tuttavia, la richiesta richiede una combinazione con Sh, che la riga dello schema non fornisce. così, la riga dello schema non viene mantenuta.

Eccezioni

Ancora una volta, questo comportamento è solitamente desiderabile, ma può portare a problemi. Uno di questi problemi si verifica quando gli standard hanno casi di carico che condividono un super caso, ma non agire simultaneamente. Per esempio, in ASCE, i carichi del vento W e i carichi del tornado Wt non agiscono contemporaneamente, sebbene condividano lo stesso super caso W. Quando ci imbattiamo in questo problema, possiamo aggiungere un'eccezione per passare a un'altra caso eccezionale prima che il codice venga eseguito nei metadati. Dietro le quinte, il simbolo che segue il “->” i caratteri verranno attribuiti al caso di carico, che simulerà i casi di carico che agiscono in esso caso eccezionale. Il risultato assomiglia a questo nella meta proprietà dello schema:

"wt" : {
  "etichetta": "Vento - Tornado",
  "rango": 8,
  "eccezioni": ["supercase->X"],
  "vecchie_etichette": []
},

Nel caso sopra, il caso eccezionale “W” verrà scambiato con “X” prima che il codice venga eseguito. Questa funzione può essere utilizzata anche per inviare casi di carico di gruppo che hanno univocità caso eccezionale simboli insieme.