Egyszerű modell létrehozása AxisVM COM szerveren keresztül

Tartalomjegyzék

Ez a cikk egy megoszló erővel terhelt kéttámaszú tartó létrehozásának lépéseit mutatja be az AXISVM COM szerver használatával, a C# programozási nyelv és a Visual studio segítségével. A COM szerver segítségével modelleket hozhatunk létre, elemzéseket futtathatunk és eredményeket olvashatunk ki az AXISVM programról. A C# nyelvet itt példaként használjuk, de más programozási nyelvek hasonlóképpen használhatók. Ez a cikk nem mutatja be a COM szerver beállításának lépéseit. Az összes beállítási lépés itt található: A COM szerver beüzemelése 

Egy egyszerű Windows Form alkalmazást hozunk létre. A felhasználó megadja a gerenda méreteit és a terhelés nagyságát. A program létrehozza a gerendát, alkalmazza a terhelést és a támaszokat, és lefuttatja az elemzést az AXISVM-ben. Végül elmenti az eredményeket, például a reakciókat, elmozdulásokat, erőket és feszültségeket, ahogy az alábbi képen látható.

A COM-Szerver API kézikönyv teljes leírást tartalmaz az összes funkcióról, amelyet a modell létrehozásához, az elemzés futtatásához és az eredmények kiolvasásához használhatunk. Megmutatja, hogyan kell használni a függvényeket, és a megfelelő paramétereket, amelyeket át kell adni a függvény sikeres alkalmazásához. Ezért itt gyakran hivatkozunk rá. Az API kézikönyv a COM szerver összes elérhető interfészét bemutatja. A fő interfész az IAxisVMApplication. Az API kézikönyv felsorolja az összes elérhető enumerációt, függvényt, struktúrát és tulajdonságot, amelyeket az AXISVM-ben adatok lekérdezésére vagy műveletek végrehajtására használhatunk. A rendelkezésre álló interfészek IAxisVM kezdődnek, de az implementált objektumok anélkül elérhetők (pl. az IAxisVMModels az axisVMApplication.Models).

Létrehozunk egy új Modellt, és egy változóban tároljuk a rá való hivatkozást. #

Az AxisVMApplication objektum létrehozása után, ahogyan az előző cikkben bemutattuk, a Models interfész használható az aktuálisan megnyitott modell eléréséhez vagy egy új modell létrehozásához az AXISVM-ben. Az API kézikönyvből látható, hogy az IAxisVMModels tartalmaz egy New() nevű függvényt, amellyel új modellt hozhatunk létre, valamint az item[int index] tulajdonságot, amellyel lekérdezhetjük a megnyitott modellt. Ahogy az alábbi kódrészletben látható, az 1. sor új modellt hoz létre, a 2. sor pedig megszerzi a létrehozott modellt, és egy model nevű változóban tárolja.

				
					axisVMApplication.Models.New();                         // Új modell létrehozása.
IAxisVMModel model = axisVMApplication.Models.Item[1];  // Tárolása a 'model' változóban.

Beállítjuk a mértékegység-rendszerét és a nemzeti szabványt. #

A következő lépés a mértékegység-rendszer és a nemzeti szabvány beállítása. Az egységrendszert az IAxisVMApplication ChangeUnitSystem(string Name) függvényével tudjuk megváltoztatni. A rendelkezésre álló mértékegységrendszerek az API kézikönyvben találhatók. Az alábbi kódrészlet 1. sora az EU mértékegységeket állítja be. A tervezési szabványt az IAxisVMSettings interfész model.Settings.NationalDesignCode tulajdonságával állíthatjuk be. Az API kézikönyvben a tulajdonság visszatérési típusa a tulajdonság nevének bal oldalán található. A NationalDesignCode tulajdonság esetében a megadott tulajdonságnak ENationalDesignCode típusúnak kell lennie, ahogy az alábbi képen látható. A kódrészlet 2. sora a NationalDesignCode-ot az Eurocode-ra állítja.

				
					int unitId = axisVMApplication.ChangeUnitSystem("eu");               // Beállítjuk a mértékegység-rendszerét 
