sec_ed_invertible.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 SEC_ED_INVERTIBLE_H
#define SEC_ED_INVERTIBLE_H

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

#ifndef SEC_ED_H
#include "SheafSystem/sec_ed.h"
#endif

#ifndef GEOMETRY_H
#include "SheafSystem/geometry.h"
#endif

namespace sheaf
{
class poset_path;
}

namespace fiber_bundle
{
class chart_point;
class chart_point_3d;
}

namespace geometry
{

class point_locator;

class SHEAF_DLL_SPEC sec_ed_invertible : public sec_ed
{

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

public:

  sec_ed_invertible();

  sec_ed_invertible(const sec_ed& xother);

  sec_ed_invertible(sec_rep_space* xhost, const scoped_index& xindex);

  sec_ed_invertible(sec_rep_space* xhost, const std::string& xname);

  sec_ed_invertible(namespace_poset* xnamespace,
                    const poset_path& xpath,
                    bool xauto_access);

  virtual sec_ed_invertible& operator=(const abstract_poset_member& xother);

  sec_ed_invertible& operator=(const sec_ed_invertible& xother);

  sec_ed_invertible& operator=(const ed& xfiber);

  sec_ed_invertible& operator=(const ed_lite& xfiber);

  ~sec_ed_invertible();

  bool is_uniform() const;

  static bool& use_d_array_point_locator();

  virtual void initialize_point_locator(bool xauto_access);

  virtual void initialize_d_array_point_locator(bool xauto_access);

  virtual void initialize_d_array_point_locator(const block<size_type>& xbin_ub,
                                                bool xauto_access);

  virtual void initialize_d_tree_point_locator(bool xauto_access);

  virtual void initialize_d_tree_point_locator(size_type xdepth,
                                               bool xauto_access);

  virtual void initialize_d_uniform_point_locator(bool xauto_access);

  virtual void update_inversion();

  bool is_invertible() const;

  const geometry::point_locator& inverter() const;

  virtual chart_point* point_at_value(const ed& xr);

  virtual void point_at_value_pa(const ed& xvalue, chart_point& xresult);

  virtual void point_at_value_ua(const sec_vd_dof_type* xvalue,
                                 size_type xvalue_ub,
                                 chart_point& xresult);


  virtual void all_points_at_value_ua(const sec_vd_value_type* xvalue,
                                      size_type xvalue_ub,
                                      block<chart_point_3d>& xresult);

  virtual void branch_points_at_value_ua(const sec_vd_value_type* xvalue,
                                         size_type xvalue_ub,
                                         block<branch_point_pair>& xresult);

protected:

  virtual void attach_handle_data_members();

private:

  point_locator* _inverter;



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

public:

  virtual sec_ed_invertible* clone() const;

  inline sec_ed_invertible* clone(bool xnew_state, bool xauto_access = true)
  {
    return static_cast<sec_ed_invertible*>
      (sec_ed::clone(xnew_state, xauto_access));
  }



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

public:

  bool is_ancestor_of(const any* other) const;

  virtual bool invariant() const;


};
 
} // namespace geometry

#endif // ifndef SEC_ED_INVERTIBLE_H