---

rdStorage.h

// rdStorage.h
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Copyright 2000 Realistic Dynamics, Inc.
// All rights reserved.
//
// Please do not read, copy, distribute, or use without permission.
// Contact: Frank C. Anderson, fca@RealisticDynamics.com
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#ifndef __rdStorage_h__
#define __rdStorage_h__


#include "rdTools.h"
#include "rdPtrArray.h"
#include "rdStateVector.h"


const int rdStorage_DEFAULT_CAPACITY = 256;


//=============================================================================
//=============================================================================
class RDTOOLS_API rdStorage : public rdPtrArray
{

//=============================================================================
// DATA
//=============================================================================
public:
   static const double LARGE_NEGATIVE;
   static const double LARGE_POSITIVE;
   static const char *DEFAULT_HEADER_TOKEN;
protected:
   char _headerToken[rdObject_NAME_LENGTH];
   char *_columnLabels;
   int _stepInterval;
   int _lastI;
   bool _writeSIMMHeader;

//=============================================================================
// METHODS
//=============================================================================
public:
   rdStorage(int aCapacity=rdStorage_DEFAULT_CAPACITY,
      const char *aName="UNKNOWN");
   rdStorage(const char* aFileName);
   rdStorage(const rdStorage &aStorage,bool aCopyData=true);
   rdStorage(const rdStorage &aStorage,int aStateIndex,int aN,
      const char *aDelimiter="\t");
   virtual ~rdStorage();

private:
   //--------------------------------------------------------------------------
   // CONSTRUCTION METHODS
   //--------------------------------------------------------------------------
   void allocateCapacity();
   void setNull();
   void copyData(const rdStorage &aStorage);
public:

   //--------------------------------------------------------------------------
   // GET AND SET
   //--------------------------------------------------------------------------
   void setWriteSIMMHeader(bool aTrueFalse);
   bool getWriteSIMMHeader() const;
   void setHeaderToken(const char *aToken);
   const char* getHeaderToken() const;
   void setColumnLabels(const char *aLabels=NULL);
   const char* getColumnLabels() const;
   void setStepInterval(int aStepInterval);
   int getStepInterval() const;
   // STATEVECTOR
   int getSmallestNumberOfStates();
   rdStateVector* getStateVector(int aTimeIndex) const;
   rdStateVector* getLastStateVector() const;
   // TIME
   double getFirstTime();
   double getLastTime();
   int getTime(int aTimeIndex,double &rTime,int aStateIndex=-1) const;
   int getTimeColumn(double *&rTimes,int aStateIndex=-1);
   // DATA
   int getData(int aTimeIndex,int aStateIndex,double &rValue) const;
   int getData(int aTimeIndex,int aStateIndex,int aN,double *rData) const;
   int getData(int aTimeIndex,int aN,double **rData) const;
   int getData(int aTimeIndex,int aN,double *rData) const;
   int getData(double aTime,int aN,double **rData);
   int getData(double aTime,int aN,double *rData);
   int getDataColumn(int aStateIndex,double *&rData) const;

   //--------------------------------------------------------------------------
   // RESET
   //--------------------------------------------------------------------------
   void resetStorage(double aT);

   //--------------------------------------------------------------------------
   // STORAGE
   //--------------------------------------------------------------------------
   virtual int append(void *aVec);
   virtual int append(rdPtrArray *aArray);
   virtual int append(double aT,int aN,double *aY);
   virtual int store(int aStep,double aT,int aN,double *aY);

   //--------------------------------------------------------------------------
   // OPERATIONS
   //--------------------------------------------------------------------------
   void shiftTime(double aValue);
   void scaleTime(double aValue);
   void add(double aValue);
   void add(int aN,double aY[]);
   void add(rdStateVector *aStateVector);
   void add(rdStorage *aStorage);
   void subtract(double aValue);
   void subtract(int aN,double aY[]);
   void subtract(rdStateVector *aStateVector);
   void subtract(rdStorage *aStorage);
   void multiply(double aValue);
   void multiply(int aN,double aY[]);
   void multiply(rdStateVector *aStateVector);
   void multiply(rdStorage *aStorage);
   void divide(double aValue);
   void divide(int aN,double aY[]);
   void divide(rdStateVector *aStateVector);
   void divide(rdStorage *aStorage);
   rdStorage* integrate(int aI1=-2,int aI2=-1);
   rdStorage* integrate(double aT1,double aT2);
   int computeArea(int aN,double *aArea);
   int computeArea(double aTI,double aTF,int aN,double *aArea);
   int computeAverage(int aN,double *aAve);
   int computeAverage(double aTI,double aTF,int aN,double *aAve);

   //--------------------------------------------------------------------------
   // UTILITY
   //--------------------------------------------------------------------------
   int findIndex(double aT);
   int findIndex(int aI,double aT);

   //--------------------------------------------------------------------------
   // IO
   //--------------------------------------------------------------------------
   void print();
   int print(const char *aFileName,const char *aMode="w");
   int print(const char *aFileName,double aDT,const char *aMode="w");
private:
   int writeHeader(FILE *rFP,double aDT=-1);
   int writeSIMMHeader(FILE *rFP,double aDT=-1);
   int writeDescription(FILE *rFP);
   int writeColumnLabels(FILE *rFP);
   int writeDefaultColumnLabels(FILE *rFP);



//=============================================================================
}; // END of class rdStorage
//=============================================================================
//=============================================================================

#endif //__rdStorage_h__

---