model.Settings.NationalDesignCode = ENationalDesignCode.ndcEuroCode; // Beállítjuk a nemzeti szabványt

Létrehozunk két csomópontot és egy sort. #

A következő lépésben létrehozunk két csomópontot és egy vonalat, amely összeköti a két csomópontot. A csomópontok létrehozásához az IAxisVMNodes interfész Add ([in] double x, [in] double y, [in] double z)függvényét kell meghívni a csomópont XYZ koordinátáival. Az API kézikönyv szerint a függvény a csomópont indexét adja vissza, ha az AXISVM sikeresen létrehozta a csomópontot, ahogy az az alábbi képen látható.

A kódrészlet 1. sora létrehoz egy csomópontot (x=0, y=0, z=0), a 2. sora pedig létrehoz egy másikat (x=gerendaHosszaúsága, y=0, z=0). A 3. sora létrehoz egy vonalelemet, amely összeköti a két csomópontot. A vonalat az IAxisVMLines interfész Add ([in] long StartNode, [in] long EndNode, [in] ELineGeomType GeomType, [i/o] RLineGeomData GeomData) függvényével hozhatjuk létre. Ahogy az alábbi képen látható, az első és a második paraméter az első és a második csomópont indexe. A harmadik paraméter egy ELineGeomType típusú enumeráció, amely meghatározza a vonal típusát: „Straight”(egyenes) vagy „circleArc”. A negyedik paraméter egy RLineGeomData típusú struktúra; ezt a circleArc vonalakhoz használjuk, ami itt nem releváns. A függvény visszaadja a vonal indexét, ha sikeresen létrehozta, vagy hibakódot.

				
					int node1Id = model.Nodes.Add(0, 0, 0);               // létrehozunk egy csomópontot.
int node2Id = model.Nodes.Add(beamLength, 0, 0);      // létrehozunk egy másik csomópontot.
int lineId = model.Lines.Add(node1Id, node2Id, ELineGeomType.lgtStraightLine, ref rLineGeomData); // létrehozunk egy vonalelemet.

Definiáljuk az anyagot és a keresztmetszetet. #

Az IAxisVMMaterials interfész számos funkciót tartalmaz az anyagok definiálásához, többek között az AddDialog, AddFromCatalog, AddFromCatalogFile. Ebben a példában az AddFromCatalog segítségével fogjuk definiálni az anyagot az AxisVM könyvtárban rendelkezésre álló anyagok segítségével. Az első paraméter a NationalDesignCode, a második paraméter az anyagnév (MaterialName), amelyet stringként kell megadni. A pontos anyagnevet az AXISVM anyagkönyvtárában található módon kell megadni. Itt példaként az Eurocode C25/30 betont használjuk. Az alábbi kódrészlet első sora az anyagdefiníciót mutatja. A függvény az anyag indexét adja vissza, ha az anyag hozzáadása (definiálása) sikeres volt. Az IAxisVMMaterials-hoz hasonlóan az IAxisVMCrossSections is számos módszert biztosít a keresztmetszetek definiálására, mint például az AddFromDialog, AddFromEditor és a kifejezetten bizonyos metszetek definiálására szolgáló függvények. Itt az AddRectangular függvényt használjuk egy téglalap keresztmetszet definiálására. Ahogy az alábbi képen látható, az első paraméter a keresztmetszet egyedi neve, a második a szélesség, a harmadik a magasság, a negyedik pedig az ECrossSectionProcess az acélszelvények esetében, ami ebben a példában nem releváns. A kódrészlet második sora egy téglalap alakú szelvényt ad hozzá az AXISVM CrossSections interfészéhez. Siker esetén a függvény visszaadja a hozzáadott keresztmetszet indexét. Az alábbi képek az AXISVM-hez hozzáadott anyagot és keresztmetszetet mutatják.

				
					int materialId = model.Materials.AddFromCatalog(ENationalDesignCode.ndcEuroCode, "C25/30");  // Definiáljuk az anyagot
int crossSectionId = model.CrossSections.AddRectangular("rectangle", width, height, ECrossSectionProcess.cspOther);   // Definiáljuk a keresztmetszetet.

A vonalat gerendaként jelöljük. #

