IAInterface.hpp

Go to the documentation of this file.

// IAInterface.hpp MeshKit version

#ifndef MESHKIT_IA_INTERFACE_HP
#define MESHKIT_IA_INTERFACE_HP

#include "meshkit/IAVariable.hpp"
#include "meshkit/Types.hpp"
#include "meshkit/Error.hpp"
#include "meshkit/MeshScheme.hpp"
#include "meshkit/ModelEnt.hpp"
#include "moab/Interface.hpp"

#include <set>
#include <vector>

namespace MeshKit {

class IAData;
class IASolution;

class IAInterface : public MeshScheme // register it with SchemeFactory
{
public:
  IAInterface(MKCore *mkcore, const MEntVector &me_vec = MEntVector()) : MeshScheme(mkcore, me_vec){}

  virtual ~IAInterface();
  IAVariable *get_variable( ModelEnt* model_entity = NULL, bool create_if_missing = true );
  // there is a reason we don't provide default parameters here, don't combine with above version.
  IAVariable *create_variable( ModelEnt* model_entity, IAVariable::Firmness set_firmness, double goal_value);
  
  typedef std::vector< IAVariable* > VariableVec;
  VariableVec::const_iterator variables_begin() const {return variables.begin();}
  VariableVec::const_iterator variables_end() const {return variables.end();}
  
  void destroy_variable( IAVariable* ia_variable );
  //typedef std::vector<ModelEnt*> MEVec;
  // Types.hpp defines std::vector<ModelEnt*> MeshKit::MEntVector
  typedef std::vector<IAVariable*> IAVariableVec;
    // convert vector of ModelEntities into vector of IAVariables
  IAVariableVec make_constraint_group( const MEntVector &model_entity_vec );
  
  void constrain_sum_equal( const IAVariableVec &side_one, const IAVariableVec &side_two );
  void constrain_sum_even( const IAVariableVec &sum_even_vars );
  //... additional constraint types...
  virtual void setup_this();

  virtual void execute_this();
  static const char* name() 
    { return "IntervalAssignment"; }

  static bool can_mesh(iBase_EntityType dim)
    { return iBase_VERTEX <= dim && iBase_REGION >= dim; }

  static bool can_mesh(ModelEnt *model_ent)
      { return can_mesh((iBase_EntityType)model_ent->dimension()); }
    
  static const moab::EntityType* output_types();

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

  void print_problem() const;
  
  void destroy_data();
  
private:
  // data
  VariableVec variables;
  typedef std::vector< VariableVec > VariableVecVec;
  VariableVecVec sumEqualConstraints1, sumEqualConstraints2; // one for each side
  VariableVecVec sumEvenConstraints;
  // ... additional types of constraints ...
  
  int variable_to_index(const IAVariable* var) const;
  IAVariable *index_to_variable(int ind) const;


  typedef std::set<int> IndexSet;
  typedef std::vector< IndexSet > IndexSetVec;
  typedef std::vector< int > IndexVec;
  typedef std::vector< IndexVec > IndexVecVec;

  void make_set_0_to_nm1( IndexSet &index_set, const size_t k); 
  void make_vec_0_to_nm1( IndexVec &index_vec, const size_t k); 
  void make_vec_unset( IndexVec &index_vec, const size_t k );

  struct VariableConstraintDependencies
  {
    IndexVecVec constraintVariables, variableConstraints;
    void print() const; // debug
  };  

  void set_variable_constraint_indices(VariableConstraintDependencies &var_con_dep);

  void set_variable_constraint_indices( VariableConstraintDependencies &var_con_dep,
                                                                                const int i_start, 
                                        const VariableVecVec &variable_vec_vec );

  class ProblemSets
  {
   public:
    IndexSet constraintSet, variableSet, hardVariableSet;
    IndexVec varMap; // map from local indices to indices in other set, i.e sub->global or global->sub
    bool empty() const {return constraintSet.empty() && variableSet.empty();}
    // default constructor makes empty sets, with an empty map, suitable for sub_problem initialization
    
    void find_dependent_set( const VariableConstraintDependencies &var_con_dep, ProblemSets &subsets );
 
                                       
    void find_variable_dependent_set( const int variable_j, 
                                      const VariableConstraintDependencies &var_con_dep, 
                                      ProblemSets &subsets );
  
    void find_constraint_dependent_set( const int constraint_i, 
                                        const VariableConstraintDependencies &var_con_dep, 
                                        ProblemSets &subsets );

    void print() const; // debug
  };
  void make_global_set(ProblemSets &problem_sets);

  void global_to_sub_side( const VariableVec &global_constraint, IndexVec &global_var_map, 
                           IndexVec &local_constraint, int &rhs ) const;

  struct SubProblem
  {
    static int max_id;
    int id;
    IAData *data;
    ProblemSets problemSets;
    IASolution *solution;
    void print() const; // debug
    SubProblem();
    virtual ~SubProblem();
  };
  typedef std::vector<SubProblem*> SubProblemVec;
  
  void fill_problem( ProblemSets &sub_sets, SubProblem *sub_problem, IndexVec &global_var_map ) const;

  void subdivide_problem(SubProblemVec &subproblems);
  void subdivide_problem_one(std::vector<IAData*> &subproblems); // just make one problem
  
  bool solve_subproblem( SubProblem *subproblem );
  
  void assign_solution( SubProblem *subproblem );
  
  static const bool debugging;
  
};

} // namespace MeshKit

#endif

/*
todo:
It shouldn't be a singleton, since there are cases I can envision where you'd want a local one.

Since IAInterface is a GraphNode, it will get destructed when the graph goes away.

- tim

On 10/26/2012 05:38 PM, Mitchell, Scott A wrote:

I'm a little confused about mkCore constructing an IAInterface.
How, if at all, is it destructed?

Should there be just one IAInterface, or many?

- Scott
*/