The “LoadCases” module

“getResDirName” returns a String corresponding to a directory in which result files are stored.

“getModelDirName” returns a String corresponding to a directory in which model files are stored.

“createGroups” performs the definition of Groups in a DataBase. The method has two arguments. The first argument is the DataBase object on which Groups are added. The second argument is a String corresponding to the version of the DataBase.

In the example, the method reads Groups from a Patran session files. Then, other Groups are defined by topological operations. The “version” argument is not used because all the DataBases contain the same Group definition. (Generally, Groups defined in different DataBases are not the same.)

The “createGroups” method is used when a new DataBase is defined.

“getDb” method returns the DataBase corresponding to a specified version. The version is given as a String argument. The method first checks if the requested DataBase already exists, i.e. if it is stored in @@dbList member data. If it already exists, the DataBase is returned. If it does not exists, a new DataBase is created. It is read from a BDF file, and groups are defined by a call to “createGroups” methods. The created DataBase is stored in @@dbList and returned.

Finally, the main method is the iterator “each”. This method has one argument corresponding to the version of the loop on load cases. The method defines two “proc¹ ” objects:

1.: “postList” loads Results from an op2 file and loops on the corresponding list of load cases. The list is given in the “lcList” Hash. The Results must be read from a single op2 file. The method “yields” and Array containing the DataBase, the name of the load case, and the name of the subcase for which Results are post-processed. After yielding, the Results corresponding to the load case are destroyed.
Note that the programming of this “proc” has been done in such a way that it can easily be switched to read Samcef result. This is the reason which the list of load cases to be processed is given in a Hash argument.
2.: “postCombili” builds Results by linear combination, yields the corresponding Results to a block, then destroys the Results. The created Results are defined by the name of the loadcase, by an Array containing the factors of the linear combination, by the list of elementary load case names.

When the two “proc” objects have been defined, they can be used by the definition of operations to load, yield and destroy Results. This is done in a case statement. One comments below several examples of uses:

A first set of load cases corresponds to the three load cases at constant temperature. They are defined as follows:
      case version
      when "thermo_const" then
         db=getDb("ORBIT")
         dirName=getResDirName()
         op2Name="temp_disc.op2"
         lcList={}
         lcList[1]="TEMP_PZ_COLD"
         lcList[2]="TEMP_PZ_HOT"
         lcList[3]="TEMP_PANLAT_COLD"
         lcList[4]="TEMP_PANLAT_HOT"
         postList.call

“thermo_const” is the “version” argument of the iterator. One first retrieves the DataBase corresponding to orbital (thermo-elastic) load cases by calling “getDb” method. Then, one specifies which op2 file is to be read. Finally, the list of load cases to be read and post-processed is build. Finally, the proc is called.
One gives below a second example with load cases defined by linear combinations of elementary load cases. The piece of code looks as follows:
      when "qs_launch" then
         db=getDb("LAUNCH")
         dirName=getResDirName()
         op2Name="unit_xyz.op2"
         elemNames=["LAUNCH_ONE_MS2_X","LAUNCH_ONE_MS2_Y",'
                    "LAUNCH_ONE_MS2_Z"]
         db.readOp2(getResDirName()+"/"+op2Name,"Results",elemNames)

         postCombili.call("GLOB_COMPRESSION",[0.0,0.0,-200.0],elemNames)
         postCombili.call("GLOB_TENSION",[0.0,-15.0,180.0],elemNames)
         postCombili.call("GLOB_LATERAL_1",[30.0,0.0,-50.0],elemNames)
         postCombili.call("GLOB_LATERAL_2",[21.21,21.21,-50.0],elemNames)
         postCombili.call("GLOB_LATERAL_3",[0.0,30.0,-50.0],elemNames)
         postCombili.call("GLOB_LATERAL_4",[-21.21,21.21,-50.0],elemNames)
         postCombili.call("GLOB_LATERAL_5",[-30.0,0.0,-50.0],elemNames)
         postCombili.call("GLOB_LATERAL_6",[-21.21,-21.21,-50.0],elemNames)
         postCombili.call("GLOB_LATERAL_7",[0.0,-30.0,-50.0],elemNames)
         postCombili.call("GLOB_LATERAL_8",[21.21,-21.21,-50.0],elemNames)

         elemNames.each do |name|
            db.removeResults("CaseId",name)
         end
         elemNames=nil
         GC.start

First, the DataBase is prepared and elementary load cases are read from “unit_xyz.op2”. Then the “postCombili” proc objects is called with the appropriate arguments to generate the linear combination of Results. At the end of the calculations, the elementary results are removed from the DataBase.

A peculiar case of iterator is defined by calling each iterator and yielding the returned parameters given in the block:

      when "All" then
         LoadCases::each("qs_launch") do |db,lcName,scName|
            yield([db,lcName,scName])
         end
         LoadCases::each("thermo_grad") do |db,lcName,scName|
            yield([db,lcName,scName])
         end
         LoadCases::each("thermo_const") do |db,lcName,scName|
            yield([db,lcName,scName])
         end

X.E.1.1 The “LoadCases” module