~ubuntu-branches/ubuntu/wily/ifrit/wily

/*=========================================================================

 

  Program:   Ionization FRont Interactive Tool (IFRIT)

  Language:  C++

 

 

Copyright (c) 2002-2006 Nick Gnedin 

All rights reserved.

 

This file may be distributed and/or modified under the terms of the

GNU General Public License version 2 as published by the Free Software

Foundation and appearing in the file LICENSE.GPL included in the

packaging of this file.

 

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR

ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 

=========================================================================*/

void iFileLoader::SwapBytesRange(_type_ *p, vtkIdType count) \

bool iFileLoader::ReadBlock(iFile& F, _type_ *p, vtkIdType len, float updateStart, float updateDuration) \

iFileLoader::ReadingBuffer iFileLoader::Buffer(_type_ *d, vtkIdType l) const \

        void Swap4BytesRange(char *data, vtkIdType count)

                vtkIdType i;

        void Swap8BytesRange(char *data, vtkIdType count)

                vtkIdType i;

        inline void SwapBytesRange(T *p, vtkIdType count)

        bool IsNumberValid(vtkTypeInt32 v){ return true; }

        bool IsNumberValid(vtkTypeInt64 v){ return true; }

        bool IsNumberValid(vtkTypeFloat32 v){ return (-iMath::_FloatMax<=v && v<=iMath::_FloatMax); }

        bool IsNumberValid(vtkTypeFloat64 v){ return (-iMath::_DoubleMax<=v && v<=iMath::_DoubleMax); }

        const int _Int32 = 1;

        const int _Int64 = 2;

        const int _Float32 = 3;

        const int _Float64 = 4;

        int TypeIndex(vtkTypeInt32 *){ return _Int32; }

        int TypeIndex(vtkTypeInt64 *){ return _Int64; }

        int TypeIndex(vtkTypeFloat32 *){ return _Float32; }

        int TypeIndex(vtkTypeFloat64 *){ return _Float64; }

        bool ReadBlockToArray(iFile& F, T *p, vtkIdType len, float updateStart, float updateDuration, bool swapbytes, iProgressEventObserver *observer)

                const vtkIdType nline = 16384L;

                vtkIdType nread, l, nstep = (len+nline-1)/nline;

                case _Int32:

                        {

                                vtkTypeInt32 *d = (vtkTypeInt32 *)b.Data;

                                return iFileLoader_Private::ReadBlockToArray(F,d,b.Length,updateStart,updateDuration,swapbytes,observer);

                        }

                case _Int64:

                        {

                                vtkTypeInt64 *d = (vtkTypeInt64 *)b.Data;

                                return iFileLoader_Private::ReadBlockToArray(F,d,b.Length,updateStart,updateDuration,swapbytes,observer);

                        }

                case _Float32:

                        {

                                vtkTypeFloat32 *d = (vtkTypeFloat32 *)b.Data;

                                return iFileLoader_Private::ReadBlockToArray(F,d,b.Length,updateStart,updateDuration,swapbytes,observer);

                        }

                case _Float64:

                        {

                                vtkTypeFloat64 *d = (vtkTypeFloat64 *)b.Data;

        mBoundaryConditions = BoundaryConditions::Wall;

        if(BoundaryConditions::IsValid(s))

        double dx[3];

        for(i=0; i<3; i++) dx[i] = dr[i] - mShift[i];

 

        for(i=0; i<this->NumStreams(); i++) if(mStreams[i]->ReleasedData != 0)

        {

                this->ShiftDataBody(mStreams[i]->ReleasedData,dx);

        }

 

        for(i=0; i<3; i++) mShift[i] = dr[i];

bool iFileLoader::SkipFortranRecord(iFile& F, vtkIdType len)

        vtkIdType lrec1, lrec2;

        vtkIdType lrec1, lrec2;

        vtkIdType lrec1, lrec2;

        vtkIdType len = b1.Length*b1.Size + b2.Length*b2.Size;

        vtkIdType lrec1, lrec2;

        vtkIdType len = b1.Length*b1.Size + b2.Length*b2.Size + b3.Length*b3.Size;

        vtkIdType lrec1, lrec2;

        vtkIdType len = 0L;

bool iFileLoader::ReadFortranHeaderFooter(iFile& F, vtkIdType &lrec)

        if(mFortranHeaderFooterLength == 8)

                vtkTypeInt64 ltmp;

                ret = F.ReadBlock(&ltmp,8);

                if(ret)

                {

                        if(mIsBigEndian != iSystem::IsBigEndianMachine()) this->SwapBytes(ltmp);

                        if(sizeof(vtkIdType) < 8)

                        {

                                IERROR_LOW("VTK is compiled with 32-bit Ids. The record length of this file is 64-bits, it cannot be read with this VTK installation. To be able to read this file you will have to recompile VTK with the advanced option VTK_USE_64BIT_IDS set to ON and then recompile IFrIT.");

                                return false;

                        }

                        lrec = ltmp;

                }

        else if(mFortranHeaderFooterLength == 4)

                vtkTypeInt32 ltmp;

                ret = F.ReadBlock(&ltmp,4);

                        lrec = ltmp;

bool iFileLoader::DetectFortranFileStructure(iFile &F, vtkIdType len)

        //  Try 4-byte records

        if(AnalyzeFirstRecordForType<vtkTypeInt32>(F,len,mIsBigEndian))

                mFortranHeaderFooterLength = sizeof(vtkTypeInt32);

        //  Try 8-byte records

        if(AnalyzeFirstRecordForType<vtkTypeInt64>(F,len,mIsBigEndian))

                mFortranHeaderFooterLength = sizeof(vtkTypeInt64);

IDATASUBJECT_DEFINE_SWAP_BYTES_FUNCTIONS(vtkTypeInt32);

IDATASUBJECT_DEFINE_SWAP_BYTES_FUNCTIONS(vtkTypeInt64);

IDATASUBJECT_DEFINE_SWAP_BYTES_FUNCTIONS(vtkTypeFloat32);

IDATASUBJECT_DEFINE_SWAP_BYTES_FUNCTIONS(vtkTypeFloat64);

IDATASUBJECT_DEFINE_READ_BLOCK_FUNCTIONS(vtkTypeInt32);

IDATASUBJECT_DEFINE_READ_BLOCK_FUNCTIONS(vtkTypeInt64);

IDATASUBJECT_DEFINE_READ_BLOCK_FUNCTIONS(vtkTypeFloat32);

IDATASUBJECT_DEFINE_READ_BLOCK_FUNCTIONS(vtkTypeFloat64);