v0.16.0
Loading...
Searching...
No Matches
Functions | Variables
add_cubit_meshsets.cpp File Reference
#include <MoFEM.hpp>

Go to the source code of this file.

Functions

int main (int argc, char *argv[])
 

Variables

static char help [] = "...\n\n"
 

Function Documentation

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 14 of file add_cubit_meshsets.cpp.

14 {
15
16 MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
17
18 auto core_log = logging::core::get();
19 core_log->add_sink(
20 LogManager::createSink(LogManager::getStrmSelf(), "ATOM_TEST"));
21 LogManager::setLog("ATOM_TEST");
22
23 try {
24
25 moab::Core mb_instance;
26 moab::Interface &moab = mb_instance;
27 int rank;
28 MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
29
30 // Create MoFEM (Joseph) database
31 MoFEM::Core core(moab);
32 MoFEM::Interface &m_field = core;
33
34 MeshsetsManager *meshsets_manager_ptr;
35 CHKERR m_field.getInterface(meshsets_manager_ptr);
36
37 MOFEM_LOG_CHANNEL("ATOM_TEST")
38 MOFEM_LOG_ATTRIBUTES("ATOM_TEST",
39 LogManager::BitLineID | LogManager::BitScope);
40 MOFEM_LOG_TAG("ATOM_TEST", "atom test");
41
42 MOFEM_LOG("ATOM_TEST", Sev::verbose) << "<<<< SIDESETs >>>>>";
43
44 bool add_block_is_there = false;
45 CHKERR meshsets_manager_ptr->addMeshset(SIDESET, 1002);
46 {
47 PressureCubitBcData mybc;
48 strncpy(mybc.data.name, "Pressure", 8);
49 mybc.data.flag1 = 0;
50 mybc.data.flag2 = 0;
51 mybc.data.value1 = 1;
52 CHKERR meshsets_manager_ptr->setBcData(SIDESET, 1002, mybc);
53 }
54 for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, SIDESET, it)) {
55 if (it->getMeshsetId() != 1002)
56 continue;
57 add_block_is_there = true;
58 PressureCubitBcData mydata;
59 CHKERR it->getBcDataStructure(mydata);
60 // Print data
61 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
62 }
63 if (!add_block_is_there)
64 SETERRQ(PETSC_COMM_WORLD, MOFEM_OPERATION_UNSUCCESSFUL,
65 "no added block set");
66
67 MOFEM_LOG("ATOM_TEST", Sev::inform) << "<<<< BLOCKSETs >>>>>";
68
69 add_block_is_there = false;
70 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1000, "ADD_BLOCK_SET");
71 std::vector<double> attr(3);
72 attr[0] = 0;
73 attr[1] = 1;
74 attr[2] = 2;
75 CHKERR meshsets_manager_ptr->setAttributes(BLOCKSET, 1000, attr);
76 for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
77 // Get block name
78 std::string name = it->getName();
79 if (name.compare(0, 13, "ADD_BLOCK_SET") == 0) {
80 add_block_is_there = true;
81 std::vector<double> attributes;
82 it->getAttributes(attributes);
83 if (attributes.size() != 3) {
84 SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
85 "should be 3 attributes but is %zu", attributes.size());
86 }
87 if (attributes[0] != 0 || attributes[1] != 1 || attributes[2] != 2) {
88 SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
89 "wrong values of attributes");
90 }
91 }
92 }
93 if (!add_block_is_there) {
94 SETERRQ(PETSC_COMM_WORLD, MOFEM_OPERATION_UNSUCCESSFUL,
95 "no added block set");
96 }
97 add_block_is_there = false;
98 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1001, "MAT_ELASTIC");
99 {
100 Mat_Elastic mydata;
101 mydata.data.Young = 1;
102 mydata.data.Poisson = 0.25;
103 CHKERR meshsets_manager_ptr->setAttributesByDataStructure(BLOCKSET, 1001,
104 mydata);
105 }
106 for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
107 if (it->getMeshsetId() != 1001)
108 continue;
109 // Get block name
110 std::string name = it->getName();
111 if (name.compare(0, 13, "MAT_ELASTIC") == 0 &&
112 (it->getBcType() & CubitBCType(MAT_ELASTICSET)).any()) {
113 add_block_is_there = true;
114 Mat_Elastic mydata;
115 CHKERR it->getAttributeDataStructure(mydata);
116 // Print data
117 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
118 if (mydata.data.Young != 1 || mydata.data.Poisson != 0.25) {
119 SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
120 "wrong values of attributes");
121 }
122 }
123 }
124 if (!add_block_is_there) {
125 SETERRQ(PETSC_COMM_WORLD, MOFEM_OPERATION_UNSUCCESSFUL,
126 "no added block set");
127 }
128
129 MOFEM_LOG("ATOM_TEST", Sev::inform) << "<<<< NODESET >>>>>";
130
131 CHKERR meshsets_manager_ptr->addMeshset(NODESET, 1010);
132 DisplacementCubitBcData disp_bc;
133 std::memcpy(disp_bc.data.name, "Displacement", 12);
134 disp_bc.data.flag1 = 1;
135 disp_bc.data.flag2 = 1;
136 disp_bc.data.flag3 = 1;
137 disp_bc.data.flag4 = 0;
138 disp_bc.data.flag5 = 0;
139 disp_bc.data.flag6 = 0;
140 disp_bc.data.value1 = 0;
141 disp_bc.data.value2 = 0;
142 disp_bc.data.value3 = 0;
143 disp_bc.data.value4 = 0;
144 disp_bc.data.value5 = 0;
145 disp_bc.data.value6 = 0;
146
147 CHKERR meshsets_manager_ptr->setBcData(NODESET, 1010, disp_bc);
148
149 for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
150 m_field, NODESET | DISPLACEMENTSET, it)) {
151 DisplacementCubitBcData disp_data;
152 CHKERR it->getBcDataStructure(disp_data);
153 MOFEM_LOG("ATOM_TEST", Sev::inform) << disp_data;
154 }
155
156 MOFEM_LOG("ATOM_TEST", Sev::inform)
157 << "<<<< ADD BLOCKSETs FROM CONFIG FILE >>>>>";
158
159 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1002, "ADD_BLOCK_SET");
160 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1003, "ADD_BLOCK_SET");
161 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1004, "ADD_BLOCK_SET");
162 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1005, "ADD_BLOCK_SET");
163 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1006, "ADD_BLOCK_SET");
164 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1007, "ADD_BLOCK_SET");
165 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1008, "ADD_BLOCK_SET");
166 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1009, "ADD_BLOCK_SET");
167 CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1010, "FOO");
168
169 CHKERR meshsets_manager_ptr->setMeshsetFromFile(
170 /*"add_cubit_meshsets.in"*/);
171
172 // List all meshsets
173 MOFEM_LOG("ATOM_TEST", Sev::inform) << "Iterate blocksets";
174
175 bool mat_elastic_trans_is_found = true;
176 bool users_array_attributes_found = false;
177 for (_IT_CUBITMESHSETS_FOR_LOOP_(m_field, it)) {
178 MOFEM_LOG("ATOM_TEST", Sev::inform) << *it;
179 if ((it->getBcType() & CubitBCType(BLOCKSET)).any()) {
180 std::vector<double> attributes;
181 it->getAttributes(attributes);
182 std::ostringstream ss;
183 ss << "Attr: ";
184 for (unsigned int ii = 0; ii != attributes.size(); ii++) {
185 ss << attributes[ii] << " ";
186 }
187 MOFEM_LOG("ATOM_TEST", Sev::inform) << ss.str();
188
189 if (it->getMeshsetId() == 1010) {
190 users_array_attributes_found = true;
191 if (attributes.size() != 11) {
192 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
193 "should be 11 attributes but is %zu", attributes.size());
194 }
195 for (unsigned int ii = 0; ii != attributes.size(); ii++) {
196 if (attributes[ii] != static_cast<double>(ii)) {
197 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
198 "wrong value from user_array");
199 }
200 }
201 }
202
203 std::string block_name = it->getName();
204 if (block_name.compare(0, block_name.size(), "MAT_ELASTIC_TRANS_ISO") ==
205 0) {
206 MOFEM_LOG("ATOM_TEST", Sev::inform) << "Mat Trans Iso block ";
207 mat_elastic_trans_is_found = true;
208 Mat_Elastic_TransIso mydata;
209 CHKERR it->getAttributeDataStructure(mydata);
210 // Print data
211 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
212 if (mydata.data.Youngp != 1)
213 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID, "Wrong value");
214 if (mydata.data.Youngz != 2)
215 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID, "Wrong value");
216 if (mydata.data.Poissonp != 3)
217 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID, "Wrong value");
218 if (mydata.data.Poissonpz != 4)
219 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID, "Wrong value");
220 if (mydata.data.Shearzp != 5)
221 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID, "Wrong value");
222 }
223 }
224 if(!mat_elastic_trans_is_found)
225 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID, "Block not found");
226
227 if ((it->getBcType() & CubitBCType(MAT_ELASTICSET)).any()) {
228 Mat_Elastic mydata;
229 CHKERR it->getAttributeDataStructure(mydata);
230 MOFEM_LOG("ATOM_TEST", Sev::inform) << "Mat elastic found ";
231 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
232 }
233 if ((it->getBcType() & CubitBCType(MAT_THERMALSET)).any()) {
234 Mat_Thermal mydata;
235 CHKERR it->getAttributeDataStructure(mydata);
236 MOFEM_LOG("ATOM_TEST", Sev::inform) << "Mat thermal found ";
237 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
238 }
239 if ((it->getBcType() & CubitBCType(DISPLACEMENTSET)).any()) {
240 DisplacementCubitBcData mydata;
241 CHKERR it->getBcDataStructure(mydata);
242 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
243 }
244 if ((it->getBcType() & CubitBCType(FORCESET)).any()) {
245 ForceCubitBcData mydata;
246 CHKERR it->getBcDataStructure(mydata);
247 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
248 }
249 if ((it->getBcType() & CubitBCType(PRESSURESET)).any()) {
250 PressureCubitBcData mydata;
251 CHKERR it->getBcDataStructure(mydata);
252 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
253 }
254 if ((it->getBcType() & CubitBCType(TEMPERATURESET)).any()) {
255 TemperatureCubitBcData mydata;
256 CHKERR it->getBcDataStructure(mydata);
257 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
258 }
259 if ((it->getBcType() & CubitBCType(HEATFLUXSET)).any()) {
260 HeatFluxCubitBcData mydata;
261 CHKERR it->getBcDataStructure(mydata);
262 MOFEM_LOG("ATOM_TEST", Sev::inform) << mydata;
263 }
264 }
265 if (!users_array_attributes_found) {
266 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
267 "user_array attributes not found");
268 }
269 }
270 CATCH_ERRORS;
271
272 MoFEM::Core::Finalize();
273}
help
static char help[]
Definition add_cubit_meshsets.cpp:12
CATCH_ERRORS
#define CATCH_ERRORS
Catch errors.
Definition definitions.h:385
TEMPERATURESET
@ TEMPERATURESET
Definition definitions.h:168
PRESSURESET
@ PRESSURESET
Definition definitions.h:165
MAT_ELASTICSET
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
Definition definitions.h:172
FORCESET
@ FORCESET
Definition definitions.h:164
HEATFLUXSET
@ HEATFLUXSET
Definition definitions.h:169
NODESET
@ NODESET
Definition definitions.h:159
SIDESET
@ SIDESET
Definition definitions.h:160
DISPLACEMENTSET
@ DISPLACEMENTSET
Definition definitions.h:163
MAT_THERMALSET
@ MAT_THERMALSET
block name is "MAT_THERMAL"
Definition definitions.h:174
BLOCKSET
@ BLOCKSET
Definition definitions.h:161
MOFEM_OPERATION_UNSUCCESSFUL
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition definitions.h:34
MOFEM_ATOM_TEST_INVALID
@ MOFEM_ATOM_TEST_INVALID
Definition definitions.h:40
CHKERR
#define CHKERR
Inline error check.
Definition definitions.h:551
MoFEM::LogManager::setLog
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
Definition LogManager.cpp:392
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition LogManager.hpp:316
MoFEM::LogManager::SeverityLevel
SeverityLevel
Severity levels.
Definition LogManager.hpp:33
MOFEM_LOG_TAG
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
Definition LogManager.hpp:347
MOFEM_LOG_CHANNEL
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
Definition LogManager.hpp:292
MOFEM_LOG_ATTRIBUTES
#define MOFEM_LOG_ATTRIBUTES(channel, bit)
Add attributes to channel.
Definition LogManager.hpp:304
MoFEM::MeshsetsManager::setBcData
MoFEMErrorCode setBcData(const CubitBCType cubit_bc_type, const int ms_id, const GenericCubitBcData &data)
Set boundary condition data for meshset.
Definition MeshsetsManager.cpp:697
MoFEM::MeshsetsManager::setAttributes
MoFEMErrorCode setAttributes(const CubitBCType cubit_bc_type, const int ms_id, const std::vector< double > &attributes, const std::string name="")
Set attributes for CUBIT meshset.
Definition MeshsetsManager.cpp:604
_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_
#define _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet in a moFEM field.
Definition MeshsetsManager.hpp:72
MoFEM::MeshsetsManager::addMeshset
MoFEMErrorCode addMeshset(const CubitBCType cubit_bc_type, const int ms_id, const std::string name="")
Add CUBIT meshset to manager.
Definition MeshsetsManager.cpp:506
_IT_CUBITMESHSETS_FOR_LOOP_
#define _IT_CUBITMESHSETS_FOR_LOOP_(MESHSET_MANAGER, IT)
Iterator that loops over all the Cubit MeshSets in a moFEM field.
Definition MeshsetsManager.hpp:57
MoFEM::MeshsetsManager::setAttributesByDataStructure
MoFEMErrorCode setAttributesByDataStructure(const CubitBCType cubit_bc_type, const int ms_id, const GenericAttributeData &data, const std::string name="")
Set attributes using data structure.
Definition MeshsetsManager.cpp:666
_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_
#define _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet having a particular BC meshset in a moFEM field.
Definition MeshsetsManager.hpp:94
MoFEM::Types::CubitBCType
std::bitset< 32 > CubitBCType
Definition Types.hpp:52
MoFEM::CoreTmp< 0 >
Core (interface) class.
Definition Core.hpp:83
MoFEM::CoreTmp< 0 >::Initialize
static MoFEMErrorCode Initialize(int *argc, char ***args, const char file[], const char help[])
Initializes the MoFEM database PETSc, MOAB and MPI.
Definition Core.cpp:68
MoFEM::CoreTmp< 0 >::Finalize
static MoFEMErrorCode Finalize()
Checks for options to be called at the conclusion of the program.
Definition Core.cpp:123
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition DeprecatedCoreInterface.hpp:16
MoFEM::DisplacementCubitBcData
Definition of the displacement bc data structure.
Definition BCData.hpp:72
MoFEM::ForceCubitBcData
Definition of the force bc data structure.
Definition BCData.hpp:135
MoFEM::HeatFluxCubitBcData
Definition of the heat flux bc data structure.
Definition BCData.hpp:423
MoFEM::LogManager
Log manager is used to build and partition problems.
Definition LogManager.hpp:26
MoFEM::LogManager::createSink
static boost::shared_ptr< SinkType > createSink(boost::shared_ptr< std::ostream > stream_ptr, std::string comm_filter)
Create a sink object.
Definition LogManager.cpp:293
MoFEM::LogManager::getStrmSelf
static boost::shared_ptr< std::ostream > getStrmSelf()
Get the strm self object.
Definition LogManager.cpp:335
MoFEM::Mat_Elastic_TransIso
Transverse Isotropic material data structure.
Definition MaterialBlocks.hpp:371
MoFEM::Mat_Elastic_TransIso::data
_data_ data
Definition MaterialBlocks.hpp:384
MoFEM::Mat_Elastic
Elastic material data structure.
Definition MaterialBlocks.hpp:139
MoFEM::Mat_Elastic::data
_data_ data
Definition MaterialBlocks.hpp:157
MoFEM::Mat_Thermal
Thermal material data structure.
Definition MaterialBlocks.hpp:201
MoFEM::MeshsetsManager
Interface for managing meshsets containing materials and boundary conditions.
Definition MeshsetsManager.hpp:208
MoFEM::MeshsetsManager::setMeshsetFromFile
MoFEMErrorCode setMeshsetFromFile(const string file_name, const bool clean_file_options=true)
add blocksets reading config file
Definition MeshsetsManager.cpp:958
MoFEM::PressureCubitBcData
Definition of the pressure bc data structure.
Definition BCData.hpp:375
MoFEM::TemperatureCubitBcData
Definition of the temperature bc data structure.
Definition BCData.hpp:302
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition UnknownInterface.hpp:93

Variable Documentation

◆ help

char help[] = "...\n\n"
static

Definition at line 12 of file add_cubit_meshsets.cpp.

Generated by Doxygen 1.9.8 and hosted at University of Glasgow