IntegralFace.hpp

#ifndef __FISH_CEPHALUS_LINEINTEGRATOR_HPP
#define __FISH_CEPHALUS_LINEINTEGRATOR_HPP

#include <ocean/eagle/PhysicalSpace.hpp>
#include <ocean/shrimp/VObjectStatus.hpp>
#include <ocean/shrimp/VEnum.hpp>

#include <fish/fiber/baseop/ExpandBBox.hpp>
#include <grid/types/LineSet.hpp>

#include <bone/FishField.hpp>
#include <bone/FishSaver.hpp>

namespace Wizt
{

        using namespace Fiber;



class   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, std::string>               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<double>       MinLineLength;             
        TypedSlot<double>       MaxSteps;
        TypedSlot<double>       StepSize;

        TypedSlot<double>       ScaleFac,
                                UniMapperScalator;      

        TypedSlot<Enum>         Ipol;
        TypedSlot<Enum>         IncludeData;
        TypedSlot<Enum>         IncludeMagnitude;
        TypedSlot<Enum>         UseDop853;


        TypedSlot<int>          InternalEmissionSeedPoints;

        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 = "IntegratlLine::" + text; 

                        puts( tmp.c_str() );fflush(stdout); 
                        return setStatusError(Context, text);
        }

        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;

                EmitterFieldData( GridSelector&EmitterGSP, FieldSelector&EmitterFSP )
                : EmitterGS(EmitterGSP)
                , EmitterFS(EmitterFSP)
                {}
        };      
        
        RefPtr<Field> getEmitterField( VRequest& Context, const EmitterFieldData&EFD  );


        struct UpdateCheckData
        {
                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)
                {}
        };

        bool    needUpdate( VRequest&Context, UpdateCheckData&UCD );
        

        struct AutoEmitterData
        {
                RefPtr<Field>& EmitterCoordinates;
                RefPtr<BoundingBox>& ToIntegratefieldBBox;
                int nSeeds;

                AutoEmitterData( RefPtr<Field>& EmitterCoordinatesP, RefPtr<BoundingBox>& ToIntegratefieldBBoxP, const int nSeedsP )
                : EmitterCoordinates(EmitterCoordinatesP)
                , ToIntegratefieldBBox(ToIntegratefieldBBoxP)
                , nSeeds(nSeedsP)
                {}
        };

        void    setDefaultEmissionPoints( VRequest& Context, AutoEmitterData& AED );
};

}


#endif // __FISH_CEPHALUS_LINEINTEGRATOR_HPP