applications/utilities/postProcessing/dataConversion/foamToFieldview9/createFields.H

   1 // Construct List of pointers to all vol fields
   2 int nFields = volScalarNames.size() + 3*volVectorNames.size();
   3 List<volScalarField*> volFieldPtrs
   4 (
   5     nFields,
   6     reinterpret_cast<volScalarField*>(NULL)
   7 );
   8
   9 stringList volFieldNames(nFields);
  10
  11 nFields = 0;
  12 {
  13     // Load all scalar fields and store ptr to it
  14     forAll(volScalarNames, fieldI)
  15     {
  16         word fieldName = volScalarNames[fieldI];
  17
  18         // Check if present
  19         IOobject ioHeader
  20         (
  21             fieldName,
  22             runTime.timeName(),
  23             mesh,
  24             IOobject::MUST_READ,
  25             IOobject::NO_WRITE
  26         );
  27
  28         if (ioHeader.headerOk())
  29         {
  30            volFieldPtrs[nFields] =
  31                 new volScalarField
  32                 (
  33                     ioHeader,
  34                     mesh
  35                 );
  36         }
  37
  38         fieldName = getFieldViewName(fieldName);
  39
  40         volFieldNames[nFields] = fieldName;
  41
  42         nFields++;
  43     }
  44
  45
  46     // Load all  (componenents of) vector fields
  47     forAll(volVectorNames, fieldI)
  48     {
  49         word fieldName = volVectorNames[fieldI];
  50
  51         // Check if present
  52         IOobject ioHeader
  53         (
  54             fieldName,
  55             runTime.timeName(),
  56             mesh,
  57             IOobject::MUST_READ,
  58             IOobject::NO_WRITE
  59         );
  60
  61         if (ioHeader.headerOk())
  62         {
  63             volVectorField vvf(ioHeader, mesh);
  64
  65             // X component
  66             volFieldPtrs[nFields] =
  67                 new volScalarField
  68                 (
  69                     vvf.component(vector::X)
  70                 );
  71
  72             // Y component
  73             volFieldPtrs[nFields+1] =
  74                 new volScalarField
  75                 (
  76                     vvf.component(vector::Y)
  77                 );
  78
  79             // Z component
  80             volFieldPtrs[nFields+2] =
  81                 new volScalarField
  82                 (
  83                     vvf.component(vector::Z)
  84                 );
  85         }
  86
  87         fieldName = getFieldViewName(fieldName);
  88
  89         volFieldNames[nFields]   = fieldName + ("x;" +  fieldName);
  90         volFieldNames[nFields+1] = fieldName + "y";
  91         volFieldNames[nFields+2] = fieldName + "z";
  92
  93         nFields += 3;
  94     }
  95 }
  96
  97
  98
  99 //
 100 // Construct List of pointers to all surface fields
 101 //
 102
 103
 104
 105 int nSurfFields = surfScalarNames.size() + 3*surfVectorNames.size();
 106 List<surfaceScalarField*> surfFieldPtrs
 107 (
 108     nSurfFields,
 109     reinterpret_cast<surfaceScalarField*>(NULL)
 110 );
 111
 112 stringList surfFieldNames(nSurfFields);
 113
 114 nSurfFields = 0;
 115 {
 116     // Load all scalar fields
 117     forAll(surfScalarNames, fieldI)
 118     {
 119         word fieldName = surfScalarNames[fieldI];
 120
 121         // Check if present
 122         IOobject ioHeader
 123         (
 124             fieldName,
 125             runTime.timeName(),
 126             mesh,
 127             IOobject::MUST_READ,
 128             IOobject::NO_WRITE
 129         );
 130
 131         if (ioHeader.headerOk())
 132         {
 133             surfFieldPtrs[nSurfFields] =
 134                 new surfaceScalarField
 135                 (
 136                     ioHeader,
 137                     mesh
 138                 );
 139         }
 140
 141         fieldName = getFieldViewName(fieldName);
 142
 143         surfFieldNames[nSurfFields] = fieldName;
 144
 145         nSurfFields++;
 146     }
 147
 148
 149     // Set (componenents of) vector fields
 150     forAll(surfVectorNames, fieldI)
 151     {
 152         word fieldName = surfVectorNames[fieldI];
 153
 154         // Check if present
 155         IOobject ioHeader
 156         (
 157             fieldName,
 158             runTime.timeName(),
 159             mesh,
 160             IOobject::MUST_READ,
 161             IOobject::NO_WRITE
 162         );
 163
 164         if (ioHeader.headerOk())
 165         {
 166             surfaceVectorField svf(ioHeader, mesh);
 167
 168             // X component
 169             surfFieldPtrs[nSurfFields] =
 170                 new surfaceScalarField
 171                 (
 172                     svf.component(vector::X)
 173                 );
 174
 175             // Y component
 176             surfFieldPtrs[nSurfFields+1] =
 177                 new surfaceScalarField
 178                 (
 179                     svf.component(vector::Y)
 180                 );
 181
 182             // Z component
 183             surfFieldPtrs[nSurfFields+2] =
 184                 new surfaceScalarField
 185                 (
 186                     svf.component(vector::Z)
 187                 );
 188         }
 189
 190         fieldName = getFieldViewName(fieldName);
 191
 192         surfFieldNames[nSurfFields]   = fieldName + ("x;" + fieldName);
 193         surfFieldNames[nSurfFields+1] = fieldName + "y";
 194         surfFieldNames[nSurfFields+2] = fieldName + "z";
 195
 196         nSurfFields += 3;
 197     }
 198 }