Changeset 5d57155


Ignore:
Timestamp:
09/25/17 16:15:39 (7 years ago)
Author:
Hal Finkel <hfinkel@…>
Branches:
master, pympi
Children:
b02d091
Parents:
fb69232
git-author:
Hal Finkel <hfinkel@…> (09/25/17 16:15:39)
git-committer:
Hal Finkel <hfinkel@…> (09/25/17 16:15:39)
Message:

Add support for float4 (and other homogeneous aggregates)

Files:
5 edited

Legend:

Unmodified
Added
Removed

  • GenericIO.cxx

    r14e73bb r5d57155  
    322322  endian_specific_value<uint64_t, IsBigEndian> Flags; 
    323323  endian_specific_value<uint64_t, IsBigEndian> Size; 
     324  endian_specific_value<uint64_t, IsBigEndian> ElementSize; 
    324325}; 
    325326 
    … …  
    583584      VH->Flags = VFlags; 
    584585      RecordSize += VH->Size = Vars[i].Size; 
     586      VH->ElementSize = Vars[i].ElementSize; 
    585587    } 
    586588 
    … …  
    13791381      } 
    13801382 
     1383      size_t ElementSize = VH->Size; 
     1384      if (offsetof_safe(VH, ElementSize) < GH->VarsSize) 
     1385        ElementSize = VH->ElementSize; 
     1386 
    13811387      VarFound = true; 
    13821388      bool IsFloat = (bool) (VH->Flags & FloatValue), 
    … …  
    13871393              " in: " << OpenFileName << ": current: " << Vars[i].Size << 
    13881394              ", file: " << VH->Size; 
     1395        throw runtime_error(ss.str()); 
     1396      } else if (ElementSize != Vars[i].ElementSize) { 
     1397        stringstream ss; 
     1398        ss << "Element size mismatch for variable " << Vars[i].Name << 
     1399              " in: " << OpenFileName << ": current: " << Vars[i].ElementSize << 
     1400              ", file: " << ElementSize; 
    13891401        throw runtime_error(ss.str()); 
    13901402      } else if (IsFloat != Vars[i].IsFloat) { 
    … …  
    15651577      // Byte swap the data if necessary. 
    15661578      if (IsBigEndian != isBigEndian()) 
    1567         for (size_t j = 0; j < RH->NElems; ++j) { 
    1568           char *Offset = ((char *) VarData) + j*Vars[i].Size; 
    1569           bswap(Offset, Vars[i].Size); 
     1579        for (size_t j = 0; 
     1580             j < RH->NElems*(Vars[i].Size/Vars[i].ElementSize); ++j) { 
     1581          char *Offset = ((char *) VarData) + j*Vars[i].ElementSize; 
     1582          bswap(Offset, Vars[i].ElementSize); 
    15701583        } 
    15711584 
    … …  
    16251638    if (VNameNull < NameSize) 
    16261639      VName.resize(VNameNull); 
     1640 
     1641    size_t ElementSize = VH->Size; 
     1642    if (offsetof_safe(VH, ElementSize) < GH->VarsSize) 
     1643      ElementSize = VH->ElementSize; 
    16271644 
    16281645    bool IsFloat = (bool) (VH->Flags & FloatValue), 
    … …  
    16341651    VI.push_back(VariableInfo(VName, (size_t) VH->Size, IsFloat, IsSigned, 
    16351652                              IsPhysCoordX, IsPhysCoordY, IsPhysCoordZ, 
    1636                               MaybePhysGhost)); 
     1653                              MaybePhysGhost, ElementSize)); 
    16371654  } 
    16381655} 

  • GenericIO.h

    r14e73bb r5d57155  
    117117  int FH; 
    118118}; 
     119 
     120namespace detail { 
     121// A standard enable_if idiom (we include our own here for pre-C++11 support). 
     122template <bool B, typename T = void> 
     123struct enable_if {}; 
     124 
     125template <typename T> 
     126struct enable_if<true, T> { typedef T type; }; 
     127 
     128// A SFINAE-based trait to detect whether a type has a member named x. This is 
     129// designed to work both with structs/classes and also with OpenCL-style vector 
     130// types. 
     131template <typename T> 
     132class has_x { 
     133  typedef char yes[1]; 
     134  typedef char no[2]; 
     135 
     136  template <typename C> 
     137  static yes &test(char(*)[sizeof((*((C *) 0)).x)]); 
     138 
     139  template <typename C> 
     140  static no &test(...); 
     141 
     142public: 
     143  enum { value = sizeof(test<T>(0)) == sizeof(yes) }; 
     144}; 
     145 
     146// A SFINAE-based trait to detect whether a type is array-like (i.e. supports 
     147// the [] operator). 
     148template <typename T> 
     149class is_array { 
     150  typedef char yes[1]; 
     151  typedef char no[2]; 
     152 
     153  template <typename C> 
     154  static yes &test(char(*)[sizeof((*((C *) 0))[0])]); 
     155 
     156  template <typename C> 
     157  static no &test(...); 
     158 
     159public: 
     160  enum { value = sizeof(test<T>(0)) == sizeof(yes) }; 
     161}; 
     162} // namespace detail 
    119163 
    120164class GenericIO { 
    … …  
    133177  struct VariableInfo { 
    134178    VariableInfo(const std::string &N, std::size_t S, bool IF, bool IS, 
    135                  bool PCX, bool PCY, bool PCZ, bool PG) 
     179                 bool PCX, bool PCY, bool PCZ, bool PG, std::size_t ES = 0) 
    136180      : Name(N), Size(S), IsFloat(IF), IsSigned(IS), 
    137181        IsPhysCoordX(PCX), IsPhysCoordY(PCY), IsPhysCoordZ(PCZ), 
    138         MaybePhysGhost(PG) {} 
     182        MaybePhysGhost(PG), ElementSize(ES ? ES : S) {} 
    139183 
    140184    std::string Name; 
    … …  
    144188    bool IsPhysCoordX, IsPhysCoordY, IsPhysCoordZ; 
    145189    bool MaybePhysGhost; 
     190    std::size_t ElementSize; 
    146191  }; 
    147192 
    148193public: 
    149   struct Variable { 
     194  class Variable { 
     195  private: 
     196    template <typename ET> 
     197    void deduceTypeInfoFromElement(ET *) { 
     198      ElementSize = sizeof(ET); 
     199      IsFloat = !std::numeric_limits<ET>::is_integer; 
     200      IsSigned = std::numeric_limits<ET>::is_signed; 
     201    } 
     202 
     203    // There are specializations here to handle array types 
     204    // (e.g. typedef float float4[4];), struct types 
     205    // (e.g. struct float4 { float x, y, z, w; };), and scalar types. 
     206    // Builtin vector types 
     207    // (e.g. typedef float float4 __attribute__((ext_vector_type(4)));) should 
     208    // also work. 
     209    template <typename T> 
     210    typename detail::enable_if<detail::is_array<T>::value, void>::type 
     211    deduceTypeInfo(T *D) { 
     212      Size = sizeof(T); 
     213      deduceTypeInfoFromElement(&(*D)[0]); 
     214    } 
     215 
     216    template <typename T> 
     217    typename detail::enable_if<detail::has_x<T>::value && 
     218                               !detail::is_array<T>::value, void>::type 
     219    deduceTypeInfo(T *D) { 
     220      Size = sizeof(T); 
     221      deduceTypeInfoFromElement(&(*D).x); 
     222    } 
     223 
     224    template <typename T> 
     225    typename detail::enable_if<!detail::has_x<T>::value && 
     226                               !detail::is_array<T>::value, void>::type 
     227    deduceTypeInfo(T *D) { 
     228      Size = sizeof(T); 
     229      deduceTypeInfoFromElement(D); 
     230    } 
     231 
     232  public: 
    150233    template <typename T> 
    151234    Variable(const std::string &N, T* D, unsigned Flags = 0) 
    152       : Name(N), Size(sizeof(T)), 
    153         IsFloat(!std::numeric_limits<T>::is_integer), 
    154         IsSigned(std::numeric_limits<T>::is_signed), 
    155         Data((void *) D), HasExtraSpace(Flags & VarHasExtraSpace), 
     235      : Name(N), Data((void *) D), HasExtraSpace(Flags & VarHasExtraSpace), 
    156236        IsPhysCoordX(Flags & VarIsPhysCoordX), 
    157237        IsPhysCoordY(Flags & VarIsPhysCoordY), 
    158238        IsPhysCoordZ(Flags & VarIsPhysCoordZ), 
    159         MaybePhysGhost(Flags & VarMaybePhysGhost) {} 
     239        MaybePhysGhost(Flags & VarMaybePhysGhost) { 
     240      deduceTypeInfo(D); 
     241    } 
     242 
     243    template <typename T> 
     244    Variable(const std::string &N, std::size_t NumElements, T* D, 
     245             unsigned Flags = 0) 
     246      : Name(N), Data((void *) D), HasExtraSpace(Flags & VarHasExtraSpace), 
     247        IsPhysCoordX(Flags & VarIsPhysCoordX), 
     248        IsPhysCoordY(Flags & VarIsPhysCoordY), 
     249        IsPhysCoordZ(Flags & VarIsPhysCoordZ), 
     250        MaybePhysGhost(Flags & VarMaybePhysGhost) { 
     251      deduceTypeInfoFromElement(D); 
     252      Size = ElementSize*NumElements; 
     253    } 
    160254 
    161255    Variable(const VariableInfo &VI, void *D, unsigned Flags = 0) 
    … …  
    166260        IsPhysCoordY((Flags & VarIsPhysCoordY) || VI.IsPhysCoordY), 
    167261        IsPhysCoordZ((Flags & VarIsPhysCoordZ) || VI.IsPhysCoordZ), 
    168         MaybePhysGhost((Flags & VarMaybePhysGhost) || VI.MaybePhysGhost) {} 
     262        MaybePhysGhost((Flags & VarMaybePhysGhost) || VI.MaybePhysGhost), 
     263        ElementSize(VI.ElementSize) {} 
    169264 
    170265    std::string Name; 
    … …  
    176271    bool IsPhysCoordX, IsPhysCoordY, IsPhysCoordZ; 
    177272    bool MaybePhysGhost; 
     273    std::size_t ElementSize; 
    178274  }; 
    179275 
    … …  
    261357  } 
    262358 
     359  template <typename T> 
     360  void addScalarizedVariable(const std::string &Name, T *Data, 
     361                             std::size_t NumElements, unsigned Flags = 0) { 
     362    Vars.push_back(Variable(Name, NumElements, Data, Flags)); 
     363  } 
     364 
     365  template <typename T, typename A> 
     366  void addScalarizedVariable(const std::string &Name, std::vector<T, A> &Data, 
     367                             std::size_t NumElements, unsigned Flags = 0) { 
     368    T *D = Data.empty() ? 0 : &Data[0]; 
     369    addScalarizedVariable(Name, D, NumElements, Flags); 
     370  } 
     371 
    263372#ifndef GENERICIO_NO_MPI 
    264373  // Writing 

  • GenericIOBenchmarkRead.cxx

    r8f0a211 r5d57155  
    5454#define MASK_T uint16_t 
    5555 
     56struct pos_t { 
     57  POSVEL_T x, y, z, w; 
     58}; 
     59 
    5660using namespace std; 
    5761using namespace gio; 
    … …  
    6468  MPI_Comm_size(MPI_COMM_WORLD, &commRanks); 
    6569 
     70  bool UseAOS = false; 
     71  int a = 1; 
     72  if (argc > 1 && string(argv[a]) == "-a") { 
     73    UseAOS = true; 
     74    --argc; 
     75    ++a; 
     76  } 
     77 
    6678  if(argc != 2) { 
    67     fprintf(stderr,"USAGE: %s <mpiioName>\n", argv[0]); 
     79    fprintf(stderr,"USAGE: %s [-a] <mpiioName>\n", argv[0]); 
    6880    exit(-1); 
    6981  } 
    7082 
    71   char *mpiioName = argv[1]; 
     83  char *mpiioName = argv[a]; 
    7284 
    7385  vector<POSVEL_T> xx, yy, zz, vx, vy, vz, phi; 
    7486  vector<ID_T> id; 
    7587  vector<MASK_T> mask; 
     88 
     89  vector<pos_t> pos, vel; 
    7690 
    7791  assert(sizeof(ID_T) == 8); 
    … …  
    93107  Np = GIO.readNumElems(); 
    94108 
    95   xx.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    96   yy.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    97   zz.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    98   vx.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    99   vy.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    100   vz.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    101   phi.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     109  if (UseAOS) { 
     110    pos.resize(Np + (GIO.requestedExtraSpace() + sizeof(pos_t) - 1)/sizeof(pos_t)); 
     111    vel.resize(Np + (GIO.requestedExtraSpace() + sizeof(pos_t) - 1)/sizeof(pos_t)); 
     112  } else { 
     113    xx.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     114    yy.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     115    zz.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     116    vx.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     117    vy.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     118    vz.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     119    phi.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     120  } 
    102121  id.resize(Np + GIO.requestedExtraSpace()/sizeof(ID_T)); 
    103122  mask.resize(Np + GIO.requestedExtraSpace()/sizeof(MASK_T)); 
    104123 
    105   GIO.addVariable("x", xx, true); 
    106   GIO.addVariable("y", yy, true); 
    107   GIO.addVariable("z", zz, true); 
    108   GIO.addVariable("vx", vx, true); 
    109   GIO.addVariable("vy", vy, true); 
    110   GIO.addVariable("vz", vz, true); 
    111   GIO.addVariable("phi", phi, true); 
    112   GIO.addVariable("id", id, true); 
    113   GIO.addVariable("mask", mask, true); 
     124  if (UseAOS) { 
     125    GIO.addVariable("pos", pos, GenericIO::VarHasExtraSpace); 
     126    GIO.addVariable("vel", vel, GenericIO::VarHasExtraSpace); 
     127  } else { 
     128    GIO.addVariable("x", xx, GenericIO::VarHasExtraSpace); 
     129    GIO.addVariable("y", yy, GenericIO::VarHasExtraSpace); 
     130    GIO.addVariable("z", zz, GenericIO::VarHasExtraSpace); 
     131    GIO.addVariable("vx", vx, GenericIO::VarHasExtraSpace); 
     132    GIO.addVariable("vy", vy, GenericIO::VarHasExtraSpace); 
     133    GIO.addVariable("vz", vz, GenericIO::VarHasExtraSpace); 
     134    GIO.addVariable("phi", phi, GenericIO::VarHasExtraSpace); 
     135  } 
     136  GIO.addVariable("id", id, GenericIO::VarHasExtraSpace); 
     137  GIO.addVariable("mask", mask, GenericIO::VarHasExtraSpace); 
    114138 
    115139  GIO.readData(); 
    116140  } // destroy GIO prior to calling MPI_Finalize 
    117141 
    118   xx.resize(Np); 
    119   yy.resize(Np); 
    120   zz.resize(Np); 
    121   vx.resize(Np); 
    122   vy.resize(Np); 
    123   vz.resize(Np); 
    124   phi.resize(Np); 
     142  if (UseAOS) { 
     143    pos.resize(Np); 
     144    vel.resize(Np); 
     145  } else { 
     146    xx.resize(Np); 
     147    yy.resize(Np); 
     148    zz.resize(Np); 
     149    vx.resize(Np); 
     150    vy.resize(Np); 
     151    vz.resize(Np); 
     152    phi.resize(Np); 
     153  } 
    125154  id.resize(Np); 
    126155  mask.resize(Np); 

  • GenericIOBenchmarkWrite.cxx

    rcda87e9 r5d57155  
    7070}; 
    7171 
     72struct pos_t { 
     73  POSVEL_T x, y, z, w; 
     74}; 
     75 
     76template <> 
     77struct Generator<pos_t> { 
     78  Generator(POSVEL_T start, POSVEL_T inc) : 
     79    GenX(start, inc), GenY(start, inc), GenZ(start, inc), GenW(start, inc) {} 
     80 
     81  pos_t operator()() { 
     82    pos_t v; 
     83    v.x = GenX(); 
     84    v.y = GenY(); 
     85    v.z = GenZ(); 
     86    v.w = GenW(); 
     87 
     88    return v; 
     89  } 
     90 
     91  Generator<POSVEL_T> GenX, GenY, GenZ, GenW; 
     92}; 
     93 
    7294int main(int argc, char *argv[]) { 
    7395  MPI_Init(&argc, &argv); 
    … …  
    7799  MPI_Comm_size(MPI_COMM_WORLD, &commRanks); 
    78100 
     101  bool UseAOS = false; 
    79102  int a = 1; 
     103  if (argc > 1 && string(argv[a]) == "-a") { 
     104    UseAOS = true; 
     105    --argc; 
     106    ++a; 
     107  } 
     108 
    80109  if (argc > 1 && string(argv[a]) == "-c") { 
    81110    GenericIO::setDefaultShouldCompress(true); 
    … …  
    85114 
    86115  if(argc != 4) { 
    87     fprintf(stderr,"USAGE: %s [-c] <mpiioName> <NP> <seed>\n", argv[0]); 
     116    fprintf(stderr,"USAGE: %s [-a] [-c] <mpiioName> <NP> <seed>\n", argv[0]); 
    88117    exit(-1); 
    89118  } 
    … …  
    103132  vector<ID_T> id; 
    104133  vector<MASK_T> mask; 
     134 
     135  vector<pos_t> pos, vel; 
    105136 
    106137  assert(sizeof(ID_T) == 8); 
    … …  
    123154  GIO.setPhysScale(256.0); 
    124155 
    125   xx.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    126   yy.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    127   zz.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    128   vx.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    129   vy.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    130   vz.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
    131   phi.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     156  if (UseAOS) { 
     157    pos.resize(Np + (GIO.requestedExtraSpace() + sizeof(pos_t) - 1)/sizeof(pos_t)); 
     158    vel.resize(Np + (GIO.requestedExtraSpace() + sizeof(pos_t) - 1)/sizeof(pos_t)); 
     159  } else { 
     160    xx.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     161    yy.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     162    zz.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     163    vx.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     164    vy.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     165    vz.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     166    phi.resize(Np + GIO.requestedExtraSpace()/sizeof(POSVEL_T)); 
     167  } 
    132168  id.resize(Np + GIO.requestedExtraSpace()/sizeof(ID_T)); 
    133169  mask.resize(Np + GIO.requestedExtraSpace()/sizeof(MASK_T)); 
    134170 
    135   std::generate(xx.begin(), xx.end(), Generator<POSVEL_T>(25, 3)); 
    136   std::generate(yy.begin(), yy.end(), Generator<POSVEL_T>(25, 3)); 
    137   std::generate(zz.begin(), zz.end(), Generator<POSVEL_T>(25, 3)); 
    138   std::generate(vx.begin(), vx.end(), Generator<POSVEL_T>(25, 3)); 
    139   std::generate(vy.begin(), vy.end(), Generator<POSVEL_T>(25, 3)); 
    140   std::generate(vz.begin(), vz.end(), Generator<POSVEL_T>(25, 3)); 
    141   std::generate(phi.begin(), phi.end(), Generator<POSVEL_T>(25, 3)); 
     171  if (UseAOS) { 
     172    std::generate(pos.begin(), pos.end(), Generator<pos_t>(25, 3)); 
     173    std::generate(vel.begin(), vel.end(), Generator<pos_t>(25, 3)); 
     174  } else { 
     175    std::generate(xx.begin(), xx.end(), Generator<POSVEL_T>(25, 3)); 
     176    std::generate(yy.begin(), yy.end(), Generator<POSVEL_T>(25, 3)); 
     177    std::generate(zz.begin(), zz.end(), Generator<POSVEL_T>(25, 3)); 
     178    std::generate(vx.begin(), vx.end(), Generator<POSVEL_T>(25, 3)); 
     179    std::generate(vy.begin(), vy.end(), Generator<POSVEL_T>(25, 3)); 
     180    std::generate(vz.begin(), vz.end(), Generator<POSVEL_T>(25, 3)); 
     181    std::generate(phi.begin(), phi.end(), Generator<POSVEL_T>(25, 3)); 
     182  } 
    142183  std::generate(id.begin(), id.end(), Generator<ID_T>(25, 3)); 
    143184  std::fill(mask.begin(), mask.end(), 25); 
    144185 
    145   GIO.addVariable("x", xx, CoordFlagsX | GenericIO::VarHasExtraSpace); 
    146   GIO.addVariable("y", yy, CoordFlagsY | GenericIO::VarHasExtraSpace); 
    147   GIO.addVariable("z", zz, CoordFlagsZ | GenericIO::VarHasExtraSpace); 
    148   GIO.addVariable("vx", vx, GenericIO::VarHasExtraSpace); 
    149   GIO.addVariable("vy", vy, GenericIO::VarHasExtraSpace); 
    150   GIO.addVariable("vz", vz, GenericIO::VarHasExtraSpace); 
    151   GIO.addVariable("phi", phi, GenericIO::VarHasExtraSpace); 
     186  if (UseAOS) { 
     187    GIO.addVariable("pos", pos, CoordFlagsX | CoordFlagsY | CoordFlagsZ | 
     188                                GenericIO::VarHasExtraSpace); 
     189    GIO.addVariable("vel", vel, GenericIO::VarHasExtraSpace); 
     190  } else { 
     191    GIO.addVariable("x", xx, CoordFlagsX | GenericIO::VarHasExtraSpace); 
     192    GIO.addVariable("y", yy, CoordFlagsY | GenericIO::VarHasExtraSpace); 
     193    GIO.addVariable("z", zz, CoordFlagsZ | GenericIO::VarHasExtraSpace); 
     194    GIO.addVariable("vx", vx, GenericIO::VarHasExtraSpace); 
     195    GIO.addVariable("vy", vy, GenericIO::VarHasExtraSpace); 
     196    GIO.addVariable("vz", vz, GenericIO::VarHasExtraSpace); 
     197    GIO.addVariable("phi", phi, GenericIO::VarHasExtraSpace); 
     198  } 
    152199  GIO.addVariable("id", id, GenericIO::VarHasExtraSpace); 
    153200  GIO.addVariable("mask", mask, GenericIO::VarHasExtraSpace); 
    … …  
    156203  } // destroy GIO prior to calling MPI_Finalize 
    157204 
    158   xx.resize(Np); 
    159   yy.resize(Np); 
    160   zz.resize(Np); 
    161   vx.resize(Np); 
    162   vy.resize(Np); 
    163   vz.resize(Np); 
    164   phi.resize(Np); 
     205  if (UseAOS) { 
     206    pos.resize(Np); 
     207    vel.resize(Np); 
     208  } else { 
     209    xx.resize(Np); 
     210    yy.resize(Np); 
     211    zz.resize(Np); 
     212    vx.resize(Np); 
     213    vy.resize(Np); 
     214    vz.resize(Np); 
     215    phi.resize(Np); 
     216  } 
    165217  id.resize(Np); 
    166218  mask.resize(Np); 

  • GenericIOPrint.cxx

    r8f0a211 r5d57155  
    6363class Printer : public PrinterBase { 
    6464public: 
    65   Printer(GenericIO &G, size_t MNE, const string &N) 
    66     : Data(MNE + G.requestedExtraSpace()/sizeof(T)) { 
    67     G.addVariable(N, Data, true); 
     65  Printer(GenericIO &G, size_t MNE, size_t NE, const string &N) 
     66    : NumElements(NE), Data(MNE*NE + G.requestedExtraSpace()/sizeof(T)) { 
     67    G.addScalarizedVariable(N, Data, NE, GenericIO::VarHasExtraSpace); 
    6868  } 
    6969 
    7070  virtual void print(ostream &os, size_t i) { 
    71     os << scientific << setprecision(numeric_limits<T>::digits10) << Data[i]; 
     71    for (size_t j = 0; j < NumElements; ++j) { 
     72      os << scientific << setprecision(numeric_limits<T>::digits10) << 
     73            Data[i*NumElements + j]; 
     74 
     75      if (j != NumElements - 1) 
     76        os << "\t"; 
     77    } 
    7278  } 
    7379 
    7480protected: 
     81  size_t NumElements; 
    7582  vector<T> Data; 
    7683}; 
    … …  
    7986PrinterBase *addPrinter(GenericIO::VariableInfo &V, 
    8087                GenericIO &GIO, size_t MNE) { 
    81   if (sizeof(T) != V.Size) 
     88  if (sizeof(T) != V.ElementSize) 
    8289    return 0; 
    8390 
    … …  
    8794    return 0; 
    8895 
    89   return new Printer<T>(GIO, MNE, V.Name); 
     96  return new Printer<T>(GIO, MNE, V.Size/V.ElementSize, V.Name); 
    9097} 
    9198 
    … …  
    241248    cout << "# "; 
    242249    for (size_t i = 0; i < VI.size(); ++i) { 
    243       cout << VI[i].Name; 
     250      if (VI[i].Size == VI[i].ElementSize) { 
     251        cout << VI[i].Name; 
     252      } else { 
     253        size_t NumElements = VI[i].Size/VI[i].ElementSize; 
     254        for (size_t j = 0; j < NumElements; ++j) { 
     255          cout << VI[i].Name; 
     256          if (j == 0) { 
     257            cout << ".x"; 
     258          } else if (j == 1) { 
     259            cout << ".y"; 
     260          } else if (j == 2) { 
     261            cout << ".z"; 
     262          } else if (j == 3) { 
     263            cout << ".w"; 
     264          } else { 
     265            cout << ".w" << (j - 3); 
     266          } 
     267 
     268          if (j != NumElements - 1) 
     269            cout << "\t"; 
     270        } 
     271      } 
     272 
    244273      if (i != VI.size() - 1) 
    245274        cout << "\t"; 
Note: See TracChangeset for help on using the changeset viewer.