IntegralFace.hpp

#ifndef __FISH_CEPHALUS_LINEINTEGRATOR_HPP
#define __FISH_CEPHALUS_LINEINTEGRATOR_HPP
 
#include <eagle/PhysicalSpace.hpp>
#include <eagle/STA.hpp>
 
#include <ocean/shrimp/VObjectStatus.hpp>
#include <ocean/shrimp/VEnum.hpp>
#include <ocean/shrimp/EaglePhysicalSpaceTVector.hpp>
#include <ocean/shrimp/EaglePhysicalSpacePoint.hpp>
 
 
#include <fish/fiber/baseop/ExpandBBox.hpp>
#include <grid/types/LineSet.hpp>
 
#include <bone/FishField.hpp>
#include <bone/FishSaver.hpp>
#include <bone/Fish.hpp>
 
#include <bone/SurfaceRefinementCriterion.hpp>
 
#include <ocean/shrimp/Options.hpp>
 
#include "fishintegratorDllApi.h"
 
namespace Wizt
{
 
        using namespace Fiber;
 
 
 
class    fishintegrator_API IntegralFace : public virtual VObject,
                                           public virtual Fish<Field>,
                                           public FishGridSavable,
                                           public StatusIndicator
{
public:
        typedef Eagle::PhysicalSpace::tvector tvector;
 
        typedef MemArray<3, double>                    ScalarArray_t;
        typedef MemArray<3, Eagle::point3>             CoordsArray_t;
        typedef MemArray<1, Eagle::point3>             CoordsArray1D_t;
        typedef MemArray<1, tvector>                   VecsArray1D_t;
        typedef MemArray<1, RefPtr<FragmentID> >        FragmentIDs_t;
        typedef MemArray<1, BoundingBox>               FragmentBounds_t;
 
        // Equip Modul with all neccessary in and outputs and steering parameters
 
        // Either the input grid or the input field should be connected.
        // If it is sufficient to have a Grid object for defining the start points of the 
        // Lines connect to grid.
        // Otherwise connect to the field. The start positions are then extracted from the 
        // Grid underlying the Field.
        TypedSlot<Grid>     StartGrid; 
        TypedSlot<Field>    StartField; 
        TypedSlot<VSurfaceRefinementCriterion>  tsSplitCriterion; 
        TypedSlot<VSurfaceRefinementCriterion>  tsFlipCriterion;
 
        TypedSlot<double>       MinLineLength;             
        TypedSlot<double>       MaxSteps;
        TypedSlot<double>       StepSize;
 
        TypedSlot<double>       UniMapperScalator;      
 
        TypedSlot<Enum>     Ipol; 
//      TypedSlot<Enum>         IncludeData; 
//      TypedSlot<Enum>         IncludeMagnitude; 
//      TypedSlot<Enum>         UseDop853;
 
        TypedSlot<int>          InternalEmissionSeedPoints; 
 
        TypedSlot<Eagle::point3> m_query_scale; // should be a tvector, but no dirct input widget available 
 
        TypedSlot<Options>      SomeOptions;
 
        VOutput<Grid>           myIntegralLines;        
 
        VOutput<int>            CurviCellsPerUniCell;
 
        IntegralFace(const string&name, int p, const RefPtr<VCreationPreferences>&VP);
 
        ~IntegralFace();
 
        bool errorMsg(VRequest&Context,const string&text) const
        {
                string tmp = "IntegralLine::" + text;
#ifdef  VERBOSE
                        puts( tmp.c_str() );fflush(stdout); 
#endif
                        return setStatusError(Context, text, false);
        }
 
        bool infoMsg(VRequest&Context,const string&text) const
        {
                string tmp = "IntegratlLine::" + text; 
 
                        puts( tmp.c_str() );fflush(stdout); 
                        return setStatusInfo(Context, text);
        }
        
        struct EmitterFieldData
        {
                GridSelector&  EmitterGS;
                FieldSelector& EmitterFS;
                double Time;
                bool   IsField;
                size_t Size; 
 
                EmitterFieldData( GridSelector&EmitterGSP, FieldSelector&EmitterFSP, double TimeP )
                : EmitterGS(EmitterGSP)
                , EmitterFS(EmitterFSP)
                , Time(TimeP)
                , IsField( false )
                , Size(0)
                {}
        };
        
        // note that this is not a member function of the above class because it uses functions
        // and operator of the integralface class.
        RefPtr<Field> getEmitterField( VRequest& Context,EmitterFieldData&EFD  );
        RefPtr<Grid>  getEmitterGrid( VRequest& Context,EmitterFieldData&EFD  );
 
 
        struct UpdateCheckData
        {
                RefPtr<Grid> EmitterGrid;
                RefPtr<Field> EmitterCoordinates;
                FieldSelector& FieldSelection;
                GridSelector&  GS;
                RefPtr<Field>& InputToIntegrateField;
                double time;
                string grid_name;
                
                UpdateCheckData(RefPtr<Field>& EmitterCoordinatesP, FieldSelector& FieldSelectionP, GridSelector&  GSP, 
                                RefPtr<Field>& InputToIntegrateFieldP, double timeP, string& grid_nameP)
                : EmitterCoordinates(EmitterCoordinatesP)
                , FieldSelection(FieldSelectionP)
                , GS(GSP)
                , InputToIntegrateField(InputToIntegrateFieldP)
                , time(timeP)
                , grid_name(grid_nameP)
                {}
 
                UpdateCheckData(RefPtr<Grid>& EmitterGridP, FieldSelector& FieldSelectionP, GridSelector&  GSP, 
                                RefPtr<Field>& InputToIntegrateFieldP, double timeP, string& grid_nameP)
                : EmitterGrid(EmitterGridP)
                , FieldSelection(FieldSelectionP)
                , GS(GSP)
                , InputToIntegrateField(InputToIntegrateFieldP)
                , time(timeP)
                , grid_name(grid_nameP)
                {}
 
                
        };
        
        // note that this is not a member function of the above class because it uses functions
        // and operator of the integralface class.
        bool needUpdate( VRequest&Context, UpdateCheckData&UCD );
 
        /*
        This is a strange class, why are the constructor parameters
        non-const refptrs and the bounding box a reference to a refptr
        as the only class member??
        Why is there a boolean flag which seems to redundantly be
        the same as the EmitterCoordinates??
        */
        struct AutoEmitterData
        {
                RefPtr<Field>  EmitterCoordinates;
                RefPtr<Grid>   EmitterGrid;
                RefPtr<Bundle> BPtr;
                RefPtr<BoundingBox>& ToIntegratefieldBBox;
                int nSeeds;
                bool isField;
 
                AutoEmitterData( RefPtr<Field>& EmitterCoordinatesP, RefPtr<BoundingBox>& ToIntegratefieldBBoxP, const int nSeedsP )
                : EmitterCoordinates(EmitterCoordinatesP)
                , ToIntegratefieldBBox(ToIntegratefieldBBoxP)
                , nSeeds(nSeedsP)
                , isField(true)
                {}
 
                AutoEmitterData( RefPtr<Grid>& EmitterGridP, RefPtr<BoundingBox>& ToIntegratefieldBBoxP, const int nSeedsP, RefPtr<Bundle>& BPtrP)
                : EmitterGrid(EmitterGridP)
                , BPtr(BPtrP)
                , ToIntegratefieldBBox(ToIntegratefieldBBoxP)
                , nSeeds(nSeedsP)
                , isField(false)
                {}
 
                
        };
 
        // note that this is not a member function of the above class because it uses functions
        // and operator of the integralface class.
        void setDefaultEmissionPoints( VRequest& Context, AutoEmitterData& AED  );
};
 
}
 
 
#endif // __FISH_CEPHALUS_LINEINTEGRATOR_HPP