# The theme to use for HTML and HTML Help pages. Major themes that come with
# Sphinx are currently 'default' and 'sphinxdoc'.
-html_theme = 'classic'
+html_theme = '@SPHINX_THEME@'
html_theme_options = {
"stickysidebar": "false",
"rightsidebar": "false",
Some comments on this code:
* The physical property to be preserved by this interpolation is
- specified using the keyword :tt:`ConservativeVolumic`
+ specified using the keyword :tt:`IntensiveMaximum`
* The parameter :tt:`P0P0` given at the preparation step of the
remapper specifies that the interpolation is done from CELLS (P0) to
CELLS (P0).
Some comments on this code:
* The physical property to be preserved by this interpolation is
- specified using the keyword :tt:`ConservativeVolumic`
+ specified using the keyword :tt:`IntensiveMaximum`
* The parameter :tt:`P0P0` given at the preparation step of the
remapper specifies that the interpolation is done from CELLS (P0) to
CELLS (P0).
field=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
field.setMesh(m3D)
field.setArray(a)
-field.checkCoherency()
+field.checkConsistencyLight()
field.setName("f")
# Save the field (and associated mesh)
# _T1A
L=0.
arr = field.getArray()
-ids = arr.getIdsInRange(L,1e300)
+ids = arr.findIdsInRange(L,1e300)
m3DSub = field.getMesh()[ids]
skin = m3DSub.computeSkin()
MEDLoader.WriteUMesh("partition_skin.med",skin,True);
# SALOME V650 requires a more complicated syntax.
m2D,desc,descI,revDesc,revDescI=m3DSub.buildDescendingConnectivity()
numberOf3DVolSharing=revDescI.deltaShiftIndex()
-ids2D=numberOf3DVolSharing.getIdsEqual(1)
+ids2D=numberOf3DVolSharing.findIdsEqual(1)
skin_V650=m2D[ids2D]
# We can check if the two skins are identical
print "Are two meshes equal between V660 and V650 ?",skin.isEqual(skin_V650,1e-12)
m=MEDFileMesh.New(fn)
m=m.getMeshAtLevel(0)
m.writeVTK(outs[i])
- mns[i]=m.deepCpy()
+ mns[i]=m.deepCopy()
if splitview:
m.translate([scal*elt for elt in trs[i]])
f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME)
da=DataArrayDouble.New()
da.alloc(m.getNumberOfCells(),1)
da.fillWithValue(i)
- dds[i]=da.deepCpy()
+ dds[i]=da.deepCopy()
f.setArray(da)
fs[i]=f
i+=1
m=MEDFileMesh.New(fn)
m=m.getMeshAtLevel(0)
m.writeVTK(outs[i])
- mns[i]=m.deepCpy()
+ mns[i]=m.deepCopy()
if splitview:
m.translate([scal*elt for elt in trs[i]])
f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME)
da=DataArrayDouble.New()
da.alloc(m.getNumberOfCells(),1)
da.fillWithValue(i)
- dds[i]=da.deepCpy()
+ dds[i]=da.deepCopy()
f.setArray(da)
fs[i]=f
i+=1
equation = "319.*cos(((x)*(x)*3+(y-0.52)*(y-0.52)+(z-0.1)*(z-0.1))*7)"
fsource=msource.fillFromAnalytic(ON_CELLS,1,equation)
fsource.setName("Temperature")
-fsource.setNature(ConservativeVolumic)
+fsource.setNature(IntensiveMaximum)
# Read the target mesh
mtarget = MEDLoader.ReadUMeshFromFile("meshtarget.med","meshtarget",0)
# _T1A
from MEDLoader import MEDLoader, ON_CELLS
-from MEDCouplingRemapper import MEDCouplingRemapper, ConservativeVolumic
+from MEDCouplingRemapper import MEDCouplingRemapper, IntensiveMaximum
# Read the source mesh and the source field
it,dt = (-1,-1)
fsource = MEDLoader.ReadField(ON_CELLS,"fieldsource.med","meshsource",0,
"Temperature",it,dt)
fsource.setMesh(msource)
-fsource.setNature(ConservativeVolumic)
+fsource.setNature(IntensiveMaximum)
# Read the target mesh
mtarget = MEDLoader.ReadUMeshFromFile("meshtarget.med","meshtarget",0)
ms=MEDFileMesh.New("MeshSource.med") ; ms=ms.getMeshAtLevel(0)
mt=MEDFileMesh.New("MeshTarget.med") ; mt=mt.getMeshAtLevel(0)
fs=ms.fillFromAnalytic(ON_CELLS,1,"319.*cos(((x)*(x)*3+(y-0.52)*(y-0.52)+(z-0.1)*(z-0.1))*7)")
-fs.setNature(ConservativeVolumic)
+fs.setNature(IntensiveMaximum)
fs.setName("Temperature")
MEDCouplingFieldDouble.WriteVTK("MeshSource.vtu",[fs])
-mt2=mt.deepCpy()
+mt2=mt.deepCopy()
mt2.translate([0.4,0.,0.])
mt2.writeVTK("MeshTarget.vtu")
#
#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;
}
- else if (nature == "ConservativeVolumic") {
- return ConservativeVolumic;
+ else if (nature == "IntensiveMaximum") {
+ return IntensiveMaximum;
}
- else if (nature == "Integral") {
- return Integral;
+ else if (nature == "ExtensiveMaximum") {
+ return ExtensiveMaximum;
}
- else if (nature == "IntegralGlobConstraint") {
- return IntegralGlobConstraint;
+ else if (nature == "ExtensiveConservation") {
+ return ExtensiveConservation;
}
- else if (nature == "RevIntegral") {
- return RevIntegral;
+ else if (nature == "IntensiveConservation") {
+ return IntensiveConservation;
}
std::string message("Error when trying to interpolate field: ");
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);
};
return PyDict_GetItemString(global_dict, python_var);
}
-std::string MEDPresentation::getFieldTypeString(ParaMEDMEM::TypeOfField fieldType)
+std::string MEDPresentation::getFieldTypeString(MEDCoupling::TypeOfField fieldType)
{
switch(fieldType)
{
- case ParaMEDMEM::ON_CELLS:
+ case MEDCoupling::ON_CELLS:
return "CELLS";
- case ParaMEDMEM::ON_NODES:
+ case MEDCoupling::ON_NODES:
return "POINTS";
default:
std::cerr << "MEDPresentation::getFieldTypeString() -- Not implemented ! Gauss points?";
this->ui.comboBoxMethod->addItems(methods);
QStringList natures;
- natures << "NoNature" << "ConservativeVolumic" << "Integral" << "IntegralGlobConstraint" << "RevIntegral";
+ natures << "NoNature" << "IntensiveMaximum" << "ExtensiveMaximum" << "ExtensiveConservation" << "IntensiveConservation";
this->ui.comboBoxNature->addItems(natures);
connect(this->ui.btnSelectMesh, SIGNAL(clicked()), this, SLOT(OnSelectMesh()));
#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)
{
MEDCalculatorDBField *MEDCalculatorDBField::operator+(double val) const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
+ MCAuto<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
return (*this)+(*par2);
}
MEDCalculatorDBField *MEDCalculatorDBField::operator-(double val) const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
+ MCAuto<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
return (*this)-(*par2);
}
MEDCalculatorDBField *MEDCalculatorDBField::operator*(double val) const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
+ MCAuto<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
return (*this)*(*par2);
}
MEDCalculatorDBField *MEDCalculatorDBField::operator/(double val) const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
+ MCAuto<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
return (*this)/(*par2);
}
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);
}
{
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
- std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> > fs2(ids.size());
+ std::vector< MCAuto<MEDCouplingFieldDouble> > fs2(ids.size());
int ii=0;
for(std::vector<int>::const_iterator iter=ids.begin();iter!=ids.end();iter++)
fs2[ii++]=_time_steps[*iter]->getFieldWithoutQuestion(_c_labels.size(),_c);
std::vector<MEDCouplingFieldDouble *> fs(fs2.size());
std::copy(fs2.begin(),fs2.end(),fs.begin());
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldOverTime> fot=MEDCouplingFieldOverTime::New(fs);
+ MCAuto<MEDCouplingFieldOverTime> fot=MEDCouplingFieldOverTime::New(fs);
//
int argc=0;
CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
int sz=steps.size();
for(int i=0;i<sz;i++)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBSliceField> elt(new MEDCalculatorDBSliceField(steps[i].getTimeStep(),steps[i].getOrder()));
+ MCAuto<MEDCalculatorDBSliceField> elt(new MEDCalculatorDBSliceField(steps[i].getTimeStep(),steps[i].getOrder()));
_time_steps.push_back(elt);
}
}
const MEDCalculatorDBFieldReal& MEDCalculatorDBFieldReal::operator=(const MEDCalculatorDBFieldReal& other) throw(INTERP_KERNEL::Exception)
{
- checkCoherency(other);
+ checkConsistencyLight(other);
std::vector<int> ids=_t.getIds(_time_steps.size());
std::vector<int> ids2=other._t.getIds(other._time_steps.size());
unsigned int sz=ids.size();
const MEDCalculatorDBFieldReal& MEDCalculatorDBFieldReal::operator=(double val) throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> other=buildCstFieldFromThis(val);
+ MCAuto<MEDCalculatorDBFieldReal> other=buildCstFieldFromThis(val);
return (*this)=*other;
}
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
+ MCAuto<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
MEDCalculatorDBField *ret=add(*othercr);
return ret;
}
MEDCalculatorDBField *MEDCalculatorDBFieldReal::add(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
{
- checkCoherency(other);
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ checkConsistencyLight(other);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
other.fetchData();
DataArrayInt *cellCor,*nodeCor;
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
+ MCAuto<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
bool ret=isEqualSameType(*othercr,precM,precF);
return ret;
}
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
+ MCAuto<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
MEDCalculatorDBField *ret=substract(*othercr);
return ret;
}
MEDCalculatorDBField *MEDCalculatorDBFieldReal::substract(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
{
- checkCoherency(other);
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ checkConsistencyLight(other);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
other.fetchData();
DataArrayInt *cellCor,*nodeCor;
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
+ MCAuto<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
MEDCalculatorDBField *ret=multiply(*othercr);
return ret;
}
MEDCalculatorDBField *MEDCalculatorDBFieldReal::multiply(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
{
- checkCoherency(other);
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ checkConsistencyLight(other);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
other.fetchData();
DataArrayInt *cellCor,*nodeCor;
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
+ MCAuto<MEDCalculatorDBFieldReal> othercr=buildCstFieldFromThis(otherc->getValue());
MEDCalculatorDBField *ret=divide(*othercr);
return ret;
}
MEDCalculatorDBField *MEDCalculatorDBFieldReal::divide(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
{
- checkCoherency(other);
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ checkConsistencyLight(other);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
other.fetchData();
DataArrayInt *cellCor,*nodeCor;
MEDCalculatorDBField *MEDCalculatorDBFieldReal::dot(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
{
- checkCoherency(other);
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ checkConsistencyLight(other);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
other.fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
MEDCalculatorDBField *MEDCalculatorDBFieldReal::crossProduct(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
{
- checkCoherency(other);
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ checkConsistencyLight(other);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
other.fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
MEDCalculatorDBField *MEDCalculatorDBFieldReal::doublyContractedProduct() const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
unsigned int sz=ids.size();
MEDCalculatorDBField *MEDCalculatorDBFieldReal::determinant() const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
unsigned int sz=ids.size();
MEDCalculatorDBField *MEDCalculatorDBFieldReal::eigenValues() const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
unsigned int sz=ids.size();
MEDCalculatorDBField *MEDCalculatorDBFieldReal::eigenVectors() const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
unsigned int sz=ids.size();
MEDCalculatorDBField *MEDCalculatorDBFieldReal::inverse() const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
unsigned int sz=ids.size();
MEDCalculatorDBField *MEDCalculatorDBFieldReal::trace() const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
unsigned int sz=ids.size();
MEDCalculatorDBField *MEDCalculatorDBFieldReal::deviator() const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
unsigned int sz=ids.size();
MEDCalculatorDBField *MEDCalculatorDBFieldReal::magnitude() const throw(INTERP_KERNEL::Exception)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
std::vector<int> ids=_t.getIds(_time_steps.size());
unsigned int sz=ids.size();
MEDCalculatorDBFieldReal *MEDCalculatorDBFieldReal::buildCstFieldFromThis(double val) const
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
+ MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
ret->_p=_p;
ret->_c_labels.resize(_c.getSize(_c_labels.size()));
std::vector<int> stps=_t.getIds(_time_steps.size());
return ret;
}
-void MEDCalculatorDBFieldReal::checkCoherency(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBFieldReal::checkConsistencyLight(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
{
if(_type!=other._type)
throw INTERP_KERNEL::Exception("Types of field mismatch !");
std::vector<int> idsInGlobalToFetch;
for(int i=0;i<sz;i++)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBSliceField> elt=_time_steps[ids[i]];
+ MCAuto<MEDCalculatorDBSliceField> elt=_time_steps[ids[i]];
if(!elt->isFetched())
{
int dt,it;
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++)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBSliceField> elt=_time_steps[idsInGlobalToFetch[i]];
+ MCAuto<MEDCalculatorDBSliceField> elt=_time_steps[idsInGlobalToFetch[i]];
elt->setField(fs[i]);
}
}
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldCst> ret=new MEDCalculatorDBFieldCst(*this);
+ MCAuto<MEDCalculatorDBFieldCst> ret=new MEDCalculatorDBFieldCst(*this);
ret->_val=_val+otherc->_val;
ret->incrRef();
return ret;
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
if(otherr)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
+ MCAuto<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
MEDCalculatorDBField *ret=(*thisr)+other;
return ret;
}
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldCst> ret=new MEDCalculatorDBFieldCst(*this);
+ MCAuto<MEDCalculatorDBFieldCst> ret=new MEDCalculatorDBFieldCst(*this);
ret->_val=_val-otherc->_val;
ret->incrRef();
return ret;
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
if(otherr)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
+ MCAuto<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
MEDCalculatorDBField *ret=(*thisr)-other;
return ret;
}
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldCst> ret=new MEDCalculatorDBFieldCst(*this);
+ MCAuto<MEDCalculatorDBFieldCst> ret=new MEDCalculatorDBFieldCst(*this);
ret->_val=_val*otherc->_val;
ret->incrRef();
return ret;
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
if(otherr)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
+ MCAuto<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
MEDCalculatorDBField *ret=(*thisr)*other;
return ret;
}
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
if(otherc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldCst> ret=new MEDCalculatorDBFieldCst(*this);
+ MCAuto<MEDCalculatorDBFieldCst> ret=new MEDCalculatorDBFieldCst(*this);
ret->_val=_val/otherc->_val;
ret->incrRef();
return ret;
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
if(otherr)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
+ MCAuto<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
MEDCalculatorDBField *ret=(*thisr)/other;
return ret;
}
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
if(otherr)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
+ MCAuto<MEDCalculatorDBFieldReal> thisr=otherr->buildCstFieldFromThis(_val);
bool ret=thisr->isEqual(other,precM,precF);
return ret;
}
#include "MEDCalculatorDBRangeSelection.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "MEDCouplingAutoRefCountObjectPtr.hxx"
+#include "MCAuto.hxx"
#include "InterpKernelException.hxx"
#include <string>
#include <vector>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCalculatorBrowserField;
class MEDCalculatorDBFieldReal;
bool isEqual(const MEDCalculatorDBField& other, double precM, double precF) const;
bool isEqualSameType(const MEDCalculatorDBFieldReal& other, double precM, double precF) const;
MEDCalculatorDBFieldReal *buildCstFieldFromThis(double val) const;
- void checkCoherency(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
+ void checkConsistencyLight(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
void fetchData() const throw(INTERP_KERNEL::Exception);
TypeOfField getType() const { return _type; }
int getNumberOfSteps() const;
MEDCalculatorDBRangeSelection _p;
std::vector<std::string> _c_labels;
MEDCalculatorDBRangeSelection _c;
- std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBSliceField> > _time_steps;
+ std::vector< MCAuto<MEDCalculatorDBSliceField> > _time_steps;
};
class MEDCALCULATOR_EXPORT MEDCalculatorDBFieldCst : public MEDCalculatorDBField
#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 "MEDLoader.hxx"
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingAutoRefCountObjectPtr.hxx"
+#include "MCAuto.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;
}
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
std::vector<int> oIds=otherC.getIds(sizeCOther);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=other->_field->keepSelectedComponents(oIds);
+ MCAuto<MEDCouplingFieldDouble> f1=other->_field->keepSelectedComponents(oIds);
_field->setSelectedComponents(f1,tIds);
}
throw INTERP_KERNEL::Exception("Slice::add : not implemented yet node/cell permutation !");
std::vector<int> tIds=thisC.getIds(sizeCThis);
std::vector<int> oIds=otherC.getIds(sizeCOther);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
f2->setMesh(f1->getMesh());
MEDCouplingFieldDouble *f3=(*f1)+(*f2);
return new MEDCalculatorDBSliceField(f3);
throw INTERP_KERNEL::Exception("Slice::substract : not implemented yet node/cell permutation !");
std::vector<int> tIds=thisC.getIds(sizeCThis);
std::vector<int> oIds=otherC.getIds(sizeCOther);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
f2->setMesh(f1->getMesh());
MEDCouplingFieldDouble *f3=(*f1)-(*f2);
return new MEDCalculatorDBSliceField(f3);
throw INTERP_KERNEL::Exception("Slice::multiply : not implemented yet node/cell permutation !");
std::vector<int> tIds=thisC.getIds(sizeCThis);
std::vector<int> oIds=otherC.getIds(sizeCOther);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
f2->setMesh(f1->getMesh());
MEDCouplingFieldDouble *f3=(*f1)*(*f2);
return new MEDCalculatorDBSliceField(f3);
throw INTERP_KERNEL::Exception("Slice::divide : not implemented yet node/cell permutation !");
std::vector<int> tIds=thisC.getIds(sizeCThis);
std::vector<int> oIds=otherC.getIds(sizeCOther);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
f2->setMesh(f1->getMesh());
MEDCouplingFieldDouble *f3=(*f1)/(*f2);
return new MEDCalculatorDBSliceField(f3);
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
std::vector<int> oIds=otherC.getIds(sizeCOther);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
f2->setMesh(f1->getMesh());
MEDCouplingFieldDouble *f3=f1->dot(*f2);
return new MEDCalculatorDBSliceField(f3);
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
std::vector<int> oIds=otherC.getIds(sizeCOther);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
f2->setMesh(f1->getMesh());
MEDCouplingFieldDouble *f3=f1->crossProduct(*f2);
return new MEDCalculatorDBSliceField(f3);
MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::doublyContractedProduct(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
MEDCouplingFieldDouble *f2=f1->doublyContractedProduct();
return new MEDCalculatorDBSliceField(f2);
}
MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::determinant(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
MEDCouplingFieldDouble *f2=f1->determinant();
return new MEDCalculatorDBSliceField(f2);
}
MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenValues(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
MEDCouplingFieldDouble *f2=f1->eigenValues();
return new MEDCalculatorDBSliceField(f2);
}
MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenVectors(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
MEDCouplingFieldDouble *f2=f1->eigenVectors();
return new MEDCalculatorDBSliceField(f2);
}
MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::inverse(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
MEDCouplingFieldDouble *f2=f1->inverse();
return new MEDCalculatorDBSliceField(f2);
}
MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::trace(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
MEDCouplingFieldDouble *f2=f1->trace();
return new MEDCalculatorDBSliceField(f2);
}
MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::deviator(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
MEDCouplingFieldDouble *f2=f1->deviator();
return new MEDCalculatorDBSliceField(f2);
}
MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::magnitude(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
MEDCouplingFieldDouble *f2=f1->magnitude();
return new MEDCalculatorDBSliceField(f2);
}
void MEDCalculatorDBSliceField::applyFunc(const char *func, int sizeCThis, const MEDCalculatorDBRangeSelection& thisC)
{
std::vector<int> tIds=thisC.getIds(sizeCThis);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
f1->applyFunc(func);
_field->setSelectedComponents(f1,tIds);
}
throw INTERP_KERNEL::Exception("Slice::isEqual : not implemented yet node/cell permutation !");
std::vector<int> tIds=thisC.getIds(sizeCThis);
std::vector<int> oIds=otherC.getIds(sizeCOther);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
+ MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
+ MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
f2->setMesh(f1->getMesh());
return f1->isEqualWithoutConsideringStr(f2,0,prec);
}
#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;
PyObject *obj2=PyTuple_GetItem(obj,2);
convertPyObjToRS2(obj2,cr,"for 3rd tuple element for components of field");
}
- MEDCouplingAutoRefCountObjectPtr<MEDCalculatorDBFieldReal> ret=self->operator()(tr,pr,cr);
+ MCAuto<MEDCalculatorDBFieldReal> ret=self->operator()(tr,pr,cr);
if(PyInt_Check(val))
{
(*ret)=double(PyInt_AS_LONG(val));
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)
+ return _MEDCalculator.MEDCouplingMappedExtrudedMesh____new___(cls,args)
%}
%pythoncode %{
#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);
da->setInfoOnComponent(0,"aaa [a]"); da->setInfoOnComponent(1,"bbb [b]"); da->setInfoOnComponent(2,"ccc [c]");
da->setInfoOnComponent(3,"ddd [d]"); da->setInfoOnComponent(4,"eee [e]"); da->setInfoOnComponent(5,"fff [f]");
da->setInfoOnComponent(6,"ggg [g]");
- f->checkCoherency();
+ f->checkConsistencyLight();
for(int i=0;i<nbOfTimeSteps;i++)
{
double *pt=da->getPointer();
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 "MEDCouplingExtrudedMeshClient.hxx"
#include "MEDCouplingMeshClient.hxx"
-#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingMemArray.hxx"
#include <vector>
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
-MEDCouplingExtrudedMesh *MEDCouplingExtrudedMeshClient::New(SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_ptr meshPtr)
+MEDCouplingMappedExtrudedMesh *MEDCouplingExtrudedMeshClient::New(SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_ptr meshPtr)
{
- MEDCouplingExtrudedMesh *ret=MEDCouplingExtrudedMesh::New();
+ MEDCouplingMappedExtrudedMesh *ret=MEDCouplingMappedExtrudedMesh::New();
MEDCouplingMeshClient::fillMeshFromCorbaData(ret,meshPtr);
return ret;
}
#include CORBA_SERVER_HEADER(MEDCouplingCorbaServant)
#include "MEDCouplingClient.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
- class MEDCouplingExtrudedMesh;
+ class MEDCouplingMappedExtrudedMesh;
class MEDCOUPLINGCLIENT_EXPORT MEDCouplingExtrudedMeshClient
{
public:
- static MEDCouplingExtrudedMesh *New(SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_ptr mesh);
+ static MEDCouplingMappedExtrudedMesh *New(SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_ptr mesh);
};
}
#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 "MEDCoupling1SGTUMeshClient.hxx"
#include "MEDCoupling1DGTUMeshClient.hxx"
#include "MEDCouplingExtrudedMeshClient.hxx"
-#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingCMeshClient.hxx"
#include "MEDCouplingCurveLinearMeshClient.hxx"
#include "MEDCouplingIMeshClient.hxx"
#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 "MEDCouplingExtrudedMeshServant.hxx"
-#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingMappedExtrudedMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
-MEDCouplingExtrudedMeshServant::MEDCouplingExtrudedMeshServant(const MEDCouplingExtrudedMesh *cppPointerOfMesh):MEDCouplingMeshServant(cppPointerOfMesh)
+MEDCouplingExtrudedMeshServant::MEDCouplingExtrudedMeshServant(const MEDCouplingMappedExtrudedMesh *cppPointerOfMesh):MEDCouplingMeshServant(cppPointerOfMesh)
{
}
#include "MEDCouplingMeshServant.hxx"
#include "MEDCouplingCorba.hxx"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
- class MEDCouplingExtrudedMesh;
+ class MEDCouplingMappedExtrudedMesh;
class MEDCOUPLINGCORBA_EXPORT MEDCouplingExtrudedMeshServant : MEDCouplingMeshServant, public virtual POA_SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface
{
public:
- typedef MEDCouplingExtrudedMesh CppType;
- MEDCouplingExtrudedMeshServant(const MEDCouplingExtrudedMesh *cppPointerOfMesh);
+ typedef MEDCouplingMappedExtrudedMesh CppType;
+ MEDCouplingExtrudedMeshServant(const MEDCouplingMappedExtrudedMesh *cppPointerOfMesh);
~MEDCouplingExtrudedMeshServant();
private:
- const MEDCouplingExtrudedMesh *getPointer() const { return (const MEDCouplingExtrudedMesh *)(_cpp_pointer); }
+ const MEDCouplingMappedExtrudedMesh *getPointer() const { return (const MEDCouplingMappedExtrudedMesh *)(_cpp_pointer); }
};
}
#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 "MEDCouplingCMesh.hxx"
#include "MEDCouplingIMesh.hxx"
#include "MEDCouplingCurveLinearMesh.hxx"
-#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCoupling1GTUMesh.hxx"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
MEDCouplingFieldServant::MEDCouplingFieldServant(const MEDCouplingField *cppPointerOfMesh):MEDCouplingRefCountServant(cppPointerOfMesh,cppPointerOfMesh)
{
SALOME_MED::MEDCouplingIMeshCorbaInterface_ptr ret=retServ->_this();//let this line even if it seems fool
return ret;
}
- const MEDCouplingExtrudedMesh *eMesh=dynamic_cast<const MEDCouplingExtrudedMesh *>(mesh);
+ const MEDCouplingMappedExtrudedMesh *eMesh=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(mesh);
if(eMesh)
{
MEDCouplingExtrudedMeshServant *retServ=new MEDCouplingExtrudedMeshServant(eMesh);
#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;
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingMeshFieldFactoryComponent.hxx"
-#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingMultiFields.hxx"
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);
myCoords->setInfoOnComponent(2,"ZZZ [m]");
myCoords->decrRef();
//
- targetMesh->checkCoherency();
+ targetMesh->checkConsistencyLight();
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();
+ meshM1D->checkConsistencyLight();
return meshM1D;
}
- ParaMEDMEM::MEDCouplingExtrudedMesh *MEDCouplingCorbaServBasicsTest::buildExtrudedMesh(ParaMEDMEM::MEDCouplingUMesh *&m2D)
+ MEDCoupling::MEDCouplingMappedExtrudedMesh *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::MEDCouplingMappedExtrudedMesh *ret=MEDCoupling::MEDCouplingMappedExtrudedMesh::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.};
a1->decrRef();
a2->decrRef();
//
- targetMesh->checkCoherency();
+ targetMesh->checkConsistencyLight();
//
return targetMesh;
}
- 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);
int structure[2]={4,5};
targetMesh->setNodeGridStructure(structure,structure+2);
//
- targetMesh->checkCoherency();
+ targetMesh->checkConsistencyLight();
//
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();
//
- targetMesh->checkCoherency();
+ targetMesh->checkConsistencyLight();
//
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();
//
- targetMesh->checkCoherency();
+ targetMesh->checkConsistencyLight();
//
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();
array->decrRef();
std::fill(tmp,tmp+mesh->getNumberOfCells()*6,7.);
mesh->decrRef();
- fieldOnCells->checkCoherency();
+ fieldOnCells->checkConsistencyLight();
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();
array->decrRef();
std::fill(tmp,tmp+mesh->getNumberOfNodes()*5,7.1234);
mesh->decrRef();
- fieldOnNodes->checkCoherency();
+ fieldOnNodes->checkConsistencyLight();
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::IntensiveMaximum);
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();
array->decrRef();
std::fill(tmp,tmp+mesh->getNumberOfCells()*6,7.);
mesh->decrRef();
- fieldOnCells->checkCoherency();
+ fieldOnCells->checkConsistencyLight();
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);
std::fill(tmp,tmp+mesh->getNumberOfCells()*3,7.);
mesh->decrRef();
fieldOnCells->setTime(6.7,1,4);
- fieldOnCells->checkCoherency();
+ fieldOnCells->checkConsistencyLight();
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();
mesh->decrRef();
fieldOnCells->setStartTime(6.7,1,4);
fieldOnCells->setEndTime(7.2,2,8);
- fieldOnCells->checkCoherency();
+ fieldOnCells->checkConsistencyLight();
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();
std::copy(arr2,arr2+20,tmp);
fieldOnCells->setStartTime(6.7,25,26);
fieldOnCells->setEndTime(17.2,125,126);
- fieldOnCells->checkCoherency();
+ fieldOnCells->checkConsistencyLight();
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]");
f->setTimeUnit("ms");
f->setDescription("mmmmmmmmmmmm");
array->decrRef();
- f->checkCoherency();
+ f->checkConsistencyLight();
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]");
f->setArray(array);
array->decrRef();
//
- f->checkCoherency();
+ f->checkConsistencyLight();
m->decrRef();
return f;
}
- ParaMEDMEM::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldVectorOnExtrudedWT()
+ MEDCoupling::MEDCouplingFieldDouble *MEDCouplingCorbaServBasicsTest::buildFieldVectorOnExtrudedWT()
{
- ParaMEDMEM::MEDCouplingUMesh *m2D=0;
- ParaMEDMEM::MEDCouplingExtrudedMesh *ext=buildExtrudedMesh(m2D);
+ MEDCoupling::MEDCouplingUMesh *m2D=0;
+ MEDCoupling::MEDCouplingMappedExtrudedMesh *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]");
f->setArray(array);
array->decrRef();
//
- f->checkCoherency();
+ f->checkConsistencyLight();
//
m2D->decrRef();
ext->decrRef();
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]");
f->setArray(array);
array->decrRef();
//
- f->checkCoherency();
+ f->checkConsistencyLight();
//
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::IntensiveMaximum);
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::ExtensiveMaximum);
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::ExtensiveConservation);
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);
- ret->checkCoherency();
+ MEDCoupling::MEDCouplingFieldOverTime *ret=MEDCoupling::MEDCouplingFieldOverTime::New(fs);
+ ret->checkConsistencyLight();
//
m1->decrRef();
m2->decrRef();
#include <string>
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingUMesh;
class MEDCouplingFieldDouble;
class MEDCouplingFieldTemplate;
- class MEDCouplingExtrudedMesh;
+ class MEDCouplingMappedExtrudedMesh;
class MEDCoupling1DGTUMesh;
class MEDCoupling1SGTUMesh;
class MEDCouplingCMesh;
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::MEDCouplingMappedExtrudedMesh *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();
};
}
#include "MEDCoupling1GTUMesh.hxx"
#include "MEDCoupling1SGTUMeshClient.hxx"
#include "MEDCoupling1DGTUMeshClient.hxx"
-#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingExtrudedMeshClient.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingCMeshClient.hxx"
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::MEDCouplingMappedExtrudedMesh *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::MEDCouplingMappedExtrudedMesh *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;
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingMultiFields.hxx"
#include "MEDCouplingFieldOverTime.hxx"
-#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingCurveLinearMesh.hxx"
#include "MEDCoupling1GTUMesh.hxx"
#include "MEDCouplingUMesh.hxx"
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::MEDCouplingMappedExtrudedMesh *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
{
public:
%extend
{
- static MEDCouplingExtrudedMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
+ static MEDCouplingMappedExtrudedMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
{
PyObject* pdict=PyDict_New();
PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingExtrudedMeshInterface_ptr !");
Py_DECREF(pdict);
Py_DECREF(iorMesh);
- MEDCouplingExtrudedMesh *ret=MEDCouplingExtrudedMeshClient::New(meshPtrCppC);
+ MEDCouplingMappedExtrudedMesh *ret=MEDCouplingExtrudedMeshClient::New(meshPtrCppC);
return ret;
}
}
}
%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)
+ return _MEDCouplingClient.MEDCouplingMappedExtrudedMesh____new___(cls,args)
%}
%include "MEDCouplingFinalize.i"
#include "DataArrayIntServant.hxx"
#include "MEDCouplingCorbaTypemaps.i"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
%}
%include "MEDCouplingCommon.i"
-namespace ParaMEDMEM
+namespace MEDCoupling
{
class MEDCouplingFieldDoubleServant
{
return buildServantAndActivate<MEDCoupling1SGTUMeshServant>(dynamic_cast<const MEDCoupling1SGTUMesh *>(cppPointerOfMesh));
if(dynamic_cast<const MEDCoupling1DGTUMesh *>(cppPointerOfMesh))
return buildServantAndActivate<MEDCoupling1DGTUMeshServant>(dynamic_cast<const MEDCoupling1DGTUMesh *>(cppPointerOfMesh));
- if(dynamic_cast<const MEDCouplingExtrudedMesh *>(cppPointerOfMesh))
- return buildServantAndActivate<MEDCouplingExtrudedMeshServant>(dynamic_cast<const MEDCouplingExtrudedMesh *>(cppPointerOfMesh));
+ if(dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(cppPointerOfMesh))
+ return buildServantAndActivate<MEDCouplingExtrudedMeshServant>(dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(cppPointerOfMesh));
if(dynamic_cast<const MEDCouplingCMesh *>(cppPointerOfMesh))
return buildServantAndActivate<MEDCouplingCMeshServant>(dynamic_cast<const MEDCouplingCMesh *>(cppPointerOfMesh));
if(dynamic_cast<const MEDCouplingIMesh *>(cppPointerOfMesh))
return buildServantAndActivate2<MEDCoupling1SGTUMeshServant>(dynamic_cast<const MEDCoupling1SGTUMesh *>(cppPointerOfMesh));
if(dynamic_cast<const MEDCoupling1DGTUMesh *>(cppPointerOfMesh))
return buildServantAndActivate2<MEDCoupling1DGTUMeshServant>(dynamic_cast<const MEDCoupling1DGTUMesh *>(cppPointerOfMesh));
- if(dynamic_cast<const MEDCouplingExtrudedMesh *>(cppPointerOfMesh))
- return buildServantAndActivate2<MEDCouplingExtrudedMeshServant>(dynamic_cast<const MEDCouplingExtrudedMesh *>(cppPointerOfMesh));
+ if(dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(cppPointerOfMesh))
+ return buildServantAndActivate2<MEDCouplingExtrudedMeshServant>(dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(cppPointerOfMesh));
if(dynamic_cast<const MEDCouplingCMesh *>(cppPointerOfMesh))
return buildServantAndActivate2<MEDCouplingCMeshServant>(dynamic_cast<const MEDCouplingCMesh *>(cppPointerOfMesh));
if(dynamic_cast<const MEDCouplingIMesh *>(cppPointerOfMesh))
public:
%extend
{
- static PyObject *_this(const MEDCouplingExtrudedMesh *cppPointerOfMesh) throw(INTERP_KERNEL::Exception)
+ static PyObject *_this(const MEDCouplingMappedExtrudedMesh *cppPointerOfMesh) throw(INTERP_KERNEL::Exception)
{
return buildServantAndActivate<MEDCouplingExtrudedMeshServant>(cppPointerOfMesh);
}
- static PyObject *_this2(const MEDCouplingExtrudedMesh *cppPointerOfMesh) throw(INTERP_KERNEL::Exception)
+ static PyObject *_this2(const MEDCouplingMappedExtrudedMesh *cppPointerOfMesh) throw(INTERP_KERNEL::Exception)
{
return buildServantAndActivate2<MEDCouplingExtrudedMeshServant>(cppPointerOfMesh);
}
}
%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)
+ return _MEDCouplingCorba.MEDCouplingMappedExtrudedMesh____new___(cls,args)
%}
%include "MEDCouplingFinalize.i"
myCoords.setInfoOnComponent(0,"X [m]");
myCoords.setInfoOnComponent(1,"YY [Pm]");
myCoords.setInfoOnComponent(2,"ZZZ [m]");
- targetMesh.checkCoherency();
+ targetMesh.checkConsistencyLight();
return targetMesh;
def buildM1DMesh(self):
meshM1D=MEDCouplingUMesh.New("wonderfull -1 D mesh",-1);
meshM1D.setDescription("buildM1DMesh");
- meshM1D.checkCoherency();
+ meshM1D.checkConsistencyLight();
return meshM1D;
def buildExtrudedMesh(self):
m2D.changeSpaceDimension(3);
m1D=self.build1DMesh();
retu=m2D.buildExtrudedMesh(m1D,0);
- ret=MEDCouplingExtrudedMesh.New(retu,m2D,2);
+ ret=MEDCouplingMappedExtrudedMesh.New(retu,m2D,2);
ret.setName("ExtrudedTestForCorbaTest");
ret.setDescription("buildExtrudedMesh");
return ret;
targetMesh.setCoordsAt(1,a2);
#
#
- targetMesh.checkCoherency();
+ targetMesh.checkConsistencyLight();
#
return targetMesh;
targetMesh.setCoords(a1);
targetMesh.setNodeGridStructure([4,5]);
#
- targetMesh.checkCoherency();
+ targetMesh.checkConsistencyLight();
#
return targetMesh;
a2=DataArrayInt([6,0,3,5,3,0,1,4,1,2,7,4,8,7,2,9],4*4,1)
targetMesh.setNodalConnectivity(a2)
#
- targetMesh.checkCoherency();
+ targetMesh.checkConsistencyLight();
#
return targetMesh;
a3=DataArrayInt([0,4,8,12,15],5,1)
targetMesh.setNodalConnectivity(a2,a3)
#
- targetMesh.checkCoherency();
+ targetMesh.checkConsistencyLight();
#
return targetMesh;
tmp=mesh.getNumberOfCells()*6*[7.]
array.setValues(tmp,mesh.getNumberOfCells(),6);
fieldOnCells.setArray(array)
- fieldOnCells.checkCoherency();
+ fieldOnCells.checkConsistencyLight();
return fieldOnCells;
def buildFieldNodeScalarOn2DNT(self):
tmp=mesh.getNumberOfNodes()*5*[7.1234]
array.setValues(tmp,mesh.getNumberOfNodes(),5);
fieldOnNodes.setArray(array);
- fieldOnNodes.checkCoherency();
+ fieldOnNodes.checkConsistencyLight();
return fieldOnNodes;
def buildFieldScalarOn3DNT(self):
mesh=self.build3DMesh();
fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
- fieldOnCells.setNature(ConservativeVolumic);
+ fieldOnCells.setNature(IntensiveMaximum);
fieldOnCells.setName("toto");
fieldOnCells.setDescription("my wonderful 3D field toto2");
fieldOnCells.setMesh(mesh);
tmp=mesh.getNumberOfCells()*6*[7.]
array.setValues(tmp,mesh.getNumberOfCells(),6);
fieldOnCells.setArray(array);
- fieldOnCells.checkCoherency();
+ fieldOnCells.checkConsistencyLight();
return fieldOnCells;
def buildFieldScalarOn3DSurfWT(self):
array.setInfoOnComponents(["aaa","bbbb","ccccc"])
fieldOnCells.setArray(array);
fieldOnCells.setTime(6.7,1,4);
- fieldOnCells.checkCoherency();
+ fieldOnCells.checkConsistencyLight();
return fieldOnCells;
def buildFieldScalarOn3DSurfCOTI(self):
fieldOnCells.setArray(array);
fieldOnCells.setStartTime(6.7,1,4);
fieldOnCells.setEndTime(7.2,2,8);
- fieldOnCells.checkCoherency();
+ fieldOnCells.checkConsistencyLight();
return fieldOnCells;
def buildFieldScalarOn2DLT(self):
fieldOnCells.setEndArray(array)
fieldOnCells.setStartTime(6.7,25,26);
fieldOnCells.setEndTime(17.2,125,126);
- fieldOnCells.checkCoherency();
+ fieldOnCells.checkConsistencyLight();
return fieldOnCells;
def buildFieldGaussPt2DWT(self):
f.setName("MyFirstFieldOnGaussPoint");
f.setTimeUnit("ms");
f.setDescription("mmmmmmmmmmmm");
- f.checkCoherency();
+ f.checkConsistencyLight();
return f;
def buildFieldGaussPtNE2DWT(self):
array.setInfoOnComponent(1,"Density [kg/m^3]");
f.setArray(array);
#
- f.checkCoherency();
+ f.checkConsistencyLight();
return f;
def buildFieldVectorOnExtrudedWT(self):
array.setInfoOnComponent(1,"Density [kg/m^3]");
f.setArray(array);
#
- f.checkCoherency();
+ f.checkConsistencyLight();
return f
def buildFieldVectorOnCMeshWT(self):
array.setInfoOnComponent(1,"Density [kg/m^3]");
f.setArray(array);
#
- f.checkCoherency();
+ f.checkConsistencyLight();
return f
def buildFieldTemplateCellOn2D(self):
def buildFieldTemplateNodeOn2D(self):
f1=self.buildFieldNodeScalarOn2DNT();
f2=MEDCouplingFieldTemplate.New(f1);
- f2.setNature(ConservativeVolumic);
+ f2.setNature(IntensiveMaximum);
return f2
def buildFieldTemplateGaussPtOn2D(self):
f1=self.buildFieldGaussPt2DWT();
f2=MEDCouplingFieldTemplate.New(f1);
- f2.setNature(Integral);
+ f2.setNature(ExtensiveMaximum);
return f2
def buildFieldTemplateGaussNEOn2D(self):
f1=self.buildFieldGaussPtNE2DWT();
f2=MEDCouplingFieldTemplate.New(f1);
- f2.setNature(IntegralGlobConstraint);
+ f2.setNature(ExtensiveConservation);
return f2
def buildMultiFields1(self):
f4.setName("f4");
f4.setTime(2.7,25,26);
ret=MEDCouplingFieldOverTime.New([f0,f1,f2,f3,f4]);
- ret.checkCoherency();
+ ret.checkConsistencyLight();
return ret;
def buildFileNameForIOR(self):
myCoords=DataArrayDouble.New()
myCoords.setValues(coords,nbOfNodes,3);
mesh.setCoords(myCoords);
- mesh.checkCoherency();
+ mesh.checkConsistencyLight();
myFalseConn=DataArrayInt.New()
myFalseConn.setValues(tab4,6,4)
return mesh
nbOfCells=mesh.getNumberOfCells()
field=MEDCouplingFieldDouble.New(ON_CELLS)
field.setMesh(mesh)
- field.setNature(Integral)
+ field.setNature(ExtensiveMaximum)
myCoords=DataArrayDouble.New()
sampleTab=[]
for i in range(nbOfCells*9):