#include <string>
#include "MEDCouplingFieldDouble.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCalculator_i * MEDCalculator_i::_instance = NULL;
#include "Basics_Utils.hxx"
#include "MEDLoader.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
#include <string>
#include <vector>
}
// Then we check that the file is readable by MEDLoader
- MEDLoader::CheckFileForRead(filepath);
+ CheckFileForRead(filepath);
// Initialise the datasource handler
MEDCALC::DatasourceHandler * datasourceHandler = new MEDCALC::DatasourceHandler();
_datasourceHandlerMap[datasourceHandler->id] = datasourceHandler;
// We start by read the list of meshes (spatial supports of fields)
- vector<string> meshNames = MEDLoader::GetMeshNames(filepath);
+ vector<string> meshNames = GetMeshNames(filepath);
int nbOfMeshes = meshNames.size();
for (int iMesh = 0; iMesh < nbOfMeshes; iMesh++) {
const char * meshName = meshNames[iMesh].c_str();
// For each mesh, we can read the list of the names of the
// associated fields, i.e. fields whose spatial support is this
// mesh.
- vector<string> fieldNames = MEDLoader::GetAllFieldNamesOnMesh(filepath,
+ vector<string> fieldNames = GetAllFieldNamesOnMesh(filepath,
meshName);
int nbOfFields = fieldNames.size();
for (int iField = 0; iField < nbOfFields; iField++) {
// to determine the types of spatial discretization defined for
// this field and to chooose one.
- vector<TypeOfField> listOfTypes = MEDLoader::GetTypesOfField(filepath,
+ vector<TypeOfField> listOfTypes = GetTypesOfField(filepath,
meshName,
fieldName);
int nbOfTypes = listOfTypes.size();
// Then, we can get the iterations associated to this field on
// this type of spatial discretization:
std::vector< std::pair<int,int> > fieldIterations =
- MEDLoader::GetFieldIterations(listOfTypes[iType],
+ GetFieldIterations(listOfTypes[iType],
filepath,
meshName,
fieldName);
try {
bool writeFromScratch = true;
- MEDLoader::WriteField(filepath, fieldDouble, writeFromScratch);
+ WriteField(filepath, fieldDouble, writeFromScratch);
writeFromScratch = false;
for(CORBA::ULong i=1; i<fieldIdList.length(); i++) {
fieldHandlerId = fieldIdList[i];
fieldHandler = getFieldHandler(fieldHandlerId);
fieldDouble = getFieldDouble(fieldHandler);
- MEDLoader::WriteField(filepath, fieldDouble, writeFromScratch);
+ WriteField(filepath, fieldDouble, writeFromScratch);
}
}
catch (INTERP_KERNEL::Exception &ex) {
std::string filepath(source_to_file((_datasourceHandlerMap[sourceid])->uri));
const char * meshName = _meshHandlerMap[meshHandlerId]->name;
int meshDimRelToMax = 0;
- myMesh = MEDLoader::ReadUMeshFromFile(filepath,meshName,meshDimRelToMax);
+ myMesh = ReadUMeshFromFile(filepath,meshName,meshDimRelToMax);
_meshMap[meshHandlerId] = myMesh;
}
return myMesh;
LOG("getFieldDouble: field "<<fieldHandler->fieldname<<" loaded from file "<<filepath);
TypeOfField type = (TypeOfField)fieldHandler->type;
int meshDimRelToMax = 0;
- MEDCouplingFieldDouble * myField = MEDLoader::ReadField(type,
+ MEDCouplingFieldDouble * myField = ReadField(type,
filepath,
meshName,
meshDimRelToMax,
throw KERNEL::createSalomeException(message.c_str());
}
-ParaMEDMEM::NatureOfField MEDDataManager_i::_getNatureOfField(const char* fieldNature) {
+MEDCoupling::NatureOfField MEDDataManager_i::_getNatureOfField(const char* fieldNature) {
std::string nature(fieldNature);
if (nature == "NoNature") {
return NoNature;
std::string method(params.method);
double defaultValue = params.defaultValue;
bool reverse = params.reverse;
- ParaMEDMEM::NatureOfField nature = this->_getNatureOfField(params.nature);
+ MEDCoupling::NatureOfField nature = this->_getNatureOfField(params.nature);
// 1. Build remapper between sourceMesh and targetMesh (compute interpolation matrix)
MEDCouplingRemapper remapper;
#include "MEDCouplingRemapper.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
/*! This map is used for lifecycle management of fields used in this operator */
#include <map>
long getUMeshId(const MEDCouplingMesh * mesh);
INTERP_KERNEL::IntersectionType _getIntersectionType(const char* intersType);
- ParaMEDMEM::NatureOfField _getNatureOfField(const char* fieldNature);
+ MEDCoupling::NatureOfField _getNatureOfField(const char* fieldNature);
};
std::string MEDPresentation::getFieldTypeString()
{
- ParaMEDMEM::TypeOfField typ = (ParaMEDMEM::TypeOfField)_fieldHandler->type;
+ MEDCoupling::TypeOfField typ = (MEDCoupling::TypeOfField)_fieldHandler->type;
switch(typ)
{
- case ParaMEDMEM::ON_CELLS:
+ case MEDCoupling::ON_CELLS:
return "CELLS";
- case ParaMEDMEM::ON_NODES:
+ case MEDCoupling::ON_NODES:
return "NODES";
default:
std::cerr << "MEDPresentation::getFieldTypeString() -- Not implemented ! Gauss points?";
#include <algorithm>
#include <functional>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
// Default constructor
// Set field name to nm and selection to flase
// Then, read the Med structur to fill time steps, components and meshes
MEDCalculatorBrowserField::MEDCalculatorBrowserField(const char *fname, const char *fieldName) : _name(fieldName), _file_name(fname), _selection(false)
{
- std::vector< std::string > meshNames=MEDLoader::GetMeshNamesOnField(fname,fieldName);
- std::vector< std::pair< std::pair<int,int>, double > > dtits=MEDLoader::GetAllFieldIterations(fname, fieldName);
+ std::vector< std::string > meshNames=GetMeshNamesOnField(fname,fieldName);
+ std::vector< std::pair< std::pair<int,int>, double > > dtits=GetAllFieldIterations(fname, fieldName);
for(std::vector<std::pair< std::pair<int,int>, double > >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
{
_steps.push_back(MEDCalculatorBrowserStep((*iter).first.first,(*iter).first.second,(*iter).second,meshNames[0]));
}
- std::vector<TypeOfField> types=MEDLoader::GetTypesOfField(fname,meshNames[0].c_str(),fieldName);
+ std::vector<TypeOfField> types=GetTypesOfField(fname,meshNames[0].c_str(),fieldName);
if(types.empty())
throw INTERP_KERNEL::Exception("MEDCalculatorBrowserField::MEDCalculatorBrowserField : the file is not loadable using MED File 3 API ! Problably presence of field on edges faces...");
_type=types[0];//To improve
MEDCouplingFieldDouble *tmpf=0;
try
{
- tmpf=MEDLoader::ReadField(_type,fname,meshNames[0].c_str(),0,fieldName,dtits[0].first.first,dtits[0].first.second);
+ tmpf=ReadField(_type,fname,meshNames[0].c_str(),0,fieldName,dtits[0].first.first,dtits[0].first.second);
}
catch(INTERP_KERNEL::Exception& e)
{
if(_type==ON_CELLS)
- tmpf=MEDLoader::ReadField(_type,fname,meshNames[0].c_str(),-1,fieldName,dtits[0].first.first,dtits[0].first.second);
+ tmpf=ReadField(_type,fname,meshNames[0].c_str(),-1,fieldName,dtits[0].first.first,dtits[0].first.second);
else
throw e;
}
_components.push_back(c);
}
tmpf->decrRef();
- _corresponding_meshes=MEDLoader::GetMeshNamesOnField(fname,fieldName);
+ _corresponding_meshes=GetMeshNamesOnField(fname,fieldName);
}
// Equal to string operator,
// This class correspond to a MED field of a file
// It contains the field name, the components, the time steps and selection methods
// It's used to select a field, it's components and time steps
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCalculatorBrowserStep;// top prevent cross include
class MEDCALCULATOR_EXPORT MEDCalculatorBrowserField
#include <deque>
#include <string>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
// Default constructor
MEDCalculatorBrowserLiteStruct::MEDCalculatorBrowserLiteStruct() : _any_selection(false)
MEDCalculatorBrowserLiteStruct::MEDCalculatorBrowserLiteStruct(const char *f) : _file(f), _any_selection(false)
{
computeBaseName();
- std::vector<std::string> meshNames=MEDLoader::GetMeshNames(_file.c_str());
+ std::vector<std::string> meshNames=GetMeshNames(_file.c_str());
for(std::vector<std::string>::const_iterator iter=meshNames.begin();iter!=meshNames.end();iter++)
_meshes.push_back(MEDCalculatorBrowserMesh((*iter).c_str()));
- std::vector<std::string> fieldNames=MEDLoader::GetAllFieldNames(_file.c_str());
+ std::vector<std::string> fieldNames=GetAllFieldNames(_file.c_str());
for(std::vector<std::string>::const_iterator iter=fieldNames.begin();iter!=fieldNames.end();iter++)
_fields.push_back(MEDCalculatorBrowserField(_file.c_str(),(*iter).c_str()));
}
// This class correspond to a MED File
// It contains fields and meshes from a file
// It also has methods for selecting/unselecting meshes, field and components from fields
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCALCULATOR_EXPORT MEDCalculatorBrowserLiteStruct
{
#include <sstream>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
// Default constructor
MEDCalculatorBrowserMesh::MEDCalculatorBrowserMesh() : _selection(false)
// This class corresponds to a MED mesh of a file
// It contains the mesh name and a flag to know if it's selected or not
// It's used only for selecting mesh, out of all fields.
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCALCULATOR_EXPORT MEDCalculatorBrowserMesh
{
#include <sstream>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCalculatorBrowserStep::~MEDCalculatorBrowserStep()
{
// This class corresponds to a time step (dt,it) of a field
// It contains the time step (dt) and the corresponding time value
// It also contains methods for selecting or unselecting this time step and it hold the name of the supporting mesh.
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCALCULATOR_EXPORT MEDCalculatorBrowserStep
{
#include <cmath>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCalculatorDBFieldReal *MEDCalculatorDBField::New(const MEDCalculatorBrowserField& ls)
{
int status=MEDLoaderBase::getStatusOfFile(fName);
if(!writeFromScratch && status==MEDLoaderBase::EXIST_RW)
{
- std::vector<std::string> ms=MEDLoader::GetMeshNames(fName);
+ std::vector<std::string> ms=GetMeshNames(fName);
if(std::find(ms.begin(),ms.end(),mesh->getName())!=ms.end())
{
std::ostringstream oss; oss << "In file \"" << fName << "\" the mesh with name \"" << mesh->getName() << "\" already exists !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::vector<std::string> fs=MEDLoader::GetAllFieldNames(fName);
+ std::vector<std::string> fs=GetAllFieldNames(fName);
if(std::find(fs.begin(),fs.end(),field->getName())!=fs.end())
{
std::ostringstream oss; oss << "In file \"" << fName << "\" the field with name \"" << field->getName() << "\" already exists !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- MEDLoader::WriteUMesh(fName,mesh,writeFromScratch);
+ WriteUMesh(fName,mesh,writeFromScratch);
for(std::vector<int>::const_iterator iter=ids.begin();iter!=ids.end();iter++)
_time_steps[*iter]->write(fName,_name,_description);
}
idsInGlobalToFetch.push_back(ids[i]);
}
}
- std::vector<MEDCouplingFieldDouble *> fs=MEDLoader::ReadFieldsOnSameMesh(_type,_file_name.c_str(),_mesh_name.c_str(),0,_field_name.c_str(),idstoFetch);
+ std::vector<MEDCouplingFieldDouble *> fs=ReadFieldsOnSameMesh(_type,_file_name.c_str(),_mesh_name.c_str(),0,_field_name.c_str(),idstoFetch);
sz=fs.size();
for(int i=0;i<sz;i++)
{
#include <string>
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCalculatorBrowserField;
class MEDCalculatorDBFieldReal;
#include <limits>
#include <sstream>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
const char MEDCalculatorDBRangeSelection::ALL_ELTS[]=":";
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCALCULATOR_EXPORT MEDCalculatorDBRangeSelection
{
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingAutoRefCountObjectPtr.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCalculatorDBSliceField::MEDCalculatorDBSliceField(int iter, int order):_iteration(iter),_order(order),_field(0),_work(0)
{
MEDCouplingFieldDouble *myF=const_cast<MEDCouplingFieldDouble *>(_field);
myF->setName(n.c_str());
myF->setDescription(d.c_str());
- MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fName,_field);
+ WriteFieldUsingAlreadyWrittenMesh(fName,_field);
myF->setName(kn.c_str());
myF->setDescription(kd.c_str());
}
MEDCouplingFieldDouble *MEDCalculatorDBSliceField::getField(TypeOfField type, const std::string& fname, const std::string& mname, const std::string& fieldName) const
{
if(!_field)
- _field=MEDLoader::ReadField(type,fname.c_str(),mname.c_str(),0,fieldName.c_str(),_iteration,_order);
+ _field=ReadField(type,fname.c_str(),mname.c_str(),0,fieldName.c_str(),_iteration,_order);
return _field;
}
#include <string>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingFieldDouble;
class MEDCouplingMesh;
#include "MEDCalculatorDBField.hxx"
#include "MEDCalculatorTypemaps.i"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
using namespace INTERP_KERNEL;
%}
-%typemap(out) ParaMEDMEM::MEDCalculatorDBField*
+%typemap(out) MEDCoupling::MEDCalculatorDBField*
{
$result=convertMEDCalculatorDBField($1,$owner);
}
-%newobject ParaMEDMEM::MEDCalculatorDBField::operator+;
-%newobject ParaMEDMEM::MEDCalculatorDBField::operator-;
-%newobject ParaMEDMEM::MEDCalculatorDBField::operator*;
-%newobject ParaMEDMEM::MEDCalculatorDBField::operator/;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::__radd__;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::__rsub__;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::__rmul__;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::__rdiv__;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::__getitem__;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::__setitem__;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::operator();
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::buildCstFieldFromThis;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::dot;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::operator^;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::crossProduct;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::doublyContractedProduct;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::determinant;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::eigenValues;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::eigenVectors;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::inverse;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::trace;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::deviator;
-%newobject ParaMEDMEM::MEDCalculatorDBFieldReal::magnitude;
+%newobject MEDCoupling::MEDCalculatorDBField::operator+;
+%newobject MEDCoupling::MEDCalculatorDBField::operator-;
+%newobject MEDCoupling::MEDCalculatorDBField::operator*;
+%newobject MEDCoupling::MEDCalculatorDBField::operator/;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::__radd__;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::__rsub__;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::__rmul__;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::__rdiv__;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::__getitem__;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::__setitem__;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::operator();
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::buildCstFieldFromThis;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::dot;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::operator^;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::crossProduct;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::doublyContractedProduct;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::determinant;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::eigenValues;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::eigenVectors;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::inverse;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::trace;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::deviator;
+%newobject MEDCoupling::MEDCalculatorDBFieldReal::magnitude;
%feature("unref") MEDCalculatorDBField "$this->decrRef();"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCalculatorBrowserLiteStruct
{
MEDCalculatorDBFieldReal(const MEDCalculatorBrowserField& ls);
~MEDCalculatorDBFieldReal();
MEDCalculatorDBFieldReal *buildCstFieldFromThis(double val) const;
- ParaMEDMEM::TypeOfField getType() const;
+ MEDCoupling::TypeOfField getType() const;
void fetchData() const throw(INTERP_KERNEL::Exception);
int getNumberOfSteps() const;
int getNumberOfFetchedSteps() const;
return ret;
}
void *argp;
- int status=SWIG_ConvertPtr(val,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCalculatorDBFieldReal,0|0);
+ int status=SWIG_ConvertPtr(val,&argp,SWIGTYPE_p_MEDCoupling__MEDCalculatorDBFieldReal,0|0);
if(!SWIG_IsOK(status))
{
throw INTERP_KERNEL::Exception("For setting only float, int or DBFieldReal supported !");
}
- const ParaMEDMEM::MEDCalculatorDBFieldReal *arg=reinterpret_cast< const ParaMEDMEM::MEDCalculatorDBFieldReal * >(argp);
+ const MEDCoupling::MEDCalculatorDBFieldReal *arg=reinterpret_cast< const MEDCoupling::MEDCalculatorDBFieldReal * >(argp);
(*ret)=*arg;
ret->incrRef();
return ret;
for(unsigned int i=0;i<r.size();i++)
{
MEDCouplingFieldDouble *tmp=r[i];
- PyList_SetItem(ret,i,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ));
+ PyList_SetItem(ret,i,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ));
}
return ret;
}
}
%pythoncode %{
-def ParaMEDMEMDataArrayDoublenew(cls,*args):
+def MEDCouplingDataArrayDoublenew(cls,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDouble____new___(cls,args)
-def ParaMEDMEMDataArrayDoubleIadd(self,*args):
+def MEDCouplingDataArrayDoubleIadd(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDouble____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIsub(self,*args):
+def MEDCouplingDataArrayDoubleIsub(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDouble____isub___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleImul(self,*args):
+def MEDCouplingDataArrayDoubleImul(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDouble____imul___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIdiv(self,*args):
+def MEDCouplingDataArrayDoubleIdiv(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDouble____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIpow(self,*args):
+def MEDCouplingDataArrayDoubleIpow(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDouble____ipow___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIadd(self,*args):
+def MEDCouplingDataArrayDoubleTupleIadd(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDoubleTuple____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIsub(self,*args):
+def MEDCouplingDataArrayDoubleTupleIsub(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDoubleTuple____isub___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleImul(self,*args):
+def MEDCouplingDataArrayDoubleTupleImul(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDoubleTuple____imul___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIdiv(self,*args):
+def MEDCouplingDataArrayDoubleTupleIdiv(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayDoubleTuple____idiv___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoublenew(cls,*args):
+def MEDCouplingFieldDoublenew(cls,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingFieldDouble____new___(cls,args)
-def ParaMEDMEMMEDCouplingFieldDoubleIadd(self,*args):
+def MEDCouplingFieldDoubleIadd(self,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingFieldDouble____iadd___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIsub(self,*args):
+def MEDCouplingFieldDoubleIsub(self,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingFieldDouble____isub___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleImul(self,*args):
+def MEDCouplingFieldDoubleImul(self,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingFieldDouble____imul___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIdiv(self,*args):
+def MEDCouplingFieldDoubleIdiv(self,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingFieldDouble____idiv___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIpow(self,*args):
+def MEDCouplingFieldDoubleIpow(self,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingFieldDouble____ipow___(self, self, *args)
-def ParaMEDMEMDataArrayIntnew(cls,*args):
+def MEDCouplingDataArrayIntnew(cls,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayInt____new___(cls,args)
-def ParaMEDMEMDataArrayIntIadd(self,*args):
+def MEDCouplingDataArrayIntIadd(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayInt____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayIntIsub(self,*args):
+def MEDCouplingDataArrayIntIsub(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayInt____isub___(self, self, *args)
-def ParaMEDMEMDataArrayIntImul(self,*args):
+def MEDCouplingDataArrayIntImul(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayInt____imul___(self, self, *args)
-def ParaMEDMEMDataArrayIntIdiv(self,*args):
+def MEDCouplingDataArrayIntIdiv(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayInt____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayIntImod(self,*args):
+def MEDCouplingDataArrayIntImod(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayInt____imod___(self, self, *args)
-def ParaMEDMEMDataArrayIntIpow(self,*args):
+def MEDCouplingDataArrayIntIpow(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayInt____ipow___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIadd(self,*args):
+def MEDCouplingDataArrayIntTupleIadd(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayIntTuple____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIsub(self,*args):
+def MEDCouplingDataArrayIntTupleIsub(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayIntTuple____isub___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleImul(self,*args):
+def MEDCouplingDataArrayIntTupleImul(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayIntTuple____imul___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIdiv(self,*args):
+def MEDCouplingDataArrayIntTupleIdiv(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayIntTuple____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleImod(self,*args):
+def MEDCouplingDataArrayIntTupleImod(self,*args):
import _MEDCalculator
return _MEDCalculator.DataArrayIntTuple____imod___(self, self, *args)
def ParaMEDMEMDenseMatrixIadd(self,*args):
def ParaMEDMEMDenseMatrixIsub(self,*args):
import _MEDCalculator
return _MEDCalculator.DenseMatrix____isub___(self, self, *args)
-def ParaMEDMEMMEDCouplingUMeshnew(cls,*args):
+def MEDCouplingUMeshnew(cls,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingUMesh____new___(cls,args)
-def ParaMEDMEMMEDCoupling1DGTUMeshnew(cls,*args):
+def MEDCoupling1DGTUMeshnew(cls,*args):
import _MEDCalculator
return _MEDCalculator.MEDCoupling1DGTUMesh____new___(cls,args)
-def ParaMEDMEMMEDCoupling1SGTUMeshnew(cls,*args):
+def MEDCoupling1SGTUMeshnew(cls,*args):
import _MEDCalculator
return _MEDCalculator.MEDCoupling1SGTUMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingCurveLinearMeshnew(cls,*args):
+def MEDCouplingCurveLinearMeshnew(cls,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingCurveLinearMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingCMeshnew(cls,*args):
+def MEDCouplingCMeshnew(cls,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingCMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingIMeshnew(cls,*args):
+def MEDCouplingIMeshnew(cls,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingIMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingExtrudedMeshnew(cls,*args):
+def MEDCouplingExtrudedMeshnew(cls,*args):
import _MEDCalculator
return _MEDCalculator.MEDCouplingExtrudedMesh____new___(cls,args)
%}
#include <limits>
-static PyObject* convertMEDCalculatorDBField(ParaMEDMEM::MEDCalculatorDBField *f, int owner)
+static PyObject* convertMEDCalculatorDBField(MEDCoupling::MEDCalculatorDBField *f, int owner)
{
PyObject *ret=0;
- if(dynamic_cast<ParaMEDMEM::MEDCalculatorDBFieldReal *>(f))
- ret=SWIG_NewPointerObj((void*)f,SWIGTYPE_p_ParaMEDMEM__MEDCalculatorDBFieldReal,owner);
- if(dynamic_cast<ParaMEDMEM::MEDCalculatorDBFieldCst *>(f))
- ret=SWIG_NewPointerObj((void*)f,SWIGTYPE_p_ParaMEDMEM__MEDCalculatorDBFieldCst,owner);
+ if(dynamic_cast<MEDCoupling::MEDCalculatorDBFieldReal *>(f))
+ ret=SWIG_NewPointerObj((void*)f,SWIGTYPE_p_MEDCoupling__MEDCalculatorDBFieldReal,owner);
+ if(dynamic_cast<MEDCoupling::MEDCalculatorDBFieldCst *>(f))
+ ret=SWIG_NewPointerObj((void*)f,SWIGTYPE_p_MEDCoupling__MEDCalculatorDBFieldCst,owner);
return ret;
}
-void convertPyObjToRS(PyObject *o, ParaMEDMEM::MEDCalculatorDBRangeSelection& rs)
+void convertPyObjToRS(PyObject *o, MEDCoupling::MEDCalculatorDBRangeSelection& rs)
{
if(PyInt_Check(o))
{
PyErr_SetString(PyExc_TypeError,"Range selection must be an integer or a string !");
}
-void convertPyObjToRS2(PyObject *o, ParaMEDMEM::MEDCalculatorDBRangeSelection& rs, const char *msg)
+void convertPyObjToRS2(PyObject *o, MEDCoupling::MEDCalculatorDBRangeSelection& rs, const char *msg)
{
if(PyInt_Check(o))
{
#include <sstream>
#include <algorithm>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
const char *SPythonInterpreter::INDENT_TOKEN[]={"def","class","for","if","while","try","except"};
#include <vector>
#include <set>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCALCULATORSPYTHON_EXPORT SPythonInterpreter
{
#include <algorithm>
#include <sstream>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
const char SPythonPredParser::FIELD_TYPE_STR[]="MEDCalculatorDBField";
#include <string>
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
typedef enum
{
std::ifstream ifs(fileName);
ifs.exceptions( std::ifstream::badbit );
char *line=new char[MAX_LINE+1];
- ParaMEDMEM::SPythonInterpreter interp(glob,loc);
+ MEDCoupling::SPythonInterpreter interp(glob,loc);
bool isspython;
while(!ifs.eof())
{
{
std::string s;
char *line=new char[MAX_LINE+1];
- ParaMEDMEM::SPythonInterpreter interp(glob,loc);
+ MEDCoupling::SPythonInterpreter interp(glob,loc);
bool isInterp=true;
while(true)
{
#include <iostream>
-void ParaMEDMEM::MEDCalculatorBasicsTest::testLightStruct1()
+void MEDCoupling::MEDCalculatorBasicsTest::testLightStruct1()
{
const char fname[]="/export/home/geay/MEDStdAlone/Salome5/V5_1_main/MED/MED_INSTALL_DEBUG/share/salome/resources/med/TimeStamps_import22.med";
MEDCalculatorBrowserLiteStruct lt(fname);
//std::cout << lt.str() << std::endl;
}
-void ParaMEDMEM::MEDCalculatorBasicsTest::testRangeSelection1()
+void MEDCoupling::MEDCalculatorBasicsTest::testRangeSelection1()
{
MEDCalculatorDBRangeSelection sel1(":");
std::vector<int> v=sel1.getIds(6);
CPPUNIT_ASSERT(exc); exc=false;
}
-void ParaMEDMEM::MEDCalculatorBasicsTest::testDBField1()
+void MEDCoupling::MEDCalculatorBasicsTest::testDBField1()
{
const char fName[]="hfile1.med";
generateAFile1(fName);
Power->decrRef();
}
-void ParaMEDMEM::MEDCalculatorBasicsTest::generateAFile1(const char *fName)
+void MEDCoupling::MEDCalculatorBasicsTest::generateAFile1(const char *fName)
{
double targetCoords[18]={-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 };
int targetConn[18]={0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4};
m->setCoords(myCoords);
myCoords->decrRef();
//
- MEDLoader::WriteUMesh(fName,m,true);
+ WriteUMesh(fName,m,true);
static const int nbOfTimeSteps=10;
static const int nbOfComponents=7;
MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
for(int k=0;k<nbOfComponents;k++,pt++)
*pt=(i+1)*100.+(j+1)*10.+k+1;
f->setTime(i*0.1,i,-i);
- MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fName,f);
+ WriteFieldUsingAlreadyWrittenMesh(fName,f);
}
da->decrRef();
f->decrRef();
m->decrRef();
}
-void ParaMEDMEM::MEDCalculatorBasicsTest::testSPython1()
+void MEDCoupling::MEDCalculatorBasicsTest::testSPython1()
{
std::string s1,s2;
bool b;
s1="12:3";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,s1);
s1="12:";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,s1);
s1="12";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(b);
CPPUNIT_ASSERT_EQUAL(s2,s1);
s1="";
- CPPUNIT_ASSERT(!ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(!MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
s1=" ";
- CPPUNIT_ASSERT(!ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(!MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
s1=":";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,s1);
s1=":12";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,s1);
s1=":12:";
- CPPUNIT_ASSERT(!ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(!MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
s1=":12 23";
- CPPUNIT_ASSERT(!ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(!MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
// some ' ' char
s1=" 12 : 3 ";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,std::string("12:3"));
s1=" 12 : 3";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,std::string("12:3"));
s1=" 12 :3 ";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,std::string("12:3"));
s1=" 12: 3 ";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,std::string("12:3"));
s1="12 : 3 ";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isElementInParenthesisMatching(s1,s2,b));
CPPUNIT_ASSERT(!b);
CPPUNIT_ASSERT_EQUAL(s2,std::string("12:3"));
}
-void ParaMEDMEM::MEDCalculatorBasicsTest::testSPython2()
+void MEDCoupling::MEDCalculatorBasicsTest::testSPython2()
{
std::string s1,s2;
s1=" 12:3 , : ,4 ";
- CPPUNIT_ASSERT(ParaMEDMEM::SPythonParser::isParenthesisMatching(s1,s2));
+ CPPUNIT_ASSERT(MEDCoupling::SPythonParser::isParenthesisMatching(s1,s2));
CPPUNIT_ASSERT_EQUAL(s2,std::string("\"12:3\",\":\",4"));
}
-void ParaMEDMEM::MEDCalculatorBasicsTest::testSPython3()
+void MEDCoupling::MEDCalculatorBasicsTest::testSPython3()
{
std::string s1,s2;
s1="( 12:3 , : ,4 )";
- s2=ParaMEDMEM::SPythonInterpreter::strip(s1);
+ s2=MEDCoupling::SPythonInterpreter::strip(s1);
CPPUNIT_ASSERT_EQUAL(s2,std::string("(12:3,:,4)"));
s1=" ( 12:3 , : ,4 ) ";
- s2=ParaMEDMEM::SPythonInterpreter::strip(s1);
+ s2=MEDCoupling::SPythonInterpreter::strip(s1);
CPPUNIT_ASSERT_EQUAL(s2,std::string("(12:3,:,4)"));
}
#include <cppunit/extensions/HelperMacros.h>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCalculatorBasicsTest : public CppUnit::TestFixture
{
#include "CppUnitTest.hxx"
#include "MEDCalculatorBasicsTest.hxx"
-CPPUNIT_TEST_SUITE_REGISTRATION( ParaMEDMEM::MEDCalculatorBasicsTest );
+CPPUNIT_TEST_SUITE_REGISTRATION( MEDCoupling::MEDCalculatorBasicsTest );
#include "BasicMainTest.hxx"
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
DataArrayDouble *DataArrayDoubleClient::New(SALOME_MED::DataArrayDoubleCorbaInterface_ptr dadPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class DataArrayDouble;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
DataArrayInt *DataArrayIntClient::New(SALOME_MED::DataArrayIntCorbaInterface_ptr dadPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class DataArrayInt;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCoupling1DGTUMesh *MEDCoupling1DGTUMeshClient::New(SALOME_MED::MEDCoupling1DGTUMeshCorbaInterface_ptr meshPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCoupling1DGTUMesh;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCoupling1SGTUMesh *MEDCoupling1SGTUMeshClient::New(SALOME_MED::MEDCoupling1SGTUMeshCorbaInterface_ptr meshPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCoupling1SGTUMesh;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingCMesh *MEDCouplingCMeshClient::New(SALOME_MED::MEDCouplingCMeshCorbaInterface_ptr meshPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingCMesh;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingCurveLinearMesh *MEDCouplingCurveLinearMeshClient::New(SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface_ptr meshPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingCurveLinearMesh;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingExtrudedMesh *MEDCouplingExtrudedMeshClient::New(SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_ptr meshPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingExtrudedMesh;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingFieldDouble *MEDCouplingFieldDoubleClient::New(SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr)
{
#include "MEDCouplingClient.hxx"
#include "MEDCouplingFieldDouble.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingFieldDoubleClient : public MEDCouplingFieldDouble
{
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingFieldOverTimeClient::MEDCouplingFieldOverTimeClient(SALOME_MED::MEDCouplingFieldOverTimeCorbaInterface_ptr field):_df(0)
{
#include "MEDCouplingClient.hxx"
#include "MEDCouplingFieldOverTime.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingDefinitionTime;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingFieldTemplate *MEDCouplingFieldTemplateClient::New(SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr fieldPtr)
{
#include "MEDCouplingClient.hxx"
#include "MEDCouplingFieldTemplate.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingFieldTemplateClient : public MEDCouplingFieldTemplate
{
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingIMesh *MEDCouplingIMeshClient::New(SALOME_MED::MEDCouplingIMeshCorbaInterface_ptr meshPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingIMesh;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingMesh *MEDCouplingMeshClient::New(SALOME_MED::MEDCouplingMeshCorbaInterface_ptr meshPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingMesh;
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingMultiFields *MEDCouplingMultiFieldsClient::New(SALOME_MED::MEDCouplingMultiFieldsCorbaInterface_ptr fieldPtr)
{
#include "MEDCouplingClient.hxx"
#include "MEDCouplingMultiFields.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingMultiFieldsClient : public MEDCouplingMultiFields
{
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingUMesh *MEDCouplingUMeshClient::New(SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr meshPtr)
{
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingUMesh;
#include "DataArrayDoubleServant.hxx"
#include "MEDCouplingMemArray.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
DataArrayDoubleServant::DataArrayDoubleServant(const DataArrayDouble *cppPointer):DataArrayServant(cppPointer)
{
#include "MEDCouplingCorba.hxx"
#include "DataArrayServant.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class DataArrayDouble;
#include "DataArrayIntServant.hxx"
#include "MEDCouplingMemArray.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
DataArrayIntServant::DataArrayIntServant(const DataArrayInt *cppPointer):DataArrayServant(cppPointer)
{
#include "MEDCouplingCorba.hxx"
#include "DataArrayServant.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class DataArrayInt;
#include "DataArrayServant.hxx"
#include "MEDCouplingMemArray.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
DataArrayServant::DataArrayServant(const DataArray *cppPointer):MEDCouplingRefCountServant(cppPointer,cppPointer)
{
#include "MEDCouplingCorba.hxx"
#include "MEDCouplingRefCountServant.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class DataArray;
#include "MEDCoupling1DGTUMeshServant.hxx"
#include "MEDCoupling1GTUMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCoupling1DGTUMeshServant::MEDCoupling1DGTUMeshServant(const MEDCoupling1DGTUMesh *cppPointerOfMesh):MEDCoupling1GTUMeshServant(cppPointerOfMesh)
{
#include "MEDCoupling1GTUMeshServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCoupling1DGTUMesh;
#include "MEDCoupling1GTUMeshServant.hxx"
#include "MEDCoupling1GTUMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCoupling1GTUMeshServant::MEDCoupling1GTUMeshServant(const MEDCoupling1GTUMesh *cppPointerOfMesh):MEDCouplingPointSetServant(cppPointerOfMesh)
{
#include "MEDCouplingPointSetServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCoupling1GTUMesh;
#include "MEDCoupling1SGTUMeshServant.hxx"
#include "MEDCoupling1GTUMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCoupling1SGTUMeshServant::MEDCoupling1SGTUMeshServant(const MEDCoupling1SGTUMesh *cppPointerOfMesh):MEDCoupling1GTUMeshServant(cppPointerOfMesh)
{
#include "MEDCoupling1GTUMeshServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCoupling1SGTUMesh;
#include "MEDCouplingCMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingCMeshServant::MEDCouplingCMeshServant(const MEDCouplingCMesh *cppPointerOfMesh):MEDCouplingStructuredMeshServant(cppPointerOfMesh)
{
#include "MEDCouplingStructuredMeshServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingCMesh;
#include "MEDCouplingCurveLinearMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingCurveLinearMeshServant::MEDCouplingCurveLinearMeshServant(const MEDCouplingCurveLinearMesh *cppPointerOfMesh):MEDCouplingStructuredMeshServant(cppPointerOfMesh)
{
#include "MEDCouplingStructuredMeshServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingCurveLinearMesh;
#include "MEDCouplingExtrudedMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingExtrudedMeshServant::MEDCouplingExtrudedMeshServant(const MEDCouplingExtrudedMesh *cppPointerOfMesh):MEDCouplingMeshServant(cppPointerOfMesh)
{
#include "MEDCouplingMeshServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingExtrudedMesh;
#include "MEDCouplingFieldDoubleServant.hxx"
#include "MEDCouplingFieldDouble.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingFieldDoubleServant::MEDCouplingFieldDoubleServant(const MEDCouplingFieldDouble *cppPointerOfMesh):MEDCouplingFieldServant(cppPointerOfMesh)
{
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class RefCountObject;
class MEDCouplingFieldDouble;
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingMemArray.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingFieldOverTimeServant::MEDCouplingFieldOverTimeServant(const MEDCouplingFieldOverTime *cppPointer):MEDCouplingMultiFieldsServant(cppPointer)
{
#include "MEDCouplingMultiFieldsServant.hxx"
#include "MEDCouplingFieldOverTime.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCOUPLINGCORBA_EXPORT MEDCouplingFieldOverTimeServant : public MEDCouplingMultiFieldsServant,
public virtual POA_SALOME_MED::MEDCouplingFieldOverTimeCorbaInterface
#include "MEDCouplingExtrudedMesh.hxx"
#include "MEDCoupling1GTUMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingFieldServant::MEDCouplingFieldServant(const MEDCouplingField *cppPointerOfMesh):MEDCouplingRefCountServant(cppPointerOfMesh,cppPointerOfMesh)
{
#include "MEDCouplingCorba.hxx"
#include "MEDCouplingRefCountServant.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingMesh;
class MEDCouplingField;
#include "MEDCouplingMemArray.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingFieldTemplateServant::MEDCouplingFieldTemplateServant(const MEDCouplingFieldTemplate *cppPointerOfMesh):MEDCouplingFieldServant(cppPointerOfMesh)
{
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class RefCountObject;
class MEDCouplingFieldTemplate;
#include "MEDCouplingIMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingIMeshServant::MEDCouplingIMeshServant(const MEDCouplingIMesh *cppPointerOfMesh):MEDCouplingStructuredMeshServant(cppPointerOfMesh)
{
#include "MEDCouplingStructuredMeshServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingIMesh;
#include "MEDCouplingMesh.hxx"
#include "MEDCouplingMemArray.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingMeshServant::MEDCouplingMeshServant(const MEDCouplingMesh *cppPointerOfMesh):MEDCouplingRefCountServant(cppPointerOfMesh,cppPointerOfMesh)
{
#include "MEDCouplingRefCountServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingMesh;
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingMemArray.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingMultiFieldsServant::MEDCouplingMultiFieldsServant(const MEDCouplingMultiFields *cppPointer):MEDCouplingRefCountServant(cppPointer,cppPointer)
{
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class RefCountObject;
class MEDCouplingMultiFields;
#include "MEDCouplingPointSet.hxx"
#include "DataArrayDoubleServant.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingPointSetServant::MEDCouplingPointSetServant(const MEDCouplingPointSet *cppPointerOfMesh):MEDCouplingMeshServant(cppPointerOfMesh)
{
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingPointSet;
class DataArrayInt;
#include <iostream>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingRefCountServant::MEDCouplingRefCountServant(const RefCountObject *pointer, const TimeLabel *pointer2):_ref_counter(1),
_cpp_pointer(pointer),
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class TimeLabel;
class RefCountObject;
#include "MEDCouplingStructuredMeshServant.hxx"
#include "MEDCouplingStructuredMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingStructuredMeshServant::MEDCouplingStructuredMeshServant(const MEDCouplingStructuredMesh *cppPointerOfMesh):MEDCouplingMeshServant(cppPointerOfMesh)
{
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingStructuredMesh;
class DataArrayInt;
#include "MEDCouplingUMeshServant.hxx"
#include "MEDCouplingUMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingUMeshServant::MEDCouplingUMeshServant(const MEDCouplingUMesh *cppPointerOfMesh):MEDCouplingPointSetServant(cppPointerOfMesh)
{
#include "MEDCouplingPointSetServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingUMesh;
namespace SALOME_TEST
{
- ParaMEDMEM::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build1DMesh()
+ MEDCoupling::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build1DMesh()
{
double coords[4]={ 0.0, 0.3, 0.75, 1.0 };
int conn[2*3]={ 0,1, 1,2, 2,3 };
- ParaMEDMEM::MEDCouplingUMesh *mesh=ParaMEDMEM::MEDCouplingUMesh::New("1DMeshForCorba",1);
+ MEDCoupling::MEDCouplingUMesh *mesh=MEDCoupling::MEDCouplingUMesh::New("1DMeshForCorba",1);
mesh->setDescription("build1DMesh");
mesh->allocateCells(3);
mesh->setTime(5.6,7,8);
mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+2);
mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+4);
mesh->finishInsertingCells();
- ParaMEDMEM::DataArrayDouble *myCoords=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *myCoords=MEDCoupling::DataArrayDouble::New();
myCoords->alloc(4,1);
std::copy(coords,coords+4,myCoords->getPointer());
mesh->setCoords(myCoords);
return mesh;
}
- ParaMEDMEM::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build2DMesh()
+ MEDCoupling::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build2DMesh()
{
double targetCoords[18]={-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 };
int targetConn[18]={0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4};
- ParaMEDMEM::MEDCouplingUMesh *targetMesh=ParaMEDMEM::MEDCouplingUMesh::New();
+ MEDCoupling::MEDCouplingUMesh *targetMesh=MEDCoupling::MEDCouplingUMesh::New();
targetMesh->setMeshDimension(2);
targetMesh->setName("MyMesh2D");
targetMesh->setDescription("build2DMesh");
targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+10);
targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+14);
targetMesh->finishInsertingCells();
- ParaMEDMEM::DataArrayDouble *myCoords=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *myCoords=MEDCoupling::DataArrayDouble::New();
myCoords->alloc(9,2);
std::copy(targetCoords,targetCoords+18,myCoords->getPointer());
targetMesh->setCoords(myCoords);
return targetMesh;
}
- ParaMEDMEM::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build3DMesh()
+ MEDCoupling::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build3DMesh()
{
double targetCoords[81]={ 0., 0., 0., 50., 0., 0. , 200., 0., 0. , 0., 50., 0., 50., 50., 0. , 200., 50., 0., 0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
0., 0., 50., 50., 0., 50. , 200., 0., 50. , 0., 50., 50., 50., 50., 50. , 200., 50., 50., 0., 200., 50., 50., 200., 50. , 200., 200., 50. ,
0., 0., 200., 50., 0., 200. , 200., 0., 200. , 0., 50., 200., 50., 50., 200. , 200., 50., 200., 0., 200., 200., 50., 200., 200. , 200., 200., 200. };
int targetConn[64]={0,1,4,3,9,10,13,12, 1,2,5,4,10,11,14,13, 3,4,7,6,12,13,16,15, 4,5,8,7,13,14,17,16,
9,10,13,12,18,19,22,21, 10,11,14,13,19,20,23,22, 12,13,16,15,21,22,25,24, 13,14,17,16,22,23,26,25};
- ParaMEDMEM::MEDCouplingUMesh *targetMesh=ParaMEDMEM::MEDCouplingUMesh::New();
+ MEDCoupling::MEDCouplingUMesh *targetMesh=MEDCoupling::MEDCouplingUMesh::New();
targetMesh->setMeshDimension(3);
targetMesh->setName("MyMesh3D");
targetMesh->setDescription("build3DMesh");
for(int i=0;i<8;i++)
targetMesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,targetConn+8*i);
targetMesh->finishInsertingCells();
- ParaMEDMEM::DataArrayDouble *myCoords=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *myCoords=MEDCoupling::DataArrayDouble::New();
myCoords->alloc(27,3);
std::copy(targetCoords,targetCoords+81,myCoords->getPointer());
targetMesh->setCoords(myCoords);
return targetMesh;
}
- ParaMEDMEM::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build3DSurfMesh()
+ MEDCoupling::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build3DSurfMesh()
{
double targetCoords[27]={-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5, -0.3,0.2,0.5, 0.2,0.2,1., 0.7,0.2,1.5, -0.3,0.7,0.5, 0.2,0.7,1., 0.7,0.7,1.5};
int targetConn[18]={0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4};
- ParaMEDMEM::MEDCouplingUMesh *targetMesh=ParaMEDMEM::MEDCouplingUMesh::New();
+ MEDCoupling::MEDCouplingUMesh *targetMesh=MEDCoupling::MEDCouplingUMesh::New();
targetMesh->setMeshDimension(2);
targetMesh->setName("MyMesh3DSurf");
targetMesh->setDescription("build3DSurfMesh");
targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+10);
targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+14);
targetMesh->finishInsertingCells();
- ParaMEDMEM::DataArrayDouble *myCoords=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *myCoords=MEDCoupling::DataArrayDouble::New();
myCoords->alloc(9,3);
std::copy(targetCoords,targetCoords+27,myCoords->getPointer());
targetMesh->setCoords(myCoords);
return targetMesh;
}
- ParaMEDMEM::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build0DMesh()
+ MEDCoupling::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::build0DMesh()
{
double targetCoords[27]={-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5, -0.3,0.2,0.5, 0.2,0.2,1., 0.7,0.2,1.5, -0.3,0.7,0.5, 0.2,0.7,1., 0.7,0.7,1.5};
const int targetConn[]={0,1,2,3,4,5,7,6};
- ParaMEDMEM::MEDCouplingUMesh *targetMesh=ParaMEDMEM::MEDCouplingUMesh::New();
+ MEDCoupling::MEDCouplingUMesh *targetMesh=MEDCoupling::MEDCouplingUMesh::New();
targetMesh->setMeshDimension(0);
targetMesh->allocateCells(8);
targetMesh->setName("Wonderfull 0D mesh");
targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+6);
targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+7);
targetMesh->finishInsertingCells();
- ParaMEDMEM::DataArrayDouble *myCoords=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *myCoords=MEDCoupling::DataArrayDouble::New();
myCoords->alloc(9,3);
std::copy(targetCoords,targetCoords+27,myCoords->getPointer());
targetMesh->setCoords(myCoords);
return targetMesh;
}
- ParaMEDMEM::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::buildM1DMesh()
+ MEDCoupling::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::buildM1DMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *meshM1D=ParaMEDMEM::MEDCouplingUMesh::New("wonderfull -1 D mesh",-1);
+ MEDCoupling::MEDCouplingUMesh *meshM1D=MEDCoupling::MEDCouplingUMesh::New("wonderfull -1 D mesh",-1);
meshM1D->setDescription("buildM1DMesh");
meshM1D->checkCoherency();
return meshM1D;
}
- ParaMEDMEM::MEDCouplingExtrudedMesh *MEDCouplingCorbaServBasicsTest::buildExtrudedMesh(ParaMEDMEM::MEDCouplingUMesh *&m2D)
+ MEDCoupling::MEDCouplingExtrudedMesh *MEDCouplingCorbaServBasicsTest::buildExtrudedMesh(MEDCoupling::MEDCouplingUMesh *&m2D)
{
m2D=build2DMesh();
m2D->changeSpaceDimension(3);
- ParaMEDMEM::MEDCouplingUMesh *m1D=build1DMesh();
- ParaMEDMEM::MEDCouplingUMesh *retu=m2D->buildExtrudedMesh(m1D,0);
+ MEDCoupling::MEDCouplingUMesh *m1D=build1DMesh();
+ MEDCoupling::MEDCouplingUMesh *retu=m2D->buildExtrudedMesh(m1D,0);
m1D->decrRef();
- ParaMEDMEM::MEDCouplingExtrudedMesh *ret=ParaMEDMEM::MEDCouplingExtrudedMesh::New(retu,m2D,2);
+ MEDCoupling::MEDCouplingExtrudedMesh *ret=MEDCoupling::MEDCouplingExtrudedMesh::New(retu,m2D,2);
ret->setName("ExtrudedTestForCorbaTest");
ret->setDescription("buildExtrudedMesh");
retu->decrRef();
return ret;
}
- ParaMEDMEM::MEDCouplingCMesh *MEDCouplingCorbaServBasicsTest::buildCMesh()
+ MEDCoupling::MEDCouplingCMesh *MEDCouplingCorbaServBasicsTest::buildCMesh()
{
- ParaMEDMEM::MEDCouplingCMesh *targetMesh=ParaMEDMEM::MEDCouplingCMesh::New();
+ MEDCoupling::MEDCouplingCMesh *targetMesh=MEDCoupling::MEDCouplingCMesh::New();
targetMesh->setTime(2.3,4,5);
targetMesh->setTimeUnit("us");
targetMesh->setName("Example of CMesh");
targetMesh->setDescription("buildCMesh");
- ParaMEDMEM::DataArrayDouble *a1=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *a1=MEDCoupling::DataArrayDouble::New();
a1->alloc(5,1);
a1->setInfoOnComponent(0,"SmthX");
const double a1Data[5]={3.,4.,5.,6.,7.};
std::copy(a1Data,a1Data+5,a1->getPointer());
- ParaMEDMEM::DataArrayDouble *a2=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *a2=MEDCoupling::DataArrayDouble::New();
a2->alloc(6,1);
a2->setInfoOnComponent(0,"SmthZ");
const double a2Data[6]={2.78,3.,4.,5.,6.,7.};
}
- ParaMEDMEM::MEDCouplingIMesh *MEDCouplingCorbaServBasicsTest::buildIMesh()
+ MEDCoupling::MEDCouplingIMesh *MEDCouplingCorbaServBasicsTest::buildIMesh()
{
- ParaMEDMEM::MEDCouplingIMesh *targetMesh(ParaMEDMEM::MEDCouplingIMesh::New());
+ MEDCoupling::MEDCouplingIMesh *targetMesh(MEDCoupling::MEDCouplingIMesh::New());
targetMesh->setTime(2.3,4,5);
targetMesh->setTimeUnit("us");
targetMesh->setName("Example of IMesh");
return targetMesh;
}
- ParaMEDMEM::MEDCouplingCurveLinearMesh *MEDCouplingCorbaServBasicsTest::buildCLMesh()
+ MEDCoupling::MEDCouplingCurveLinearMesh *MEDCouplingCorbaServBasicsTest::buildCLMesh()
{
- ParaMEDMEM::MEDCouplingCurveLinearMesh *targetMesh=ParaMEDMEM::MEDCouplingCurveLinearMesh::New();
+ MEDCoupling::MEDCouplingCurveLinearMesh *targetMesh=MEDCoupling::MEDCouplingCurveLinearMesh::New();
targetMesh->setTime(2.3,4,5);
targetMesh->setTimeUnit("us");
targetMesh->setName("Example of Cuve linear mesh");
targetMesh->setDescription("buildCLMesh");
- ParaMEDMEM::DataArrayDouble *a1=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *a1=MEDCoupling::DataArrayDouble::New();
a1->alloc(3*20,1);
a1->iota(7.);
a1->rearrange(3);
return targetMesh;
}
- ParaMEDMEM::MEDCoupling1SGTUMesh *MEDCouplingCorbaServBasicsTest::build1SGTUMesh()
+ MEDCoupling::MEDCoupling1SGTUMesh *MEDCouplingCorbaServBasicsTest::build1SGTUMesh()
{
- ParaMEDMEM::MEDCoupling1SGTUMesh *targetMesh=ParaMEDMEM::MEDCoupling1SGTUMesh::New("Mesh1SGT",INTERP_KERNEL::NORM_QUAD4);
+ MEDCoupling::MEDCoupling1SGTUMesh *targetMesh=MEDCoupling::MEDCoupling1SGTUMesh::New("Mesh1SGT",INTERP_KERNEL::NORM_QUAD4);
targetMesh->setTime(2.3,44,-55);
targetMesh->setTimeUnit("us");
targetMesh->setDescription("My Description of 1SGTU");
- ParaMEDMEM::DataArrayDouble *a1=ParaMEDMEM::DataArrayDouble::New(); a1->alloc(10,3); a1->setInfoOnComponent(0,"X1 [m]"); a1->setInfoOnComponent(1,"YY2 [km]"); a1->setInfoOnComponent(2,"ZZZ3 [km]");
+ MEDCoupling::DataArrayDouble *a1=MEDCoupling::DataArrayDouble::New(); a1->alloc(10,3); a1->setInfoOnComponent(0,"X1 [m]"); a1->setInfoOnComponent(1,"YY2 [km]"); a1->setInfoOnComponent(2,"ZZZ3 [km]");
const double coords[30]={1.,1.,0.,2.,1.,0.,3.,1.,0.,1.,0.,0.,2.,0.,0.,0.,0.,0.,0.,1.,0.,3.,0.,0.,4.,0.,0.,4.,1.,0.};
const int conn[16]={6,0,3,5,3,0,1,4,1,2,7,4,8,7,2,9};
std::copy(coords,coords+30,a1->getPointer()); targetMesh->setCoords(a1); a1->decrRef();
- ParaMEDMEM::DataArrayInt *a2(ParaMEDMEM::DataArrayInt::New()); a2->alloc(4*4,1);
+ MEDCoupling::DataArrayInt *a2(MEDCoupling::DataArrayInt::New()); a2->alloc(4*4,1);
std::copy(conn,conn+16,a2->getPointer());
targetMesh->setNodalConnectivity(a2); a2->decrRef();
//
return targetMesh;
}
- ParaMEDMEM::MEDCoupling1DGTUMesh *MEDCouplingCorbaServBasicsTest::build1DGTUMesh()
+ MEDCoupling::MEDCoupling1DGTUMesh *MEDCouplingCorbaServBasicsTest::build1DGTUMesh()
{
- ParaMEDMEM::MEDCoupling1DGTUMesh *targetMesh=ParaMEDMEM::MEDCoupling1DGTUMesh::New("Mesh1DGT",INTERP_KERNEL::NORM_POLYGON);
+ MEDCoupling::MEDCoupling1DGTUMesh *targetMesh=MEDCoupling::MEDCoupling1DGTUMesh::New("Mesh1DGT",INTERP_KERNEL::NORM_POLYGON);
targetMesh->setTime(2.3,55,-66);
targetMesh->setTimeUnit("us");
targetMesh->setDescription("My Description of 1DGTU");
- ParaMEDMEM::DataArrayDouble *a1=ParaMEDMEM::DataArrayDouble::New(); a1->alloc(10,3); a1->setInfoOnComponent(0,"X1 [m]"); a1->setInfoOnComponent(1,"YY2 [km]"); a1->setInfoOnComponent(2,"ZZZ3 [km]");
+ MEDCoupling::DataArrayDouble *a1=MEDCoupling::DataArrayDouble::New(); a1->alloc(10,3); a1->setInfoOnComponent(0,"X1 [m]"); a1->setInfoOnComponent(1,"YY2 [km]"); a1->setInfoOnComponent(2,"ZZZ3 [km]");
const double coords[30]={1.,1.,0.,2.,1.,0.,3.,1.,0.,1.,0.,0.,2.,0.,0.,0.,0.,0.,0.,1.,0.,3.,0.,0.,4.,0.,0.,4.,1.,0.};
const int conn[15]={6,0,3,5,3,0,1,4,1,2,7,4,8,7,2};
const int conni[5]={0,4,8,12,15};
std::copy(coords,coords+30,a1->getPointer()); targetMesh->setCoords(a1); a1->decrRef();
- ParaMEDMEM::DataArrayInt *a2(ParaMEDMEM::DataArrayInt::New()); a2->alloc(15,1);
+ MEDCoupling::DataArrayInt *a2(MEDCoupling::DataArrayInt::New()); a2->alloc(15,1);
std::copy(conn,conn+15,a2->getPointer());
- ParaMEDMEM::DataArrayInt *a3(ParaMEDMEM::DataArrayInt::New()); a3->alloc(5,1);
+ MEDCoupling::DataArrayInt *a3(MEDCoupling::DataArrayInt::New()); a3->alloc(5,1);
std::copy(conni,conni+5,a3->getPointer());
targetMesh->setNodalConnectivity(a2,a3); a2->decrRef(); a3->decrRef();
//
return targetMesh;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DNT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DNT()
{
- ParaMEDMEM::MEDCouplingUMesh *mesh=build2DMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldOnCells=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::NO_TIME);
+ MEDCoupling::MEDCouplingUMesh *mesh=build2DMesh();
+ MEDCoupling::MEDCouplingFieldDouble *fieldOnCells=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::NO_TIME);
fieldOnCells->setTimeUnit("ms");
fieldOnCells->setName("toto");
fieldOnCells->setMesh(mesh);
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
array->alloc(mesh->getNumberOfCells(),6);
fieldOnCells->setArray(array);
double *tmp=array->getPointer();
return fieldOnCells;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldNodeScalarOn2DNT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldNodeScalarOn2DNT()
{
- ParaMEDMEM::MEDCouplingUMesh *mesh=build2DMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldOnNodes=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_NODES,ParaMEDMEM::NO_TIME);
+ MEDCoupling::MEDCouplingUMesh *mesh=build2DMesh();
+ MEDCoupling::MEDCouplingFieldDouble *fieldOnNodes=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_NODES,MEDCoupling::NO_TIME);
fieldOnNodes->setName("toto2");
fieldOnNodes->setTimeUnit("s");
fieldOnNodes->setDescription("my wonderful field toto2");
fieldOnNodes->setMesh(mesh);
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
array->alloc(mesh->getNumberOfNodes(),5);
fieldOnNodes->setArray(array);
double *tmp=array->getPointer();
return fieldOnNodes;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DNT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DNT()
{
- ParaMEDMEM::MEDCouplingUMesh *mesh=build3DMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldOnCells=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::NO_TIME);
- fieldOnCells->setNature(ParaMEDMEM::ConservativeVolumic);
+ MEDCoupling::MEDCouplingUMesh *mesh=build3DMesh();
+ MEDCoupling::MEDCouplingFieldDouble *fieldOnCells=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::NO_TIME);
+ fieldOnCells->setNature(MEDCoupling::ConservativeVolumic);
fieldOnCells->setName("toto");
fieldOnCells->setDescription("my wonderful 3D field toto2");
fieldOnCells->setMesh(mesh);
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
array->alloc(mesh->getNumberOfCells(),6);
fieldOnCells->setArray(array);
double *tmp=array->getPointer();
return fieldOnCells;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfWT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfWT()
{
- ParaMEDMEM::MEDCouplingUMesh *mesh=build3DSurfMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldOnCells=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingUMesh *mesh=build3DSurfMesh();
+ MEDCoupling::MEDCouplingFieldDouble *fieldOnCells=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::ONE_TIME);
fieldOnCells->setName("toto25");
fieldOnCells->setDescription("my wonderful 3D surf field toto25");
fieldOnCells->setTimeUnit("us");
fieldOnCells->setMesh(mesh);
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
array->alloc(mesh->getNumberOfCells(),3);
array->setInfoOnComponent(0,"aaa"); array->setInfoOnComponent(1,"bbbb"); array->setInfoOnComponent(2,"ccccc");
fieldOnCells->setArray(array);
return fieldOnCells;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfCOTI()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfCOTI()
{
- ParaMEDMEM::MEDCouplingUMesh *mesh=build3DSurfMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldOnCells=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::CONST_ON_TIME_INTERVAL);
+ MEDCoupling::MEDCouplingUMesh *mesh=build3DSurfMesh();
+ MEDCoupling::MEDCouplingFieldDouble *fieldOnCells=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::CONST_ON_TIME_INTERVAL);
fieldOnCells->setName("toto26");
fieldOnCells->setDescription("my wonderful 3D surf field toto26");
fieldOnCells->setTimeUnit("us");
fieldOnCells->setMesh(mesh);
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
array->alloc(mesh->getNumberOfCells(),3);
fieldOnCells->setArray(array);
double *tmp=array->getPointer();
return fieldOnCells;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DLT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DLT()
{
- ParaMEDMEM::MEDCouplingUMesh *mesh=build2DMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldOnCells=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::LINEAR_TIME);
+ MEDCoupling::MEDCouplingUMesh *mesh=build2DMesh();
+ MEDCoupling::MEDCouplingFieldDouble *fieldOnCells=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::LINEAR_TIME);
fieldOnCells->setName("toto27");
fieldOnCells->setDescription("my wonderful 2D field toto27");
fieldOnCells->setTimeUnit("ms");
fieldOnCells->setMesh(mesh);
- ParaMEDMEM::DataArrayDouble *array1=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array1=MEDCoupling::DataArrayDouble::New();
array1->alloc(mesh->getNumberOfCells(),4);
fieldOnCells->setArray(array1);
double *tmp=array1->getPointer();
array1->decrRef();
const double arr1[20]={1.2,1.02,1.002,1.0002, 3.4,3.04,3.004,3.0004, 5.6,5.06,5.006,5.0006, 7.8,7.08,7.008,7.0008, 9.1,9.01,9.001,9.0001};
std::copy(arr1,arr1+20,tmp);
- ParaMEDMEM::DataArrayDouble *array2=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array2=MEDCoupling::DataArrayDouble::New();
array2->alloc(mesh->getNumberOfCells(),4);
fieldOnCells->setEndArray(array2);
tmp=array2->getPointer();
return fieldOnCells;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldGaussPt2DWT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldGaussPt2DWT()
{
const double _a=0.446948490915965;
const double _b=0.091576213509771;
std::vector<double> _refCoo1(refCoo1,refCoo1+6);
std::vector<double> _gsCoo1(gsCoo1,gsCoo1+12);
std::vector<double> _wg1(wg1,wg1+6);
- ParaMEDMEM::MEDCouplingUMesh *m=build2DMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *f=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_GAUSS_PT,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingUMesh *m=build2DMesh();
+ MEDCoupling::MEDCouplingFieldDouble *f=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_GAUSS_PT,MEDCoupling::ONE_TIME);
f->setTime(6.7,1,4);
f->setMesh(m);
m->decrRef();
std::vector<double> _refCoo2(refCoo2,refCoo2+8);
_gsCoo1.resize(4); _wg1.resize(2);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
array->alloc(18,2);
array->setInfoOnComponent(0,"Power [MW]");
array->setInfoOnComponent(1,"Density [kg/m^3]");
return f;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldGaussPtNE2DWT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldGaussPtNE2DWT()
{
- ParaMEDMEM::MEDCouplingUMesh *m=build2DMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *f=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_GAUSS_NE,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingUMesh *m=build2DMesh();
+ MEDCoupling::MEDCouplingFieldDouble *f=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_GAUSS_NE,MEDCoupling::ONE_TIME);
f->setTime(6.8,11,8);
f->setMesh(m);
f->setTimeUnit("ms");
f->setName("MyFirstFieldOnNE");
f->setDescription("MyDescriptionNE");
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
array->alloc(18,2);
array->setInfoOnComponent(0,"Power [MW]");
array->setInfoOnComponent(1,"Density [kg/m^3]");
return f;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldVectorOnExtrudedWT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldVectorOnExtrudedWT()
{
- ParaMEDMEM::MEDCouplingUMesh *m2D=0;
- ParaMEDMEM::MEDCouplingExtrudedMesh *ext=buildExtrudedMesh(m2D);
+ MEDCoupling::MEDCouplingUMesh *m2D=0;
+ MEDCoupling::MEDCouplingExtrudedMesh *ext=buildExtrudedMesh(m2D);
//
- ParaMEDMEM::MEDCouplingFieldDouble *f=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::ONE_TIME);
f->setTime(6.8,11,8);
f->setMesh(ext);
f->setName("MyFieldOnExtruM");
f->setDescription("desc of MyFiOnExtruM");
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
int nbOfCells=ext->getNumberOfCells();
array->alloc(nbOfCells,2);
array->setInfoOnComponent(0,"Power [MW]");
return f;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldVectorOnCMeshWT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldVectorOnCMeshWT()
{
- ParaMEDMEM::MEDCouplingCMesh *m=buildCMesh();
- ParaMEDMEM::MEDCouplingFieldDouble *f=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingCMesh *m=buildCMesh();
+ MEDCoupling::MEDCouplingFieldDouble *f=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::ONE_TIME);
f->setTime(6.8,11,8);
f->setMesh(m);
m->decrRef();
f->setName("MyFieldOnCMesh");
f->setDescription("desc of MyFiOnCMesh");
- ParaMEDMEM::DataArrayDouble *array=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *array=MEDCoupling::DataArrayDouble::New();
int nbOfCells=m->getNumberOfCells();
array->alloc(nbOfCells,2);
array->setInfoOnComponent(0,"Power [GW]");
return f;
}
- ParaMEDMEM::MEDCouplingFieldTemplate *MEDCouplingCorbaServBasicsTest::buildFieldTemplateCellOn2D()
+ MEDCoupling::MEDCouplingFieldTemplate *MEDCouplingCorbaServBasicsTest::buildFieldTemplateCellOn2D()
{
- ParaMEDMEM::MEDCouplingFieldDouble *f1=buildFieldScalarOn2DNT();
- ParaMEDMEM::MEDCouplingFieldTemplate *f2=ParaMEDMEM::MEDCouplingFieldTemplate::New(*f1);
- f2->setNature(ParaMEDMEM::NoNature);
+ MEDCoupling::MEDCouplingFieldDouble *f1=buildFieldScalarOn2DNT();
+ MEDCoupling::MEDCouplingFieldTemplate *f2=MEDCoupling::MEDCouplingFieldTemplate::New(*f1);
+ f2->setNature(MEDCoupling::NoNature);
f1->decrRef();
return f2;
}
- ParaMEDMEM::MEDCouplingFieldTemplate *MEDCouplingCorbaServBasicsTest::buildFieldTemplateNodeOn2D()
+ MEDCoupling::MEDCouplingFieldTemplate *MEDCouplingCorbaServBasicsTest::buildFieldTemplateNodeOn2D()
{
- ParaMEDMEM::MEDCouplingFieldDouble *f1=buildFieldNodeScalarOn2DNT();
- ParaMEDMEM::MEDCouplingFieldTemplate *f2=ParaMEDMEM::MEDCouplingFieldTemplate::New(*f1);
- f2->setNature(ParaMEDMEM::ConservativeVolumic);
+ MEDCoupling::MEDCouplingFieldDouble *f1=buildFieldNodeScalarOn2DNT();
+ MEDCoupling::MEDCouplingFieldTemplate *f2=MEDCoupling::MEDCouplingFieldTemplate::New(*f1);
+ f2->setNature(MEDCoupling::ConservativeVolumic);
f1->decrRef();
return f2;
}
- ParaMEDMEM::MEDCouplingFieldTemplate *MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussPtOn2D()
+ MEDCoupling::MEDCouplingFieldTemplate *MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussPtOn2D()
{
- ParaMEDMEM::MEDCouplingFieldDouble *f1=buildFieldGaussPt2DWT();
- ParaMEDMEM::MEDCouplingFieldTemplate *f2=ParaMEDMEM::MEDCouplingFieldTemplate::New(*f1);
- f2->setNature(ParaMEDMEM::Integral);
+ MEDCoupling::MEDCouplingFieldDouble *f1=buildFieldGaussPt2DWT();
+ MEDCoupling::MEDCouplingFieldTemplate *f2=MEDCoupling::MEDCouplingFieldTemplate::New(*f1);
+ f2->setNature(MEDCoupling::Integral);
f1->decrRef();
return f2;
}
- ParaMEDMEM::MEDCouplingFieldTemplate *MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussNEOn2D()
+ MEDCoupling::MEDCouplingFieldTemplate *MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussNEOn2D()
{
- ParaMEDMEM::MEDCouplingFieldDouble *f1=buildFieldGaussPtNE2DWT();
- ParaMEDMEM::MEDCouplingFieldTemplate *f2=ParaMEDMEM::MEDCouplingFieldTemplate::New(*f1);
- f2->setNature(ParaMEDMEM::IntegralGlobConstraint);
+ MEDCoupling::MEDCouplingFieldDouble *f1=buildFieldGaussPtNE2DWT();
+ MEDCoupling::MEDCouplingFieldTemplate *f2=MEDCoupling::MEDCouplingFieldTemplate::New(*f1);
+ f2->setNature(MEDCoupling::IntegralGlobConstraint);
f1->decrRef();
return f2;
}
- ParaMEDMEM::MEDCouplingMultiFields *MEDCouplingCorbaServBasicsTest::buildMultiFields1()
+ MEDCoupling::MEDCouplingMultiFields *MEDCouplingCorbaServBasicsTest::buildMultiFields1()
{
- ParaMEDMEM::MEDCouplingUMesh *m1=build2DMesh();
+ MEDCoupling::MEDCouplingUMesh *m1=build2DMesh();
m1->setName("m1");
- ParaMEDMEM::MEDCouplingUMesh *m2=build2DMesh();
+ MEDCoupling::MEDCouplingUMesh *m2=build2DMesh();
m2->setName("m2");
const double vals0[]={-0.7,-1.,-2.,-3.,-4.};
const double vals1[]={0.,1.,2.,3.,4.,0.1,0.2,0.3,0.4};
const double vals2[]={5.,6.,7.,8.,9.};
const double vals4[]={15.,16.,17.,18.,19.};
//
- ParaMEDMEM::DataArrayDouble *d0=ParaMEDMEM::DataArrayDouble::New(); d0->alloc(5,1); std::copy(vals0,vals0+5,d0->getPointer());
- ParaMEDMEM::DataArrayDouble *d1=ParaMEDMEM::DataArrayDouble::New(); d1->alloc(9,1); std::copy(vals1,vals1+9,d1->getPointer());
- ParaMEDMEM::DataArrayDouble *d1_1=ParaMEDMEM::DataArrayDouble::New(); d1_1->alloc(9,1); std::copy(vals1_1,vals1_1+9,d1_1->getPointer());
- ParaMEDMEM::DataArrayDouble *d2=ParaMEDMEM::DataArrayDouble::New(); d2->alloc(5,1); std::copy(vals2,vals2+5,d2->getPointer());
- ParaMEDMEM::DataArrayDouble *d4=ParaMEDMEM::DataArrayDouble::New(); d4->alloc(5,1); std::copy(vals4,vals4+5,d4->getPointer());
+ MEDCoupling::DataArrayDouble *d0=MEDCoupling::DataArrayDouble::New(); d0->alloc(5,1); std::copy(vals0,vals0+5,d0->getPointer());
+ MEDCoupling::DataArrayDouble *d1=MEDCoupling::DataArrayDouble::New(); d1->alloc(9,1); std::copy(vals1,vals1+9,d1->getPointer());
+ MEDCoupling::DataArrayDouble *d1_1=MEDCoupling::DataArrayDouble::New(); d1_1->alloc(9,1); std::copy(vals1_1,vals1_1+9,d1_1->getPointer());
+ MEDCoupling::DataArrayDouble *d2=MEDCoupling::DataArrayDouble::New(); d2->alloc(5,1); std::copy(vals2,vals2+5,d2->getPointer());
+ MEDCoupling::DataArrayDouble *d4=MEDCoupling::DataArrayDouble::New(); d4->alloc(5,1); std::copy(vals4,vals4+5,d4->getPointer());
//
d0->setName("d0"); d1->setName("d1"); d1_1->setName("d1_1"); d2->setName("d2"); d4->setName("d4");
d0->setInfoOnComponent(0,"c1");
d2->setInfoOnComponent(0,"c5");
d4->setInfoOnComponent(0,"c7");
//
- ParaMEDMEM::MEDCouplingFieldDouble *f0=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f0=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::ONE_TIME);
f0->setMesh(m1);
f0->setArray(d0);
f0->setTime(0.2,5,6);
f0->setName("f0");
- ParaMEDMEM::MEDCouplingFieldDouble *f1=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_NODES,ParaMEDMEM::LINEAR_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f1=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_NODES,MEDCoupling::LINEAR_TIME);
f1->setMesh(m1);
- std::vector<ParaMEDMEM::DataArrayDouble *> d1s(2); d1s[0]=d1; d1s[1]=d1_1;
+ std::vector<MEDCoupling::DataArrayDouble *> d1s(2); d1s[0]=d1; d1s[1]=d1_1;
f1->setArrays(d1s);
f1->setStartTime(0.7,7,8);
f1->setEndTime(1.2,9,10);
f1->setName("f1");
- ParaMEDMEM::MEDCouplingFieldDouble *f2=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::CONST_ON_TIME_INTERVAL);
+ MEDCoupling::MEDCouplingFieldDouble *f2=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::CONST_ON_TIME_INTERVAL);
f2->setMesh(m2);
f2->setArray(d2);
f2->setTime(1.2,11,12);
f2->setEndTime(1.5,13,14);
f2->setName("f2");
- ParaMEDMEM::MEDCouplingFieldDouble *f3=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f3=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::ONE_TIME);
f3->setMesh(m1);
f3->setArray(d2);
f3->setTime(1.7,15,16);
f3->setName("f3");
- ParaMEDMEM::MEDCouplingFieldDouble *f4=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::NO_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f4=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::NO_TIME);
f4->setMesh(m2);
f4->setArray(d4);
f4->setName("f4");
//
- std::vector<ParaMEDMEM::MEDCouplingFieldDouble *> fs(5);
+ std::vector<MEDCoupling::MEDCouplingFieldDouble *> fs(5);
fs[0]=f0; fs[1]=f1; fs[2]=f2; fs[3]=f3; fs[4]=f4;
- ParaMEDMEM::MEDCouplingMultiFields *ret=ParaMEDMEM::MEDCouplingMultiFields::New(fs);
+ MEDCoupling::MEDCouplingMultiFields *ret=MEDCoupling::MEDCouplingMultiFields::New(fs);
//
m1->decrRef();
m2->decrRef();
return ret;
}
- ParaMEDMEM::DataArrayDouble *MEDCouplingCorbaServBasicsTest::buildArrayDouble1()
+ MEDCoupling::DataArrayDouble *MEDCouplingCorbaServBasicsTest::buildArrayDouble1()
{
- ParaMEDMEM::DataArrayDouble *ret=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *ret=MEDCoupling::DataArrayDouble::New();
ret->alloc(4,3);
const double vals[12]={2.4,3.2,5.6,9.6,47.6,20.4,24.6,278.1,2.01,3.3,2.4,9.4};
std::copy(vals,vals+12,ret->getPointer());
return ret;
}
- ParaMEDMEM::DataArrayDouble *MEDCouplingCorbaServBasicsTest::buildArrayDouble2()
+ MEDCoupling::DataArrayDouble *MEDCouplingCorbaServBasicsTest::buildArrayDouble2()
{
- ParaMEDMEM::DataArrayDouble *ret=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *ret=MEDCoupling::DataArrayDouble::New();
ret->setName("titi");
return ret;
}
- ParaMEDMEM::DataArrayDouble *MEDCouplingCorbaServBasicsTest::buildArrayDouble3()
+ MEDCoupling::DataArrayDouble *MEDCouplingCorbaServBasicsTest::buildArrayDouble3()
{
- ParaMEDMEM::DataArrayDouble *ret=ParaMEDMEM::DataArrayDouble::New();
+ MEDCoupling::DataArrayDouble *ret=MEDCoupling::DataArrayDouble::New();
ret->setName("titi");
ret->alloc(0,3);
ret->setInfoOnComponent(0,"sss");
return ret;
}
- ParaMEDMEM::DataArrayInt *MEDCouplingCorbaServBasicsTest::buildArrayInt1()
+ MEDCoupling::DataArrayInt *MEDCouplingCorbaServBasicsTest::buildArrayInt1()
{
- ParaMEDMEM::DataArrayInt *ret=ParaMEDMEM::DataArrayInt::New();
+ MEDCoupling::DataArrayInt *ret=MEDCoupling::DataArrayInt::New();
ret->alloc(4,3);
const int vals[12]={2,3,5,9,47,20,24,278,2,3,2,9};
std::copy(vals,vals+12,ret->getPointer());
return ret;
}
- ParaMEDMEM::DataArrayInt *MEDCouplingCorbaServBasicsTest::buildArrayInt2()
+ MEDCoupling::DataArrayInt *MEDCouplingCorbaServBasicsTest::buildArrayInt2()
{
- ParaMEDMEM::DataArrayInt *ret=ParaMEDMEM::DataArrayInt::New();
+ MEDCoupling::DataArrayInt *ret=MEDCoupling::DataArrayInt::New();
ret->setName("titi");
return ret;
}
- ParaMEDMEM::DataArrayInt *MEDCouplingCorbaServBasicsTest::buildArrayInt3()
+ MEDCoupling::DataArrayInt *MEDCouplingCorbaServBasicsTest::buildArrayInt3()
{
- ParaMEDMEM::DataArrayInt *ret=ParaMEDMEM::DataArrayInt::New();
+ MEDCoupling::DataArrayInt *ret=MEDCoupling::DataArrayInt::New();
ret->setName("titi");
ret->alloc(0,3);
ret->setInfoOnComponent(0,"sss");
return ret;
}
- ParaMEDMEM::MEDCouplingFieldOverTime *MEDCouplingCorbaServBasicsTest::buildMultiFields2()
+ MEDCoupling::MEDCouplingFieldOverTime *MEDCouplingCorbaServBasicsTest::buildMultiFields2()
{
- ParaMEDMEM::MEDCouplingUMesh *m1=build2DMesh();
+ MEDCoupling::MEDCouplingUMesh *m1=build2DMesh();
m1->setName("m1");
- ParaMEDMEM::MEDCouplingUMesh *m2=build2DMesh();
+ MEDCoupling::MEDCouplingUMesh *m2=build2DMesh();
m2->setName("m2");
const double vals0[]={-0.7,-1.,-2.,-3.,-4.};
const double vals1[]={0.,1.,2.,3.,4.};
const double vals2[]={5.,6.,7.,8.,9.};
const double vals4[]={15.,16.,17.,18.,19.};
//
- ParaMEDMEM::DataArrayDouble *d0=ParaMEDMEM::DataArrayDouble::New(); d0->alloc(5,1); std::copy(vals0,vals0+5,d0->getPointer());
- ParaMEDMEM::DataArrayDouble *d1=ParaMEDMEM::DataArrayDouble::New(); d1->alloc(5,1); std::copy(vals1,vals1+5,d1->getPointer());
- ParaMEDMEM::DataArrayDouble *d1_1=ParaMEDMEM::DataArrayDouble::New(); d1_1->alloc(5,1); std::copy(vals1_1,vals1_1+5,d1_1->getPointer());
- ParaMEDMEM::DataArrayDouble *d2=ParaMEDMEM::DataArrayDouble::New(); d2->alloc(5,1); std::copy(vals2,vals2+5,d2->getPointer());
- ParaMEDMEM::DataArrayDouble *d4=ParaMEDMEM::DataArrayDouble::New(); d4->alloc(5,1); std::copy(vals4,vals4+5,d4->getPointer());
+ MEDCoupling::DataArrayDouble *d0=MEDCoupling::DataArrayDouble::New(); d0->alloc(5,1); std::copy(vals0,vals0+5,d0->getPointer());
+ MEDCoupling::DataArrayDouble *d1=MEDCoupling::DataArrayDouble::New(); d1->alloc(5,1); std::copy(vals1,vals1+5,d1->getPointer());
+ MEDCoupling::DataArrayDouble *d1_1=MEDCoupling::DataArrayDouble::New(); d1_1->alloc(5,1); std::copy(vals1_1,vals1_1+5,d1_1->getPointer());
+ MEDCoupling::DataArrayDouble *d2=MEDCoupling::DataArrayDouble::New(); d2->alloc(5,1); std::copy(vals2,vals2+5,d2->getPointer());
+ MEDCoupling::DataArrayDouble *d4=MEDCoupling::DataArrayDouble::New(); d4->alloc(5,1); std::copy(vals4,vals4+5,d4->getPointer());
//
d0->setName("d0"); d1->setName("d1"); d1_1->setName("d1_1"); d2->setName("d2"); d4->setName("d4");
d0->setInfoOnComponent(0,"c1");
d2->setInfoOnComponent(0,"c5");
d4->setInfoOnComponent(0,"c7");
//
- ParaMEDMEM::MEDCouplingFieldDouble *f0=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f0=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::ONE_TIME);
f0->setMesh(m1);
f0->setArray(d0);
f0->setTime(0.2,5,6);
f0->setName("f0");
- ParaMEDMEM::MEDCouplingFieldDouble *f1=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::LINEAR_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f1=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::LINEAR_TIME);
f1->setMesh(m1);
- std::vector<ParaMEDMEM::DataArrayDouble *> d1s(2); d1s[0]=d1; d1s[1]=d1_1;
+ std::vector<MEDCoupling::DataArrayDouble *> d1s(2); d1s[0]=d1; d1s[1]=d1_1;
f1->setArrays(d1s);
f1->setStartTime(0.7,7,8);
f1->setEndTime(1.2,9,10);
f1->setName("f1");
- ParaMEDMEM::MEDCouplingFieldDouble *f2=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::CONST_ON_TIME_INTERVAL);
+ MEDCoupling::MEDCouplingFieldDouble *f2=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::CONST_ON_TIME_INTERVAL);
f2->setMesh(m2);
f2->setArray(d2);
f2->setTime(1.2,11,12);
f2->setEndTime(1.5,13,14);
f2->setName("f2");
- ParaMEDMEM::MEDCouplingFieldDouble *f3=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f3=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::ONE_TIME);
f3->setMesh(m1);
f3->setArray(d2);
f3->setTime(1.7,15,16);
f3->setName("f3");
- ParaMEDMEM::MEDCouplingFieldDouble *f4=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME);
+ MEDCoupling::MEDCouplingFieldDouble *f4=MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS,MEDCoupling::ONE_TIME);
f4->setMesh(m2);
f4->setArray(d4);
f4->setName("f4");
f4->setTime(2.7,25,26);
//
- std::vector<ParaMEDMEM::MEDCouplingFieldDouble *> fs(5);
+ std::vector<MEDCoupling::MEDCouplingFieldDouble *> fs(5);
fs[0]=f0; fs[1]=f1; fs[2]=f2; fs[3]=f3; fs[4]=f4;
- ParaMEDMEM::MEDCouplingFieldOverTime *ret=ParaMEDMEM::MEDCouplingFieldOverTime::New(fs);
+ MEDCoupling::MEDCouplingFieldOverTime *ret=MEDCoupling::MEDCouplingFieldOverTime::New(fs);
ret->checkCoherency();
//
m1->decrRef();
#include <string>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingUMesh;
class MEDCouplingFieldDouble;
class MEDCouplingCorbaServBasicsTest
{
public:
- static ParaMEDMEM::MEDCouplingUMesh *build1DMesh();
- static ParaMEDMEM::MEDCouplingUMesh *build2DMesh();
- static ParaMEDMEM::MEDCouplingUMesh *build3DMesh();
- static ParaMEDMEM::MEDCouplingUMesh *build3DSurfMesh();
- static ParaMEDMEM::MEDCouplingUMesh *build0DMesh();
- static ParaMEDMEM::MEDCouplingUMesh *buildM1DMesh();
- static ParaMEDMEM::MEDCouplingExtrudedMesh *buildExtrudedMesh(ParaMEDMEM::MEDCouplingUMesh *&m2D);
- static ParaMEDMEM::MEDCouplingCMesh *buildCMesh();
- static ParaMEDMEM::MEDCouplingIMesh *buildIMesh();
- static ParaMEDMEM::MEDCouplingCurveLinearMesh *buildCLMesh();
- static ParaMEDMEM::MEDCoupling1SGTUMesh *build1SGTUMesh();
- static ParaMEDMEM::MEDCoupling1DGTUMesh *build1DGTUMesh();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldScalarOn2DNT();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldNodeScalarOn2DNT();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldScalarOn3DNT();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldScalarOn3DSurfWT();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldScalarOn3DSurfCOTI();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldScalarOn2DLT();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldGaussPt2DWT();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldGaussPtNE2DWT();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldVectorOnExtrudedWT();
- static ParaMEDMEM::MEDCouplingFieldDouble *buildFieldVectorOnCMeshWT();
- static ParaMEDMEM::MEDCouplingFieldTemplate *buildFieldTemplateCellOn2D();
- static ParaMEDMEM::MEDCouplingFieldTemplate *buildFieldTemplateNodeOn2D();
- static ParaMEDMEM::MEDCouplingFieldTemplate *buildFieldTemplateGaussPtOn2D();
- static ParaMEDMEM::MEDCouplingFieldTemplate *buildFieldTemplateGaussNEOn2D();
- static ParaMEDMEM::MEDCouplingMultiFields *buildMultiFields1();
- static ParaMEDMEM::DataArrayDouble *buildArrayDouble1();
- static ParaMEDMEM::DataArrayDouble *buildArrayDouble2();
- static ParaMEDMEM::DataArrayDouble *buildArrayDouble3();
- static ParaMEDMEM::DataArrayInt *buildArrayInt1();
- static ParaMEDMEM::DataArrayInt *buildArrayInt2();
- static ParaMEDMEM::DataArrayInt *buildArrayInt3();
- static ParaMEDMEM::MEDCouplingFieldOverTime *buildMultiFields2();
+ static MEDCoupling::MEDCouplingUMesh *build1DMesh();
+ static MEDCoupling::MEDCouplingUMesh *build2DMesh();
+ static MEDCoupling::MEDCouplingUMesh *build3DMesh();
+ static MEDCoupling::MEDCouplingUMesh *build3DSurfMesh();
+ static MEDCoupling::MEDCouplingUMesh *build0DMesh();
+ static MEDCoupling::MEDCouplingUMesh *buildM1DMesh();
+ static MEDCoupling::MEDCouplingExtrudedMesh *buildExtrudedMesh(MEDCoupling::MEDCouplingUMesh *&m2D);
+ static MEDCoupling::MEDCouplingCMesh *buildCMesh();
+ static MEDCoupling::MEDCouplingIMesh *buildIMesh();
+ static MEDCoupling::MEDCouplingCurveLinearMesh *buildCLMesh();
+ static MEDCoupling::MEDCoupling1SGTUMesh *build1SGTUMesh();
+ static MEDCoupling::MEDCoupling1DGTUMesh *build1DGTUMesh();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldScalarOn2DNT();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldNodeScalarOn2DNT();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldScalarOn3DNT();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldScalarOn3DSurfWT();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldScalarOn3DSurfCOTI();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldScalarOn2DLT();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldGaussPt2DWT();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldGaussPtNE2DWT();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldVectorOnExtrudedWT();
+ static MEDCoupling::MEDCouplingFieldDouble *buildFieldVectorOnCMeshWT();
+ static MEDCoupling::MEDCouplingFieldTemplate *buildFieldTemplateCellOn2D();
+ static MEDCoupling::MEDCouplingFieldTemplate *buildFieldTemplateNodeOn2D();
+ static MEDCoupling::MEDCouplingFieldTemplate *buildFieldTemplateGaussPtOn2D();
+ static MEDCoupling::MEDCouplingFieldTemplate *buildFieldTemplateGaussNEOn2D();
+ static MEDCoupling::MEDCouplingMultiFields *buildMultiFields1();
+ static MEDCoupling::DataArrayDouble *buildArrayDouble1();
+ static MEDCoupling::DataArrayDouble *buildArrayDouble2();
+ static MEDCoupling::DataArrayDouble *buildArrayDouble3();
+ static MEDCoupling::DataArrayInt *buildArrayInt1();
+ static MEDCoupling::DataArrayInt *buildArrayInt2();
+ static MEDCoupling::DataArrayInt *buildArrayInt3();
+ static MEDCoupling::MEDCouplingFieldOverTime *buildMultiFields2();
static std::string buildFileNameForIOR();
};
}
SALOME_TEST::MEDCouplingMeshFieldFactory_ptr SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::_objC;
-ParaMEDMEM::MEDCouplingUMesh *SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::_mesh_from_distant=0;
+MEDCoupling::MEDCouplingUMesh *SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::_mesh_from_distant=0;
int SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::_argc=0;
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkContentOfFetched1DMesh()
{
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr meshPtr=_objC->get1DMesh();
- _mesh_from_distant=ParaMEDMEM::MEDCouplingUMeshClient::New(meshPtr);
+ _mesh_from_distant=MEDCoupling::MEDCouplingUMeshClient::New(meshPtr);
char *meshName=meshPtr->getName();
std::string meshNameCpp(meshName);
CPPUNIT_ASSERT(meshNameCpp=="1DMeshForCorba");
CORBA::release(meshPtr);
CPPUNIT_ASSERT_EQUAL(3,_mesh_from_distant->getSpaceDimension());
CPPUNIT_ASSERT_EQUAL(1,_mesh_from_distant->getMeshDimension());
- ParaMEDMEM::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build1DMesh();
+ MEDCoupling::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build1DMesh();
CPPUNIT_ASSERT(_mesh_from_distant->isEqual(meshRef,1e-12));
meshRef->decrRef();
_mesh_from_distant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetching2D()
{
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr meshPtr=_objC->get2DMesh();
- _mesh_from_distant=ParaMEDMEM::MEDCouplingUMeshClient::New(meshPtr);
+ _mesh_from_distant=MEDCoupling::MEDCouplingUMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
CPPUNIT_ASSERT_EQUAL(2,_mesh_from_distant->getSpaceDimension());
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkContentOfFetched2DMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build2DMesh();
+ MEDCoupling::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build2DMesh();
CPPUNIT_ASSERT(_mesh_from_distant->isEqual(meshRef,1e-12));
meshRef->decrRef();
_mesh_from_distant->decrRef();
for(int i=0;i<1000;i++)
{
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr meshPtr=_objC->get2DMesh();
- _mesh_from_distant=ParaMEDMEM::MEDCouplingUMeshClient::New(meshPtr);
+ _mesh_from_distant=MEDCoupling::MEDCouplingUMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build2DMesh();
+ MEDCoupling::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build2DMesh();
CPPUNIT_ASSERT(_mesh_from_distant->isEqual(meshRef,1e-12));
meshRef->decrRef();
_mesh_from_distant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetching3D()
{
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr meshPtr=_objC->get3DMesh();
- _mesh_from_distant=ParaMEDMEM::MEDCouplingUMeshClient::New(meshPtr);
+ _mesh_from_distant=MEDCoupling::MEDCouplingUMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
CPPUNIT_ASSERT_EQUAL(3,_mesh_from_distant->getSpaceDimension());
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkContentOfFetched3DMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build3DMesh();
+ MEDCoupling::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build3DMesh();
CPPUNIT_ASSERT(_mesh_from_distant->isEqual(meshRef,1e-12));
meshRef->decrRef();
_mesh_from_distant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetching3DSurf()
{
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr meshPtr=_objC->get3DSurfMesh();
- _mesh_from_distant=ParaMEDMEM::MEDCouplingUMeshClient::New(meshPtr);
+ _mesh_from_distant=MEDCoupling::MEDCouplingUMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
CPPUNIT_ASSERT_EQUAL(3,_mesh_from_distant->getSpaceDimension());
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkContentOfFetched3DSurfMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build3DSurfMesh();
+ MEDCoupling::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build3DSurfMesh();
CPPUNIT_ASSERT(_mesh_from_distant->isEqual(meshRef,1e-12));
meshRef->decrRef();
_mesh_from_distant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetching0D()
{
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr meshPtr=_objC->get0DMesh();
- _mesh_from_distant=ParaMEDMEM::MEDCouplingUMeshClient::New(meshPtr);
+ _mesh_from_distant=MEDCoupling::MEDCouplingUMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build0DMesh();
+ MEDCoupling::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build0DMesh();
CPPUNIT_ASSERT_EQUAL(3,_mesh_from_distant->getSpaceDimension());
CPPUNIT_ASSERT_EQUAL(0,_mesh_from_distant->getMeshDimension());
CPPUNIT_ASSERT(_mesh_from_distant->isEqual(meshRef,1e-12));
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetchingM1D()
{
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr meshPtr=_objC->getM1DMesh();
- _mesh_from_distant=ParaMEDMEM::MEDCouplingUMeshClient::New(meshPtr);
+ _mesh_from_distant=MEDCoupling::MEDCouplingUMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildM1DMesh();
+ MEDCoupling::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildM1DMesh();
CPPUNIT_ASSERT_EQUAL(-1,_mesh_from_distant->getMeshDimension());
CPPUNIT_ASSERT(_mesh_from_distant->isEqual(meshRef,1e-12));
meshRef->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetchingExtruded()
{
SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_ptr meshPtr=_objC->getExtrudedMesh();
- ParaMEDMEM::MEDCouplingExtrudedMesh *meshFromDistant=ParaMEDMEM::MEDCouplingExtrudedMeshClient::New(meshPtr);
+ MEDCoupling::MEDCouplingExtrudedMesh *meshFromDistant=MEDCoupling::MEDCouplingExtrudedMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCouplingUMesh *meshRef2;
- ParaMEDMEM::MEDCouplingExtrudedMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildExtrudedMesh(meshRef2);
+ MEDCoupling::MEDCouplingUMesh *meshRef2;
+ MEDCoupling::MEDCouplingExtrudedMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildExtrudedMesh(meshRef2);
CPPUNIT_ASSERT(meshFromDistant->isEqual(meshRef,1e-12));
CPPUNIT_ASSERT(meshFromDistant->getMesh2D()->isEqual(meshRef2,1e-12));
meshRef2->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetchingCMesh()
{
SALOME_MED::MEDCouplingCMeshCorbaInterface_ptr meshPtr=_objC->getCMesh();
- ParaMEDMEM::MEDCouplingCMesh *meshFromDistant=ParaMEDMEM::MEDCouplingCMeshClient::New(meshPtr);
+ MEDCoupling::MEDCouplingCMesh *meshFromDistant=MEDCoupling::MEDCouplingCMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCouplingCMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildCMesh();
+ MEDCoupling::MEDCouplingCMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildCMesh();
CPPUNIT_ASSERT(meshFromDistant->isEqual(meshRef,1e-12));
meshRef->decrRef();
meshFromDistant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetchingIMesh()
{
SALOME_MED::MEDCouplingIMeshCorbaInterface_ptr meshPtr=_objC->getIMesh();
- ParaMEDMEM::MEDCouplingIMesh *meshFromDistant=ParaMEDMEM::MEDCouplingIMeshClient::New(meshPtr);
+ MEDCoupling::MEDCouplingIMesh *meshFromDistant=MEDCoupling::MEDCouplingIMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCouplingIMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildIMesh();
+ MEDCoupling::MEDCouplingIMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildIMesh();
CPPUNIT_ASSERT(meshFromDistant->isEqual(meshRef,1e-12));
meshRef->decrRef();
meshFromDistant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetchingCurveLinearMesh()
{
SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface_ptr meshPtr=_objC->getCLMesh();
- ParaMEDMEM::MEDCouplingCurveLinearMesh *meshFromDistant=ParaMEDMEM::MEDCouplingCurveLinearMeshClient::New(meshPtr);
+ MEDCoupling::MEDCouplingCurveLinearMesh *meshFromDistant=MEDCoupling::MEDCouplingCurveLinearMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCouplingCurveLinearMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildCLMesh();
+ MEDCoupling::MEDCouplingCurveLinearMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildCLMesh();
CPPUNIT_ASSERT(meshFromDistant->isEqual(meshRef,1e-12));
meshRef->decrRef();
meshFromDistant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetching1SGTUMesh()
{
SALOME_MED::MEDCoupling1SGTUMeshCorbaInterface_ptr meshPtr=_objC->get1SGTUMesh();
- ParaMEDMEM::MEDCoupling1SGTUMesh *meshFromDistant=ParaMEDMEM::MEDCoupling1SGTUMeshClient::New(meshPtr);
+ MEDCoupling::MEDCoupling1SGTUMesh *meshFromDistant=MEDCoupling::MEDCoupling1SGTUMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCoupling1SGTUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build1SGTUMesh();
+ MEDCoupling::MEDCoupling1SGTUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build1SGTUMesh();
CPPUNIT_ASSERT(meshFromDistant->isEqual(meshRef,1e-12));
meshRef->decrRef();
meshFromDistant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFetching1DGTUMesh()
{
SALOME_MED::MEDCoupling1DGTUMeshCorbaInterface_ptr meshPtr=_objC->get1DGTUMesh();
- ParaMEDMEM::MEDCoupling1DGTUMesh *meshFromDistant=ParaMEDMEM::MEDCoupling1DGTUMeshClient::New(meshPtr);
+ MEDCoupling::MEDCoupling1DGTUMesh *meshFromDistant=MEDCoupling::MEDCoupling1DGTUMeshClient::New(meshPtr);
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::MEDCoupling1DGTUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build1DGTUMesh();
+ MEDCoupling::MEDCoupling1DGTUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build1DGTUMesh();
CPPUNIT_ASSERT(meshFromDistant->isEqual(meshRef,1e-12));
meshRef->decrRef();
meshFromDistant->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaField2DNTFetching()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldScalarOn2DNT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DNT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DNT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
CPPUNIT_ASSERT_THROW(fieldCpp->setTime(1.23,4,5),INTERP_KERNEL::Exception);
refField->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaField2DNTMultiFetching()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldScalarOn2DNT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp2=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp2=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
CPPUNIT_ASSERT(fieldCpp->isEqual(fieldCpp2,1.e-12,1.e-15));
char *stackS=(char *)stack;
CORBA::Object_var obj=_orb->string_to_object(stackS);
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=SALOME_MED::MEDCouplingFieldDoubleCorbaInterface::_narrow(obj);
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
CORBA::release(fieldPtr);
return fieldCpp;
}
//doing nbOfThreads-1 Register.
char *ior=_orb->object_to_string(fieldPtr);
pthread_t threads[nbOfThreads];
- ParaMEDMEM::MEDCouplingFieldDouble *rets[nbOfThreads];
+ MEDCoupling::MEDCouplingFieldDouble *rets[nbOfThreads];
for(int i=0;i<nbOfThreads;i++)
pthread_create(&threads[i],0,checkCorbaField2DNTMultiFetchingMTStatic,ior);
for(int i=0;i<nbOfThreads;i++)
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldNode2DNTFetching()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldNodeScalarOn2DNT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldNodeScalarOn2DNT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldNodeScalarOn2DNT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
CPPUNIT_ASSERT_THROW(fieldCpp->setTime(1.23,4,5),INTERP_KERNEL::Exception);
refField->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaField3DNTFetching()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldScalarOn3DNT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DNT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DNT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
CPPUNIT_ASSERT_THROW(fieldCpp->setTime(1.23,4,5),INTERP_KERNEL::Exception);
refField->decrRef();
CPPUNIT_ASSERT(std::string((*comps)[2])=="ccccc");
delete comps;
//
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfWT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfWT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
int dt,it;
fieldCpp->getTime(dt,it);
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaField3DSurfCOTIFetching()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldScalarOn3DSurfCOTI();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfCOTI();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfCOTI();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
int dt,it;
fieldCpp->getStartTime(dt,it);
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaField2DLTFetching()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldScalarOn2DLT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
double res[4];
CPPUNIT_ASSERT_DOUBLES_EQUAL(25.04,res[1],1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(25.004,res[2],1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(25.0004,res[3],1e-12);
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DLT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DLT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
int dt,it;
CPPUNIT_ASSERT_DOUBLES_EQUAL(6.7,fieldCpp->getStartTime(dt,it),1e-14);
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldGaussPt2DWTFetching()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldGaussPt2DWT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldGaussPt2DWT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldGaussPt2DWT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldGaussPtNE2DWTFetching()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldGaussPtNE2DWT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldGaussPtNE2DWT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldGaussPtNE2DWT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldVectorOnExtrudedWT()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldVectorOnExtrudedWT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldVectorOnExtrudedWT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldVectorOnExtrudedWT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldVectorOnCMeshWT()
{
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr fieldPtr=_objC->getFieldVectorOnCMeshWT();
- ParaMEDMEM::MEDCouplingFieldDouble *fieldCpp=ParaMEDMEM::MEDCouplingFieldDoubleClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldDouble *fieldCpp=MEDCoupling::MEDCouplingFieldDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldVectorOnCMeshWT();
+ MEDCoupling::MEDCouplingFieldDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldVectorOnCMeshWT();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldTemplateCellOn2D()
{
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr fieldPtr=_objC->getFieldTemplateCellOn2D();
- ParaMEDMEM::MEDCouplingFieldTemplate *fieldCpp=ParaMEDMEM::MEDCouplingFieldTemplateClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldTemplate *fieldCpp=MEDCoupling::MEDCouplingFieldTemplateClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingFieldTemplate *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldTemplateCellOn2D();
+ MEDCoupling::MEDCouplingFieldTemplate *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldTemplateCellOn2D();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldTemplateNodeOn2D()
{
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr fieldPtr=_objC->getFieldTemplateNodeOn2D();
- ParaMEDMEM::MEDCouplingFieldTemplate *fieldCpp=ParaMEDMEM::MEDCouplingFieldTemplateClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldTemplate *fieldCpp=MEDCoupling::MEDCouplingFieldTemplateClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingFieldTemplate *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldTemplateNodeOn2D();
+ MEDCoupling::MEDCouplingFieldTemplate *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldTemplateNodeOn2D();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldTemplateGaussPtOn2D()
{
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr fieldPtr=_objC->getFieldTemplateGaussPtOn2D();
- ParaMEDMEM::MEDCouplingFieldTemplate *fieldCpp=ParaMEDMEM::MEDCouplingFieldTemplateClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldTemplate *fieldCpp=MEDCoupling::MEDCouplingFieldTemplateClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingFieldTemplate *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussPtOn2D();
+ MEDCoupling::MEDCouplingFieldTemplate *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussPtOn2D();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaFieldTemplateGaussNEOn2D()
{
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr fieldPtr=_objC->getFieldTemplateGaussNEOn2D();
- ParaMEDMEM::MEDCouplingFieldTemplate *fieldCpp=ParaMEDMEM::MEDCouplingFieldTemplateClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingFieldTemplate *fieldCpp=MEDCoupling::MEDCouplingFieldTemplateClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingFieldTemplate *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussNEOn2D();
+ MEDCoupling::MEDCouplingFieldTemplate *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussNEOn2D();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaMultiFields1()
{
SALOME_MED::MEDCouplingMultiFieldsCorbaInterface_ptr fieldPtr=_objC->getMultiFields1();
- ParaMEDMEM::MEDCouplingMultiFields *fieldCpp=ParaMEDMEM::MEDCouplingMultiFieldsClient::New(fieldPtr);
+ MEDCoupling::MEDCouplingMultiFields *fieldCpp=MEDCoupling::MEDCouplingMultiFieldsClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::MEDCouplingMultiFields *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildMultiFields1();
+ MEDCoupling::MEDCouplingMultiFields *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildMultiFields1();
CPPUNIT_ASSERT(fieldCpp->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
fieldCpp->decrRef();
CPPUNIT_ASSERT(std::string((*comps)[2])=="ttt");
delete comps;
//
- ParaMEDMEM::DataArrayDouble *fieldCpp=ParaMEDMEM::DataArrayDoubleClient::New(fieldPtr);
+ MEDCoupling::DataArrayDouble *fieldCpp=MEDCoupling::DataArrayDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::DataArrayDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayDouble1();
+ MEDCoupling::DataArrayDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayDouble1();
CPPUNIT_ASSERT(fieldCpp->isEqual(*refField,1.e-12));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaArrayDouble2()
{
SALOME_MED::DataArrayDoubleCorbaInterface_ptr fieldPtr=_objC->getArrayDouble2();
- ParaMEDMEM::DataArrayDouble *fieldCpp=ParaMEDMEM::DataArrayDoubleClient::New(fieldPtr);
+ MEDCoupling::DataArrayDouble *fieldCpp=MEDCoupling::DataArrayDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::DataArrayDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayDouble2();
+ MEDCoupling::DataArrayDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayDouble2();
CPPUNIT_ASSERT(fieldCpp->isEqual(*refField,1.e-12));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaArrayDouble3()
{
SALOME_MED::DataArrayDoubleCorbaInterface_ptr fieldPtr=_objC->getArrayDouble3();
- ParaMEDMEM::DataArrayDouble *fieldCpp=ParaMEDMEM::DataArrayDoubleClient::New(fieldPtr);
+ MEDCoupling::DataArrayDouble *fieldCpp=MEDCoupling::DataArrayDoubleClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::DataArrayDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayDouble3();
+ MEDCoupling::DataArrayDouble *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayDouble3();
CPPUNIT_ASSERT(fieldCpp->isEqual(*refField,1.e-12));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaArrayInt1()
{
SALOME_MED::DataArrayIntCorbaInterface_ptr fieldPtr=_objC->getArrayInt1();
- ParaMEDMEM::DataArrayInt *fieldCpp=ParaMEDMEM::DataArrayIntClient::New(fieldPtr);
+ MEDCoupling::DataArrayInt *fieldCpp=MEDCoupling::DataArrayIntClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::DataArrayInt *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayInt1();
+ MEDCoupling::DataArrayInt *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayInt1();
CPPUNIT_ASSERT(fieldCpp->isEqual(*refField));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaArrayInt2()
{
SALOME_MED::DataArrayIntCorbaInterface_ptr fieldPtr=_objC->getArrayInt2();
- ParaMEDMEM::DataArrayInt *fieldCpp=ParaMEDMEM::DataArrayIntClient::New(fieldPtr);
+ MEDCoupling::DataArrayInt *fieldCpp=MEDCoupling::DataArrayIntClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::DataArrayInt *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayInt2();
+ MEDCoupling::DataArrayInt *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayInt2();
CPPUNIT_ASSERT(fieldCpp->isEqual(*refField));
refField->decrRef();
fieldCpp->decrRef();
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaArrayInt3()
{
SALOME_MED::DataArrayIntCorbaInterface_ptr fieldPtr=_objC->getArrayInt3();
- ParaMEDMEM::DataArrayInt *fieldCpp=ParaMEDMEM::DataArrayIntClient::New(fieldPtr);
+ MEDCoupling::DataArrayInt *fieldCpp=MEDCoupling::DataArrayIntClient::New(fieldPtr);
fieldPtr->UnRegister();
CORBA::release(fieldPtr);
//
- ParaMEDMEM::DataArrayInt *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayInt3();
+ MEDCoupling::DataArrayInt *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildArrayInt3();
CPPUNIT_ASSERT(fieldCpp->isEqual(*refField));
refField->decrRef();
fieldCpp->decrRef();
SALOME_MED::DataArrayDoubleCorbaInterface_ptr cooPtr=meshPtr->getCoords();
meshPtr->UnRegister();
CORBA::release(meshPtr);
- ParaMEDMEM::DataArrayDouble *cooCpp=ParaMEDMEM::DataArrayDoubleClient::New(cooPtr);
- ParaMEDMEM::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build3DSurfMesh();
+ MEDCoupling::DataArrayDouble *cooCpp=MEDCoupling::DataArrayDoubleClient::New(cooPtr);
+ MEDCoupling::MEDCouplingUMesh *meshRef=SALOME_TEST::MEDCouplingCorbaServBasicsTest::build3DSurfMesh();
//
CPPUNIT_ASSERT(meshRef->getCoords()->isEqual(*cooCpp,1e-12));
//
void SALOME_TEST::MEDCouplingCorbaServBasicsTestClt::checkCorbaMultiFields2()
{
SALOME_MED::MEDCouplingFieldOverTimeCorbaInterface_ptr fotPtr=_objC->getMultiFields2();
- ParaMEDMEM::MEDCouplingFieldOverTimeClient *fotc=ParaMEDMEM::MEDCouplingFieldOverTimeClient::New(fotPtr);
+ MEDCoupling::MEDCouplingFieldOverTimeClient *fotc=MEDCoupling::MEDCouplingFieldOverTimeClient::New(fotPtr);
fotPtr->UnRegister();
CORBA::release(fotPtr);
//
- ParaMEDMEM::MEDCouplingFieldOverTime *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildMultiFields2();
+ MEDCoupling::MEDCouplingFieldOverTime *refField=SALOME_TEST::MEDCouplingCorbaServBasicsTest::buildMultiFields2();
CPPUNIT_ASSERT(fotc->isEqual(refField,1.e-12,1.e-15));
refField->decrRef();
std::vector<double> ts=fotc->getTimeSteps();
#include <cppunit/extensions/HelperMacros.h>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingUMesh;
}
static void *checkCorbaField2DNTMultiFetchingMTStatic(void *stack);
private:
static SALOME_TEST::MEDCouplingMeshFieldFactory_ptr _objC;
- static ParaMEDMEM::MEDCouplingUMesh *_mesh_from_distant;
+ static MEDCoupling::MEDCouplingUMesh *_mesh_from_distant;
public:
static int _argc;
static char **_argv;
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::get1DMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build1DMesh();
- ParaMEDMEM::MEDCouplingUMeshServant *m=new ParaMEDMEM::MEDCouplingUMeshServant(m1);
+ MEDCoupling::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build1DMesh();
+ MEDCoupling::MEDCouplingUMeshServant *m=new MEDCoupling::MEDCouplingUMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::get2DMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build2DMesh();
- ParaMEDMEM::MEDCouplingUMeshServant *m=new ParaMEDMEM::MEDCouplingUMeshServant(m1);
+ MEDCoupling::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build2DMesh();
+ MEDCoupling::MEDCouplingUMeshServant *m=new MEDCoupling::MEDCouplingUMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::get3DMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build3DMesh();
- ParaMEDMEM::MEDCouplingUMeshServant *m=new ParaMEDMEM::MEDCouplingUMeshServant(m1);
+ MEDCoupling::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build3DMesh();
+ MEDCoupling::MEDCouplingUMeshServant *m=new MEDCoupling::MEDCouplingUMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::get3DSurfMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build3DSurfMesh();
- ParaMEDMEM::MEDCouplingUMeshServant *m=new ParaMEDMEM::MEDCouplingUMeshServant(m1);
+ MEDCoupling::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build3DSurfMesh();
+ MEDCoupling::MEDCouplingUMeshServant *m=new MEDCoupling::MEDCouplingUMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::get0DMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build0DMesh();
- ParaMEDMEM::MEDCouplingUMeshServant *m=new ParaMEDMEM::MEDCouplingUMeshServant(m1);
+ MEDCoupling::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::build0DMesh();
+ MEDCoupling::MEDCouplingUMeshServant *m=new MEDCoupling::MEDCouplingUMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getM1DMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::buildM1DMesh();
- ParaMEDMEM::MEDCouplingUMeshServant *m=new ParaMEDMEM::MEDCouplingUMeshServant(m1);
+ MEDCoupling::MEDCouplingUMesh *m1=MEDCouplingCorbaServBasicsTest::buildM1DMesh();
+ MEDCoupling::MEDCouplingUMeshServant *m=new MEDCoupling::MEDCouplingUMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingUMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getExtrudedMesh()
{
- ParaMEDMEM::MEDCouplingUMesh *m2D;
- ParaMEDMEM::MEDCouplingExtrudedMesh *m1=MEDCouplingCorbaServBasicsTest::buildExtrudedMesh(m2D);
+ MEDCoupling::MEDCouplingUMesh *m2D;
+ MEDCoupling::MEDCouplingExtrudedMesh *m1=MEDCouplingCorbaServBasicsTest::buildExtrudedMesh(m2D);
m2D->decrRef();
- ParaMEDMEM::MEDCouplingExtrudedMeshServant *m=new ParaMEDMEM::MEDCouplingExtrudedMeshServant(m1);
+ MEDCoupling::MEDCouplingExtrudedMeshServant *m=new MEDCoupling::MEDCouplingExtrudedMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingCMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getCMesh()
{
- ParaMEDMEM::MEDCouplingCMesh *m1=MEDCouplingCorbaServBasicsTest::buildCMesh();
- ParaMEDMEM::MEDCouplingCMeshServant *m=new ParaMEDMEM::MEDCouplingCMeshServant(m1);
+ MEDCoupling::MEDCouplingCMesh *m1=MEDCouplingCorbaServBasicsTest::buildCMesh();
+ MEDCoupling::MEDCouplingCMeshServant *m=new MEDCoupling::MEDCouplingCMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingCMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingIMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getIMesh()
{
- ParaMEDMEM::MEDCouplingIMesh *m1=MEDCouplingCorbaServBasicsTest::buildIMesh();
- ParaMEDMEM::MEDCouplingIMeshServant *m=new ParaMEDMEM::MEDCouplingIMeshServant(m1);
+ MEDCoupling::MEDCouplingIMesh *m1=MEDCouplingCorbaServBasicsTest::buildIMesh();
+ MEDCoupling::MEDCouplingIMeshServant *m=new MEDCoupling::MEDCouplingIMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingIMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getCLMesh()
{
- ParaMEDMEM::MEDCouplingCurveLinearMesh *m1=MEDCouplingCorbaServBasicsTest::buildCLMesh();
- ParaMEDMEM::MEDCouplingCurveLinearMeshServant *m=new ParaMEDMEM::MEDCouplingCurveLinearMeshServant(m1);
+ MEDCoupling::MEDCouplingCurveLinearMesh *m1=MEDCouplingCorbaServBasicsTest::buildCLMesh();
+ MEDCoupling::MEDCouplingCurveLinearMeshServant *m=new MEDCoupling::MEDCouplingCurveLinearMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCoupling1SGTUMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::get1SGTUMesh()
{
- ParaMEDMEM::MEDCoupling1SGTUMesh *m1=MEDCouplingCorbaServBasicsTest::build1SGTUMesh();
- ParaMEDMEM::MEDCoupling1SGTUMeshServant *m=new ParaMEDMEM::MEDCoupling1SGTUMeshServant(m1);
+ MEDCoupling::MEDCoupling1SGTUMesh *m1=MEDCouplingCorbaServBasicsTest::build1SGTUMesh();
+ MEDCoupling::MEDCoupling1SGTUMeshServant *m=new MEDCoupling::MEDCoupling1SGTUMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCoupling1SGTUMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCoupling1DGTUMeshCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::get1DGTUMesh()
{
- ParaMEDMEM::MEDCoupling1DGTUMesh *m1=MEDCouplingCorbaServBasicsTest::build1DGTUMesh();
- ParaMEDMEM::MEDCoupling1DGTUMeshServant *m=new ParaMEDMEM::MEDCoupling1DGTUMeshServant(m1);
+ MEDCoupling::MEDCoupling1DGTUMesh *m1=MEDCouplingCorbaServBasicsTest::build1DGTUMesh();
+ MEDCoupling::MEDCoupling1DGTUMeshServant *m=new MEDCoupling::MEDCoupling1DGTUMeshServant(m1);
m1->decrRef();
SALOME_MED::MEDCoupling1DGTUMeshCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldScalarOn2DNT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DNT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DNT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldNodeScalarOn2DNT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldNodeScalarOn2DNT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldNodeScalarOn2DNT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldScalarOn3DNT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DNT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DNT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldScalarOn3DSurfWT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfWT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfWT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldScalarOn3DSurfCOTI()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfCOTI();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn3DSurfCOTI();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldScalarOn2DLT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DLT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldScalarOn2DLT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldGaussPt2DWT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldGaussPt2DWT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldGaussPt2DWT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldGaussPtNE2DWT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldGaussPtNE2DWT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldGaussPtNE2DWT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldVectorOnExtrudedWT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldVectorOnExtrudedWT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldVectorOnExtrudedWT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldVectorOnCMeshWT()
{
- ParaMEDMEM::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldVectorOnCMeshWT();
- ParaMEDMEM::MEDCouplingFieldDoubleServant *m=new ParaMEDMEM::MEDCouplingFieldDoubleServant(field);
+ MEDCoupling::MEDCouplingFieldDouble *field=MEDCouplingCorbaServBasicsTest::buildFieldVectorOnCMeshWT();
+ MEDCoupling::MEDCouplingFieldDoubleServant *m=new MEDCoupling::MEDCouplingFieldDoubleServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldTemplateCellOn2D()
{
- ParaMEDMEM::MEDCouplingFieldTemplate *field=MEDCouplingCorbaServBasicsTest::buildFieldTemplateCellOn2D();
- ParaMEDMEM::MEDCouplingFieldTemplateServant *m=new ParaMEDMEM::MEDCouplingFieldTemplateServant(field);
+ MEDCoupling::MEDCouplingFieldTemplate *field=MEDCouplingCorbaServBasicsTest::buildFieldTemplateCellOn2D();
+ MEDCoupling::MEDCouplingFieldTemplateServant *m=new MEDCoupling::MEDCouplingFieldTemplateServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldTemplateNodeOn2D()
{
- ParaMEDMEM::MEDCouplingFieldTemplate *field=MEDCouplingCorbaServBasicsTest::buildFieldTemplateNodeOn2D();
- ParaMEDMEM::MEDCouplingFieldTemplateServant *m=new ParaMEDMEM::MEDCouplingFieldTemplateServant(field);
+ MEDCoupling::MEDCouplingFieldTemplate *field=MEDCouplingCorbaServBasicsTest::buildFieldTemplateNodeOn2D();
+ MEDCoupling::MEDCouplingFieldTemplateServant *m=new MEDCoupling::MEDCouplingFieldTemplateServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldTemplateGaussPtOn2D()
{
- ParaMEDMEM::MEDCouplingFieldTemplate *field=MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussPtOn2D();
- ParaMEDMEM::MEDCouplingFieldTemplateServant *m=new ParaMEDMEM::MEDCouplingFieldTemplateServant(field);
+ MEDCoupling::MEDCouplingFieldTemplate *field=MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussPtOn2D();
+ MEDCoupling::MEDCouplingFieldTemplateServant *m=new MEDCoupling::MEDCouplingFieldTemplateServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getFieldTemplateGaussNEOn2D()
{
- ParaMEDMEM::MEDCouplingFieldTemplate *field=MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussNEOn2D();
- ParaMEDMEM::MEDCouplingFieldTemplateServant *m=new ParaMEDMEM::MEDCouplingFieldTemplateServant(field);
+ MEDCoupling::MEDCouplingFieldTemplate *field=MEDCouplingCorbaServBasicsTest::buildFieldTemplateGaussNEOn2D();
+ MEDCoupling::MEDCouplingFieldTemplateServant *m=new MEDCoupling::MEDCouplingFieldTemplateServant(field);
field->decrRef();
SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_ptr ret=m->_this();
return ret;
SALOME_MED::MEDCouplingMultiFieldsCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getMultiFields1()
{
- ParaMEDMEM::MEDCouplingMultiFields *fields=MEDCouplingCorbaServBasicsTest::buildMultiFields1();
- ParaMEDMEM::MEDCouplingMultiFieldsServant *s=new ParaMEDMEM::MEDCouplingMultiFieldsServant(fields);
+ MEDCoupling::MEDCouplingMultiFields *fields=MEDCouplingCorbaServBasicsTest::buildMultiFields1();
+ MEDCoupling::MEDCouplingMultiFieldsServant *s=new MEDCoupling::MEDCouplingMultiFieldsServant(fields);
fields->decrRef();
SALOME_MED::MEDCouplingMultiFieldsCorbaInterface_ptr ret=s->_this();
return ret;
SALOME_MED::DataArrayDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getArrayDouble1()
{
- ParaMEDMEM::DataArrayDouble *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayDouble1();
- ParaMEDMEM::DataArrayDoubleServant *retServ=new ParaMEDMEM::DataArrayDoubleServant(retCpp);
+ MEDCoupling::DataArrayDouble *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayDouble1();
+ MEDCoupling::DataArrayDoubleServant *retServ=new MEDCoupling::DataArrayDoubleServant(retCpp);
retCpp->decrRef();
return retServ->_this();
}
SALOME_MED::DataArrayDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getArrayDouble2()
{
- ParaMEDMEM::DataArrayDouble *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayDouble2();
- ParaMEDMEM::DataArrayDoubleServant *retServ=new ParaMEDMEM::DataArrayDoubleServant(retCpp);
+ MEDCoupling::DataArrayDouble *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayDouble2();
+ MEDCoupling::DataArrayDoubleServant *retServ=new MEDCoupling::DataArrayDoubleServant(retCpp);
retCpp->decrRef();
return retServ->_this();
}
SALOME_MED::DataArrayDoubleCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getArrayDouble3()
{
- ParaMEDMEM::DataArrayDouble *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayDouble3();
- ParaMEDMEM::DataArrayDoubleServant *retServ=new ParaMEDMEM::DataArrayDoubleServant(retCpp);
+ MEDCoupling::DataArrayDouble *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayDouble3();
+ MEDCoupling::DataArrayDoubleServant *retServ=new MEDCoupling::DataArrayDoubleServant(retCpp);
retCpp->decrRef();
return retServ->_this();
}
SALOME_MED::DataArrayIntCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getArrayInt1()
{
- ParaMEDMEM::DataArrayInt *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayInt1();
- ParaMEDMEM::DataArrayIntServant *retServ=new ParaMEDMEM::DataArrayIntServant(retCpp);
+ MEDCoupling::DataArrayInt *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayInt1();
+ MEDCoupling::DataArrayIntServant *retServ=new MEDCoupling::DataArrayIntServant(retCpp);
retCpp->decrRef();
return retServ->_this();
}
SALOME_MED::DataArrayIntCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getArrayInt2()
{
- ParaMEDMEM::DataArrayInt *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayInt2();
- ParaMEDMEM::DataArrayIntServant *retServ=new ParaMEDMEM::DataArrayIntServant(retCpp);
+ MEDCoupling::DataArrayInt *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayInt2();
+ MEDCoupling::DataArrayIntServant *retServ=new MEDCoupling::DataArrayIntServant(retCpp);
retCpp->decrRef();
return retServ->_this();
}
SALOME_MED::DataArrayIntCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getArrayInt3()
{
- ParaMEDMEM::DataArrayInt *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayInt3();
- ParaMEDMEM::DataArrayIntServant *retServ=new ParaMEDMEM::DataArrayIntServant(retCpp);
+ MEDCoupling::DataArrayInt *retCpp=MEDCouplingCorbaServBasicsTest::buildArrayInt3();
+ MEDCoupling::DataArrayIntServant *retServ=new MEDCoupling::DataArrayIntServant(retCpp);
retCpp->decrRef();
return retServ->_this();
}
SALOME_MED::MEDCouplingFieldOverTimeCorbaInterface_ptr MEDCouplingMeshFieldFactoryComponent::getMultiFields2()
{
- ParaMEDMEM::MEDCouplingFieldOverTime *fot=MEDCouplingCorbaServBasicsTest::buildMultiFields2();
- ParaMEDMEM::MEDCouplingFieldOverTimeServant *retServ=new ParaMEDMEM::MEDCouplingFieldOverTimeServant(fot);
+ MEDCoupling::MEDCouplingFieldOverTime *fot=MEDCouplingCorbaServBasicsTest::buildMultiFields2();
+ MEDCoupling::MEDCouplingFieldOverTimeServant *retServ=new MEDCoupling::MEDCouplingFieldOverTimeServant(fot);
fot->decrRef();
return retServ->_this();
}
#endif
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServantTest)
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingUMesh;
}
#include <iostream>
#include <fstream>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
CPPUNIT_TEST_SUITE_REGISTRATION( SALOME_TEST::MEDCouplingCorbaServBasicsTestClt );
#include <iostream>
#include <fstream>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
int mainCorbaServ(int argc, char **argv);
#include <iostream>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
%}
%include "MEDCouplingCommon.i"
-%newobject ParaMEDMEM::MEDCouplingFieldDoubleClient::New;
-%newobject ParaMEDMEM::MEDCouplingFieldTemplateClient::New;
-%newobject ParaMEDMEM::MEDCouplingUMeshClient::New;
-%newobject ParaMEDMEM::MEDCoupling1SGTUMeshClient::New;
-%newobject ParaMEDMEM::MEDCoupling1DGTUMeshClient::New;
-%newobject ParaMEDMEM::MEDCouplingExtrudedMeshClient::New;
-%newobject ParaMEDMEM::MEDCouplingCMeshClient::New;
-%newobject ParaMEDMEM::MEDCouplingIMeshClient::New;
-%newobject ParaMEDMEM::MEDCouplingCurveLinearMeshClient::New;
-%newobject ParaMEDMEM::MEDCouplingMultiFieldsClient::New;
-%newobject ParaMEDMEM::MEDCouplingFieldOverTimeClient::New;
-%newobject ParaMEDMEM::DataArrayDoubleClient::New;
-%newobject ParaMEDMEM::DataArrayIntClient::New;
+%newobject MEDCoupling::MEDCouplingFieldDoubleClient::New;
+%newobject MEDCoupling::MEDCouplingFieldTemplateClient::New;
+%newobject MEDCoupling::MEDCouplingUMeshClient::New;
+%newobject MEDCoupling::MEDCoupling1SGTUMeshClient::New;
+%newobject MEDCoupling::MEDCoupling1DGTUMeshClient::New;
+%newobject MEDCoupling::MEDCouplingExtrudedMeshClient::New;
+%newobject MEDCoupling::MEDCouplingCMeshClient::New;
+%newobject MEDCoupling::MEDCouplingIMeshClient::New;
+%newobject MEDCoupling::MEDCouplingCurveLinearMeshClient::New;
+%newobject MEDCoupling::MEDCouplingMultiFieldsClient::New;
+%newobject MEDCoupling::MEDCouplingFieldOverTimeClient::New;
+%newobject MEDCoupling::DataArrayDoubleClient::New;
+%newobject MEDCoupling::DataArrayIntClient::New;
%nodefaultctor;
%nodefaultdtor;
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingFieldDoubleClient
{
}
%pythoncode %{
-def ParaMEDMEMDataArrayDoublenew(cls,*args):
+def MEDCouplingDataArrayDoublenew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDouble____new___(cls,args)
-def ParaMEDMEMDataArrayDoubleIadd(self,*args):
+def MEDCouplingDataArrayDoubleIadd(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDouble____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIsub(self,*args):
+def MEDCouplingDataArrayDoubleIsub(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDouble____isub___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleImul(self,*args):
+def MEDCouplingDataArrayDoubleImul(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDouble____imul___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIdiv(self,*args):
+def MEDCouplingDataArrayDoubleIdiv(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDouble____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIpow(self,*args):
+def MEDCouplingDataArrayDoubleIpow(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDouble____ipow___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoublenew(cls,*args):
+def MEDCouplingFieldDoublenew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingFieldDouble____new___(cls,args)
-def ParaMEDMEMMEDCouplingFieldDoubleIadd(self,*args):
+def MEDCouplingFieldDoubleIadd(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingFieldDouble____iadd___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIsub(self,*args):
+def MEDCouplingFieldDoubleIsub(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingFieldDouble____isub___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleImul(self,*args):
+def MEDCouplingFieldDoubleImul(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingFieldDouble____imul___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIdiv(self,*args):
+def MEDCouplingFieldDoubleIdiv(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingFieldDouble____idiv___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIpow(self,*args):
+def MEDCouplingFieldDoubleIpow(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingFieldDouble____ipow___(self, self, *args)
-def ParaMEDMEMDataArrayIntnew(cls,*args):
+def MEDCouplingDataArrayIntnew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayInt____new___(cls,args)
-def ParaMEDMEMDataArrayIntIadd(self,*args):
+def MEDCouplingDataArrayIntIadd(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayInt____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayIntIsub(self,*args):
+def MEDCouplingDataArrayIntIsub(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayInt____isub___(self, self, *args)
-def ParaMEDMEMDataArrayIntImul(self,*args):
+def MEDCouplingDataArrayIntImul(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayInt____imul___(self, self, *args)
-def ParaMEDMEMDataArrayIntIdiv(self,*args):
+def MEDCouplingDataArrayIntIdiv(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayInt____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayIntImod(self,*args):
+def MEDCouplingDataArrayIntImod(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayInt____imod___(self, self, *args)
-def ParaMEDMEMDataArrayIntIpow(self,*args):
+def MEDCouplingDataArrayIntIpow(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayInt____ipow___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIadd(self,*args):
+def MEDCouplingDataArrayDoubleTupleIadd(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDoubleTuple____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIsub(self,*args):
+def MEDCouplingDataArrayDoubleTupleIsub(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDoubleTuple____isub___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleImul(self,*args):
+def MEDCouplingDataArrayDoubleTupleImul(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDoubleTuple____imul___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIdiv(self,*args):
+def MEDCouplingDataArrayDoubleTupleIdiv(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayDoubleTuple____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIadd(self,*args):
+def MEDCouplingDataArrayIntTupleIadd(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayIntTuple____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIsub(self,*args):
+def MEDCouplingDataArrayIntTupleIsub(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayIntTuple____isub___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleImul(self,*args):
+def MEDCouplingDataArrayIntTupleImul(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayIntTuple____imul___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIdiv(self,*args):
+def MEDCouplingDataArrayIntTupleIdiv(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayIntTuple____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleImod(self,*args):
+def MEDCouplingDataArrayIntTupleImod(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DataArrayIntTuple____imod___(self, self, *args)
def ParaMEDMEMDenseMatrixIadd(self,*args):
def ParaMEDMEMDenseMatrixIsub(self,*args):
import _MEDCouplingClient
return _MEDCouplingClient.DenseMatrix____isub___(self, self, *args)
-def ParaMEDMEMMEDCouplingUMeshnew(cls,*args):
+def MEDCouplingUMeshnew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingUMesh____new___(cls,args)
-def ParaMEDMEMMEDCoupling1DGTUMeshnew(cls,*args):
+def MEDCoupling1DGTUMeshnew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCoupling1DGTUMesh____new___(cls,args)
-def ParaMEDMEMMEDCoupling1SGTUMeshnew(cls,*args):
+def MEDCoupling1SGTUMeshnew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCoupling1SGTUMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingCurveLinearMeshnew(cls,*args):
+def MEDCouplingCurveLinearMeshnew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingCurveLinearMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingCMeshnew(cls,*args):
+def MEDCouplingCMeshnew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingCMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingIMeshnew(cls,*args):
+def MEDCouplingIMeshnew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingIMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingExtrudedMeshnew(cls,*args):
+def MEDCouplingExtrudedMeshnew(cls,*args):
import _MEDCouplingClient
return _MEDCouplingClient.MEDCouplingExtrudedMesh____new___(cls,args)
%}
#include "DataArrayIntServant.hxx"
#include "MEDCouplingCorbaTypemaps.i"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
%}
%include "MEDCouplingCommon.i"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingFieldDoubleServant
{
}
%pythoncode %{
-def ParaMEDMEMDataArrayDoublenew(cls,*args):
+def MEDCouplingDataArrayDoublenew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDouble____new___(cls,args)
-def ParaMEDMEMDataArrayDoubleIadd(self,*args):
+def MEDCouplingDataArrayDoubleIadd(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDouble____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIsub(self,*args):
+def MEDCouplingDataArrayDoubleIsub(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDouble____isub___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleImul(self,*args):
+def MEDCouplingDataArrayDoubleImul(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDouble____imul___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIdiv(self,*args):
+def MEDCouplingDataArrayDoubleIdiv(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDouble____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleIpow(self,*args):
+def MEDCouplingDataArrayDoubleIpow(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDouble____ipow___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoublenew(cls,*args):
+def MEDCouplingFieldDoublenew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingFieldDouble____new___(cls,args)
-def ParaMEDMEMMEDCouplingFieldDoubleIadd(self,*args):
+def MEDCouplingFieldDoubleIadd(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingFieldDouble____iadd___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIsub(self,*args):
+def MEDCouplingFieldDoubleIsub(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingFieldDouble____isub___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleImul(self,*args):
+def MEDCouplingFieldDoubleImul(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingFieldDouble____imul___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIdiv(self,*args):
+def MEDCouplingFieldDoubleIdiv(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingFieldDouble____idiv___(self, self, *args)
-def ParaMEDMEMMEDCouplingFieldDoubleIpow(self,*args):
+def MEDCouplingFieldDoubleIpow(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingFieldDouble____ipow___(self, self, *args)
-def ParaMEDMEMDataArrayIntnew(cls,*args):
+def MEDCouplingDataArrayIntnew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayInt____new___(cls,args)
-def ParaMEDMEMDataArrayIntIadd(self,*args):
+def MEDCouplingDataArrayIntIadd(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayInt____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayIntIsub(self,*args):
+def MEDCouplingDataArrayIntIsub(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayInt____isub___(self, self, *args)
-def ParaMEDMEMDataArrayIntImul(self,*args):
+def MEDCouplingDataArrayIntImul(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayInt____imul___(self, self, *args)
-def ParaMEDMEMDataArrayIntIdiv(self,*args):
+def MEDCouplingDataArrayIntIdiv(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayInt____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayIntImod(self,*args):
+def MEDCouplingDataArrayIntImod(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayInt____imod___(self, self, *args)
-def ParaMEDMEMDataArrayIntIpow(self,*args):
+def MEDCouplingDataArrayIntIpow(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayInt____ipow___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIadd(self,*args):
+def MEDCouplingDataArrayDoubleTupleIadd(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDoubleTuple____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIsub(self,*args):
+def MEDCouplingDataArrayDoubleTupleIsub(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDoubleTuple____isub___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleImul(self,*args):
+def MEDCouplingDataArrayDoubleTupleImul(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDoubleTuple____imul___(self, self, *args)
-def ParaMEDMEMDataArrayDoubleTupleIdiv(self,*args):
+def MEDCouplingDataArrayDoubleTupleIdiv(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayDoubleTuple____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIadd(self,*args):
+def MEDCouplingDataArrayIntTupleIadd(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayIntTuple____iadd___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIsub(self,*args):
+def MEDCouplingDataArrayIntTupleIsub(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayIntTuple____isub___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleImul(self,*args):
+def MEDCouplingDataArrayIntTupleImul(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayIntTuple____imul___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleIdiv(self,*args):
+def MEDCouplingDataArrayIntTupleIdiv(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayIntTuple____idiv___(self, self, *args)
-def ParaMEDMEMDataArrayIntTupleImod(self,*args):
+def MEDCouplingDataArrayIntTupleImod(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DataArrayIntTuple____imod___(self, self, *args)
-def ParaMEDMEMDenseMatrixIadd(self,*args):
+def MEDCouplingDenseMatrixIadd(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DenseMatrix____iadd___(self, self, *args)
-def ParaMEDMEMDenseMatrixIsub(self,*args):
+def MEDCouplingDenseMatrixIsub(self,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.DenseMatrix____isub___(self, self, *args)
-def ParaMEDMEMMEDCouplingUMeshnew(cls,*args):
+def MEDCouplingUMeshnew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingUMesh____new___(cls,args)
-def ParaMEDMEMMEDCoupling1DGTUMeshnew(cls,*args):
+def MEDCoupling1DGTUMeshnew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCoupling1DGTUMesh____new___(cls,args)
-def ParaMEDMEMMEDCoupling1SGTUMeshnew(cls,*args):
+def MEDCoupling1SGTUMeshnew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCoupling1SGTUMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingCurveLinearMeshnew(cls,*args):
+def MEDCouplingCurveLinearMeshnew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingCurveLinearMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingCMeshnew(cls,*args):
+def MEDCouplingCMeshnew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingCMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingIMeshnew(cls,*args):
+def MEDCouplingIMeshnew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingIMesh____new___(cls,args)
-def ParaMEDMEMMEDCouplingExtrudedMeshnew(cls,*args):
+def MEDCouplingExtrudedMeshnew(cls,*args):
import _MEDCouplingCorba
return _MEDCouplingCorba.MEDCouplingExtrudedMesh____new___(cls,args)
%}