Az anyag és a keresztmetszet definiálása után a vonalelemet az IAxisVMLine interfész DefineAsBeam függvényével gerendaként lehet megjelölni. A kódrészlet első sora az IAxisVMLines interfész Item[int index] tulajdonsága segítségével megszerzi a korábban hozzáadott vonalelemet, és az axisVMLine változóban tárolja. Ahogy a második sorban látható, a DefineAsBeam függvénnyel megjelölhetjük a vonalat gerendaként az MaterialIndex, StartCrossSectionIndex, EndCrossSectionIndex, és az RPoint3d struktúra külpontosság pontjai segítségével. A külpontosság pontokat referenciaként (a ref kulcsszóval) kell átadni.

				
					IAxisVMLine axisVMLine = model.Lines.Item[lineId];
int beamId = axisVMLine.DefineAsBeam(materialId, crossSectionId, crossSectionId, ref startEndEccentricity, ref startEndEccentricity);

Definiáljuk a támaszokat. #

Az IAxisVMNodalSupports interfész AddNodalGlobal_V153 használatával definiálhatjuk a gerendatámaszokat. Az alábbi képen látható módon két paramétert kell megadni a függvénynek: az RNodalSupportSpringParams típusú NodalSupportSpringParameters és az integer típusú NodeId. Az RNodalSupportSpringParams egy olyan struktúra, amely egy másik, RSpringParamIndexes típusú struktúrát tartalmaz. Meg kell adnunk a rugók indexeit az RSpringParamIndexes-nek az XYZ irányú támaszok definiálásához. Ezért a támaszok definiálásához egy új RNodalSupportSpringParams objektumot kell definiálni a kódrészlet 2. sorában látható módon és a SpringParamIndexes-t (x, y, z, xx, yy és zz) irányban a megfelelő rugóindexekkel kell megadni. Az AXISVM-ben a Rigid-Translation és a Rigid-Rotation rugók indexe a model.SpringParams.IndexOfName(springName) segítségével kérhető le a megfelelő rugó nevével, ahogyan az a 3-4. sorban látható. Végül az AddNodalGlobal_V153 segítségével hozzáadjuk a támaszt, ahogyan az az 5. sorban látható.

				
					AxisVMNodalSupports axisVMNodalSupports = model.NodalSupports;
RNodalSupportSpringParams rNodalSupportSpring1 = new RNodalSupportSpringParams();
rNodalSupportSpring1.SpringParamIndexes.x = model.SpringParams.IndexOfName("Rigid - Translational");
rNodalSupportSpring1.SpringParamIndexes.yy = model.SpringParams.IndexOfName("Soft - Rotational");
int nodeSupport1 = axisVMNodalSupports.AddNodalGlobal_V153(ref rNodalSupportSpring2, node1Id);

Alkalmazzuk az önsúlyt és a megoszló terhelést. #

Az önsúlyt az IAxisVMLoads interfész AddBeamSelfWeight függvényével alkalmazzuk , amint az az alábbi 2. sorban látható. A függvény két paramétert igényel, a gerenda LineId-t és a LoadCaseId-t , amely az első terhelési esetnél 1. Az IAxisVMLoads interfész segítségével többféle terhelést alkalmazhatunk, például AddBeamConcentrated, AddBeamDistributed, AddBeamStress vagy AddBeamThermal. Példaként az AddBeamDistributed segítségével megoszló terhelést alkalmazunk a gerendára. Ahogy az alábbi képen látható, az AddBeamDistributed egy RLoadBeamDistributed típusú paramétert igényel, amely egy struktúra. A 4. sorban látható módon definiálunk egy új objektumot, és az 5-12. sorban látható módon értékeket rendelünk a RLoadBeamDistributed tulajdonságaihoz, beleértve a DistributionType, LoadCaseID és LineID értékeket. qx1, qy1, qz1, qx2, qy2, qz2 az első és a második pontra az x y z irányban megoszló terhelés értékei. Position1 és Position2 az első és a második pont pozíciója. Az API kézikönyv teljes leírást tartalmaz az RLoadBeamDistributed tulajdonságairól. Végül a definiált RLoadBeamDistributed-t át kell adni a függvénynek a megoszló terhelés alkalmazásához. Ha a teher sikeresen hozzáadásra került, a függvény visszaadja a teher indexét.

				
					// Az önsúly alkalmazása.
