applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightOutputCase.H

   1 // write time values to case file
   2
   3 scalar timeCorrection = 0;
   4 if (timeDirs[0].value() < 0)
   5 {
   6     timeCorrection = - timeDirs[0].value();
   7     Info<< "Correcting time values. Adding " << timeCorrection << endl;
   8 }
   9
  10 // the case file is always ASCII
  11 Info << "write case: " << caseFileName.c_str() << endl;
  12
  13 OFstream caseFile
  14 (
  15     ensightDir/caseFileName,
  16     ios_base::out|ios_base::trunc,
  17     IOstream::ASCII
  18 );
  19 caseFile.setf(ios_base::left);
  20
  21 caseFile.setf(ios_base::scientific, ios_base::floatfield);
  22 caseFile.precision(5);
  23
  24 caseFile
  25     << "FORMAT" << nl
  26     << setw(16) << "type:" << "ensight gold" << nl << nl;
  27
  28 if (hasMovingMesh)
  29 {
  30     caseFile
  31         << "GEOMETRY" << nl
  32         << setw(16) << "model: 1" << (dataMask/geometryName).c_str() << nl;
  33 }
  34 else
  35 {
  36     caseFile
  37         << "GEOMETRY" << nl
  38         << setw(16) << "model:" << geometryName << nl;
  39 }
  40
  41
  42 // add information for clouds
  43 // multiple clouds currently require the same time index
  44 forAllConstIter(HashTable<HashTable<word> >, cloudFields, cloudIter)
  45 {
  46     const word& cloudName = cloudIter.key();
  47
  48     caseFile
  49         << setw(16) << "measured: 2"
  50         << fileName(dataMask/cloud::prefix/cloudName/"positions").c_str()
  51             << nl;
  52 }
  53 caseFile
  54     << nl << "VARIABLE" << nl;
  55
  56 forAllConstIter(HashTable<word>, volumeFields, fieldIter)
  57 {
  58     const word& fieldName = fieldIter.key();
  59     const word& fieldType = fieldIter();
  60     string ensightType;
  61
  62     if (fieldType == volScalarField::typeName)
  63     {
  64         ensightType = "scalar";
  65     }
  66     else if (fieldType == volVectorField::typeName)
  67     {
  68         ensightType = "vector";
  69     }
  70     else if (fieldType == volSphericalTensorField::typeName)
  71     {
  72         ensightType = "tensor symm";
  73     }
  74     else if (fieldType == volSymmTensorField::typeName)
  75     {
  76         ensightType = "tensor symm";
  77     }
  78     else if (fieldType == volTensorField::typeName)
  79     {
  80         ensightType = "tensor asym";
  81     }
  82
  83     if (ensightType.size())
  84     {
  85         ensightCaseEntry
  86         (
  87             caseFile,
  88             ensightType,
  89             fieldName,
  90             dataMask
  91         );
  92     }
  93 }
  94
  95 // TODO: allow similar/different time-steps for each cloud
  96
  97
  98 label cloudNo = 0;
  99 forAllConstIter(HashTable<HashTable<word> >, cloudFields, cloudIter)
 100 {
 101     const word& cloudName = cloudIter.key();
 102
 103     forAllConstIter(HashTable<word>, cloudIter(), fieldIter)
 104     {
 105         const word& fieldName = fieldIter.key();
 106         const word& fieldType = fieldIter();
 107         string ensightType;
 108
 109         if (fieldType == scalarIOField::typeName)
 110         {
 111             ensightType = "scalar";
 112         }
 113         else if (fieldType == vectorIOField::typeName)
 114         {
 115             ensightType = "vector";
 116         }
 117         else if (fieldType == tensorIOField::typeName)
 118         {
 119             ensightType = "tensor";
 120         }
 121
 122         if (ensightType.size())
 123         {
 124             ensightCaseEntry
 125             (
 126                 caseFile,
 127                 ensightType,
 128                 fieldName,
 129                 dataMask,
 130                 cloud::prefix/cloudName,
 131                 cloudNo,
 132                 2
 133             );
 134         }
 135     }
 136     cloudNo++;
 137 }
 138
 139
 140 // add time values
 141 caseFile << nl << "TIME" << nl;
 142
 143 // time set 1 - geometry and volume fields
 144 if (fieldTimesUsed.size())
 145 {
 146     caseFile
 147         << "time set:        " << 1 << nl
 148         << "number of steps: " << fieldTimesUsed.size() << nl
 149         << "filename numbers:" << nl;
 150
 151     label count = 0;
 152     forAll (fieldTimesUsed, i)
 153     {
 154         caseFile
 155             << " " << setw(12) << fieldTimesUsed[i];
 156
 157         if (++count % 6 == 0)
 158         {
 159             caseFile << nl;
 160         }
 161     }
 162
 163     caseFile
 164         << nl << "time values:" << nl;
 165
 166     count = 0;
 167     forAll (fieldTimesUsed, i)
 168     {
 169         caseFile
 170             << " " << setw(12)
 171                 << timeIndices[fieldTimesUsed[i]] + timeCorrection;
 172
 173         if (++count % 6 == 0)
 174         {
 175             caseFile << nl;
 176         }
 177     }
 178     caseFile << nl << nl;
 179 }
 180
 181 // TODO: allow similar/different time-steps for each cloud
 182 cloudNo = 0;
 183 forAllConstIter(HashTable<DynamicList<label> >, cloudTimesUsed, cloudIter)
 184 {
 185     // const word& cloudName = cloudIter.key();
 186     const DynamicList<label>& timesUsed = cloudIter();
 187
 188     if (timesUsed.size() && cloudNo == 0)
 189     {
 190         caseFile
 191             << "time set:        " << 2 << nl
 192             << "number of steps: " << timesUsed.size() << nl
 193             << "filename numbers:" << nl;
 194
 195         label count = 0;
 196         forAll (timesUsed, i)
 197         {
 198             caseFile
 199                 << " " << setw(12) << timesUsed[i];
 200
 201             if (++count % 6 == 0)
 202             {
 203                 caseFile << nl;
 204             }
 205         }
 206
 207         caseFile
 208             << nl << "time values:" << nl;
 209
 210         count = 0;
 211         forAll (timesUsed, i)
 212         {
 213             caseFile
 214                 << " " << setw(12)
 215                     << timeIndices[timesUsed[i]] + timeCorrection;
 216
 217             if (++count % 6 == 0)
 218             {
 219                 caseFile << nl;
 220             }
 221         }
 222         caseFile << nl << nl;
 223
 224         cloudNo++;
 225     }
 226 }
 227
 228 caseFile << "# end" << nl;
 229