src/Plugins/MedReader/IO/vtkMedField.cxx

   1 // Copyright (C) 2010-2011  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "vtkMedField.h"
  21
  22 #include "vtkObjectFactory.h"
  23 #include "vtkSmartPointer.h"
  24 #include "vtkStringArray.h"
  25 #include "vtkMedFieldOverEntity.h"
  26 #include "vtkMedFieldStep.h"
  27 #include "vtkMedUtilities.h"
  28 #include "vtkMedFieldOnProfile.h"
  29 #include "vtkMedInterpolation.h"
  30 #include "vtkMedFile.h"
  31
  32 #include <string>
  33 #include <map>
  34 using namespace std;
  35
  36 vtkCxxGetObjectVectorMacro(vtkMedField, Interpolation, vtkMedInterpolation);
  37 vtkCxxSetObjectVectorMacro(vtkMedField, Interpolation, vtkMedInterpolation);
  38
  39 vtkCxxSetObjectMacro(vtkMedField, ParentFile, vtkMedFile);
  40
  41 // vtkCxxRevisionMacro(vtkMedField, "$Revision$")
  42 vtkStandardNewMacro(vtkMedField)
  43
  44 vtkMedField::vtkMedField()
  45 {
  46   this->NumberOfComponent = -1;
  47   this->DataType = MED_FLOAT64;
  48   this->Name = NULL;
  49   this->MeshName = NULL;
  50   this->TimeUnit = NULL;
  51   this->FieldStep = new vtkMedComputeStepMap<vtkMedFieldStep> ();
  52   this->Unit = vtkStringArray::New();
  53   this->ComponentName = vtkStringArray::New();
  54   this->Interpolation = new vtkObjectVector<vtkMedInterpolation> ();
  55   this->MedIterator = -1;
  56   this->FieldType = UnknownFieldType;
  57   this->ParentFile = NULL;
  58   this->Local = 1;
  59 }
  60
  61 vtkMedField::~vtkMedField()
  62 {
  63   this->SetName(NULL);
  64   this->SetMeshName(NULL);
  65   this->SetTimeUnit(NULL);
  66   delete this->FieldStep;
  67   this->Unit->Delete();
  68   this->ComponentName->Delete();
  69 }
  70
  71 void vtkMedField::ComputeFieldType()
  72 {
  73   this->FieldType = UnknownFieldType;
  74
  75   // look for the med_entity_type
  76   // on which this field is.
  77   for(int sid = 0; sid < this->GetNumberOfFieldStep(); sid++)
  78     {
  79     vtkMedFieldStep* step = this->GetFieldStep(sid);
  80
  81     for(int eid = 0; eid < step->GetNumberOfFieldOverEntity(); eid++)
  82       {
  83       vtkMedFieldOverEntity* fieldOverEntity = step->GetFieldOverEntity(eid);
  84       med_entity_type type = fieldOverEntity->GetEntity().EntityType;
  85
  86       if (type == MED_NODE)
  87         {
  88         this->FieldType |= PointField;
  89         }
  90       else if(type == MED_NODE_ELEMENT )
  91         {
  92         this->FieldType |= ElnoField;
  93         }
  94       else
  95         {
  96         for(int pid=0; pid<fieldOverEntity->GetNumberOfFieldOnProfile(); pid++)
  97           {
  98           vtkMedFieldOnProfile* fop = fieldOverEntity->GetFieldOnProfile(pid);
  99           const char* locname = fop->GetLocalizationName();
 100           if(strcmp(locname, MED_GAUSS_ELNO) == 0 )
 101             {
 102             this->FieldType = ElnoField;
 103             }
 104           else if(strcmp(locname, MED_NO_LOCALIZATION) != 0 )
 105             {
 106             this->FieldType |= QuadratureField;
 107             }
 108           else
 109             {
 110             this->FieldType |= CellField;
 111             }
 112           }
 113         }
 114       }
 115     }
 116
 117   if(this->FieldType == UnknownFieldType)
 118     this->FieldType = PointField;
 119 }
 120
 121 int vtkMedField::HasManyFieldTypes()
 122 {
 123   int numberOfTypes = 0;
 124   numberOfTypes += (this->FieldType & vtkMedField::PointField) != 0;
 125   numberOfTypes += (this->FieldType & vtkMedField::CellField) != 0;
 126   numberOfTypes += (this->FieldType & vtkMedField::QuadratureField) != 0;
 127   numberOfTypes += (this->FieldType & vtkMedField::ElnoField) != 0;
 128
 129   return numberOfTypes > 1;
 130 }
 131
 132 int vtkMedField::GetFirstType()
 133 {
 134   if((this->FieldType & vtkMedField::PointField) != 0)
 135     return vtkMedField::PointField;
 136
 137   if((this->FieldType & vtkMedField::CellField) != 0)
 138     return vtkMedField::CellField;
 139
 140   if((this->FieldType & vtkMedField::QuadratureField) != 0)
 141     return vtkMedField::QuadratureField;
 142
 143   if((this->FieldType & vtkMedField::ElnoField) != 0)
 144     return vtkMedField::ElnoField;
 145 }
 146
 147 void  vtkMedField::ExtractFieldType(vtkMedField* otherfield, int type)
 148 {
 149   this->SetName(otherfield->GetName());
 150   this->SetLocal(otherfield->GetLocal());
 151   this->SetMedIterator(otherfield->GetMedIterator());
 152   this->SetDataType(otherfield->GetDataType());
 153   this->SetMeshName(otherfield->GetMeshName());
 154   this->SetTimeUnit(otherfield->GetTimeUnit());
 155   this->SetParentFile(otherfield->GetParentFile());
 156
 157   this->SetNumberOfComponent(otherfield->GetNumberOfComponent());
 158   for(int i=0; i< this->GetNumberOfComponent(); i++)
 159     {
 160     this->GetComponentName()->SetValue(i, otherfield->
 161                                        GetComponentName()->GetValue(i));
 162     }
 163
 164   this->AllocateNumberOfInterpolation(otherfield->GetNumberOfInterpolation());
 165   for(int i=0; i<this->GetNumberOfInterpolation(); i++)
 166     {
 167     this->SetInterpolation(i, otherfield->GetInterpolation(i));
 168     }
 169
 170   this->GetUnit()->SetNumberOfValues(
 171       otherfield->GetUnit()->GetNumberOfValues());
 172   for(int i=0; i<this->GetUnit()->GetNumberOfValues(); i++)
 173     {
 174     this->GetUnit()->SetValue(i, otherfield->GetUnit()->GetValue(i));
 175     }
 176
 177   int nstep = otherfield->GetNumberOfFieldStep();
 178   map<vtkMedFieldStep*, vtkMedFieldStep*> stepmap;
 179   for(int stepid=0; stepid<nstep; stepid++)
 180     {
 181     vtkMedFieldStep* otherstep = otherfield->GetFieldStep(stepid);
 182     vtkMedFieldStep* step = vtkMedFieldStep::New();
 183     step->SetComputeStep(otherstep->GetComputeStep());
 184     this->AddFieldStep(step);
 185     step->Delete();
 186
 187     stepmap[otherstep] = step;
 188
 189     vtkMedFieldStep* previousstep = NULL;
 190     if(stepmap.find(otherstep->GetPreviousStep()) != stepmap.end())
 191       {
 192       previousstep = stepmap[otherstep->GetPreviousStep()];
 193       }
 194     step->SetPreviousStep(previousstep);
 195     step->SetParentField(this);
 196     step->SetMeshComputeStep(otherstep->GetMeshComputeStep());
 197
 198     for(int eid=0; eid<otherstep->GetNumberOfFieldOverEntity(); eid++)
 199       {
 200       vtkMedFieldOverEntity* fieldOverEntity = otherstep->GetFieldOverEntity(eid);
 201
 202       if(type == vtkMedField::PointField)
 203         {
 204         if(fieldOverEntity->GetEntity().EntityType != MED_NODE)
 205           {
 206           continue;
 207           }
 208         step->AppendFieldOverEntity(fieldOverEntity);
 209         otherstep->RemoveFieldOverEntity(fieldOverEntity);
 210         fieldOverEntity->SetParentStep(step);
 211         }
 212       else if(type == vtkMedField::ElnoField)
 213         {
 214         if(fieldOverEntity->GetEntity().EntityType != MED_NODE_ELEMENT)
 215           {
 216           continue;
 217           }
 218
 219         step->AppendFieldOverEntity(fieldOverEntity);
 220         otherstep->RemoveFieldOverEntity(fieldOverEntity);
 221         eid--;
 222         fieldOverEntity->SetParentStep(step);
 223         }
 224       else
 225         {
 226         if(fieldOverEntity->GetEntity().EntityType == MED_NODE)
 227           {
 228           continue;
 229           }
 230         vtkMedFieldOverEntity* newfoe = vtkMedFieldOverEntity::New();
 231         newfoe->SetEntity(fieldOverEntity->GetEntity());
 232         newfoe->SetHasProfile(fieldOverEntity->GetHasProfile());
 233         newfoe->SetParentStep(step);
 234         step->AppendFieldOverEntity(newfoe);
 235         newfoe->Delete();
 236         for(int pid=0; pid<fieldOverEntity->GetNumberOfFieldOnProfile(); pid++)
 237           {
 238           vtkMedFieldOnProfile* fop = fieldOverEntity->GetFieldOnProfile(pid);
 239           const char* locname = fop->GetLocalizationName();
 240           if((type == vtkMedField::QuadratureField
 241              && strcmp(locname, MED_NO_LOCALIZATION) != 0) ||
 242              (type == vtkMedField::CellField
 243              && strcmp(locname, MED_NO_LOCALIZATION) == 0 ))
 244             {
 245             newfoe->AppendFieldOnProfile(fop);
 246             fieldOverEntity->RemoveFieldOnProfile(fop);
 247             pid--;
 248             fop->SetParentFieldOverEntity(newfoe);
 249             }
 250           }
 251         if(fieldOverEntity->GetNumberOfFieldOnProfile() == 0)
 252           {
 253           otherstep->RemoveFieldOverEntity(fieldOverEntity);
 254           eid--;
 255           }
 256         }
 257       }
 258     }
 259
 260   this->ComputeFieldType();
 261   otherfield->ComputeFieldType();
 262 }
 263
 264 void vtkMedField::SetNumberOfComponent(int ncomp)
 265 {
 266   if (this->NumberOfComponent == ncomp)
 267     return;
 268
 269   this->NumberOfComponent = ncomp;
 270   this->GetUnit()->SetNumberOfValues(this->NumberOfComponent);
 271   this->GetComponentName()->SetNumberOfValues(this->NumberOfComponent);
 272
 273   this->Modified();
 274 }
 275
 276 void  vtkMedField::AddFieldStep(vtkMedFieldStep* step)
 277 {
 278   this->FieldStep->AddObject(step->GetComputeStep(), step);
 279 }
 280
 281 void  vtkMedField::ClearFieldStep()
 282 {
 283   this->FieldStep->clear();
 284 }
 285
 286 vtkMedFieldStep* vtkMedField::GetFieldStep(const vtkMedComputeStep& cs)
 287 {
 288   return this->FieldStep->GetObject(cs);
 289 }
 290
 291 vtkMedFieldStep* vtkMedField::FindFieldStep(const vtkMedComputeStep& cs,
 292                                             int strategy)
 293 {
 294   return this->FieldStep->FindObject(cs, strategy);
 295 }
 296
 297 med_int vtkMedField::GetNumberOfFieldStep()
 298 {
 299   return this->FieldStep->GetNumberOfObject();
 300 }
 301
 302 vtkMedFieldStep* vtkMedField::GetFieldStep(med_int id)
 303 {
 304   return this->FieldStep->GetObject(id);
 305 }
 306
 307 void  vtkMedField::GatherFieldTimes(std::set<med_float>& times)
 308 {
 309   this->FieldStep->GatherTimes(times);
 310 }
 311
 312 void  vtkMedField::GatherFieldIterations(med_float time,
 313                                          std::set<med_int>& iterations)
 314 {
 315   this->FieldStep->GatherIterations(time, iterations);
 316 }
 317
 318 void vtkMedField::PrintSelf(ostream& os, vtkIndent indent)
 319 {
 320   this->Superclass::PrintSelf(os, indent);
 321   PRINT_IVAR(os, indent, MedIterator);
 322   PRINT_IVAR(os, indent, NumberOfComponent);
 323   PRINT_IVAR(os, indent, FieldType);
 324   PRINT_IVAR(os, indent, DataType);
 325   PRINT_IVAR(os, indent, Local);
 326 }