section_evaluator.h

//
// 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.
//

// Interface for class section_evaluator

#ifndef SECTION_EVALUATOR_H
#define SECTION_EVALUATOR_H

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

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

#ifndef FIBER_BUNDLE_H
#include "SheafSystem/fiber_bundle.h"
#endif

#ifndef POD_TYPES_H
#include "SheafSystem/pod_types.h"
#endif
  
namespace sheaf
{
template <typename T> class block;
}

namespace fiber_bundle
{

using namespace sheaf;

class SHEAF_DLL_SPEC section_evaluator : public any
{

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

public:
 
  // The following types are derived from the role the evaluators play
  // in the section space classes. The domain of an evaluator must be
  // a local chart of a base space and the range must be a fiber space.
  // Hence the coord type here must be chart_point::coord_type and the value
  // type here must be vd::value_type. Although it is tempting to make a
  // similar argument about the dof type, the sections and the fibers don't
  // actually share representations or dofs anywhere, so there is no reason
  // in principle they need to be the same type. In practice, of course,
  // everything is a double.

  typedef chart_point_coord_type coord_type;

  typedef vd_value_type value_type;

  typedef sec_vd_dof_type dof_type;


  section_evaluator(const section_evaluator& xother);

  virtual ~section_evaluator();

protected:

  section_evaluator();

private:


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

public:
 
  virtual int db() const = 0;

  virtual void local_coordinates(pod_index_type xindex,
                                 coord_type xresult[],
                                 size_type xresult_ub) const = 0;

  void local_coordinates(pod_index_type xindex, block<coord_type>& xresult) const;

  virtual void center(coord_type xresult[], size_type xresult_ub) const;

  void center(block<coord_type>& xresult) const;

  virtual bool in_standard_domain(const dof_type xlocal_coords[],
                                  size_type xlocal_coords_ub) const = 0;

  bool in_standard_domain(const block<dof_type>& xlocal_coords) const;

protected:

private:


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

public:

  virtual size_type dof_ct() const = 0;

  bool df_is_variable() const;
  
  virtual int df() const;

  virtual dof_type value_at_coord(const dof_type xdofs[],
                                  size_type xdofs_ub,
                                  const dof_type xlocal_coords[],
                                  size_type xlocal_coords_ub) const;

  dof_type value_at_coord(const block<dof_type>& xdofs,
                          const block<dof_type>& xlocal_coords) const;

  virtual void value_at_coord(const dof_type xdofs[],
                              size_type xdofs_ub,
                              const dof_type xlocal_coords[],
                              size_type xlocal_coords_ub,
                              dof_type xresult[],
                              size_type xresult_ub) const = 0;
  void value_at_coord(const block<dof_type>& xdofs,
                      const block<dof_type>& xlocal_coords,
                      block<dof_type>& xresult) const;
  virtual void coord_at_value(const dof_type xdofs[],
                              size_type xdofs_ub,
                              const dof_type xvalue[],
                              size_type xvalue_ub,
                              dof_type xlocal_coords[],
                              size_type xlocal_coords_ub) const = 0;

  void coord_at_value(const block<dof_type>& xdofs,
                      const block<dof_type>& xvalue,
                      block<dof_type>& xlocal_coords) const;
 
  virtual dof_type min(const dof_type xdofs[], size_type xdofs_ub) const;

  dof_type min(const block<dof_type>& xdofs) const;

  virtual void min(const dof_type xdofs[],
                   size_type xdofs_ub,
                   dof_type xresult[],
                   size_type xresult_ub) const;

  void min(const block<dof_type>& xdofs, block<dof_type>& xresult) const;

  virtual dof_type max(const dof_type xdofs[], size_type xdofs_ub) const;

  dof_type max(const block<dof_type>& xdofs) const;

  virtual void max(const dof_type xdofs[],
                   size_type xdofs_ub,
                   dof_type xresult[],
                   size_type xresult_ub) const;

  void max(const block<dof_type>& xdofs, block<dof_type>& xresult) const;

protected:

private:



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

public:
 
  virtual section_evaluator* clone() const = 0;

  virtual section_evaluator& operator=(const section_evaluator& xother);

  virtual bool invariant() const;

  virtual bool is_ancestor_of(const any* other) const;

protected:

private:


};

//==============================================================================
// NON-MEMBER FUNCTIONS
//==============================================================================

size_t
SHEAF_DLL_SPEC
deep_size(const section_evaluator& xe, bool xinclude_shallow = true);
 

} // namespace fiber_bundle

#endif // ifndef SECTION_EVALUATOR_H