base_space_map.h

Go to the documentation of this file.

//
// Copyright (c) 2014 Limit Point Systems, Inc. 
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//


#ifndef BASE_SPACE_MAP_H
#define BASE_SPACE_MAP_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef ANY_H
#include "SheafSystem/any.h"
#endif

#ifndef FIELDS_H
#include "SheafSystem/fields.h"
#endif

#ifndef SECTION_PUSHER_PULLBACK_ACTION_H
#include "SheafSystem/section_pusher_pullback_action.h"
#endif

#ifndef SEC_ED_INVERTIBLE_H
#include "SheafSystem/sec_ed_invertible.h"
#endif

#ifndef SEC_REP_SPACE_H
#include "SheafSystem/sec_rep_space.h"
#endif

#ifndef STD_SET_H
#include "SheafSystem/std_set.h"
#endif

#ifndef STL_SCOPED_INDEX_H
#include "SheafSystem/stl_scoped_index.h"
#endif

namespace fiber_bundle
{
class base_space_poset;
class discretization_context;
class eval_iterator;
}

namespace fields
{

using namespace sheaf;
using namespace fiber_bundle; 

class base_space_map_push_action;
class field_vd;

class SHEAF_DLL_SPEC base_space_map : public any
{

  // =============================================================================
  // =============================================================================

public:

  base_space_map(const base_space_map& xother);

  base_space_map(const sec_ed& xdomain_coord, const sec_ed& xrange_coord,
                 bool xauto_access);

  virtual ~base_space_map();

  const base_space_poset& domain() const;

   const geometry::sec_ed_invertible& domain_coords() const;

   const base_space_poset& range() const;

   const sec_ed& range_coords() const;

  void push(const sec_vd& xinput, sec_vd& xoutput, bool xauto_access);

  void push(const block<sec_vd*>& xinputs, block<sec_vd*>& xoutputs, bool xauto_access);

  bool same_base(const sec_vd& xsec1, const sec_vd& xsec2, bool xauto_access) const;

  bool same_rep(const sec_vd& xsec1, const sec_vd& xsec2, bool xauto_access) const;

  bool same_fiber(const sec_vd& xsec1, const sec_vd& xsec2, bool xauto_access) const;

  base_space_map_push_action& overlap_action() const;

  base_space_map_push_action& default_overlap_action() const;

  base_space_map_push_action& extension_action() const;

  base_space_map_push_action& default_extension_action() const;

  void put_overlap_action(base_space_map_push_action& xoverlap_action);

  void put_extension_action(base_space_map_push_action& xextension_action);

protected:

  base_space_map();

private:

  base_space_poset* _domain;

  base_space_poset* _range;

  geometry::sec_ed_invertible _domain_coords;

  sec_ed _range_coords;

  typedef section_pusher_pullback_action::pb_type pb_type;

  typedef section_pusher_pullback_action::pb_map_type pb_map_type;

  typedef section_pusher_pullback_action::pb_map_itr_type pb_map_itr_type;

  typedef section_pusher_pullback_action::pb_map_range_type pb_map_range_type;

  block<pb_map_type*> _pb_maps;

  typedef void (base_space_map::*pull_back_function_type)(discretization_context&);

  void pull_back_output_disc(const sec_vd& xinput0,
                             section_space_schema_member& xoutput_schema);

  void pull_back_output_disc_mono_mono(const discretization_context& xcontext, pb_type& xpb);

  void pull_back_output_disc_mono_multi(const discretization_context& xcontext,
                                        pb_type& xpb,
                                        std::set< stl_scoped_index<> >& xbranches);

  void pull_back_output_disc_multi_mono(const discretization_context& xcontext, pb_type& xpb);

  void pull_back_output_disc_multi_multi(const discretization_context& xcontext, pb_type& xpb);

  typedef hash_multimap<pod_index_type, scoped_index> chart_to_branch_map_type;

  chart_to_branch_map_type _chart_to_branch_map;

  int _control_section;

  void set_control_section(const block<sec_vd*>& xinputs);

  scoped_index _first_branch;

  index_space_handle* _coord_branch_id_space;

  block<index_space_handle*> _prop_branch_id_spaces;

  index_space_handle* _control_branch_id_space;

  void set_branch_id_spaces(const block<sec_vd*>& xinputs);

  void make_maps(sec_vd& xinput);

  void clear_maps();

  int _prop_df;

  int _domain_db;

  block<chart_point_3d> _chart_pts;

  block<branch_point_pair> _branch_pts;

  block< block<sec_vd_dof_type>* > _in_dofs;

  block< block<sec_vd_dof_type>* > _out_dofs;

  void make_dof_buffers(const block<sec_vd*>& xinputs, block<sec_vd*>& xoutputs);

  void clear_dof_buffers();

  void define_overlap(const block<sec_vd*>& xinputs, block<sec_vd*>& xoutputs);

  void push_eval_mbr(const eval_iterator& xeval_itr,
                     const block<sec_vd*>& xinputs,
                     block<sec_vd*>& xoutputs);

  void define_extension(block<sec_vd*>& xoutputs);

  base_space_map_push_action* _overlap_action;

  base_space_map_push_action* _default_overlap_action;

  base_space_map_push_action* _extension_action;

  base_space_map_push_action* _default_extension_action;

  void initialize();



  // =============================================================================
  // =============================================================================

public:

  virtual bool invariant() const;


};


// ===========================================================
// NONMEMBER FUNCTIONS
// ===========================================================
 
} // namespace fields

#endif // ifndef BASE_SPACE_MAP_H