int selfWeight=axisVMLoads.AddBeamSelfWeight(lineId, LoadCaseId);
// Az megoszló terhelés definiálása 
RLoadBeamDistributed rLoadBeam = new RLoadBeamDistributed(); // Az RLoadBeamDistributed új objektumának definiálása
rLoadBeam.DistributionType = EBeamRibDistributionType.brdtLength; 
rLoadBeam.LoadCaseId = loadCaseId;                          // Teher eset ID
rLoadBeam.LineId = beamId;                                  // Gerenda ID
rLoadBeam.qz1 = -distributedLoad;                           // A terhelés értéke - első pont
rLoadBeam.qz2 = -distributedLoad;                           // A terhelés értéke - második pont
rLoadBeam.Position1 = 0;                                    // A terhelés helyzete - első pont
rLoadBeam.Position2 = length;                               // A terhelés helyzete - második pont
rLoadBeam.SystemGLR = ESystem.sysGlobal;                    // koordináta-rendszer 
// Az megoszló terhelés alkalmazása
int loadId = axisVMLoads.AddBeamDistributed(rLoadBeam);

A végeredmény az AXISVM-ben. #

Az alábbi képek a korábban említett függvények eredményét mutatják a COM-interfész használatával.

Elmentjük a modellt. #

A modell mentéséhez az IAxisVMModel SaveToFile függvényét használjuk. A függvény első paramétere a FileName, amely a mentett modell neve, a második paraméter pedig az ELongBoolean típusú SaveResults, amely azt jelzi, hogy az aktuálisan elérhető eredmények mentésre kerülnek-e vagy sem.

				
					ELongBoolean modelSaveStatus = model.SaveToFile("model1", ELongBoolean.lbTrue);   // Elmentjük a modellt egy fájlba.

Lefuttatjuk az elemzést. #

Az IAxisVMCalculation felület lehetővé teszi többféle elemzés futtatását, például lineáris, nemlineáris , kihajlás és rezgés. Itt a LinearAnalysis2 függvényt használjuk a lineáris elemzés futtatására. Amint az alábbi képen látható, a függvény három paramétert vesz fel; az első ECalculationUserInteraction típusú, amely eldönti, hogy a felhasználó interakcióba lép-e az AXISVM-mel, hogy reagáljon a figyelmeztető üzenetekre. A második ELongBoolean típusú, hogy hibaüzeneteket jelenítsen meg az AXISVM-ben. A harmadik paraméter a String típusú ErrorList, amelyet az out kulcsszóval kell átadni, hogy a függvény végrehajtása után megkapjuk a hibákat. Az alábbi kódrészlet mutatja, hogyan adjuk át a paramétereket a függvénynek. A függvény az ElongBoolean.lbTrue értéket adja vissza, ha az elemzés sikeresen befejeződött.

				
					String errorList;     // string típusú változó definiálása.
ELongBoolean analysisStatus = model.Calculation.LinearAnalysis2(ECalculationUserInteraction.cuiNoUserInteractionWithAutoCorrect, ELongBoolean.lbTrue, out errorList);

Az eredmények lekérdezése az elemzés után. #

