omega_h_n.h

vs.lib is a math library in C++ with a set of linear algebra and integrable / differentiable objects

#ifndef __OMEGA_H_N_H
#define __OMEGA_H_N_H

//==============================================================================
//
//   classes for
//   A. One Region, Many Fields:
//   	Mixed and Lagrangian Multiplier Formulation, Hybrid Method
//    Coupled Problems
//   B. Many Regions, One Field:
//   	Static Condensation (Substructuring), Contact Mechanics
//
//==============================================================================

class Omega_h_i : public Omega_h {
	int the_index;
	public:
   Omega_h_i(int i); // client program suplied constructor
   int index() const { return the_index; }
};

class gh_on_Gamma_h_i : public gh_on_Gamma_h {
	int the_index;
	public:
   gh_on_Gamma_h_i(int i, int ndf, Omega_h& omega_h); // client program suplied constructor
   int index() const { return the_index; }
};

//==============================================================================
//
// classes Matrix_Representation_Couple and Element_Formulation_Couple are designed
// for One_Region-Many_Field Problems (Mixed, Hybrid, and Coupled)
//
//==============================================================================

class Global_Discretization_Couple : public Global_Discretization {
	Global_Discretization_Couple *type_id;
	Global_Discretization& the_subordinate_discretization;
public:
	Global_Discretization_Couple(Global_Discretization& principal = Global_Discretization(),
   	Global_Discretization& subordinate = Global_Discretization(),
      Global_Discretization_Couple *id = 0) : Global_Discretization(principal),
      the_subordinate_discretization(subordinate), type_id(id) {}
   Global_Discretization_Couple(const Global_Discretization_Couple& a) :
   	Global_Discretization(a), the_subordinate_discretization(a.the_subordinate_discretization), type_id(a.type_id) {}
   Global_Discretization_Couple& operator=(const Global_Discretization_Couple&);
   Global_Discretization& global_discretization() { return *((Global_Discretization*)this); }
   Global_Discretization global_discretization() const { return *((Global_Discretization*)this); }
   Global_Discretization& principal_discretization() { return global_discretization(); }
   Global_Discretization principal_discretization() const { return global_discretization(); }
   Global_Discretization& subordinate_discretization() { return the_subordinate_discretization; }
   Global_Discretization subordinate_discretization() const { return the_subordinate_discretization; }
   Global_Discretization* type() const { return type_id; }
   Global_Discretization* type() { return type_id; }
};

class Element_Formulation_Couple : public Element_Formulation {
	Global_Discretization& the_subordinate_discretization;
protected:
	int s_element_no, s_material_type_no, s_nen, s_nsd, s_ndf;
	C0 s_xl,                 // nodal coordinates
      s_gl,                 // nodal fixed variables
      s_ul,                 // nodal free variables
   	s_force,              // calculated in user supplied Element Formulation Constructor
      the_s_reaction,       // - s_stiff * s_gl
      the_s_rhs;
   virtual C0& __lhs();                   
   virtual C0& __reaction();              virtual C0& __s_reaction();
   virtual C0& __rhs();                   virtual C0& __s_rhs();
public:
   Element_Formulation_Couple(Element_Type_Register a);
   virtual ~Element_Formulation_Couple() {} // do nothing
   // for diagonal block
   virtual Element_Formulation *make(int, Global_Discretization&) { return 0; }
   Element_Formulation_Couple(int, Global_Discretization&);
   // for off-diagonal block
   virtual Element_Formulation_Couple *make(int, Global_Discretization_Couple& gdc) { return 0; }
   Element_Formulation_Couple(int, Global_Discretization_Couple& gdc);
	// to be called by Matrix_Representation_Couple assembly memember function
	C0& lhs() { return __lhs(); }
	C0& reaction() { return __reaction(); }
	C0& rhs();
   C0& subordinate_reaction() { return __s_reaction(); }
   C0& subordinate_rhs() { return __s_rhs(); }
};

