060-RegularFragmentTopology.cpp File Reference

[← Previous Example] [Next Example → 061-RegularFragmentTopologyWithHigherTopology.cpp ]. More...

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
#include <fiber/field/ArrayRef.hpp>
#include <fiber/field/RegularlyFragmentedField.hpp>
#include <fiber/field/UniformCartesianArray.hpp>
#include <fiber/grid/types/FragmentedUniformGrid3D.hpp>

Functions
int	main ()

Detailed Description

[← Previous Example] [Next Example → 061-RegularFragmentTopologyWithHigherTopology.cpp ].

In FiberLib Tutorial

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
#include <fiber/field/ArrayRef.hpp>
#include <fiber/field/RegularlyFragmentedField.hpp>
#include <fiber/field/UniformCartesianArray.hpp>
#include <fiber/grid/types/FragmentedUniformGrid3D.hpp>
 
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
 
int     main()
{
        // Initialize I/O layers (required for standalone programs)
        Finit();
 
RefPtr<Cache>&theGlobalCache = Cache::MemCache();
const   int KiB = 1024, MiB = KiB*KiB;
#if     1
        theGlobalCache->setMaxCost( 3*MiB );
#endif
 
 
        //
        // Create a bundle object with a grid at T=1.0, named "DemoGrid", in
        // a three-dimensional Cartesian representation, using the default
        // coordinate system.
        //
BundlePtr       BP;
Grid&myGrid = BP[0.0]["DemoGrid"];
 
        BP->bindTo("outfile.f5");
 
#if     0
        if (RefPtr< RegularlyFragmentedField<3> > Positions = myGrid.getCartesianPositions())
                Verbose(0) << " --> have regular positions.";
        else
                Verbose(0) << " --> we do NOT have regular positions.";
#endif
 
Eagle::point3 BBoxMin(-1.0, -1.0, -0.5), BBoxMax( 1.0, 1.0, 0.5);
MultiIndex<3> NumberOfFragments =
#if     0
        MIndex(7,9,3);          // large dataset
#else
        MIndex(3,2,1);          // small dataset
#endif
 
const MultiIndex<3> BlockSize = { 64,64,64 }; // blocksize is 256k
 
 
FragmentedUniformGrid3D
        MyUniGrid3D = FragmentedUniformGrid3D::create( NumberOfFragments,
                                                       myGrid,
                                                       BBoxMin,
                                                       BlockSize,
                                                       BBoxMax);
        if (!MyUniGrid3D)
        {
                Verbose(0) << "Could not create a fragmented uniform grid - incompatible bind file?";
                return 0;
        }
 
 
        if (MyUniGrid3D.Positions->nFragments() == 0)
        {
                Verbose(0) << " error, no input fragments found!";
                return 1;
        }
 
RefPtr< RegularlyFragmentedField<3> > Values = MyUniGrid3D.newVertexField( "Values");
const MultiIndex<3>&N = MyUniGrid3D.NumberOfFragments();
 
        //
        // Iterate over all fragments
        //
        {
        VerboseSection(0,' ');
                Verbose(0) << "Iterating over " << N << " fragments.";
 
        for(MultiIndex<3> FragmentIndex : N)
        {
        RefPtr<FragmentID> fID = MyUniGrid3D.getFragmentID( FragmentIndex );
                //
                // Add some data to each field fragment.
                //
                {
                ArrayRef<double, 3> GridValues(BlockSize);
                        GridValues->CacheInfoString = "Data for " + fID->Name();
 
                auto    U = MyUniGrid3D.getCoords(FragmentIndex);
                        if (!U)
                        {
                                Verbose(0) << "Unsuitable fragment coordinates: " << MyUniGrid3D.FragmentCoordinates;
                                Verbose(0) << "Unsuitable positions: " << MyUniGrid3D.Positions;
 
                        RefPtr< RegularlyFragmentedField<3> > R = MyUniGrid3D.Positions;
                                Verbose(1) << "Fragments: " << R->getNumberOfFragments() << " Index: " << FragmentIndex;
                                Verbose(1) << "Regular Positions:\n" << R->xml();
 
                        auto    C = MyUniGrid3D.getCoordCreator( FragmentIndex );
                                Verbose(0) << "Creator: " << C;
                                if (C) Verbose(0) << "Data: " << C->create();
                                break;
                        }
 
                UniformCartesianArray&Pts = *U;
                        for(MultiIndex<3> I : BlockSize)
                        {
                        double& value = GridValues[ I ];
                        Eagle::point3 P = Pts[ I ];
 
                                //
                                // Some analytic function here used to produce some
                                // halfway interestingly looking scalar field.
                                //
                                value = P.x()*P.x() - P.y()*P.y() + P.z()*P.z();
                        }
 
                        if (MemBase::Creator_t
                            ValueCreator = Values->createCreator(GridValues, fID) )
                        {
                                ValueCreator->touch();
                        }
                }
 
                printf("**** At fragment [%s] cache uses %ld Bytes (%ldMiB) \n",
                       fID->Name().c_str(), long(theGlobalCache->totalCost() ),
                       long(theGlobalCache->totalCost() )/MiB
                        );fflush(stdout);
        }
        }
 
        printf("After fragment loop: cache uses %ld Bytes\n", long(theGlobalCache->totalCost() ));fflush(stdout);
 
        return 0;
}