Az IAxisVMResults interfész különböző függvényeket tartalmaz az elemzés eredményeinek lekérdezésére. Az interfész tartalmazza az elmozdulások, igénybevételek, feszültségek, vasbeton- és acéltervezés eredményeit stb. Az IAxisVMResults interfészben az IAxisVMDisplacements, IAxisVMForces és IAxisVMStresses interfészeket használhatjuk az elmozdulások, erők és feszültségek lekérdezésére. Például az IAxisVMDisplacements-ben a GetMemberDisplacementsByLoadCaseId segítségével lekérdezhetjük a gerenda elmozdulásait. Több paramétert kell átadni a függvénynek, ahogy az alábbi képen látható, beleértve a MemberID, LoadCaseID, LoadLevelOrModeShapeOrTimeStep, az Analysistype, az ELongBoolean típusú WithReinforcement paramétereket. Két tömböt kell átadnunk az outkulcsszóval az elmozdulások és a PosX számára. A LoadLevelOrModeShapeOrTimeStep más elemzési típusokhoz, például nemlineáris vagy rezgéselemzéshez használható. A lineáris elemzés esetén LoadLevelOrModeShapeOrTimeStep= 1. Az out kulcsszóval átadott két tömb a függvény végrehajtása után az elmozdulás eredményeit fogja tartalmazni. A tömböket a C# Array.CreateInstance(Type type ,int32 dimension) függvény segítségével definiálhatjuk és inicializálhatjuk, ahogyan azt az alábbi kódrészlet 1-2. sora mutatja. A GetMemberDisplacementsByLoadCaseId függvény visszaadja a keresztmetszetek számát a gerenda hossza mentén. Az elmozdulások tömbje ugyanannyi RDisplacementValues objektumot tartalmaz, ahány keresztmetszet létezik. Az objektumok az egyes keresztmetszeteknél a deformáció komponenseit tartalmazzák. A PosX tömb tartalmazza a keresztmetszetek helyét a gerenda hossza mentén. A tömbök az 1-es indexszel kezdődnek. Hasonló függvények használhatók az erők és feszültségek lekérdezésére a Forces.GetMemberForcesByLoadCaseId és a Stresses.GetMemberStressesByLoadCaseId használatával.

				
					Array displacementResults = Array.CreateInstance(typeof(RDisplacementValues), 1); // RDisplacementValues típusú tömb definálása
Array crossSectionPositionsDisplacement = Array.CreateInstance(typeof(double), 1); //double típusú tömb definálása 
int displacementResultStatus = model.Results.Displacements.GetMemberDisplacementsByLoadCaseId(beamId, loadCaseId, loadLevel, EAnalysisType.atLinearStatic, ELongBoolean.lbFalse, out displacementResults, out crossSectionPositionsDisplacement);

Array forcesResults = Array.CreateInstance(typeof(RLineForceValues), 1);
Array crossSectionPositionsForces = Array.CreateInstance(typeof(double), 1);
int forcesResultStatus = model.Results.Forces.GetMemberForcesByLoadCaseId(beamId, loadCaseId, loadLevel, EAnalysisType.atLinearStatic, out forcesResults, out crossSectionPositionsForces);

Array stressResults = Array.CreateInstance(typeof(RLineStressValues), 1);
Array crossSectionPositionsStress = Array.CreateInstance(typeof(double), 1);
int stressResultStatus = model.Results.Stresses.GetMemberStressesByLoadCaseId(beamId, loadCaseId, loadLevel, EAnalysisType.atLinearStatic, out stressResults, out crossSectionPositionsStress);

Az elemzés eredményeit a programban mutatjuk meg (Főablak), vagy elmentjük egy fájlba, ahogyan az alábbi képen látható.

Modellnézet módosítása. #

Az IAxisVMModel View tulajdonságával beállíthatjuk a nézetet az AXISVM-ben, ahol az EView.vFront az X-Z iránynak felel meg az API kézikönyv szerint. Az IAxisVMModel FitInView() függvénye használható arra, hogy a modellt teljes ábra nézetbe tegyük, amint azt az alábbi kódrészlet mutatja.

				
					model.View = EView.vFront;        // A nézetet X-Z-re állítjuk.
model.FitInView();                // Teljes ábra.

Hibák kezelése. #

Minden interfész rendelkezik egy speciális enummal, amely tartalmazza a funkciók végrehajtása során kapott hibakódok listáját és azok jelentését. Például az IAxisVMDisplacements interfész tartalmaz egy EDisplacementError enumot, amely tartalmazza az összes lehetséges hibát, amelyet a GetMemberDisplacementsByLoadCaseIdalkalmazásakor kaphatunk. A C# Enum.GetName(Type, Object) függvény segítségével az egyes hibakódok neve lekérdezhető, amint azt az alábbi kódrészlet mutatja.

				
					Enum.GetName(typeof(EDisplacementError), errorCode);      // Az Enum nevének lekérdezése.

A teljes projekt letölthető innen.

A lépések röviden: