MOAB: Mesh Oriented datABase  (version 5.4.1)
Public Member Functions | Private Member Functions | Private Attributes
MBMesquite::TargetWriter Class Reference

#include <TargetWriter.hpp>

+ Inheritance diagram for MBMesquite::TargetWriter:
+ Collaboration diagram for MBMesquite::TargetWriter:

Public Member Functions

MESQUITE_EXPORT TargetWriter (TargetCalculator *tc, WeightCalculator *wc=0, std::string target_base_name="MSQ_TARGET_MATRIX", std::string weight_base_name="MSQ_TARGET_WEIGHT")
virtual MESQUITE_EXPORT ~TargetWriter ()
MESQUITE_EXPORT double loop_over_mesh (MeshDomainAssoc *mesh_and_domain, const Settings *, MsqError &)
MESQUITE_EXPORT void initialize_queue (MeshDomainAssoc *mesh_and_domain, const Settings *settings, MsqError &err)
MESQUITE_EXPORT std::string get_name () const
 Get string name for use in diagnostic and status output.

Private Member Functions

TagHandle get_target_tag (unsigned dimension, unsigned count, Mesh *mesh, MsqError &err)
TagHandle get_weight_tag (unsigned count, Mesh *mesh, MsqError &err)
TagHandle get_tag_handle (const std::string &base_name, unsigned num_dbl, Mesh *mesh, MsqError &err)

Private Attributes

TargetCalculator * targetCalc
WeightCalculator * weightCalc
std::string targetName
std::string weightName
std::vector< TagHandle > targetTags
std::vector< TagHandle > weightTags

Detailed Description

Save target matrices in tag data

Store element target matrices in tag data. The stored target matrices may be retreived using the TargetReader class.

Definition at line 50 of file TargetWriter.hpp.

Constructor & Destructor Documentation

MBMesquite::TargetWriter::TargetWriter ( TargetCalculator *  tc,
WeightCalculator *  wc = 0,
std::string  target_base_name = "MSQ_TARGET_MATRIX",
std::string  weight_base_name = "MSQ_TARGET_WEIGHT" 
)

Definition at line 48 of file TargetWriter.cpp.

    : targetCalc( tc ), weightCalc( wc ), targetName( target_base_name ), weightName( weight_base_name )
{
}
MBMesquite::TargetWriter::~TargetWriter ( ) [virtual]

Definition at line 56 of file TargetWriter.cpp.

{}

Member Function Documentation

std::string MBMesquite::TargetWriter::get_name ( ) const [virtual]

Get string name for use in diagnostic and status output.

Implements MBMesquite::Instruction.

Definition at line 58 of file TargetWriter.cpp.

{
    return "TargetWriter";
}
TagHandle MBMesquite::TargetWriter::get_tag_handle ( const std::string &  base_name,
unsigned  num_dbl,
Mesh *  mesh,
MsqError &  err 
) [private]

Definition at line 222 of file TargetWriter.cpp.

References MBMesquite::MsqError::clear(), MBMesquite::Mesh::DOUBLE, MBMesquite::MsqError::error_code(), MSQ_CHKERR, MSQ_ERRZERO, MSQ_SETERR, MBMesquite::MsqError::TAG_ALREADY_EXISTS, MBMesquite::Mesh::tag_create(), MBMesquite::Mesh::tag_get(), MBMesquite::MsqError::TAG_NOT_FOUND, and MBMesquite::Mesh::tag_properties().

Referenced by get_target_tag(), and get_weight_tag().

{
    std::ostringstream sstr;
    sstr << base_name << num_dbl;

    TagHandle handle = mesh->tag_get( sstr.str().c_str(), err );
    if( !MSQ_CHKERR( err ) )
    {
        std::string temp_name;
        Mesh::TagType temp_type;
        unsigned temp_length;
        mesh->tag_properties( handle, temp_name, temp_type, temp_length, err );
        MSQ_ERRZERO( err );

        if( temp_type != Mesh::DOUBLE || temp_length != num_dbl )
        {
            MSQ_SETERR( err )
            ( MsqError::TAG_ALREADY_EXISTS, "Mismatched type or length for existing tag \"%s\"", sstr.str().c_str() );
        }
    }
    else if( err.error_code() == MsqError::TAG_NOT_FOUND )
    {
        err.clear();
        handle = mesh->tag_create( sstr.str().c_str(), Mesh::DOUBLE, num_dbl, 0, err );
        MSQ_ERRZERO( err );
    }
    return handle;
}
TagHandle MBMesquite::TargetWriter::get_target_tag ( unsigned  dimension,
unsigned  count,
Mesh *  mesh,
MsqError &  err 
) [private]

Definition at line 188 of file TargetWriter.cpp.

References dim, get_tag_handle(), MBMesquite::TargetCalculator::have_surface_orient(), MSQ_CHKERR, targetCalc, targetName, and targetTags.

Referenced by loop_over_mesh().

{
    if( dim == 2 && !targetCalc->have_surface_orient() )
        count *= 4;
    else
        count *= 3 * dim;  // num doubles
    if( targetTags.size() <= count ) targetTags.resize( count + 1, 0 );
    if( !targetTags[count] )
    {
        targetTags[count] = get_tag_handle( targetName, count, mesh, err );
        if( MSQ_CHKERR( err ) )
        {
            targetTags[count] = 0;
            return 0;
        }
    }
    return targetTags[count];
}
TagHandle MBMesquite::TargetWriter::get_weight_tag ( unsigned  count,
Mesh *  mesh,
MsqError &  err 
) [private]

Definition at line 207 of file TargetWriter.cpp.

References get_tag_handle(), MSQ_CHKERR, weightName, and weightTags.

Referenced by loop_over_mesh().

{
    if( weightTags.size() <= count ) weightTags.resize( count + 1, 0 );
    if( !weightTags[count] )
    {
        weightTags[count] = get_tag_handle( weightName, count, mesh, err );
        if( MSQ_CHKERR( err ) )
        {
            weightTags[count] = 0;
            return 0;
        }
    }
    return weightTags[count];
}
void MBMesquite::TargetWriter::initialize_queue ( MeshDomainAssoc *  mesh_and_domain,
const Settings *  settings,
MsqError &  err 
) [virtual]

Called for all instructions in queue before loop_over_mesh is called for any insetruction in queue. Default behavior is to do nothing.

Implements MBMesquite::Instruction.

Definition at line 251 of file TargetWriter.cpp.

{}
double MBMesquite::TargetWriter::loop_over_mesh ( MeshDomainAssoc *  mesh_and_domain,
const Settings *  settings,
MsqError &  err 
) [virtual]

Virtual fuction implementing primary functionaliy of instruction instance.

Implements MBMesquite::Instruction.

Definition at line 63 of file TargetWriter.cpp.

References MBMesquite::arrptr(), MBMesquite::PatchData::attach_settings(), moab::cross(), MBMesquite::det(), dim, MBMesquite::PatchData::element_by_index(), MBMesquite::TargetCalculator::get_2D_target(), MBMesquite::TargetCalculator::get_3D_target(), MBMesquite::MeshDomainAssoc::get_domain(), MBMesquite::PatchData::get_element_handles_array(), MBMesquite::MsqMeshEntity::get_element_type(), MBMesquite::MeshDomainAssoc::get_mesh(), MBMesquite::ElementPatches::get_patch(), MBMesquite::ElementPatches::get_patch_handles(), MBMesquite::PatchData::get_samples(), MBMesquite::TargetCalculator::get_surface_target(), get_target_tag(), MBMesquite::WeightCalculator::get_weight(), get_weight_tag(), MBMesquite::TargetCalculator::have_surface_orient(), MBMesquite::MsqError::INVALID_ARG, mesh, MSQ_ERRZERO, MSQ_SETERR, MBMesquite::PatchData::num_elements(), MBMesquite::PatchData::set_domain(), MBMesquite::PatchSet::set_mesh(), MBMesquite::PatchData::set_mesh(), MBMesquite::PatchData::set_mesh_entities(), MBMesquite::Mesh::tag_set_element_data(), targetCalc, and weightCalc.

Referenced by TargetReadWriteTest::read_write_2D_targets(), TargetReadWriteTest::read_write_3D_targets(), TargetReadWriteTest::read_write_surface_targets(), and TargetReadWriteTest::read_write_weights().

{
    Mesh* mesh         = mesh_and_domain->get_mesh();
    MeshDomain* domain = mesh_and_domain->get_domain();

    PatchData patch;
    patch.set_mesh( mesh );
    patch.set_domain( domain );
    if( settings ) patch.attach_settings( settings );

    ElementPatches patch_set;
    patch_set.set_mesh( mesh );
    std::vector< PatchSet::PatchHandle > patches;
    std::vector< PatchSet::PatchHandle >::iterator p;
    std::vector< Mesh::VertexHandle > patch_verts;
    std::vector< Mesh::ElementHandle > patch_elems;

    patch_set.get_patch_handles( patches, err );
    MSQ_ERRZERO( err );

    std::vector< MsqMatrix< 3, 3 > > targets3d;
    std::vector< MsqMatrix< 3, 2 > > targets2dorient;
    std::vector< MsqMatrix< 2, 2 > > targets2d;
    std::vector< double > weights;
    std::vector< Sample > samples;
    for( p = patches.begin(); p != patches.end(); ++p )
    {
        patch_verts.clear();
        patch_elems.clear();
        patch_set.get_patch( *p, patch_elems, patch_verts, err );
        MSQ_ERRZERO( err );
        patch.set_mesh_entities( patch_elems, patch_verts, err );
        MSQ_ERRZERO( err );
        assert( patch.num_elements() == 1 );

        MsqMeshEntity& elem = patch.element_by_index( 0 );
        EntityTopology type = elem.get_element_type();
        patch.get_samples( 0, samples, err );
        MSQ_ERRZERO( err );
        if( samples.empty() ) continue;

        if( targetCalc )
        {
            const unsigned dim = TopologyInfo::dimension( type );
            if( dim == 3 )
            {
                targets3d.resize( samples.size() );
                for( unsigned i = 0; i < samples.size(); ++i )
                {
                    targetCalc->get_3D_target( patch, 0, samples[i], targets3d[i], err );
                    MSQ_ERRZERO( err );

                    if( DBL_EPSILON > det( targets3d[i] ) )
                    {
                        MSQ_SETERR( err )( "Inverted 3D target", MsqError::INVALID_ARG );
                        return 0.0;
                    }
                }

                TagHandle tag = get_target_tag( 3, samples.size(), mesh, err );
                MSQ_ERRZERO( err );
                mesh->tag_set_element_data( tag, 1, patch.get_element_handles_array(), arrptr( targets3d ), err );
                MSQ_ERRZERO( err );
            }
            else if( targetCalc->have_surface_orient() )
            {
                targets2dorient.resize( samples.size() );
                for( unsigned i = 0; i < samples.size(); ++i )
                {
                    targetCalc->get_surface_target( patch, 0, samples[i], targets2dorient[i], err );
                    MSQ_ERRZERO( err );

                    MsqMatrix< 3, 1 > cross = targets2dorient[i].column( 0 ) * targets2dorient[i].column( 1 );
                    if( DBL_EPSILON > ( cross % cross ) )
                    {
                        MSQ_SETERR( err )( "Degenerate 2D target", MsqError::INVALID_ARG );
                        return 0.0;
                    }
                }

                TagHandle tag = get_target_tag( 2, samples.size(), mesh, err );
                MSQ_ERRZERO( err );
                mesh->tag_set_element_data( tag, 1, patch.get_element_handles_array(), arrptr( targets2dorient ), err );
                MSQ_ERRZERO( err );
            }
            else
            {
                targets2d.resize( samples.size() );
                for( unsigned i = 0; i < samples.size(); ++i )
                {
                    targetCalc->get_2D_target( patch, 0, samples[i], targets2d[i], err );
                    MSQ_ERRZERO( err );

                    if( DBL_EPSILON > det( targets2d[i] ) )
                    {
                        MSQ_SETERR( err )( "Degenerate/Inverted 2D target", MsqError::INVALID_ARG );
                        return 0.0;
                    }
                }

                TagHandle tag = get_target_tag( 2, samples.size(), mesh, err );
                MSQ_ERRZERO( err );
                mesh->tag_set_element_data( tag, 1, patch.get_element_handles_array(), arrptr( targets2d ), err );
                MSQ_ERRZERO( err );
            }
        }

        if( weightCalc )
        {
            weights.resize( samples.size() );
            for( unsigned i = 0; i < samples.size(); ++i )
            {
                weights[i] = weightCalc->get_weight( patch, 0, samples[i], err );
                MSQ_ERRZERO( err );
            }
            TagHandle tag = get_weight_tag( samples.size(), mesh, err );
            MSQ_ERRZERO( err );
            mesh->tag_set_element_data( tag, 1, patch.get_element_handles_array(), arrptr( weights ), err );
            MSQ_ERRZERO( err );
        }
    }

    return 0.0;
}

Member Data Documentation

TargetCalculator* MBMesquite::TargetWriter::targetCalc [private]

Definition at line 75 of file TargetWriter.hpp.

Referenced by get_target_tag(), and loop_over_mesh().

std::string MBMesquite::TargetWriter::targetName [private]

Definition at line 78 of file TargetWriter.hpp.

Referenced by get_target_tag().

std::vector< TagHandle > MBMesquite::TargetWriter::targetTags [private]

Definition at line 79 of file TargetWriter.hpp.

Referenced by get_target_tag().

WeightCalculator* MBMesquite::TargetWriter::weightCalc [private]

Definition at line 76 of file TargetWriter.hpp.

Referenced by loop_over_mesh().

std::string MBMesquite::TargetWriter::weightName [private]

Definition at line 78 of file TargetWriter.hpp.

Referenced by get_weight_tag().

std::vector< TagHandle > MBMesquite::TargetWriter::weightTags [private]

Definition at line 79 of file TargetWriter.hpp.

Referenced by get_weight_tag().

List of all members.

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines