AssyGen.hpp

Go to the documentation of this file.

//-----------------------------------C++-------------------------------------//
// File: src/algs/meshkit/AssyGen.hpp
//
// Brief: AssyGen class definition:
//        Creates reactor assembly geometry (ACIS or OCC format) and cubit mesh script as specified in a user defined input
//         class, AssyGen
//---------------------------------------------------------------------------//

#ifndef MESHKIT_ASSYGEN_HPP
#define MESHKIT_ASSYGEN_HPP

#include <cassert>
#include <string>
#include <vector>
#include <set>

#include "meshkit/Types.hpp"
#include "meshkit/Error.hpp"
#include "meshkit/MeshScheme.hpp"
#include "meshkit/ModelEnt.hpp"
#include "meshkit/MKCore.hpp"
#include "meshkit/SizingFunction.hpp"
#include "meshkit/RegisterMeshOp.hpp"

#include "meshkit/LocalSet.hpp"
#include "meshkit/LocalTag.hpp"
#include "meshkit/Matrix.hpp"

#include "meshkit/iMesh.hpp"
//#include "meshkit/iGeom.hpp"
#include "iGeom.h"
#include "MBCN.h"

#include "meshkit/SimpleArray.hpp"

#include "meshkit/vectortemplate.hpp"
#include "meshkit/matrixtemplate.hpp"
#include "meshkit/pincell.hpp"
#include "meshkit/parser.hpp"
#include "meshkit/clock.hpp"

namespace MeshKit {

#define DEFAULT_TEST_FILE  "assygen_default"
#define TEST_FILE_NAME "assygen_default"

//#define CHECK( STR ) if (err != iBase_SUCCESS) return Print_Error( STR, err, geom, __FILE__, __LINE__ )

  enum ErrorStates {PINCELLS, INVALIDINPUT, EMAT, EGEOMTYPE, EGEOMENGINE, ENEGATIVE, EALIAS, EPIN, EUNEQUAL};

  class MKCore;

  class AssyGen : public MeshScheme
  {
  public:
    /* \brief Constructor
     *
     * Create a new AssyGen instance
     * \param impl the iGeom instance handle for the Geom
     */
    AssyGen(MKCore *mk, const MEntVector &me_vec);

    /* \brief Destructor
     */
    virtual ~AssyGen();

    enum ErrorStates {PINCELLS, INVALIDINPUT, EMAT, EGEOMTYPE, EGEOMENGINE, ENEGATIVE, EALIAS, EPIN, EUNEQUAL};

    static const char* name();

    static bool can_mesh(iBase_EntityType dim);

    static bool can_mesh(ModelEnt *me);

    static const moab::EntityType* output_types();

    virtual const moab::EntityType* mesh_types_arr() const;

    virtual bool add_modelent(ModelEnt *model_ent);

    virtual void setup_this();

    virtual void execute_this();

    void PrepareIO (int argc, char *argv[], std::string TestDir);

    void ReadCommonInp ();

    void ReadInputPhase1 ();

    void ReadAndCreate ();

    void CreateAssyGenInputFiles();

    void Name_Faces( const std::string sMatName, const iBase_EntityHandle body,
                     iBase_TagHandle this_tag);

    void Center_Assm( char&);

    void Section_Assm ( char&, double&, const std::string);

    void Rotate_Assm ( char&, double&);

    void Move_Assm ( double&, double&, double&);

    void Create_HexAssm( std::string &);

    void Create_CartAssm( std::string &);

    void CreateOuterCovering();

    void Imprint_Merge (bool, bool);

    void Subtract_Pins ();

    void Create2DSurf();

    void ReadPinCellData( int i);

    void CreatePinCell_Intersect( int i, double dX,
                                  double dY, double dZ);

    void CreatePinCell( int i, double dX,
                        double dY, double dZ);

    void CreateCubitJournal();

    void ComputePinCentroid( int, CMatrix<std::string>, int, int,
                             double&, double&, double&);

  private:
    // iGeom Impl for calling geometry creation/manipulation operations
    iGeom *igeomImpl;

    // number of sides in the geometry
    int m_nSides;

    // file Input
    std::ifstream m_FileInput, m_FileCommon;

    // journal file Output
    std::ofstream m_FileOutput, m_SchemesFile, m_AssmInfo, m_PyCubGeomFile;

    // string for file names
    std::string m_szSmooth, m_szAssmInfo, m_szLogFile, m_szCommonFile, m_szFile, m_szInFile,
    m_szGeomFile, m_szGeomFile1, m_szJouFile, m_szSchFile, m_szPyCubGeom;

    // matrix for holding pincell arrangement
    CMatrix<std::string> m_Assembly;

    // matrix for holding verts coordinates used in tet-meshing
    CMatrix<double> m_dMTopSurfCoords;

    // vector for duct specification
    CMatrix<double> m_dMAssmPitch, m_dMAssmPitchX, m_dMAssmPitchY, m_dMXYAssm, m_dMZAssm;

    // vector for material names
    CVector<std::string> m_szAssmMat, m_szAssmMatAlias;
    CMatrix<std::string> m_szMMAlias;

    // vector holding a pincell
    CVector<CPincell> m_Pincell;

    CVector<double> m_dAxialSize, m_dBLMatBias;

    // string for geomtype, engine, meshtype
    std::string m_szEngine;
    std::string m_szGeomType;
    std::string m_szMeshType;
    std::string m_szSideset;
    std::vector<std::string> m_szDuctMats;
    // integers for vectors sizes, err etc
    int m_nAssemblyMat, m_nDimensions, m_nPincells , m_nAssmVol, m_nPin, m_nPinX, m_nPinY, err, m_nLineNumber, m_nPlanar,
      m_nNeumannSetId, m_nMaterialSetId, m_nDuct, m_nDuctNum, m_nJouFlag, m_nAssyGenInputFiles,  m_nTotalPincells;

    // doubles for pincell pitch, pi and mesh sizes resp.
    double m_dPitch, pi, m_dRadialSize, m_dTetMeshSize, m_dMergeTol, m_dZstart, m_dZend;

    // igeom related
    SimpleArray<iBase_EntityHandle> assms, in_pins;
    //iGeom_Instance geom;
    iBase_EntitySetHandle root_set;


    // error handlers
    void IOErrorHandler (ErrorStates) const;
    friend class CPincell;

    struct superblocks{
        int m_nSuperBlockId;
        std::string m_szSuperBlockAlias;
        int m_nNumSBContents;
        CVector<int> m_nSBContents;
    };

    int m_nSuperBlocks;
    CVector<superblocks> sb;
    int tmpSB;

    // parsing related
    std::string szInputString;
    std::string szComment;
    int MAXCHARS, MAXLINES;

    std::vector< std::vector<iBase_EntityHandle> > cp_inpins;

    CVector<std::string> m_szBLAssmMat;
    CVector<int> m_nListMatSet, m_nListNeuSet, m_nBLMatIntervals;

    int m_edgeInterval;
    int m_nStartpinid;
    std::string m_szInfo;
    std::string m_szMeshScheme;
    std::string pin_name;
    int m_nHblock;
    bool m_bCreateMatFiles;
    bool save_exodus, m_bmerge, m_bimprint;
    bool have_common;
    int com_run_count;
    int m_nBLAssemblyMat;
    std::string m_szInnerDuct;
  };

  inline const char* AssyGen::name()
  {
    return "AssyGen";
  }

  inline bool AssyGen::can_mesh(iBase_EntityType)
  {
    return false;
  }

  inline bool AssyGen::can_mesh(ModelEnt *)
  {
    return true;
  }

  inline const moab::EntityType* AssyGen::mesh_types_arr() const
  {
    return output_types();
  }

} // namespace MeshKit
#endif