class Matrix_Representation_Couple : public Matrix_Representation {
   Global_Discretization &the_subordinate_discretization;
   friend class Coupled_Global_Tensor;
	Coupled_Global_Tensor *the_lhs;
	friend class Element_Tensor;
   friend class Global_Tensor;
   int rhs_owner;                      // flag for principal rhs ownership
   Global_Tensor *the_rhs,           
                 *the_subordinate_rhs; // always by reference
   int total_var_no, **var;
   Global_Discretization_Couple *gdc_type_id;
	Matrix_Representation *the_subordinate_matrix_representation;
public:
   void __initialization(char *s, Global_Tensor*, Global_Tensor*);
	enum assembly_switch { ALL = 0, // default for member function assembly
   	                    LHS, RHS, LHS_AND_RHS, SUBORDINATE_RHS};
   static assembly_switch Assembly_Switch;
   Matrix_Representation_Couple(Global_Discretization_Couple& gdc = Global_Discretization_Couple(),
      char* s = 0, Global_Tensor* principal_rhs = 0, Global_Tensor* subordinate_rhs = 0,
      Matrix_Representation* = 0);
   Matrix_Representation_Couple(const Matrix_Representation_Couple&);
   Matrix_Representation_Couple& operator=(const Matrix_Representation_Couple&);
	~Matrix_Representation_Couple();
   Global_Tensor& lhs() { return *((Global_Tensor*)the_lhs); }
   Global_Tensor& rhs() { return *the_rhs; }
   Global_Tensor*& rhs_ptr() { return the_rhs; }
   Global_Tensor& subordinate_rhs() { return *the_subordinate_rhs; }
   Global_Discretization& global_discretization() { return Matrix_Representation::global_discretization(); }
   Global_Discretization global_discretization() const { 
	   return ((Matrix_Representation)(*this)).Matrix_Representation::global_discretization(); }
   Global_Discretization& principal_discretization() { return Matrix_Representation::global_discretization(); }
   Global_Discretization principal_discretization() const { 
	   return ((Matrix_Representation)(*this)).Matrix_Representation::global_discretization(); }
   Global_Discretization& subordinate_discretization() { return the_subordinate_discretization; }
   Global_Discretization subordinate_discretization() const { return the_subordinate_discretization; }
   Matrix_Representation* subordinate_matrix_representation() { return the_subordinate_matrix_representation; }
   int** equation_no_table() { return eqn; } // for principal dof
   int** variable_no_table() { return var; } // for subordinate dof
   Global_Discretization_Couple* gdc_type() const { return gdc_type_id; }
   Global_Discretization_Couple* gdc_type() { return gdc_type_id; }
   void assembly(int en1 = -1, int en2 = 0, int eni = 1, int nodal_load_flag = TRUE);
};

class Coupled_Global_Tensor : public Global_Tensor {
	Matrix_Representation_Couple &the_matrix_representation_couple;
public:
	Coupled_Global_Tensor(C0& cgt = C0(), Matrix_Representation_Couple &mrc = Matrix_Representation_Couple())
   	: Global_Tensor(cgt, mrc), the_matrix_representation_couple(mrc) {}
   Coupled_Global_Tensor(const Coupled_Global_Tensor& a) : Global_Tensor(a),
   	the_matrix_representation_couple(a.the_matrix_representation_couple) { }
   Coupled_Global_Tensor& operator=(const Coupled_Global_Tensor& a) {
   	if(this == &a) return *this;
   	the_matrix_representation_couple = a.the_matrix_representation_couple;
      return *this;
   }
   operator C0() { return Global_Tensor::global_tensor(); }
   C0& global_tensor() { return Global_Tensor::global_tensor(); }
   C0 global_tensor() const { return Global_Tensor::global_tensor(); }
	C0& operator+=(Element_Tensor& element_tensor);
};

#endif